ngcdcsCLDC.hpp

Go to the documentation of this file.

#ifndef ngcdcsCLDC_H
#define ngcdcsCLDC_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <ngc/core/ngcbAddr.h>
#include <ngc/core/ngcbMOD.hpp>
#include <ngc/core/ngcdcsTypes.hpp>

#define ngcdcsCLDC_LBNL 0x00010000  //< CLDC with HV-circuit for LBNL CCD

#define ngcdcsCLDC_ERR_PROTECTION 0x1
 

#define ngcdcsCLDC_BUFSIZE (1024 * 128)

#define ngcdcsCLDC_DCLK 2

#define ngcdcsCLDC_CAL_MAX 0.2

#define ngcdcsCLDC_VDIFF_MAX 1.0

#define ngcdcsCLDC_MAX_CHAN ((ngcbCLDC_MAX_CLK * 2) + ngcbCLDC_MAX_DC)

#define ngcdcsCLDC_MAX_TEL 80

struct ngcdcs_dc_t {
  double volt;     //< Setup value (V)
  double range[2]; //< Valid range (V)
  double dacCorr;  //< Correction factor (gain)
  double telGain;  //< Telemetry gain
  double comp;     //< Error compensation (V)
  double margin;   //< Telemetry check margin (V, absolute value)
  int voltReg;     //< Actual register value
  int dacChan;     //< DAC channel
  int telChan;     //< Telemetry channel
  char name[64];   //< Name (string)
  int connected;   //< Connected flag
  int directReg;   //< Setup register value
  int set;         //< Flag indicating that voltage has been set
  char unit[4];    //< Optional unit

  ngcdcs_dc_t() {
    volt = 0.0;
    range[0] = -20.0;
    range[1] = 20.0;
    dacCorr = 1.0;
    telGain = 1.0;
    comp = 0.0;
    margin = -1.0;       // -> use global value
    voltReg = 0x0;
    memset(name, 0, sizeof(name));
    name[0] = '\0';
    dacChan = 0;
    telChan = 0;
    connected = 1;
    directReg = 0;
    set = 0;
    unit[0] = '\0';
  }
};

struct ngcdcs_clk_t {
  ngcdcs_dc_t level[ngcdcsCLDC_DCLK]; //< Voltage structure
  int connected;                      //< Connected flag                   

  ngcdcs_clk_t() {connected = 1;}
};

struct ngcdcs_clkv_t{
  double volt[ngcdcsCLDC_DCLK]; //< Voltage for each level (V)

  ngcdcs_clkv_t() {
    int i;
    for (i=0;i<ngcdcsCLDC_DCLK;i++) volt[i] = 0.0;
  }
};

class ngcdcsCLDC0: public ngcbMOD
{
public:
  int vstat;

  int autoEnable;

  int autoDisable;

  int ilck;

  int ilckOn;

  int protection;

  int protectionOn;

  int autoCal;

  double calMax;         

  ngcdcs_clk_t *clk; 

  int numClk; 

  ngcdcs_dc_t *dc; 

  int numDc;

  ngcdcs_clkv_t *clkTel;

  double *dcTel; 
  
  int haveCurrentTel;

  double margin;

  double dacTime; 

  char voltageInitFile[256]; 

  char cfgFile[256]; 

  int toggle;

  int telFlag; 

  double cvg1;

  double cvg2;           
  
  double cvOffset;           
  
  char serNoBoard[32]; 

  char serNoTrans[32];   

  ngcdcsCLDC0(const ngcb_route_t &r, int nc, int nb) 
    : ngcbMOD(r) {
    numClk = nc;
    numDc = nb;
    Init_();
  }

  ngcdcsCLDC0(ngcbIFC *ifc, const ngcb_route_t &r, int nc, int nb) 
    : ngcbMOD(ifc, r) {
    numClk = nc; numDc = nb;
    Init_();
  }

  virtual ~ngcdcsCLDC0() {
    if (clk != NULL) delete[] clk;
    if (clkTel != NULL) delete[] clkTel;
    if (dc != NULL) delete[] dc;
    if (dcTel != NULL) delete[] dcTel;
  }

  virtual int AtOnline() {
    return (Success());
  }
  
  virtual int Selftest() {
    Verbose("ngcdcsCLDC%d: selftest\n", Instance()+1);
    return (Success());
  }

  virtual int VSetup(int autoCtrl = 0) {
    USE (autoCtrl);
    return (Success());
  }

  virtual int Check() {return (Success());}

  virtual int OutputEnable() {
    vstat = ngcbCLDC_STAT_ENABLED;
    strcpy(statStr_, "enabled");
    return (Success());
  }

  virtual int OutputDisable() {
    vstat = ngcbCLDC_STAT_DISABLED;
    strcpy(statStr_, "disabled");
    return (Success());
  }

  virtual int OutputEnabled() {return (vstat == ngcbCLDC_STAT_ENABLED);}

  virtual int Protection(int flag) {
    protectionOn = flag;
    return (Success());
  }

  virtual int Calibrate(int noSetup = 0) {
    USE(noSetup);
    calibrated_ = 1;
    return (Success());
  }

  virtual void ClearCalibration() {calibrated_ = 0;}

  virtual int Calibrated() {return (calibrated_);}

  virtual int Zero() {
    int i;
    for (i=0;numClk;i++)
      {
      ngcdcs_clkv_t cv; // this is initialized with 0.0
      if (VoltageClk(i, cv, 0) != Success())
    {
    return (ngcbMOD_ERR);
    }
      }
    for (i=0;numDc;i++)
      {
      if (VoltageDC(i, 0.0, 0) != Success())
    {
    return (ngcbMOD_ERR);
    }
      }
    telFlag = 1;
    return (Success());
  }

  virtual int VoltageDC(int num, double volt, int rangeCheck = 1) {
    USE(rangeCheck);
    if ((num < 0) || (num >= numDc))
      {
      sprintf(ErrMsg(), "bias channel number out of range");
      return (ngcbMOD_ERR);
      }
    dc[num].volt = volt;
    return (Success());
  }

  virtual int VoltageClk(int num, int l, double volt, int rangeCheck = 1) {
    USE(rangeCheck);
    if ((num < 0) || (num >= numClk))
      {
      sprintf(ErrMsg(), "clock channel number out of range");
      return (ngcbMOD_ERR);
      }
    clk[num].level[l].volt = volt;
    return (Success());
  }

  virtual int VoltageClk(int num, ngcdcs_clkv_t cv, int rangeCheck = 1) {
    int j;
    for (j=0;j<ngcdcsCLDC_DCLK;j++)
      {
      if (VoltageClk(num, j, cv.volt[j], rangeCheck) != Success())
    {
    return (ngcbMOD_ERR);
    }
      }
    return (Success());
  }

  virtual int VoltageRegDC(int num, int value, int rangeCheck = 1) {
    USE(rangeCheck);
    if ((num < 0) || (num >= numDc))
      {
      sprintf(ErrMsg(), "bias channel number out of range");
      return (ngcbMOD_ERR);
      }
    dc[num].voltReg = value;
    return (Success());
  }

  virtual int VoltageRegClk(int num, int l, int value, int rangeCheck = 1) {
    USE(rangeCheck);
    if ((num < 0) || (num >= numClk))
      {
      sprintf(ErrMsg(), "clock channel number out of range");
      return (ngcbMOD_ERR);
      }
    clk[num].level[l].voltReg = value;
    return (Success());
  }

  virtual int VoltageErrDC(int num, double volt) {
    if ((num < 0) || (num >= numDc))
      {
      sprintf(ErrMsg(), "bias channel number out of range");
      return (ngcbMOD_ERR);
      }
    dc[num].comp = volt;
    return (Success());
  }

  virtual int VoltageErrClk(int num, int l, double volt) {
    if ((num < 0) || (num >= numClk))
      {
      sprintf(ErrMsg(), "clock channel number out of range");
      return (ngcbMOD_ERR);
      }
    clk[num].level[l].comp = volt;
    return (Success());
  }

  virtual double TelCurrent(int chan) {
    USE(chan);
    return (0.0);
  }

  virtual int TelDC(int num, double *volt) {
    if ((num < 0) || (num >= numDc))
      {
      sprintf(ErrMsg(), "bias channel number out of range");
      return (ngcbMOD_ERR);
      }
    *volt = dc[num].volt;
    return (Success());
  }

  virtual int TelClk(int num, int l, double *volt) {
    if ((num < 0) || (num >= numClk))
      {
      sprintf(ErrMsg(), "clock channel number out of range");
      return (ngcbMOD_ERR);
      }
    *volt = clk[num].level[l].volt;
    return (Success());
  }

  virtual int TelClk(int num, ngcdcs_clkv_t *cv) {
    int j;
    for (j=0;j<ngcdcsCLDC_DCLK;j++)
      {
      double volt;
      if (TelClk(num, j, &volt) != Success())
    {
    return (ngcbMOD_ERR);
    }
      else
    {
    cv->volt[j] = volt;
    }
      }
    return (Success());
  }

  virtual int Snapshot() {return (Success());}

  virtual char *VStatusString() {return statStr_;}

  virtual int VStatus(int *s) {*s = 0x0; return (Success());}    

  virtual int LoadCfgFile(const char *fileName = NULL) {
    if (fileName != NULL)
      {
      if (strlen(fileName) > 0)
    {
    strcpy(cfgFile, fileName);
    ngcbCleanPath(cfgFile);
    toggle = (toggle + 1) % 2;  // to trace update
    }
      else
    {
    cfgFile[0] = '\0';
    toggle = (toggle + 1) % 2;  // to trace update
    }
      }
    return (Success());
  }

  virtual int SaveCfgFile(const char *fileName) {
    USE(fileName);
    return (Success());
  }

  virtual int SaveErrFile(const char *fileName) {
    USE(fileName);
    return (Success());
  }

  virtual int Restore(const char *keyword) {
    USE(keyword);
    return (Success());
  }

  virtual int SetupKey(const char *key, const int *idx, const char *value,
               int *status = NULL);

  virtual int StatusKey(const char *key, const int *idx, char *value, 
            int *status = NULL);
 
protected:
private:
  char statStr_[32];

  int calibrated_;

  void Init_() {
    int i;
    vstat = ngcbCLDC_STAT_DISABLED;
    memset(statStr_, 0, sizeof(statStr_));
    strcpy(statStr_, "disabled");
    autoEnable = 0;
    autoDisable = 0;
    ilck = 0; ilckOn = 0; protection = 0; protectionOn = 1;
    autoCal = 0;
    calMax = ngcdcsCLDC_CAL_MAX;
    calibrated_ = 0;
 
    clk = NULL;
    clkTel = NULL;
    dc = NULL;
    dcTel = NULL;
    margin = ngcdcsCLDC_VDIFF_MAX;
    dacTime = 10.0;
    cvg1 = 1.0;
    cvg2 = 1.0;
    cvOffset = 0.0;
    haveCurrentTel = 0;
 
    serNoBoard[0] = '\0';
    serNoTrans[0] = '\0';
 
    if (numClk < 0) numClk = 0;
    if (numClk > ngcbCLDC_MAX_CLK) numClk = ngcbCLDC_MAX_CLK;
    if (numDc < 0) numDc = 0;
    if (numDc > ngcbCLDC_MAX_DC) numDc = ngcbCLDC_MAX_DC;
    if (numClk > 0)
      {
      clk = new ngcdcs_clk_t[ngcbCLDC_MAX_CLK];
      clkTel = new ngcdcs_clkv_t[ngcbCLDC_MAX_CLK];
      if ((clk == NULL) || (clkTel == NULL))
    {
    numClk = 0;
    }
      else
    {
    /*
     * Set default clock values
     */
    for (i=0;i<numClk;i++)
      {
      int j;
      for (j=0;j<ngcdcsCLDC_DCLK;j++)
        {
        sprintf(clk[i].level[j].name, "CLOCK_%d_L%d", i + 1, j);
        clkTel[i].volt[j] = 0.0;
        }
      }
    }
      }
    if (numDc > 0)
      {
      dc = new ngcdcs_dc_t[ngcbCLDC_MAX_DC];
      dcTel = new double[ngcbCLDC_MAX_DC];
      if ((dc == NULL) || (dcTel == NULL))
    {
    numDc = 0;
    }
      else
    {
    /*
     * Set default bias values
     */
    for (i=0;i<numDc;i++)
      {
      sprintf(dc[i].name, "DC-%d", i + 1);
      dcTel[i] = 0.0;
      }
    }
      }
    memset(cfgFile, 0, sizeof(cfgFile));
    voltageInitFile[0] = '\0';
    cfgFile[0] = '\0';
    toggle = 0;
    telFlag = 1;
  }
 
};

class ngcdcsCLDC: public ngcdcsCLDC0
{
public:
  ngcdcsCLDC(const ngcb_route_t &r, int nc, int nb);

  ngcdcsCLDC(ngcbIFC *ifc, const ngcb_route_t &r, int nc, int nb);

  virtual ~ngcdcsCLDC();     

  double offsetClk;

  double offsetDC;                    

  int clkMon1; 

  int clkMon2;                        
  
  double preampOffset;

  double diodeBias;

  double lbnlGain;

  double lbnlOffset;

  double lbnlTelGain;

  double lbnlTelOffset;

  double dacDelay;

  ngcdcs_tel_t tel[ngcdcsCLDC_MAX_TEL];

  ngcbMOD *vcm[ngcdcsCLDC_MAX_CHAN];

  int clkSetupMap[ngcbCLDC_MAX_CLK];

  int dcSetupMap[ngcbCLDC_MAX_DC];

  void BoardType(int b);

  virtual void ClkMap(ngcdcs_clk_t *cv);

  virtual void DcMap(ngcdcs_dc_t *dv);

  void Reset();                       

  int Enable(int check = 1);

  int Disable();

  int Selftest();

  void TimeStamp(int chan);

  int VSetup(int autoCtrl = 0);

  int Check();

  int Calibrate(int noSetup = 0); 

  void ClearCalibration();

  int Calibrated();

  virtual int Adjust(int chan);

  int DacChan(int chan, double volt);  
         
  int VoltageDC(int num, double volt, int rangeCheck = 1); 

  int VoltageClk(int num, int l, double volt, int rangeCheck = 1);

  int VoltageClk(int num, ngcdcs_clkv_t cv, int rangeCheck = 1);

  int VoltageRegDC(int num, int value, int rangeCheck = 1);

  int VoltageRegClk(int num, int l, int value, int rangeCheck = 1); 

  int VoltageErrDC(int num, double volt); 

  int VoltageErrClk(int num, int l, double volt);

  int TelChan(int chan);

  int TelChan();

  virtual int TelChan(int chan, double *volt);

  int TelData(double *volt);
  
  virtual int TelIntern(int sel = -1);

  int TelDC(int num, double *volt);

  int TelClk(int num, ngcdcs_clkv_t *cv); 

  int TelClk(int num, int l, double *volt);

  int Snapshot();

  char *VStatusString(); 

  int VStatus(int *hwStat);

  int OutputEnable();

  int OutputDisable();

  int OutputEnabled();

  int Protection(int flag);

  int Zero(); 

  virtual int Monitor(int num, int clkChan); 

  virtual int OffsetClk(double volt); 

  virtual int OffsetDC(double volt);

  virtual int PreampOffset(double volt); 

  virtual int VideoOffset(double *volt);  

  virtual int DiodeBias(double volt);

  virtual double OffsetClk(); 

  virtual double OffsetDC(); 

  int LoadCfgFile(const char *fileName = NULL);

  int SaveCfgFile(const char *fileName);

  int SaveErrFile(const char *fileName);

  int Restore(const char *keyWord); 

  virtual double ConvertTel(int value);

  virtual int Volt2Reg(double *volt, int chan, double corr = 1.0);

  virtual double Reg2Volt(int reg, int chan, double corr = 1.0);

  virtual int DacReg(int value, int chan);

  virtual void DefaultSetup(const char *keyWord = NULL);

  int SetupKey(const char *key, const int *idx, const char *value,
           int *status = NULL);

  int StatusKey(const char *key, const int *idx, char *value, 
        int *status = NULL);
 
protected:
  int GetTelCfg(size_t start);
 
private:
  void Init_();                                 

  int DAC_(int value, int chan);

  int havePreampDac_;
  
  int ilck_;

  int ctrlReg_;

  void NewStatus_(int newStatus);
 
  char statStr_[32]; 
                   
  ngcbALARM *alarm_;
  
  int revision_;                        

  ngcdcs_clkv_t *clkv_;                 

  double *dcv_;                         

  double offsetClk_;                    

  int offsetRegClk_;                    

  double offsetDC_;                     

  int offsetRegDC_;                     

  int fileBufferLen_;                   

  char fileBuffer_[ngcdcsCLDC_BUFSIZE]; 

  int telChan_;                         

  double *errVec_;                      

  double *dac_;                         

  struct timeval *dacTime_;             

  int btype_;

  int clkChan_;                         

  int calibrated_;                      

  double videoOffset_;                  

  int LoadCfg_(const char *restoreKey, const char *tmpFile); 

  int VoltDiff_(double *volt, int chan1, int chan2, double corr = 1.0); 

  int AutoOffsetClk_(double *off, ngcdcs_clk_t *v);

  int AutoOffsetDC_(double *off,  ngcdcs_clk_t *vc, ngcdcs_dc_t *v);
};
 
#endif