ngcdcsCFG.hpp

Go to the documentation of this file.

#ifndef ngcdcsCFG_H
#define ngcdcsCFG_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <ngc/core/ngcbIFC.hpp>
#include <ngc/core/ngcdcsAO.hpp>
#include <ngc/core/ngcdcsLISA.hpp>
 
/*
 * Built-in configurations
 */
#define ngcdcsCFG_FILE      0  //< configuration from file
#define ngcdcsCFG_FEB       1  //< one front-end-basic board
#define ngcdcsCFG_OPT       2  //< optical system with one FEB
#define ngcdcsCFG_ASIC      3  //< ASIC
#define ngcdcsCFG_AO        4  //< AO camera
#define ngcdcsCFG_NGSD      5  //< NGSD

struct ngcdcs_dev_cfg_t {
  char name[128];

  char env[32];

  char host[64];

  char srv[64];

  char type[64];

  char setup[64];

  int backPlane;

  int sideLink;

  int master; 

  int skip;

  int chain;

  int netTimeout;
               
  ngcb_route_t cfgRoute;

  ngcdcs_dev_cfg_t() {
    strcpy(name, "/dev/ngc0_com");  // default device
    env[0] = '\0';                  // use default environment name
    host[0] = '\0';                 // no host - interface is local
    srv[0] = '\0';                  // use default driver interface process
    type[0] = '\0';                 // default type
    setup[0] = '\0';                // use default setup
    backPlane = 1;                  // default is first back-plane
    sideLink = 0;                   // no side link
    master = 0;                     // no master
    skip = 0;                       // direct connection
    chain = 0;                      // direct connection
    netTimeout = -2;                // apply default timeout
  }
};

struct ngcdcs_cldc_dcf_t {
  char voltageInitFile[256];

  char voltageFile[256];

  double preampOffset;

  double diodeBias;                 

  int ilck;
 
  ngcdcs_cldc_dcf_t() {
    voltageFile[0] = '\0';          // no voltage file given
    voltageInitFile[0] = '\0';      // no initialization file given
    preampOffset = 0.0;             // zero offset
    diodeBias = 0.0;                // zero bias
    ilck = 0;                       // interlock disabled
  }
};

struct ngcdcs_cldc_cfg_t {
  int devIdx; 

  ngcb_route_t route;

  int maxClk;

  int maxDc;

  int autoEnable;

  int autoDisable;

  int ilck;

  int autoCal;

  double margin; 

  double calMax;

  char group[64]; 

  char name[64];

  char spec[64];                    

  ngcdcs_cldc_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    maxClk = ngcbCLDC_FEB_MAX_CLK;  // default maximum
    maxDc = 64;                     // default maximum (TBD)
    autoEnable = 0;                 // no auto-enable
    autoDisable = 0;                // no auto-disable
    autoCal = 0;                    // no auto-calibration
    ilck = 0;                       // interlock disabled
    margin = 0.0;                   // maximum margin (0.0 = disabled)
    calMax = ngcdcsCLDC_CAL_MAX;    // default maximum correction value
    group[0] = '\0';                // no group assigned
    name[0] = '\0';                 // no name assigned
    spec[0] = '\0';                 // no type specifier
  }
};

struct ngcdcs_seq_dcf_t { 
  char clkFile[256];
              
  int timeFactor;

  int timeAdd;

  int continuous;

  int runCtrl; 

  int cvtExt;                       

  int syncExt;                       

  int autoStop;

  ngcdcs_seq_dcf_t() {
    clkFile[0] = '\0';              // no clock-file given
    timeFactor = 1;                 // no global mutliplier
    timeAdd = 0;                    // no global add-value
    continuous = 0;                 // non-continuous mode
    runCtrl = 1;                    // external run-signal
    cvtExt = 1;                     // external convert  
    syncExt = 1;                    // external SYNC-pulse 
    autoStop = 1;                   // automatic stop
  }
};

struct ngcdcs_seq_cfg_t {
  int devIdx;
       
  ngcb_route_t route;

  double clock;

  int softMon;
             
  char group[64];

  char name[64];

  char spec[64];                    
  
  ngcdcs_seq_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    clock = 10e-9;                  // default clock is 10 nanoseconds
    softMon = 0;                    // no soft-monitor
    group[0] = '\0';                // no group assigned
    name[0] = '\0';                 // no name assigned
    spec[0] = '\0';                 // no type specifier
  }
};

struct ngcdcs_adc_dcf_t {
  int delay; 

  double offset;

  int enable;

  int simMode;

  int opMode;

  int packetSize;

  int packetCnt;

  int convert1;

  int convert2; 

  int clamp;

  int filter;                      

  ngcdcs_adc_dcf_t() {
    delay = 0;                      // no conversion strobe delay
    offset = 0.0;                   // no offset
    enable = -1;                    // enable all
    simMode = ngcbADC_SIM_NUMBERS;  // simulate channel numbers
    opMode = ngcbADC_MODE_NORMAL;   // normal mode (no simulation)
    packetSize = 0;                 // let system choose
    packetCnt = 0;                  // no data from down-link
    convert1 = 1;                   // conversion on strobe 1
    convert2 = 0;                   // no conversion on strobe 2
    clamp = 0;                      // no clamp
    filter = 0;                     // filter = 0.5us
  }
};

struct ngcdcs_adc_cfg_t {
  int devIdx;

  ngcb_route_t route;

  int num;

  int bitPix;

  int firstInChain;

  int packetCnt;

  char group[64];

  char name[64]; 

  char spec[64];                    

  ngcdcs_adc_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    num = 4;                        // 4 ADC units on board
    bitPix = 16;                    // 16-bit ADC
    firstInChain = 1;               // first module in the chain
    packetCnt = 0;                  // no data from down-link
    group[0] = '\0';                // no group assigned
    name[0] = '\0';                 // no name assigned
    spec[0] = '\0';                 // no type specifier
  }
};

struct ngcdcs_shut_cfg_t {
  int devIdx; 

  ngcb_route_t route;

  char name[64];
           
  char spec[64];                    
  
  ngcdcs_shut_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    name[0] = '\0';                 // no name assigned
    spec[0] = '\0';                 // no type specifier
  }
};

struct ngcdcs_pa_cfg_t {
  int devIdx;

  ngcb_route_t route;

  int numChan;

  char group[64];

  char name[64];

  char spec[64];

  double version;                    

  ngcdcs_pa_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    numChan = 4;                    // four channels
    version = 3.0;                  // version 3.0
    group[0] = '\0';                // no group assigned
    name[0] = '\0';                 // no name assigned
    spec[0] = '\0';                 // no type specifier
  }
};

struct ngcdcs_ngc2_cfg_t {
  int devIdx;

  ngcb_route_t route;

  char name[64]; 

  char spec[64];                    

  ngcdcs_ngc2_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    name[0] = '\0';
    spec[0] = '\0';
  }
};

struct ngcdcs_ngc2_dcf_t {
  char initFile[ngcdcsNGC2_MAX_INITFILES][256];

  ngcdcs_ngc2_dcf_t() {
    int i;
    for (i=0;i<ngcdcsNGC2_MAX_INITFILES;i++) initFile[i][0] = '\0';
   }
};

struct ngcdcs_ao_cfg_t {
  int devIdx;

  ngcb_route_t route;

  char name[64]; 

  char spec[64];                    

  ngcdcs_ao_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    name[0] = '\0';
    spec[0] = '\0';
  }
};

struct ngcdcs_ao_dcf_t {
  char initFile[ngcdcsAO_MAX_INITFILES][256];
  
  int delay[42];

  double vsph[4];

  double viph[4];

  int nx;

  int ny;

  int master;

  int hwRev;

  double reDelay[8];

  double feDelay[8];

  ngcdcs_aocal_t calib[4];
  
  ngcdcs_afe_t afe;

  ngcdcsAO_RMP rmp;
 
  // HV-channel map
  int hvChan[4];

  int shpWidth;
  
  ngcdcs_ao_dcf_t() {
    int i;
 
    for (i=0;i<ngcdcsAO_MAX_INITFILES;i++) initFile[i][0] = '\0';
    nx = 240; 
    ny = 240;
    master = 0;
    hwRev = 1;
 
    for (i=0;i<42;i++)
      {
      delay[i] = 0;       // no delay
      }
    for (i=0;i<4;i++)
      {
      vsph[i] = 0.0;      // all levels are zero
      viph[i] = 0.0;      // all levels are zero
      }
    for (i=0;i<8;i++)
      {
      reDelay[i] = 0.0;   // no delay on rising edges
      feDelay[i] = 0.0;   // no delay on falling edges
      }
 
    hvChan[0] = 0;
    hvChan[1] = 2;
    hvChan[2] = 4;
    hvChan[3] = 6;
 
    shpWidth = 9;
  }
};

struct ngcdcs_lisa_cfg_t {
  int devIdx;

  ngcb_route_t route;

  char name[64]; 

  char spec[64];                    

  ngcdcs_lisa_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    name[0] = '\0';
    spec[0] = '\0';
  }
};

struct ngcdcs_lisa_dcf_t {
  char initFile[ngcdcsLISA_MAX_INITFILES][256];

  char gainMap[256];

  int rgAddrTop;

  int rgAddrBot;

  int numRg;

  int chan[12];

  ngcdcs_lisa_dcf_t() {
    int i;
    for (i=0;i<ngcdcsLISA_MAX_INITFILES;i++) initFile[i][0] = '\0';
    gainMap[0] = '\0';;
    rgAddrTop = 0;
    rgAddrBot = 0;
    numRg = 100;
    for (i=0;i<12;i++) chan[i] = 1;
   }
};

struct ngcdcs_ngsd_cfg_t {
  int devIdx;

  ngcb_route_t route;

  char name[64]; 

  char spec[64];                    

  double extRef;

  ngcdcs_ngsd_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    name[0] = '\0';
    spec[0] = '\0';
    extRef = 0.0;
  }
};

struct ngcdcs_tec_cfg_t {
  int devIdx; 

  ngcb_route_t route;

  char name[64];
           
  char spec[64];                    
  
  ngcdcs_tec_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    name[0] = '\0';                 // no name assigned
    spec[0] = '\0';                 // no type specifier
  }
};

struct ngcdcs_geosnap_cfg_t {
  int devIdx; 

  ngcb_route_t route;

  char name[64];
           
  char spec[64];                    
  
  ngcdcs_geosnap_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    name[0] = '\0';                 // no name assigned
    spec[0] = '\0';                 // no type specifier
  }
};

struct ngcdcs_sca_cfg_t {
  int devIdx; 

  ngcb_route_t route;

  int id;   

  char name[64];

  char spec[64];                    
  
  ngcdcs_sca_cfg_t() {
    devIdx = 0;
    route.numHdr = 1;
    route.hdr[0] = 0x2;
    id = 0;
    name[0] = '\0';
    spec[0] = '\0';
  }
};

#define ngcdcsREG_READ  1

#define ngcdcsREG_WRITE 2

struct ngcdcs_reg_t {
  int devIdx;

  ngcb_route_t route;

  int address;

  int mask;

  int shift;

  int mirror;

  char name[64];

  char value[256];

  int access;                

  ngcdcs_reg_t() {
    devIdx = 0;
    address = 0x0;
    mask = 0xffffffff;
    shift = 0;
    mirror = 0x0;
    name[0] = '\0';
    value[0] = '\0';
    access = ngcdcsREG_WRITE | ngcdcsREG_READ;
  }
};

struct ngcdcs_fmp_t {
  char frame[32]; 

  char param[32]; 

  int acq[ngcdcsACQ_MAX_PROC + 1];  
  
  ngcdcs_fmp_t() {
    frame[0] = '\0';
    param[0] = '\0';
    acq[0] = 0;       // all processes
    acq[1] = -1;      // list termination
  }

  int Valid(int idx) {
    int i;
    for (i=0;i<ngcdcsACQ_MAX_PROC;i++)
      {
      if ((acq[i] == 0) || (acq[i] == idx)) return (1);
      else if (acq[i] == -1) break;
      }
    return (0);
  }
};

#define ngcdcsMAX_FRAME_PARAM (ngcdcsMAX_FRAME_TYPES * ngcdcsACQ_MAX_PROC)

struct ngcdcs_alias_t {
  char name[64]; //< Command name
  char cmd[128]; //< Command alias

  ngcdcs_alias_t() {name[0] = '\0'; cmd[0] = '\0';}
};

#define ngcdcsMAX_ALIAS 32

struct ngcdcs_refboard_t {
  char serNo[80];      //< Serial number
  int serNoX;          //< Serial number differs
  char serNoTrans[80]; //< Transition board serial number
  int serNoTransX;     //< Transition board serial number differs
  char serNoBack[80];  //< Backplane serial number
  int serNoBackX;      //< Backplane serial number differs
  char type[64];       //< Board type
  int typeX;           //< Board type differs
  int version;         //< Version
  int versionX;        //< Version differs
  char revision[32];   //< Revision
  int revisionX;       //< Revision differs

  ngcdcs_refboard_t() {Clear();}

  void Clear() {
    serNo[0] = '\0'; serNoTrans[0] = '\0'; serNoBack[0] = '\0';
    serNoX = 0; serNoTransX = 0; serNoBackX = 0;
    type[0] = '\0'; typeX = 0;
    version = 0x0; versionX = 0;
    revision[0] = '\0'; revisionX = 0;
  }

  int Compare() {
    return (serNoX || serNoTransX || serNoBackX || typeX || versionX || 
        revisionX);
  }
};

struct ngcdcs_refdev_t {
  int numBoard;      //< Number of boards
  int numBoardX;     //< Number of boards differs
  char serNo[80];    //< Serial number
  int serNoX;        //< Serial number differs
  char revision[32]; //< Revision
  int revisionX;     //< Revision differs
  ngcdcs_refboard_t board[ngcdcsCTRL_MAX_BOARD]; //< reference boards

  ngcdcs_refdev_t() {Clear();}

  void Clear() {
    int i;
    numBoard = 0; numBoardX = 0;
    revisionX = 0; serNoX = 0;
    revision[0] = '\0'; serNo[0] = '\0';
    for (i=0;i<ngcdcsCTRL_MAX_BOARD;i++) board[i].Clear();
  }
  
  int Compare() {
    int i;
    int x = numBoardX;
    for (i=0;i<numBoard;i++) x = x || board[i].Compare();
    return (x);
  }
};

struct ngcdcs_refsys_t {
  int numDev;   //< Number of devices
  int numDevX;  //< Number of devices differs
  ngcdcs_refdev_t dev[ngcdcsCTRL_MAX_DEV]; //< Reference devices

  ngcdcs_refsys_t() {Clear();}

  void Clear() {
    int i;
    numDev = 0; numDevX = 0;
    for (i=0;i<ngcdcsCTRL_MAX_DEV;i++) dev[i].Clear();
  }

  int Compare() {
    int i;
    int x = numDevX;
    for (i=0;i<numDev;i++) x = x || dev[i].Compare();
    return (x);
  }
};

struct ngcdcs_syscfg_t {
  ngcdcs_dev_cfg_t dev[ngcdcsCTRL_MAX_DEV];
   
  ngcdcs_cldc_cfg_t cldc[ngcdcsCTRL_MAX_CLDC];
   
  ngcdcs_seq_cfg_t seq[ngcdcsCTRL_MAX_SEQ]; 
   
  ngcdcs_adc_cfg_t adc[ngcdcsCTRL_MAX_ADCMOD];
   
  ngcdcs_shut_cfg_t shutter[ngcdcsCTRL_MAX_SHUTTER];

  ngcdcs_pa_cfg_t preamp[ngcdcsCTRL_MAX_PREAMP];
   
  ngcdcs_ngc2_cfg_t ngc2[ngcdcsCTRL_MAX_NGC2];
   
  ngcdcs_ao_cfg_t ao[ngcdcsCTRL_MAX_AO];
   
  ngcdcs_lisa_cfg_t lisa[ngcdcsCTRL_MAX_LISA];
   
  ngcdcs_ngsd_cfg_t ngsd[ngcdcsCTRL_MAX_NGSD];
   
  ngcdcs_tec_cfg_t tec[ngcdcsCTRL_MAX_TEC];
   
  ngcdcs_geosnap_cfg_t geosnap[ngcdcsCTRL_MAX_GEOSNAP];
   
  ngcdcs_sca_cfg_t sca[ngcdcsCTRL_MAX_SCA];
   
  ngcdcs_reg_t reg[ngcdcsCTRL_MAX_REG];

  ngcdcs_acq_cfg_t acq[ngcdcsACQ_MAX_PROC]; 

  ngcdcs_fmp_t fmp[ngcdcsMAX_FRAME_PARAM];

  int numDev; 

  int numCldcMod;

  int numSeqMod;

  int numAdcMod; 

  int numShutterMod;

  int numPreampMod;

  int numNgc2Mod;

  int numAoMod;

  int numLisaMod;

  int numNgsdMod;

  int numTecMod;

  int numGeosnapMod;

  int numScaMod;

  int numAcqMod; 

  int numTccdMod; 

  int sim; 

  int fitsBlock; 

  int extFits;

  int fileFormat; 

  int naming; 

  int oneFile;

  int autoOnline;

  int autoStart; 

  char detCfgFile[256]; 

  char fileName[256]; 

  char dsup[256];

  int polling; 

  int pollInterval; 

  int procMon;

  int largeFile;

  int led;

  int rtdDb;

  ngcdcs_alias_t alias[ngcdcsMAX_ALIAS];

  ngcdcs_refsys_t reference;  

  ngcdcs_refsys_t reference0;  

  char macro[256];
  
  int ditPrecision;

  ngcdcs_syscfg_t() {
    numDev = 0;
    numCldcMod = 0;
    numSeqMod = 0;
    numAdcMod = 0;
    numScaMod = 0;
    numShutterMod = 0;
    numPreampMod = 0;
    numNgc2Mod = 0;
    numAoMod = 0;
    numLisaMod = 0;
    numNgsdMod = 0;
    numTecMod = 0;
    numGeosnapMod = 0;
    numAcqMod = 0;
    numTccdMod = 0;
    sim = 0;
    fitsBlock = 16;
    extFits = 1;
    fileFormat = ngcdcsEXP_FORMAT_SINGLE;
    naming = ngcdcsEXP_NAMING_REQUEST;
    oneFile = 1;
    autoOnline = 0;
    autoStart = 0;
    memset(detCfgFile, 0, sizeof(detCfgFile));
    memset(fileName, 0, sizeof(fileName));
    detCfgFile[0] = '\0';
    fileName[0] = '\0';
    dsup[0] = '\0';
    polling = 0;
    pollInterval = 1000;
    procMon = 1;
    largeFile = 0;
    led = 1;
    rtdDb = 0;
    macro[0] = '\0';
    ditPrecision = 0;
  }
};

#define ngcdcsMAX_RM 32

struct ngcdcs_rm_t {
  int id;

  char name[64];

  char desc[256];  

  char seqPrg[ngcdcsCTRL_MAX_SEQ][256]; 

  char acqProc[ngcdcsACQ_MAX_PROC][256]; 

  char dsup[256]; 

  explicit ngcdcs_rm_t(int n = -1) {
    int i;
    id = n;
    if (id >= 0) sprintf(name, "Mode%d", id);
    else name[0] = '\0';
    desc[0] = '\0';
    for (i=0;i<ngcdcsCTRL_MAX_SEQ;i++) seqPrg[i][0] = '\0';
    for (i=0;i<ngcdcsACQ_MAX_PROC;i++) acqProc[i][0] = '\0';
    dsup[0] = '\0';
  }
};

struct ngcdcs_detcfg_t {
  ngcdcs_seq_dcf_t seq[ngcdcsCTRL_MAX_SEQ];

  ngcdcs_cldc_dcf_t cldc[ngcdcsCTRL_MAX_CLDC];

  ngcdcs_adc_dcf_t adc[ngcdcsCTRL_MAX_ADCMOD];

  ngcdcs_ngc2_dcf_t ngc2[ngcdcsCTRL_MAX_NGC2];
  
  ngcdcs_lisa_dcf_t lisa[ngcdcsCTRL_MAX_LISA];
  
  ngcdcs_ao_dcf_t ao[ngcdcsCTRL_MAX_AO];
  
  ngcdcs_chip_t chip[ngcdcsMAX_DET]; 

  int numDet;

  int haveChipIndex;

  char name[32]; 

  char id[32];

  int numOutput;
                   
  int splitX[ngcdcsACQ_MAX_PROC];

  int splitY[ngcdcsACQ_MAX_PROC];    

  ngcdcs_rm_t rm[ngcdcsMAX_RM];

  int numReadMod; 

  int rmDefault;                    

  char fileName[256];

  char dsup[256];                    

  ngcdcs_win_t win;

  ngcdcs_win_t acqWin[ngcdcsACQ_MAX_PROC];

  ngcdcs_detcfg_t() {
    int i;
    for (i=0;i<ngcdcsACQ_MAX_PROC;i++) {splitX[i] = 0; splitY[i] = 0;}
    numDet = 1;
    numReadMod = 0;
    rmDefault = 0;
    numOutput = 4; 
    strcpy(name, "DET-NAME");
    strcpy(id, "DET-ID");
    memset(fileName, 0, sizeof(fileName));
    fileName[0] = '\0';
    dsup[0] = '\0';
    haveChipIndex = 0;
  }
  
};
 
#endif