Select Git revision
-
Sonia Zorba authoredSonia Zorba authored
ComponentCore.h 20.57 KiB
#ifndef _BASECOMPONENTCORE_H_
#define _BASECOMPONENTCORE_H_
/***********************************************************************\
IRA Istituto di Radioastronomia
This code is under GNU General Public License (GPL).
Andrea Orlati (andrea.orlati@inaf.it): Author
\***********************************************************************/
#include "Configuration.h"
#include <ReceiverControl.h>
#include <LocalOscillatorInterfaceC.h>
#include <ReceiversErrors.h>
#include <ManagmentDefinitionsC.h>
#define NUMBER_OF_STAGES 1
#define PHYSICAL_FEEDS 3
#define KBAND_FEED 0
#define QBAND_FEED 1
#define WBAND_FEED 2
/**
* This class extends the ReceiverControl class in order to include the bypass activation on the Wband RF chain to enable Sun observations
* @author <a href=mailto:andrea.orlati@inaf.it>Andrea Orlati</a>,
* Istituto di Radioastronomia, Italia
* <br>
*/
class CKQWReceiverControl: public virtual IRA::ReceiverControl {
public:
CKQWReceiverControl(const std::string dewar_ip,
const unsigned short dewar_port,
const std::string lna_ip,
const unsigned short lna_port,
const unsigned int guard_time=250000,
const unsigned short number_of_feeds=1) : ReceiverControl(dewar_ip,dewar_port,lna_ip,lna_port,guard_time,number_of_feeds) {}
virtual ~CKQWReceiverControl() {}
/**
* @throw ReceiverControlEx
*/
bool enableBypass();
/**
* @throw ReceiverControlEx
*/
bool disableBypass();
};
/**
* This class contains the code of almost all the features of the component
* @author <a href=mailto:andrea.orlati@inaf.it>Andrea Orlati</a>,
* Istituto di Radioastronomia, Italia
* <br>
*/
class CComponentCore {
public:
CComponentCore();
virtual ~CComponentCore();
/**
* This method initializes the object
* @param service pointer to container services object provided by the container
*/
virtual void initialize(maci::ContainerServices* services);
/** * This method prepares the object for execution.
* @return the pointer to the configuration class
* @throw (ComponentErrors::CDBAccessExImpl, ComponentErrors::MemoryAllocationExImpl, ComponentErrors::SocketErrorExImpl,
* ReceiversErrors::ModeErrorExImpl)
*/
virtual CConfiguration<maci::ContainerServices> const * const execute();
/**
* This function is responsible to free all allocated resources
*/
virtual void cleanup();
/*
* It sets the local oscillators. Before commanding the new value
* some check are done. The corresponding signal amplitude is computed.
* @param lo lists of values for the local oscillator (MHz), one for each IF.
* In that case just the first one is significant. In a -1 is passed the present value is kept.
* @throw ComponentErrors::ValidationErrorExImpl
* @throw ComponentErrors::ValueOutofRangeExImpl
* @throw ComponentErrors::CouldntGetComponentExImpl
* @throw ComponentErrors::CORBAProblemExImpl
* @thorw ReceiversErrors::LocalOscillatorErrorExImpl
*/
void setLO(const ACS::doubleSeq& lo);
/**
* It activate the receiver, in other words it allows to setup the default configuration
* and to make sure the LNA are turned on.
* @throw ReceiversErrors::ModeErrorExImpl,
* @throw ComponentErrors::ValidationErrorExImpl,
* @throw ComponentErrors::ValueOutofRangeExImpl,
* @throw ComponentErrors::CouldntGetComponentExImpl,
* @throw ComponentErrors::CORBAProblemExImpl,
* @throw ReceiversErrors::LocalOscillatorErrorExImpl,
* @throw ReceiversErrors::NoRemoteControlErrorExImpl,
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void activate();
/**
* It deactivates the receiver.
* @throw ReceiversErrors::NoRemoteControlErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void deactivate();
/**
* It allows to compute the value of the calibration mark for any given sub bands in
* the IF space.
* @param result this the sequence of computed mark values, the first entry correspond to
* first sub band and so on....
* @param, resFreq the sequence reports the initial observed sky frequency (MHz), the
* first entry correspond to first sub band and so on....
* @param resBw the sequence reports the real bandwidth observed (MHz), the first entry
* correspond to first sub band and so on....
* @param freqs list of start frequencies (MHz)
* @param bandwidth list of the band widths (MHz)
* @param feeds list of feed identifier, it allows to specifies form which feed the sub
* band comes from. In that case it is neglected since the receiver is a single feed
* @param ifs list of IF identifier, it allows to specifies from which receiver IF the
* sub band comes from.
* @param scale value to scale tsys measurement
* @throw ComponentErrors::ValidationErrorExImpl
* @throw ComponentErrors::ValueOutofRangeExImpl
*/
void getCalibrationMark(
ACS::doubleSeq& result, ACS::doubleSeq& resFreq,
ACS::doubleSeq& resBw,
const ACS::doubleSeq& freqs,
const ACS::doubleSeq& bandwidths,
const ACS::longSeq& feeds,
const ACS::longSeq& ifs,
bool& onoff,
double &scale
);
/**
* It is called to get the all the receiver output information in one call.
* An output is identified by providing the feed and the IF identifier. It can process any number of requests at a time.
* @param feeds is a list that stores the corresponding feed of the output we are asking for
* @param ifs is a list that identifies which IFs of the feed we are interested in, usually 0..<i>IFs</i>-1
* @param freq used to return the start frequency of the band provided by the output the oscillator
* (if present) is not added (MHz)
* @param bw used to return the total provided bandwidth. (MHz)
* @param pols it specifies the polarization of the receiver output, since ACS does not support for enum
* sequences the correct value must be matched against the <i>Receivers::TPolarization</i> enumeration.
* @param LO it gives (if present) the value of the local oscillator (MHz).
* @throw ComponentErrors::ValidationErrorExImpl
* @throw ComponentErrors::ValueOutofRangeExImpl
*/
void getIFOutput(
const ACS::longSeq& feeds,
const ACS::longSeq& ifs,
ACS::doubleSeq& freqs,
ACS::doubleSeq& bw,
ACS::longSeq& pols,
ACS::doubleSeq& LO
);
/**
* It computes the taper given a reference band.
* @param freq start frequency of the reference band
* @param bw width of the reference band
* @param feed feed number
* @param ifNumber IF chain identifier
* @param waveLen wave length of the reference band, the band is transformed in a real sky
* observed band and the the central frequency is taken.
* @throw ComponentErrors::ValidationErrorExImpl
* @thorw ComponentErrors::ValueOutofRangeExImpl
*/
double getTaper(
const double& freq,
const double& bw,
const long& feed,
const long& ifNumber,
double& waveLen
);
/** It turns the calibration diode on.
* @throw ReceiversErrors::NoRemoteControlErrorExImpl
* @throw ComponentErrors::ValidationErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void calOn();
/** It turns the calibration diode off
* @throw ReceiversErrors::NoRemoteControlErrorExImpl
* @throw ComponentErrors::ValidationErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void calOff();
/** It turns the external calibration diode on.
* @throw ReceiversErrors::NoRemoteControlErrorExImpl
* @throw ComponentErrors::ValidationErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void externalCalOn();
/** It turns the external calibration diode off.
* @throw ReceiversErrors::NoRemoteControlErrorExImpl
* @throw ComponentErrors::ValidationErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void externalCalOff();
/** It turns on the sensor for vacuum measurement.
* @throw ReceiversErrors::NoRemoteControlErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void vacuumSensorOn();
/** It turns off the sensor for vacuum measurement.
* @throw ReceiversErrors::NoRemoteControlErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl)
*/
void vacuumSensorOff();
/** It allows to turn LNA on
* @throw ReceiversErrors::NoRemoteControlErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl)
*/
void lnaOn();
/** It allows to turn LNA off
* @throw ReceiversErrors::NoRemoteControlErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl)
*/
void lnaOff();
/**
* It reads and updates from the control board the current value of the vacuum
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateVacuum();
/**
* It check if the vacuum pump is on and check is the status is fault or not (<i>VACUUMPUMPFAULT</i>)
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateVacuumPump();
/**
* It checks if the vacuum valve is opened or not
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateVacuumValve();
/**
* It reads and updates from the control board the current cryo temperature measured near the cool head
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateCryoCoolHead();
/**
* It reads and updates from the control board the current cryo temperature measured near the cool head window
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateCryoCoolHeadWin();
/**
* It reads and updates from the control board the current cryo temperature measured near the LNA
*/
void updateCryoLNA();
/**
* It reads and updates from the control board the current cryo temperature measured near the LNA window
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateCryoLNAWin();
/**
* It reads and updates from the control board the current vertex temperature
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateVertexTemperature();
/**
* It checks if the Dewar power box is in remote or not
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateIsRemote();
/**
* It checks if the cool head is turned on or not
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateCoolHead();
/**
* It checks is the status of the noise mark correspond to the commanded status,
* otherwise it sets the <i>NOISEMARKERROR</i> bit. It also check if the
* external control of the noise mark has been enabled or not
*/
void updateNoiseMark();
/**
* This method resumes the whole status of the component. It set the <i>componentStatus</i> member variable.
*/
void updateComponent();
/**
* This is getter method. No need to make it thread safe......
* @return the current value of the vacuum in mbar
*/
double getVacuum() const { return m_vacuum; }
/**
* This is getter method. No need to make it thread safe......
* @return the current value of the cryogenic temperature at cool head in °K
*/
CConfiguration<maci::ContainerServices>::BoardValue getCryoCoolHead() const { return m_cryoCoolHead; }
/**
* This is getter method. No need to make it thread safe......
* @return the current value of the cryogenic temperature at cool head window in °K
*/
CConfiguration<maci::ContainerServices>::BoardValue getCryoCoolHeadWin() const { return m_cryoCoolHeadWin; }
/**
* This is getter method. No need to make it thread safe......
* @return the current value of the cryogenic temperature at LNA in °K
*/
CConfiguration<maci::ContainerServices>::BoardValue getCryoLNA() const { return m_cryoLNA; }
/**
* This is getter method. No need to make it thread safe......
* @return the current value of the cryogenic temperature at LNA window in °K
*/
CConfiguration<maci::ContainerServices>::BoardValue getCryoLNAWin() const { return m_cryoLNAWin; }
/**
* This is getter method. No need to make it thread safe......
* @return the current vertex temperature in °K
*/
CConfiguration<maci::ContainerServices>::BoardValue getVertexTemperature() const { return m_envTemperature; }
/**
* This is getter method. No need to make it thread safe......
* @return the current status word
*/
DWORD getStatusWord() const { return m_statusWord; }
/**
* It returns the feed geometry of the receiver with respect to the central one.
* For this implementation it is just a placeholder since there is just one feed.
*/
long getFeeds(ACS::doubleSeq& X, ACS::doubleSeq& Y, ACS::doubleSeq& power);
/**
* It returns the current operating mode of the receiver.
* @return output string
*/
const IRA::CString& getActualMode();
/**
* It returns the number of IF chains for each feed
* @return output value
*/
const DWORD& getIFs();
/**
* It returns the number of feeds
* @return output value
*/
const DWORD& getFeeds();
/**
* @return the status flag of the component
*/
const Management::TSystemStatus& getComponentStatus();
/**
* Allows to set the "default_value" for the vacuum characteristic. In principle it is possible
* to read it directly from CDB, but I found it more
* comfortable to get it directly from the characteristic itself.
*/ inline void setVacuumDefault(const double& val) { m_vacuumDefault=val; }
void getBandwidth(ACS::doubleSeq& bw);
void getInitialFreq(ACS::doubleSeq& f);
void getLocalOscillator(ACS::doubleSeq& lo);
void getPolarizations(ACS::longSeq& pol);
/**
* It allows to change the operating mode of the receiver.
* If the mode does not correspond to a valid mode an error is thrown.
* @param mode mode code as a string
* @throw ComponentErrors::ValidationErrorExImpl
* @throw ComponentErrors::ValueOutofRangeExImpl
* @throw ComponentErrors::CouldntGetComponentExImpl
* @throw ComponentErrors::CORBAProblemExImpl
* @throw ReceiversErrors::LocalOscillatorErrorExImpl
* @throw ComponentErrors::CDBAccessExImpl
* @throw ReceiversErrors::ModeErrorExImpl
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
virtual void setMode(const char * mode);
/*
* This method will update the last readout of the gate voltage parameters of the LNAs
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateVgLNAControls();
/*
* This method will update the last readout of the drain voltage parameters of the LNAs
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateVdLNAControls();
/*
* This method will update the last readout of the drain current parameters of the LNAs
* @throw ReceiversErrors::ReceiverControlBoardErrorExImpl
*/
void updateIdLNAControls();
ACS::doubleSeq getStageValues(const IRA::ReceiverControl::FetValue& control, DWORD ifs, DWORD stage);
protected:
/** Obtain a valid reference to the local oscillator device
* @throw ComponentErrors::CouldntGetComponentExImpl
*/
void loadLocalOscillator(Receivers::LocalOscillator_var& device,bool &fault,const IRA::CString& name);
/** Used to free the reference to the local oscillator device */
void unloadLocalOscillator(Receivers::LocalOscillator_var& device,const IRA::CString& name);
/************************ CONVERSION FUNCTIONS **************************/
// Convert the voltage value of the vacuum to mbar
static double voltage2mbar(double voltage) { return(pow(10, 1.5 * voltage - 12)); }
// Convert the voltage value of the temperatures to Kelvin
static double voltage2Kelvin(double voltage) {
return voltage < 1.12 ? \
(660.549422889947 * pow(voltage, 6)) - (2552.334255456860 * \
pow(voltage, 5)) + (3742.529989384570 * pow(voltage, 4)) - \
(2672.656926956470 * pow(voltage, 3)) + (947.905578508975 * \
pow(voltage, 2)) - 558.351002849576 * voltage + 519.607622398508 \
:
(865.747519105672 * pow(voltage, 6)) - (7271.931957100480 * \ pow(voltage, 5)) + (24930.666241800500 * pow(voltage, 4)) - \
(44623.988512320400 * pow(voltage, 3)) + (43962.922216886600 * \
pow(voltage, 2)) - 22642.245121997700 * voltage + 4808.631312836750;
}
// Convert the voltage value of the temperatures to Celsius (Sensor B57703-10K)
static double voltage2Celsius(double voltage)
{ return -5.9931 * pow(voltage, 5) + 40.392 * pow(voltage, 4) - 115.41 * pow(voltage, 3) + 174.67 * pow(voltage, 2) - 174.23 * voltage + 112.79; }
// Convert the ID voltage value to the mA value
static double currentConverter(double voltage) { return(10 * voltage); }
// Convert the VD and VG voltage values using a right scale factor
static double voltageConverter(double voltage) { return(voltage); }
/********************** END CONVERSION FUNCTIONS ***********************/
enum TStatusBit {
LOCAL=0,
VACUUMSENSOR=1,
VACUUMPUMPSTATUS=2,
VACUUMPUMPFAULT=3,
VACUUMVALVEOPEN=4,
COOLHEADON=5,
COMPRESSORFAULT=6,
NOISEMARK=7,
NOISEMARKERROR=8,
EXTNOISEMARK=9,
CONNECTIONERROR=10,
UNLOCKED=11
};
/** This function will set the a status bit. It may be considered thread safe due to its definition */
inline void setStatusBit(TStatusBit bit) { m_statusWord |= 1 << bit; }
/** This function will unset (clear) a status bit. It may be considered thread safe due to its definition */
inline void clearStatusBit(TStatusBit bit) { m_statusWord &= ~(1 << bit); }
/** This function check is a bit is set or not. It may be considered thread safe due to its definition */
inline bool checkStatusBit(TStatusBit bit) { return m_statusWord & (1 << bit); }
CConfiguration<maci::ContainerServices> m_configuration;
CKQWReceiverControl *m_control; // This object is thread safe
BACIMutex m_mutex;
//IRA::CString m_actualMode;
//IRA::CString m_setupMode;
private:
maci::ContainerServices* m_services;
Receivers::LocalOscillator_var m_localOscillatorDevice_K;
bool m_localOscillatorFault_K;
Receivers::LocalOscillator_var m_localOscillatorDevice_Q;
bool m_localOscillatorFault_Q;
Receivers::LocalOscillator_var m_localOscillatorDevice_WL;
bool m_localOscillatorFault_WL;
Receivers::LocalOscillator_var m_localOscillatorDevice_WH;
bool m_localOscillatorFault_WH;
//double m_localOscillatorValue;
double m_vacuum;
CConfiguration<maci::ContainerServices>::BoardValue m_cryoCoolHead;
CConfiguration<maci::ContainerServices>::BoardValue m_cryoCoolHeadWin;
CConfiguration<maci::ContainerServices>::BoardValue m_cryoLNA; CConfiguration<maci::ContainerServices>::BoardValue m_cryoLNAWin;
CConfiguration<maci::ContainerServices>::BoardValue m_envTemperature;
std::vector<IRA::ReceiverControl::StageValues> m_vdStageValues;
std::vector<IRA::ReceiverControl::StageValues> m_idStageValues;
std::vector<IRA::ReceiverControl::StageValues> m_vgStageValues;
double m_vacuumDefault;
bool m_calDiode;
IRA::ReceiverControl::FetValues m_fetValues;
DWORD m_statusWord;
// m_ioMarkError is a flag used to know if we already got an IO
// error.
bool m_ioMarkError;
Management::TSystemStatus m_componentStatus;
void setComponentStatus(const Management::TSystemStatus& status)
{
if (status>m_componentStatus) m_componentStatus=status;
}
double linearFit(ACS::doubleSeq& X,ACS::doubleSeq& Y, const WORD& size, double x) const;
double linearFit(double *X,double *Y,const WORD& size,double x) const;
};
#endif