ngcdcsSRV.hpp

Go to the documentation of this file.

#ifndef ngcdcsSRV_H
#define ngcdcsSRV_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <ngc/core/ngcb.h>
#include <ngc/core/ngcbShell.h>
#include <ngc/core/ngcbSIO.hpp>
#include <ngc/core/ngcbIFC.hpp>
#include <ngc/core/ngcbPARAM.hpp>
#include <ngc/core/ngcbCMD.hpp>
#include <ngc/core/ngcbATTR.hpp>
#include <ngc/core/ngcbDIC.hpp>
#include <ngc/core/ngcbTMPFILE.hpp>
#include <ngc/core/ngcdcsACQ.hpp>
#include <ngc/core/ngcdcsTCCD.hpp>
#include <ngc/core/ngcdcsCTRL.hpp>
#include <ngc/core/ngcdcsCFG.hpp>
#include <ngc/core/ngcdcsEXP.hpp>
#include <ngc/core/ngcdcsEXPDRV.hpp>
#include <ngc/core/ngcdcsMRGLIST.hpp>
 
#ifdef VLT_CCS
 
/*
 * Server states
 */
#include "evhStates.h"
#define ngcdcsSTATE_OFF      evhSTATE_OFF     //< OFF-state
#define ngcdcsSTATE_LOADED   evhSTATE_LOADED  //< LOADED-state
#define ngcdcsSTATE_STANDBY  evhSTATE_STANDBY //< STANDBY-state
#define ngcdcsSTATE_ONLINE   evhSTATE_ONLINE  //< ONLINE-state
 
/*
 * Error definitions
 */
#include "ngcdcsErrors.h"
 
#else
 
/*
 * Server states
 */
#define ngcdcsSTATE_OFF          1  //< OFF-state
#define ngcdcsSTATE_LOADED       2  //< LOADED-state
#define ngcdcsSTATE_STANDBY      3  //< STANDBY-state
#define ngcdcsSTATE_ONLINE       4  //< ONLINE-state
 
/*
 * Error definitions
 */
#define ngcdcsERR_SYSTEM         1  //< general system error
#define ngcdcsERR_IO             2  //< i/o-error
#define ngcdcsERR_INIT           3  //< initialization error
#define ngcdcsERR_WARNING        4  //< just a warning
#define ngcdcsERR_FATAL          5  //< fatal error forcing exit
#define ngcdcsERR_DB_READ        6  //< database read failed
#define ngcdcsERR_DB_WRITE       7  //< database write failed
#define ngcdcsERR_DB_INIT        8  //< database initialization failed
#define ngcdcsERR_ACQ_IO         9  //< acquisition process i/o-error
#define ngcdcsERR_ACQ_OVERRUN   10  //< run-time error: buffer overrun
#define ngcdcsERR_ACQ_OVERFLOW  11  //< run-time error: FIFO overflow
#define ngcdcsERR_ACQ_EXEC      12  //< acquisition process exec failed
#define ngcdcsERR_EXP_IO        13  //< exposure data chain i/o-error
#define ngcdcsERR_EXP_FILE      14  //< exposure file i/o-error
#define ngcdcsERR_EXP_PROC      15  //< exposure post-processing error
#define ngcdcsERR_ACCESS        16  //< missing access rights
#define ngcdcsERR_MERGE         17  //< data merging failed
#define ngcdcsERR_CLDC          18  //< CLDC protection error
#define ngcdcsERR_AOBIAS        19  //< AOBIAS protection error
#define ngcdcsERR_NGSDBIAS      20  //< NGSDBIAS protection error
 
#endif

#define ngcdcsGUI_DEFAULT "ngcgui"
 
/*
 * Server sub-states
 */
#define ngcdcsSUBSTATE_NONE       0  //< not yet set (unknown)
#define ngcdcsSUBSTATE_IDLE       1  //< idle 
#define ngcdcsSUBSTATE_BUSY       2  //< busy 
#define ngcdcsSUBSTATE_ACTIVE     6  //< exposure active
#define ngcdcsSUBSTATE_ERROR      8  //< error 
 
#define ngcdcsSUBSTATE_READY      3  //< ready 
#define ngcdcsSUBSTATE_NOT_READY  4  //< not ready
#define ngcdcsSUBSTATE_INIT       5  //< initializing
#define ngcdcsSUBSTATE_RECOVER    7  //< recovering
#define ngcdcsSUBSTATE_RUNNING    9  //< acquisition running
 
/*
 * Server operational modes
 */
#define ngcdcsOPMODE_NORMAL   0  //< normal mode (accessing DFE)
#define ngcdcsOPMODE_HWSIM    1  //< simulation mode (accessing DWS, no DFE)
#define ngcdcsOPMODE_LCUSIM   2  //< simulation mode (local simulation, no DWS)

#define ngcdcsMERGE_MAX_PROC 4

#define ngcdcsMAX_LOG 50
 
/*
 * Log levels
 */
#define ngcdcsLOG_INFO   0  //< informal log
 
/*
 * Error test cases
 */
#define ngcdcsTESTERR_BLOCK  0x800 //< service blocks forever

struct ngcdcs_wait_t {
  int fd;  //< File descriptor for reply
  int id;  //< Waiter id

  ngcdcs_wait_t() {fd = -1; id = 0;}

  virtual ~ngcdcs_wait_t() {}
};

struct ngcdcs_srvinfo_t {
  struct timeval startTime; //< Server start time
  unsigned int nExpStart;   //< Number of exposures started
  unsigned int nExpCompl;   //< Number of exposures completed
  unsigned int nExpAbort;   //< Number of exposures aborted
  unsigned int nExpFail;    //< Number of exposures failed
  unsigned int nFram;       //< Number of processed data frames
  unsigned int nFile;       //< Number of files stored

  ngcdcs_srvinfo_t() {
    ngcbGetTime(&startTime);
    nExpStart = 0; nExpCompl = 0; nExpAbort = 0; nExpFail = 0; 
    nFram = 0; nFile = 0;
  }
};

class ngcdcsEVT
{
public:
  int id;      //< Event id
  int devices; //< Device list (32-bit list)
  int status;  //< Event status

  ngcdcsEVT() {id = -1; devices = 0x0; status = ngcbEVT_PENDING;}

  explicit ngcdcsEVT(int i) {id = i; devices = 0x0; status = ngcbEVT_PENDING;}

  ngcdcsEVT(int i, int d) {id = i; devices = d; status = ngcbEVT_PENDING;}

  virtual ~ngcdcsEVT() {}
 
protected:
private:
};

class ngcdcsALARM_SYS: public ngcbALARM_SYS
{
public:
  ngcbSERVICE *services; //< System services
  int verboseLevel;      //< Verbose level
  int logLevel;          //< Logging level

  ngcdcsALARM_SYS() : services(NULL),
              verboseLevel(0),
              logLevel(0),
              id_((ngcb_alarm_id)0L) {}
  
  virtual ~ngcdcsALARM_SYS() {}

  ngcb_alarm_id Issue(ngcbALARM *a) {
    Store(a, ++id_);
    if (services != NULL)
      {
      char logMsg[512];
      sprintf(logMsg, "ALARM(%s)-%lu: %s (%s)\n", a->Name(), id_, 
          a->Msg(), a->Value(1));
      if (verboseLevel > 0) services->Logger(ngcbVB_PRINT, logMsg);
      services->Logger(ngcbVB_LOG, logMsg); // we always log the alarm
      }
    return (id_);
  }

  void Cancel(ngcb_alarm_id id) {
    ngcbALARM *a = Get(id);
    if (a != NULL)
      {
      if ((services != NULL) &&  ((verboseLevel > 0) || (logLevel > 0)))
    {
    char logMsg[64];
    sprintf(logMsg, "ALARM(%s)-%lu: cancelled\n", a->Name(), id);
    if (verboseLevel > 0) services->Logger(ngcbVB_PRINT, logMsg);
    if (logLevel > 0) services->Logger(ngcbVB_LOG, logMsg);
    }
      }
    Remove(id);
  }

  void Ack(ngcb_alarm_id id) {
    ngcbALARM *a = Get(id);
    if (a != NULL)
      {
      a->Ack();
 
      if ((services != NULL) && ((verboseLevel > 0) || (logLevel > 0)))
    {
    char logMsg[64];
    sprintf(logMsg, "ALARM(%s)-%lu: acknowledged\n", a->Name(), id);
    if (verboseLevel > 0) services->Logger(ngcbVB_PRINT, logMsg);
    if (logLevel > 0) services->Logger(ngcbVB_LOG, logMsg);
    }    
      }
    Remove(id);
  }
 
protected:
private:
  ngcb_alarm_id id_;
};

class ngcdcsSRV: public ngcbSIO, public ngcbCMD_SRV, private ngcdcsACQ_SERVICE
{
public:
  ngcdcsSRV();                             

  explicit ngcdcsSRV(ngcdcsCTRL *controller);  

  virtual ~ngcdcsSRV();                   
 
 
  /*
   * System configuration
   */
  
  int forceStartup;

  int detIndex; 

  char thisHost[64]; 

  int maxDfeMod; 

  int deviceEvents;

  ngcbLIST evtList;

  int EvtAddWait(int fd, int id);

  ngcdcs_syscfg_t sysCfg; 

  char configDir[256];  

  int CfgPath(char *path, const char *cfgFile);

  int ConfigureSystem(ngcdcs_syscfg_t newCfg, int copy = 1); 

  int Check(const ngcdcs_syscfg_t &cfg);

  int SysCfg(const char *cfgFile); 
         
  void SysCfgDefault(const char *cfg);

  int InitSysCfg(const char *cfgFile);

  int StoreCfg(const char *fileName);
 
 
  /*
   * System shutdown
   */

  void Release();

  void Shutdown(); 

  FILE *watchdog;
 
 
  /*
   * System info
   */

  void Info(char *s);

  void SysInfo(char *s);

  void ModInfo(char *s);

  void BoardInfo(char *s);

  int AdcInfo(int id, char *s);

  int AcqInfo(int id, char *s);

  void RpcTranslate(void *payload, size_t size, int request, int how, char *s);

  void CheckDev(int idx, char *s);

  int GetPat(int id, int num, char *s);

  int GetPrg(int id, int num, char *s);

  int CheckTriggerPeriod(int id, double period);
 
 
  /*
   * Detector configuration
   */

  ngcdcs_detcfg_t detCfg;

  int Check(const ngcdcs_detcfg_t &cfg);

  int DetCfg(const char *cfgFile); 
 
 
  /*
   * Controller Interface
   */

  ngcdcsCTRL *ctrl;

  ngcbIFC *ctrlDev[ngcdcsCTRL_MAX_DEV];

  int RouteComp(ngcbMOD *, ngcbMOD *);

  ngcdcsTCCD *tccd[ngcdcsTCCD_MAX_PROC];

  int numTccdMod;
 
 
  /*
   * Acquisition module
   */

  ngcdcsACQ *acq[ngcdcsACQ_MAX_PROC];

  int numAcqMod;

  int FrameHandler(void *buffer, ngcdcs_finfo_t *finfo, char *erms);

  int FitsMerger(ngcbFITS *hdr, char *erms); 

  int Statistics(int id, char *s);

  int AcqProc(int id, const char *procName);

  int Rtd(int idx);

  int FrameGen(int id, const char *name, int flag);

  int FrameStore(int id, const char *name, int flag);

  int FrameLocal(int id, const char *name, int flag);

  int FrameExport(int id, const char *name, int flag);

  int FrameBreak(int id, const char *name, int n);

  int FrameWin(int id, const char *name, int sx, int sy, int nx, int ny);

  void GetFrames(int id, char *s);
 
 
  /*
   * Read-out modes
   */
 
  int readModeId;

  char readModeName[64];

  int updateReadModeList;

  int ReadModeIdx(int id);    

  int ReadModeIdx(const char *name);

  int ReadMode(int idx);      
 
 
  /* 
   * Exposure handling
   */

  ngcdcsEXP exposure;

  int FitsBlock();

  int PrepareFits(int refresh = 1);

  int DumpFits(const char *fileName = NULL);

  int CheckExp();

  void ExpStatus(unsigned int newStat, const char *erms = NULL);

  void ExpStatus2String(char *s, int stat);

  void ExpStatus2String(char *s);

  char *ExpStatusString();

  int RecStart(const char *id, double absTime = 0.0);

  int ExpStart(int acqId = 0, double absTime = 0.0); 

  int ExpAbort(int acqId = 0); 

  int ExpEnd(int acqId = 0);

  int ExpPause(int id = 0); 

  int ExpCont(int id = 0); 

  int ExpAddWait(int fd, int id);

  void ExpPoll();

  int PostProcEnabled();

  void Publish(const ngcdcs_exp_topic &topic);

  uint64_t FramesProcessed();

  uint64_t SizeRecorded();

  double TimeElapsed();

  double RemainingTime();
 
 
  /* 
   * Exposure driver
   */

  ngcdcsEXPDRV *expDrv;  

  void ExpDrvStatus(unsigned int newStat);

  int ExpDrvLoad(const char *module, const char *name = NULL);

  int ExpDrvUnload(const char *name, const char *symbol = NULL);

  int ExpDrvUnload();

  int ExpDrvLoaded(const char *module);

  int ExpDrvCfg(const char *s);

  void ExpDrvList(char *s);

  void ExpDrvModList(char *s);

  char expDrvFeedBack[128];

  int ExpDrvSelect(const char *name);

  int ExpDrvClose();

  int ExpDrvStart();

  int ExpDrvAbort();

  int ExpDrvAddWait(int fd);
 
 
  /*
   * Data merger
   */

  int autoMerge; 

  int concurrentMerge; 

  ngcdcsMRGLIST mergeList;

  int mergeDisplay; 

  int mergeVerify; 

  int mergeInvalidate;

  int mergeChunk;

  char mergeArg[128]; 

  virtual void MergeReset(int relaunch = 0);

  virtual int MergeStart(const char *name, int display, int id, int cleanup=0);

  virtual int MergeStop(int id);

  virtual int MergeStatus(int id, char *stat = NULL);

  virtual int MergeMsg(int id, char *msg);

  virtual void MergeNext();

  int MergeAlign();
 
 
  /*
   * Server state
   */

  char opMode[32]; 

  int integrityCheck; 
  
  int state;  

  char stateString[32];

  void State(int newState, int update = 1);

  int subState;  

  char subStateString[32]; 

  void SubState(int newState);

  void ClearSubState(); 

  int ErrState();

  int OpMode(int level);

  int OpMode(const char *mode);

  int OpenDebugConnection();

  int CloseDebugConnection(); 

  int polling; 

  int pollInterval;

  int HIRES_TIMER;

  void DevPoll();
 
  int HaveLocalEvents();

  virtual void Query();

  virtual void PollStatConfigure(int enable, int interval);

  virtual void HiResTimer(int enable);

  void FatalError(const char *erms);

  int FatalError();                    

  double LifeTime();

  int Disable();
  
  int NeedEnableCycle();

  int Enable(int check);
  
  int Off();

  int Recover();

  int ResetDfe();

  int ResetSensors();
 
 
  /*
   * Server setup
   */

  void Profile(const char *name = NULL);

  void ProcName(const char *name);

  const char *ProcName();

  void PrintUsage();

  int ParseArguments(int argc, char **argv);

  const char *Version();

  void ExportVersion(const char *newVersion);
  
  void Port(int port);

  void Instance(const char *name);

  char *Instance();

  void ExecShell(const char *name);

  const char *DicList();

  char *ErrMsg();

  void SaveErr(const char *erms); 

  const char *LastErr();

  int ShutdownService(int port);

  char gui[256];                               
 
 
  /* 
   * Verbose output and logging
   */

  FILE *debugStream;                           

  ngcbALARM_SYS *alarmSystem;

  int fitsLogLevel;

  int fitsLogPeriod;

  void Logger(int flag, const char *msg);

  int Xterm();

  int VerboseLevel();

  void VerboseLevel(int level);

  int LogLevel();

  void LogLevel(int level);

  void Verbose(int level, const char *format, ...)
    __attribute__ ((format(printf, 3, 4)));

  void Verbose(const char *fromat, ...)
    __attribute__ ((format(printf, 2, 3)));

  void Log(int level, const char *format, ...)
    __attribute__ ((format(printf, 3, 4)));

  void Log(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));

  void ErrLog(int severity, const char *format, ...)
    __attribute__ ((format(printf, 3, 4)));

  void Print(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));

  void AddLog(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));

  int ConfigureLogging(int vb, int log, int xt);

  int DebugStream(int flag);

  void BroadcastAlarm(const char *msg);

  void ClrLog();
    
  void CatLog(char *s);
 
 
  /*
   * Module event handlers
   */
  
  void DeviceEvent(void *origin, void *event);

  void DevError(const char *erms, int id, void *descriptor);

  void AcqError(const char *erms, int id, void *descriptor);
 
 
  /* 
   * Database
   */

  char dbPoint[256]; 

  void DisableDbMirror();
  
  int DbAdd(ngcbATTR *attr);

  void DbExport();

  int DbConfigure();

  int Update(); 

  virtual void DbLock();

  virtual void DbUnlock();      
 
 
  /*
   * Command services
   */

  int AddCmd(const char *cmd, ngcb_function_t function, int flags, 
         const char *syntax, const char *help);

  void DelCmd(const char *cmd);

  int Execute(const char *cmd, char *reply, int protect = 0, int fd = -1);

  int Execute(const char *cmd, int protect = 0, int fd = -1);

  int Macro(const char *fileName, char *reply, int protection = 0);

  int SimError(int error, int idx = 0);
 
 
  /*
   * Server main-loop
   */

  virtual void ExitSignal(int sig); 

  int Initialize(); 

  int Reset();

  void Abort(); 

  int InMainLoop();

  int SrvPortOrig();

  int CoreShell();

  int MainLoop(); 

  void LockService();

  void UnlockService();
 
 
  /*
   * Run-Control
   */

  int autoRestart;              

  int AcqStop(int id = 0);

  int AcqStart(int id = 0);

  int SeqIdle(int id = 0); 

  int SeqWaiting();         

  int SeqStop(int id = 0);

  int SeqStart(int id = 0, struct timeval *ts = NULL, double absTime = 0.0);

  int SeqTrigger(int id);

  int SeqPause(int id = 0);

  int SeqContinue(int id = 0);

  int SeqBreak(int id = 0);

  int SeqWait(int id, int event, int timeout, int interval);

  void ClearState(int id = 0);

  void StoreState();

  int RestoreState();

  int ShutterAction(int id, const char *action, char *reply);

  int TecAction(int id, const char *action, char *reply);

  int GeosnapAction(int id, const char *action, char *reply);
 
 
  /*
   * Parameter handling
   */

  ngcbDIC dictionary;

  ngcbPARAM_LIST *ParamList();

  int ParamDefault(); 

  int LoadSetup(const char *fileName, char **list, int *listLength, 
        int max = -1);

  int LoadSetup(const char *fileName);

  ngcbPARAM *ParamDefine(const char *name, const char *value, int id,
             int *status = NULL); 

  int ParamDefine(const char *name, const char *value, const char *unit);

  void ParamUndefine(const char *name, int id);

  int SetupList(const char *paramBuf);

  int SetupList(char **paramBuf, int size);

  int SetupList(ngcbPARAM_LIST *list);

  int SetupParam(const char *name, const char *value); 

  int StatusList(const char *list, char *reply);

  int StatusList(char **list, int size, char *reply);

  int StatusParam(const char *name, char *value);

  int ParamLookup(const char *name, char *value, int flag = 0); 

  int updateParam; 
 
 
  /*
   * Module factories
   */

  ngcdcsCLDC *CldcMod(const char *spec, ngcbIFC *dev,
              const ngcb_route_t &route,
              int nc, int nb, double extRef);

  ngcdcsSEQ *SeqMod(const char *spec, ngcbIFC *dev, const ngcb_route_t &route,
            ngcbPARAM_LIST *p);

  ngcdcsADC *AdcMod(const char *spec, ngcbIFC *dev, const ngcb_route_t &route, 
            int num, int bitPix);

  virtual ngcdcsSHUTTER *ShutterMod(const char *spec, ngcbIFC *dev, 
                    const ngcb_route_t &route);

  virtual ngcdcsPREAMP *PreampMod(const char *spec, ngcbIFC *dev, 
                  const ngcb_route_t &route);

  ngcdcsNGC2 *NGC2Mod(const char *spec, ngcbIFC *dev, 
              const ngcb_route_t &route);

  ngcdcsAO *AOMod(const char *spec, ngcbIFC *dev, const ngcb_route_t &route);

  ngcdcsLISA *LISAMod(const char *spec, ngcbIFC *dev,
              const ngcb_route_t &route);

  ngcdcsNGSD *NGSDMod(const char *spec, ngcbIFC *dev, 
              const ngcb_route_t &route, double extRef);

  ngcdcsTEC *TECMod(const char *spec, ngcbIFC *dev, const ngcb_route_t &route);

  ngcdcsGEOSNAP *GeosnapMod(const char *spec, ngcbIFC *dev, const ngcb_route_t &route);

  ngcdcsSCA *ScaMod(const char *spec, ngcbIFC *dev, const ngcb_route_t &route, 
            ngcbPARAM_LIST *p);

  ngcdcsACQ *AcqMod(const char *spec, const ngcdcs_acq_cfg_t &cfg, 
            ngcbPARAM_LIST *p);
 
 
  /*
   * ASIC mapping
   */

  int numSeqFn;

  int numCldcFn;
  
  ngcdcsSEQ0* SeqFn(int idx);             

  ngcdcsCLDC0* CldcFn(int idx);
 
 
  /*
   * CLDC functions
   */

  int CldcEnable(int id);

  int CldcDisable(int id);

  int CldcDefault(int id);

  int CldcCheck(int id);

  int CldcCalibrate(int id);

  int CldcClearCalibration(int id);

  int CldcRestore(int id, const char *key = NULL);

  int Snapshot(int id, char *s);

  int Telemetry(int id, char *s);

  void Voltages(ngcdcsCLDC0 *mod, char *s);
 
 
  /*
   * Selftests
   */

  int SelftestCldc(int id);

  int SelftestSeq(int id);

  int SelftestAdc(int id);

  int SelftestShutter(int id);

  int SelftestPreamp(int id);

  int SelftestSca(int id);

  int SelftestAcq(int id);
 
protected:
  virtual ngcbCMD_LIST *CreateCmdList();

  virtual void InstallSignalHandlers();

  virtual int ResolvePath(char *resolved, const char *fileName);
  
  virtual void SysCfgOverride(ngcdcs_syscfg_t *newCfg);

  virtual int ConfigureSystemCB1(ngcdcs_syscfg_t &newCfg);

  virtual int ConfigureSystemCB2(ngcdcs_syscfg_t &newCfg);

  virtual int LoadSysCfg(ngcdcs_syscfg_t *newCfg, const char *fileName);

  virtual int LoadDetCfg(ngcdcs_detcfg_t *newCfg, const char *fileName); 

  virtual void ShutdownSystemCB1();

  virtual void ShutdownSystemCB2();

  virtual void MergeInit();

  virtual int LookupCB(const char *paramName, char *value); 

  size_t ppStackSize;

  virtual int FrameHandlerCB(void *buffer, ngcdcs_finfo_t *finfo, char *erms);

  virtual int FitsMergerCB(ngcbFITS *hdr, char *erms);

  int HandleExpEvt();                               

  virtual int ExpStartCB();               

  virtual int ExpCountDownCB();               

  ngcdcsEXPDRV *ExpDrv(const char *name, const ngcb_fb_t &feedBackChannel);

  virtual void AgEvent(int acqInst, ngcdcs_2ag_t ag, int errorId, 
              const char *erms);

  virtual void ErrorEvent(int id, const char *erms); 

  virtual void ErrLogEvent(int id, const char *erms);

  virtual void VerboseCB(const char *msg, int level = ngcdcsLOG_INFO);

  virtual void LogCB(const char *msg, int level = ngcdcsLOG_INFO);

  virtual void DbLogCB(const char *msg); 

  void DbLog(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));

  virtual int DbConfCB();

  virtual int DbUpdateCB(); 
    
  virtual void PublishExpEvent(int errorId, unsigned int newStat, 
                   const char *fileName, int merge, 
                   const char *erms);

  virtual void PublishLogPars();

  virtual void PublishState();

  virtual void PublishSubState();

  virtual void PublishExpDrvStatus();
 
 
  /*
   * TCP/IP services
   */

  virtual int AddSockCB(int fd);

  virtual int DelSockCB(int fd);   
 
 
  /*
   * Module creation hooks
   */

  virtual ngcdcsCLDC *MakeCLDC(ngcbIFC *dev, const ngcb_route_t &route,
                   int nc, int nb);

  virtual ngcdcsC20B20 *MakeC20B20(ngcbIFC *dev, const ngcb_route_t &route, 
                   int nc, int nb);

  virtual ngcdcsB24 *MakeB24(ngcbIFC *dev, const ngcb_route_t &route, int nb);

  virtual ngcdcsC24 *MakeC24(ngcbIFC *dev, const ngcb_route_t &route);

  virtual ngcdcsAPD *MakeAPD(ngcbIFC *dev, const ngcb_route_t &route, int nb);

  virtual ngcdcsAOBIAS *MakeAOBIAS(ngcbIFC *dev, const ngcb_route_t &route, 
                   int nb);

  virtual ngcdcsALBIAS *MakeALBIAS(ngcbIFC *dev, const ngcb_route_t &route, 
                   int nb);

  virtual ngcdcsLISABIAS *MakeLISABIAS(ngcbIFC *dev, const ngcb_route_t &route, 
                       int nb);

  virtual ngcdcsNGSDBIAS *MakeNGSDBIAS(ngcbIFC *dev, 
                       const ngcb_route_t &route, 
                       int nb, double extRef);

  virtual ngcdcsSEQ *MakeSEQ(ngcbIFC *dev, const ngcb_route_t &route, 
                 ngcbPARAM_LIST *p);
    
  virtual ngcdcsADC *MakeADC(ngcbIFC *dev, const ngcb_route_t &route, int num, 
                 int bitPix);

  virtual ngcdcsSHUTTER *MakeSHUTTER(ngcbIFC *dev, const ngcb_route_t &route);

  virtual ngcdcsPREAMP *MakePREAMP(ngcbIFC *dev, const ngcb_route_t &route);

  virtual ngcdcsNGC2 *MakeNGC2(ngcbIFC *dev, const ngcb_route_t &route);

  virtual ngcdcsAO *MakeAO(ngcbIFC *dev, const ngcb_route_t &route);

  virtual ngcdcsLISA *MakeLISA(ngcbIFC *dev, const ngcb_route_t &route);

  virtual ngcdcsNGSD *MakeNGSD(ngcbIFC *dev, const ngcb_route_t &route, 
                   double extRef);

  virtual ngcdcsTEC *MakeTEC(ngcbIFC *dev, const ngcb_route_t &route);

  virtual ngcdcsGEOSNAP *MakeGeosnap(ngcbIFC *dev, const ngcb_route_t &route);

  virtual ngcdcsSCA *MakeSCA(ngcbIFC *dev, const ngcb_route_t &route, 
                 ngcbPARAM_LIST *p);

  virtual ngcdcsACQ *MakeACQ(const ngcdcs_acq_cfg_t &cfg, ngcbPARAM_LIST *p);
 
 
  /*
   * Call-backs from ngcbSIO
   */

  int ProtocolAscii(int fd);

  int ProtocolBin(int fd);

  int FdCB(int fd);

  int NewEventConnection(int fd);
  
  int TimerCB();                
 
private:
  void Init_();
  
  int initialized_;

  char erms_[256];

  char versionString_[256];

  char thisVersion_[256];

  struct timeval t0_; 

  char testParam_[256];        

  char procName_[128];

  int srvCmdPort_;

  int srvEvtPort_;

  char profile_[32];
  
  ngcb_port_t service_[8];
  
  int services_;

  ngcbSEM *semService_; 

  int endian_;

  ngcbSHMDB *tcpdb_;

  int executor_; 

  char instance_[64]; 

  int nativeCtrl_;

  int aborted_;
       
  pthread_t serviceThread_;
 
  /* 
   * Debugging functions
   */

  ngcbSEM *semVerbose_; 

  ngcbSEM *semFrame_; 

  void VbLock_();

  void VbUnlock_(); 
           
  int debugConnection_;

  int OpenDebugStream_();

  void CloseDebugStream_();

  void AlignLogging_(); 

  void InternalLog_(const char *msg);
  
  char lastErrMsg_[512]; 

  int verboseLevel_; 

  int logLevel_; 

  char *logMsg_[ngcdcsMAX_LOG];
  
  int nlog_;

  int plog_;

  ngcdcsALARM_SYS alarmSystem_;

  int localHost_; 

  int xterm_; 

  ngcdcs_srvinfo_t info_;

  ngcbTMPFILE *sdebug_;

  int debugPort_;
 
 
  /*
   * User Interfaces
   */

  int shell_;  

  int coreShell_;

  int shellPid_; 

  void ExternalShell_();

  int guiPid_;                 

  void GUI_();
 
 
  /*
   * Error handling
   */

  int fatalError_;

  int telemetryError_; 

  int acqRtError_;             

  int MapError_(int id, ngcbOBJ *obj);

  void DevErrState_(const char *msg, int id, ngcbIFC *dev, ngcbMOD *mod);
  
  void AcqErrState_(const char *msg, int id, ngcdcsACQ *mod);
 
 
  /*
   * Parameter handling
   */

  char dicList_[256];
  
  char *dicBuf_;

  int dicIdx_;

  ngcbPARAM_LIST paramList_;

  ngcbPARAM_LIST dicParam_;

  int locked_;

  void AttachDic_(ngcbPARAM_LIST *list);

  int ApplyParamList_(ngcbPARAM_LIST *list, int noBackup = 0);
  
  int ApplyDefaultSetup_(const char *fileName, int id);

  int SetupParam_(const char *name, const char *value, int *status = NULL);

  int SetupDEV_(const char *name, const char *value, int *status = NULL);

  int SetupSEQ_(const char *name, const char *value, int *status = NULL);

  int SetupCLDC_(const char *name, const char *value, int *status = NULL);

  int SetupADC_(const char *name, const char *value, int *status = NULL);

  int SetupNGC2_(const char *name, const char *value, int *status = NULL);

  int SetupAO_(const char *name, const char *value, int *status = NULL);

  int SetupLISA_(const char *name, const char *value, int *status = NULL);

  int SetupNGSD_(const char *name, const char *value, int *status = NULL);

  int SetupTEC_(const char *name, const char *value, int *status = NULL);

  int SetupGeosnap_(const char *name, const char *value, int *status = NULL);

  int SetupPREAMP_(const char *name, const char *value, int *status = NULL);

  int SetupSHUT_(const char *name, const char *value, int *status = NULL);

  int SetupSCA_(const char *name, const char *value, int *status = NULL);

  int SetupSCA_();

  int SetupACQ_(const char *name, const char *value, int *status = NULL);

  int StatusParam_(const char *name, char *value);

  int StatusDEV_(const char *name, char *value, int *status);

  int StatusSEQ_(const char *name, char *value, int *status);

  int StatusCLDC_(const char *name, char *value, int *status);

  int StatusADC_(const char *name, char *value, int *status);

  int StatusNGC2_(const char *name, char *value, int *status);

  int StatusAO_(const char *name, char *value, int *status);

  int StatusLISA_(const char *name, char *value, int *status);

  int StatusNGSD_(const char *name, char *value, int *status);

  int StatusTEC_(const char *name, char *value, int *status);

  int StatusGeosnap_(const char *name, char *value, int *status);

  int StatusPREAMP_(const char *name, char *value, int *status);

  int StatusSHUT_(const char *name, char *value, int *status);

  int StatusSCA_(const char *name, char *value, int *status);

  int StatusACQ_(const char *name, char *value, int *status);

  int StatusCHIP_(const char *name, char *value, int *status);

  int GroupList_(ngcbPARAM_LIST *list);

  void IgnoreErr_(int flag);

  int ParamList2PP_();

  int SlxCfg_();
 
 
  /*
   * Configuration
   */

  char sysCfgFile_[256];

  ngcbPARAM_LIST *sysCfgPreset_;

  ngcdcsRTD *rtd_;

  int aoCameraType_;
  
  int InitialCfg_();
  
  void SysCfgPreset_(const char *name, const char *value);

  int AcqChipMap_(int *n, int *d, ngcdcs_detcfg_t cfg);

  void DefaultFrames_(ngcdcs_syscfg_t *cfg);

  int configured_;

  int needShutdown_;

  ngcbCMD_LIST *cmdList_;

  int InstallCommands_();

  int ReferenceCheck_();

  int haveLoadedState_;
 
  /*
   * Exposure handling
   */

  char expStatStr_[32];

  double lastExposureTime_;

  int fitsBlock_; 

  ngcdcsSUBFRM subFrames_;

  ngcdcs_wait_t waitObj_[ngcbSIO_MAX_CON];
  
  ngcdcs_wait_t expDrvWaitObj_[ngcbSIO_MAX_CON];

  ngcdcs_wait_t evtWaitObj_[ngcbSIO_MAX_CON]; 
  
  void ComputeExpTime_();  

  char expLastFile_[256];                   

  int postProcEnabled_;

  int hires_;

  int hiresSkip_;

  int mrgEvtPid_; 
  
  int Chip2Fits_(ngcbFITS *f, int idx);

  int expDrvSetup_;

  int HaveFrame_();

  int HaveBreakCond_();

  int ExpDrvFeedBack_(ngcb_fb_t *fb);

  void ExpDrvInit_();

  void ExpDrvNext_();

  int MergeList_();
 
 
  /*
   * Some convenience functions
   */

  int SeqDwellTime_(int id, int factor, int add);

  int SeqClkFile_(int id, const char *fileName);

  int SeqPrgFile_(ngcdcsSEQ0 *mod, const char *fileName = NULL);

  int SeqWin_(int id, ngcdcs_win_t win);

  int AcqProc_(int id, const char *procName);

  int AcqBurst_(int id, int num);

  void AcqWinMap_(int id, int *fx, int *fy, int *sx, int *sy);

  int AcqCheckRestart_(ngcbPARAM *p);
 
 
  /*
   * Run-control
   */
  int resetFlag_;  

  int Online_(int update = 1);

  int SeqBreakTmo_(int id = 0);
    
  int SeqStartSync_(int id); 

  int SeqStopSync_(int id, int force = 0);

  int seqRestart_[ngcdcsCTRL_MAX_SEQ];

  int AcqStop_(int id);

  int subStateSaved_;       

  int traceSubState_;       

  int dbSubState_;       

  void SubState2String_(int st, char *s);

  int seqBreak_; 

  int seqBreakTmo_;    

  int acqExecMap_[ngcdcsACQ_MAX_PROC]; 

  ngcdcsSEQ_EMU *seqEmu_;
 
 
  /* 
   * Database
   */

  int dbMirror_;

  ngcbDB db_;
  
  ngcbATTR *attr_[ngcbDB_MAX_ATTR];

  ngcbSEM *semDb_;
  
  int DbUpdate_();

  void DbUpdateParam_(int fd = -1);

  void DbUpdateReadModeList_(int fd = -1);

  void DbUpdateFrames_(int id, int fd = -1);
 
  /*
   * Implemented commands
   */
 
  int ExecAck_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAcq_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAcqCmd_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAcqInfo_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAcqProc_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAdc_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAdcInfo_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAoClk_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAoGain_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAoReset_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecAoShift_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecBoardInfo_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecCatLog_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecCheckDev_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecCheckPat_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecCheckSeq_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecCheckTim_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecCldc_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecClkMon_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecClose_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDacChan_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDataKill_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDictionary_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDisable_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDiskCreat_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDiskDel_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDwellTime_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecHelp_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDebug_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDefine_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecEnable_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecEvtPort_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecEvtWait_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecExit_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecExpDrv_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecExpStart_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecExpEnd_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecExpAbort_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecExpPause_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecExpCont_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecDump_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecFrame_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecGetFrames_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecGetPat_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecGetSeq_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecInfo_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecInit_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecIor_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecIoTest_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecIow_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecLastErr_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecLd_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecLdClk_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecLdSeq_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecLock_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecUnlock_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecLogin_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecLogout_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecMacro_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecMerge_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecMinPulse_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecModInfo_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecNop_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecOff_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecOpen_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecPatClk_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecPinfo_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecPing_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecPrgInit_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecPrgParam_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecPrgRun_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecPrgStep_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecPulseCnt_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecRecover_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecReadAddr_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecReset_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecResetDfe_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecResetDev_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecRestore_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecRpc_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecRtd_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSave_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSaveClk_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSaveVoltages_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSaveErrVoltages_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecScaRead_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecScaWrite_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSDebug_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSensReset_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSeq_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSeqWait_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSetTime_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSetup_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecShutter_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSimErr_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSimulat_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecStart_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecState_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecStatistics_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecStatus_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecStop_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecStopSim_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecGeosnap_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecSysInfo_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecTask_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecTec_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecTel_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecTelChan_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecTelData_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecTest_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecTestAddr_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecTsu_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecTimeout_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecVersion_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecVget_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecWait_(ngcb_cmd_handle_t *handle, char *reply);
  int ExecWriteAddr_(ngcb_cmd_handle_t *handle, char *reply);

  int inMacro_;
  
  int Execute_(const char *cmd, char *reply, int protect, int fd);

  int EventHandler_(const char *msg, char *reply);

  void DeviceEvent_(ngcbIFC *dev, ngcb_evt_st_t *event);
 
  /*
   * Exposure steps
   */
  int ExpStepInit_();         //< initialize exposure
  int ExpStepWiping_();       //< wiping step
  int ExpStepIntegrating_();  //< integrating step
  int ExpStepReading_();      //< reading step

  int ExpStateHandler_();      

  int ExpStepTriggered_(int stat);
 
};

void ngcdcsSrvBreakHandler(int sig);

void ngcdcsSrvExitHandler(int sig);

int ngcdcsCfg2Arg(int argc, char **argv, char *argStr);
 
#endif