ngcdcsSEQ.hpp

Go to the documentation of this file.

#ifndef ngcdcsSEQ_H
#define ngcdcsSEQ_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/ngcbPARAM.hpp>
#include <ngc/core/ngcbDIC.hpp>
#include <ngc/core/ngcdcsCLDC.hpp>
#include <ngc/core/ngcdcsSEQ_PRG.hpp>

#define ngcdcsSEQ_NGCII 0x00010000

#define ngcdcsSEQ_MAX_PAT (ngcbSEQ_PATRAM_SIZE / 4)

#define ngcdcsSEQ_MAX_STATES ngcbSEQ_PATRAM_SIZE
 
/*
 * Sequencer soft states
 */
#define ngcdcsSEQ_STAT_IDLE      0x00000000  //< sequencer idle state
#define ngcdcsSEQ_STAT_WAITING   0x00000001  //< sequencer waiting state
#define ngcdcsSEQ_STAT_RUNNING   0x00000002  //< sequencer running state
#define ngcdcsSEQ_STAT_PAUSED    0x00000004  //< sequencer paused state
#define ngcdcsSEQ_STAT_FAILURE   0x10000000  //< sequencer failure state
 
/*
 * Trigger modes
 */
#define ngcdcsSEQ_TRIGGERMODE_DIRECT  0x0    //< direct trigger mode
#define ngcdcsSEQ_TRIGGERMODE_SHUTTER 0x1    //< shutter mode
 
/*
 * Sequencer control flags alignment
 */
#define ngcdcsSEQ_CTRL_DISABLE  0  //< disable sequencer control flags
#define ngcdcsSEQ_CTRL_ALIGN    1  //< align sequencer control flags

struct ngcdcs_pat_st_t {
  unsigned int low;

  unsigned int high; 

  int time;

  int mod;                  

  ngcdcs_pat_st_t() {low = 0x0; high = 0x0; time = 0; mod = 0;}
};

class ngcdcs_pat_t 
{
public:
  int addr;   

  ngcdcs_pat_st_t *state;

  int numStates;

  int time;

  char name[128];           

  ngcdcs_pat_t() {
    addr = -1;
    numStates = 0;
    time = 0;
    memset(name, 0, sizeof(name));
    state = NULL;
  }

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

class ngcdcs_pat_ld_t : public ngcdcs_pat_t 
{
public:
  ngcdcs_pat_ld_t() {state = new ngcdcs_pat_st_t[ngcdcsSEQ_MAX_STATES];}

  virtual ~ngcdcs_pat_ld_t() {delete[] state;}
 
protected:
private:
};

struct ngcdcs_pat_assign_t {
  int idx;       //< Pattern index
  char name[64]; //< Pattern name

  ngcdcs_pat_assign_t() {idx = 0; name[0] = '\0';}
};

struct ngcdcs_key_assign_t {
  char name[64];   //< Keyword name
  char value[256]; //< Keyword value

  ngcdcs_key_assign_t() {name[0] = '\0'; value[0] = '\0';}
};

struct ngcdcs_win_t {
  int sx;       //< Start pixel in x-direction
  int sy;       //< Start pixel in y-direction
  int nx;       //< Window dimension in x-direction
  int ny;       //< Window dimension in y-direction
  int dx;       //< Chip dimension in x-direction
  int dy;       //< Chip dimension in y-direction
  int rot;      //< Rotation
  int sx_flag;  //< Start pixel in x-direction changed
  int sy_flag;  //< Start pixel in y-direction changed
  int nx_flag;  //< Dimension in x-direction changed  
  int ny_flag;  //< Dimension in y-direction changed
  int rot_flag; //< Rotation has changed

  ngcdcs_win_t() {
    sx = 1; sy = 1;
    nx = 0;  ny = 0;  // full size
    rot = 0; dx = 0; dy = 0;  // no rotation
    sx_flag = 0; sy_flag = 0;
    nx_flag = 0; ny_flag = 0;
    rot_flag = 0;
  }
};

class ngcdcsSEQ0: public ngcdcsCLDC0
{
public:
  double clock; 

  int runCtrl;

  int cvtExt; 

  int syncExt;

  int breakMode;

  int continuous;

  int updateFlag; 

  int new_prgfile; 

  int useBreakTmo; 

  int triggerCtrl; 

  int status; 

  ngcdcs_win_t win;

  char clkFile[256]; 

  char prgFile[256];

  int triggerOn;

  int triggerMode;

  int timeFactor;

  int timeAdd;

  int timeSim;

  int stopDelay;

  double realDit;

  double tim;

  int timAuto;

  int sync;

  int convert[2];

  int autoStop;

  int optimize;

  ngcbDIC *dictionary;
  
  ngcbPARAM_LIST *dicParam;

  ngcbPARAM_LIST postSetup;

  ngcbPARAM_LIST useList;

  FILE *sdebug;

  ngcdcsSEQ0(const ngcb_route_t &r, int nc, int nb) 
    : ngcdcsCLDC0(r, nc, nb) {
    Init_();
  }
  
  ngcdcsSEQ0(ngcbIFC *ifc, const ngcb_route_t &r, int nc, int nb) 
    : ngcdcsCLDC0(ifc, r, nc, nb) {
    Init_();
  }

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

  virtual int RunCtrl(int flag) {
    runCtrl = flag;
    return (Success());
  }

  virtual int CvtExt(int flag) {
    cvtExt = flag;
    return (Success());
  }

  virtual int Convert(int strobe, int flag) {
    if ((strobe == 1) || (strobe == 2)) convert[strobe - 1] = flag;
    return (Success());
  }

  virtual int SyncExt(int flag) {
    syncExt = flag;
    return (Success());
  }

  virtual int Start() {
    numTrigger_ = 0;
    NewStatus(ngcdcsSEQ_STAT_RUNNING);
    return (Success());
  }

  virtual int Pause() {
    NewStatus(ngcdcsSEQ_STAT_PAUSED);
    return (Success());
  }

  virtual int Stop(int align, int force = 0) {
    USE(align); USE(force); 
    NewStatus(ngcdcsSEQ_STAT_IDLE);
    return (Success());
  }  
  
  virtual int Align() {return (Success());}  
  
  virtual int Disarm() {return (Success());}  
  
  virtual int Break(int trigger = 1) {
    USE(trigger);
    return (Stop(ngcdcsSEQ_CTRL_ALIGN, 1));
  }  

  virtual int BreakTimeout(int force = 0) {
    USE(force);
    return (0);
  }

  virtual int Wait(int event, int timeout, int interval) {
    USE(event); USE(timeout); USE(interval);
    return (Success());
  }  
  
  virtual int TriggerOn(int flag) {
    triggerOn = flag;
    return (Success());
  }

  virtual int TriggerMode(int mode) {
    triggerMode = mode;
    return (Success());
  }

  virtual int Trigger(int armed=1) {
    USE(armed);
    numTrigger_++;
    return (Success());
  }           

  virtual int ClearPrgFile() {
    prgFile[0] = '\0';
    return (Success());
  }       

  virtual int LoadPrgFile(const char *fileName = NULL) {
    if (fileName != NULL) str2str(prgFile, fileName, sizeof(prgFile) - 1);
    return (Success());
  }

  virtual int Window(ngcdcs_win_t w) {
    win.sx = w.sx; win.sy = w.sy; win.nx = w.nx; win.ny = w.ny; 
    win.rot = w.rot;
    updateFlag = 1;
    Verbose("ngcdcsSEQ%d: window is [%d,%d,%d,%d] - rot = %d\n", 
        Instance() + 1, win.sx, win.sy, win.nx, win.ny, win.rot);
 
    return (Success());
  }

  virtual void NewStatus(int newStatus) {
    status = newStatus;
    switch (status)
      {
      case ngcdcsSEQ_STAT_IDLE:
        {
    strcpy(statStr_, "idle"); break;
    }
      case ngcdcsSEQ_STAT_RUNNING:
        {
    strcpy(statStr_, "running"); break;
    }
      case ngcdcsSEQ_STAT_PAUSED:
        {
    strcpy(statStr_, "paused"); break;
    }
      case ngcdcsSEQ_STAT_WAITING:
        {
    strcpy(statStr_, "waiting"); break;
    }
      case ngcdcsSEQ_STAT_FAILURE:
        {
    strcpy(statStr_, "failure"); break;
    }
      default:
        {
    strcpy(statStr_, "unknown"); break;
    }
      }
  }

  virtual char *StatusString() {return statStr_;}

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

  virtual int RunningState() {
    return ((status != ngcdcsSEQ_STAT_IDLE) && 
        (status != ngcdcsSEQ_STAT_FAILURE));
  }

  virtual int FailureState() {return (status == ngcdcsSEQ_STAT_FAILURE);}
  
  virtual ngcb_evt_t Event(int stat) {
    ngcb_evt_t e;
    e.board = route.Board();
    e.addr = ngcbDFE_ADDR_STAT;
    e.mask = ngcbDFE_STAT_SEQ;
    e.cond = 1;
    switch (stat) 
      {
      case ngcdcsSEQ_STAT_RUNNING:
        {
    e.reference = e.mask;
    break;
    }
      default:
        {
    e.reference = ~e.mask;
    break;
    }
      }
    return (e);
  }

  virtual int DwellTime(int f, int a) {
    timeFactor = f; timeAdd = a;
    return (Success());
  }

  virtual int TimeFactor(int f) {
    timeFactor = f;
    return (Success());
  }
  
  virtual int TimeAdd(int a) {
    timeAdd = a;
    return (Success());
  }

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

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

  virtual unsigned int NumTrigger() {return (0);}

  virtual unsigned int BlindTrigger() {return (0);}
  
  virtual unsigned int LostTrigger() {return (0);}
 
protected:
 
private:
  char statStr_[32];

  int numTrigger_;

  void Init_() {
    status = ngcdcsSEQ_STAT_IDLE;
    strcpy(statStr_, "idle");
    clock = 10e-9;  // default clock is 10 nanoseconds
    runCtrl = 1;
    cvtExt = 1;
    breakMode = 0;
    continuous = 0;
    memset(clkFile, 0, sizeof(clkFile));
    memset(prgFile, 0, sizeof(prgFile));
    clkFile[0] = '\0';
    prgFile[0] = '\0';
    triggerOn = 0;
    triggerMode = ngcdcsSEQ_TRIGGERMODE_DIRECT;
    timeFactor = 1;
    timeAdd = 0;
    timeSim = 1;
    updateFlag = 0;
    new_prgfile = 0;
    useBreakTmo = 0;
    triggerCtrl = 1;
    numTrigger_ = 0;
    realDit = 0.0;
    tim = 0.0;
    timAuto = 0;
    autoStop = 1;
    sync = 0x2; // disbled by default
    stopDelay = 5; // 5 milliseconds
    syncExt = 1;
    convert[0] = 1;
    convert[1] = 1;
    dictionary = NULL;
    dicParam = NULL;
    sdebug = NULL;
    optimize = 0;
  }
};

class ngcdcsSEQ: public ngcdcsSEQ0
{
public:
  explicit ngcdcsSEQ(const ngcb_route_t &r);

  ngcdcsSEQ(ngcbIFC *ifc, const ngcb_route_t &r);
      
  ngcdcsSEQ(const ngcb_route_t &r, ngcbPARAM_LIST *p);

  ngcdcsSEQ(ngcbIFC *ifc, const ngcb_route_t &r, ngcbPARAM_LIST *p);

  virtual ~ngcdcsSEQ();     

  ngcdcs_pat_t *pattern; 

  ngcdcs_seqp_t program;

  int autoInit;                
 
  int clkMon1;

  int clkMon2;

  int clkMon3;

  int softMon;                 

  int pdu[4];

  int packets[4];

  int bpix[4];

  ngcdcs_slxcfg_t slx;

  int Selftest();
 
  /*
   * Clock patterns
   */

  int ClkState(int idx, int flag);

  int ClkState(int idx);

  int PatTime(const ngcdcs_pat_t &pat, int apply = 1);

  int PatNumStates(const ngcdcs_pat_t &pat);

  void StorePatSetup(); 

  int RestorePatSetup();

  int InitPat(int low, int high);  

  int InitPatLow(int value); 

  int InitPatHigh(int value);

  int InitPatFirst(int n);

  int InitPatLast(int n);  

  int InitPatLow(); 

  int InitPatHigh(); 

  int LastPat(int *low, int *high); 

  int FirstPat(int *low, int *high); 

  int SetupPat(int stopFlag = 1);

  int SetPat(int idx, ngcdcs_pat_t &pat); 

  int GetPat(ngcdcs_pat_t *pat); 

  int GetPat(int idx, ngcdcs_pat_t *pat); 

  int CheckPatRam();

  int GetState(int *low, int *high, int patNum, int stateNum); 

  int SetPatClk(int idx, int clkNum, const char *s);

  void DumpPat(char *reply, const ngcdcs_pat_t &pat);     

  int DwellTime(int factor, int add); 

  int TimeFactor(int factor); 

  int TimeAdd(int add);

  int LoadClkFile(const char *name);

  int SaveClkFile(const char *fileName);          

  virtual int LoadClk(const char *fileName);

  virtual int SaveClk(const char *fileName);          

  int Monitor(int num, int clkChan);                  
 
  /*
   * Sequencer program
   */

  int ExecTime(double *execTime);  
               
  int ExecTime(double *execTime, int *prgCode, int codeAddr, int length);

  int ResolveSubRt(ngcdcs_seqp_t *prg);      
  
  int CleanLoop(ngcdcs_seqp_t *prg);            

  int CheckPrg(const ngcdcs_seqp_t &prg);          

  int CheckSeqRam();          

  int SetPrg(const ngcdcs_seqp_t &prg);             

  int GetPrg(ngcdcs_seqp_t *prg);            

  void DumpCode(char *reply, const ngcdcs_seqp_t &prg, int offset, int length);

  int DumpPrg(char *reply, ngcdcs_seqp_t &prg, int n = -1);  

  int ClearPrgFile();                     

  int LoadPrgFile(const char *name = NULL); 

  virtual int PrgFile(const char *fileName);          

  int Parameters(const char *fileName, char *list);   

  int MinPulse(double *min, int clkNum);            

  int PulseCnt(int *rising, int *falling, int clkNum);        

  int BreakTimeout(int force = 0);          

  int SimPrg(ngcdcsSEQ_EMU *emulator, ngcdcs_ticks_t start, int length);

  int SimSeqTiming(); 

  int SetPdu(int value, int chan = 0);

  int SetPackets(int value, int chan = 0);

  int SetBytesPerPix(int value, int chan = 0);
 
  // Get RTMS frame configuration
  int GetFramCfg(int *pduValue, int *packetsValue, int *bpix, int chan);
 
  /*
   * Sequencer control
   */

  void Reset();                           

  int Enable(int check = 1);

  int Disable();

  int Convert(int strobe, int flag);

  int TriggerOn(int flag);                     

  int TriggerMode(int mode);                   

  int RunCtrl(int flag);                       

  int CvtExt(int flag);                       

  int SyncExt(int flag);                       

  int Start();                            

  int Step();                             

  int Stop(int align, int force = 0);                  

  int Align();

  int Disarm();
  
  int Pause();                            

  int Break(int trigger = 1);                            

  int BreakWait(int timeout, int interval = 100);       
 
  // Poll with timeout until status matches event
  int Wait(int event, int timeout, int interval = 100);   
  
  int Trigger(int armed = 1);                          
 
  
  /*
   * Status
   */

  void NewStatus(int newStatus);                    

  char *StatusString();             

  int Status(int *hwStat);                      

  ngcb_evt_t Event(int stat);

  int RunningState() {
    return ((status != ngcdcsSEQ_STAT_IDLE) && 
        (status != ngcdcsSEQ_STAT_FAILURE));
  }

  int FailureState() {return (status == ngcdcsSEQ_STAT_FAILURE);}

  unsigned int NumTrigger() {return (numTrigger_);} 

  unsigned int BlindTrigger() {return (blindTrigger_);}

  unsigned int LostTrigger() {return (lostTrigger_);}

  virtual int LookupCB(const char *name, char *value); 
  
  int SlxEnable();

  int SlxDisable();

  int ShiftOut(const char *array, int numBits);

  int ShiftOut(const int *array, int numBits);

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

  int SlxStatus(const char *key, const int *idx, char *value, 
        int *status = NULL);
 
protected: 
 
private:
  void Init_();                      

  int revision_;

  ngcbPARAM_LIST *paramList_;        
 
  
  /*
   * Clock patterns
   */

  ngcdcs_pat_st_t patRam_[ngcbSEQ_PATRAM_SIZE];

  ngcdcs_pat_st_t patRamSave_[ngcbSEQ_PATRAM_SIZE];
            
  ngcdcs_pat_t *pattern_;

  int clkMask_[2];

  int initPatLow_;

  int initPatHigh_;

  int initPatLow0_;

  int initPatHigh0_; 

  int initPatNum_;

  int autoInitDone_;

  int InitPat_(int low, int high);

  int AutoInit_(); 

  int patStored_;

  int WritePat_(const ngcdcs_pat_t &pat); 

  int LoadClkBin_(const char *fileName);

  int SaveClkBin_(const char *fileName);

  int LoadClkAscii_(const char *fileName);  

  int SaveClkAscii_(const char *fileName);

  int ResetPatterns_(int clr = 0);     

  int ClockVal_(int c, const ngcdcs_pat_st_t &s);  

  int CheckDwellTime_(int factor, int add);

  int LastPatNum_(const ngcdcs_seqp_t &prg, const int *code, int size);

  int FirstPatNum_(const ngcdcs_seqp_t &prg, const int *code, int size);
 
 
  /*
   * Sequencer program
   */

  int seqRamClr_[3];

  int seqRam_[ngcbSEQ_RAM_SIZE];

  int breakTmo_; 

  int breakTmoFlag_;                    

  int WritePrg_(const ngcdcs_seqp_t &prg);

  int PrgFileBin_(const char *fileName);

  int PrgFileAscii_(const char *fileName, char *setupBuf = NULL);

  void AddSeqIdx_(char *keyWord);

  void DelSeqIdx_(char *keyWord);  

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

  ngcbPARAM *DynParam_(const char *name); 

  int CleanLoop_(int *code, int *codeLength);            

  int LdCode_(const char *fileName, int *code, int *length, 
          ngcdcs_shift_t *shift, char *setupBuf = NULL); 

  int Script_(const char *shell, const char *script, FILE *dbg,
          ngcdcs_key_assign_t *defParam, int numDefParam,
          ngcdcs_key_assign_t *defSubRt, int numDefSubRt,
          ngcdcs_pat_assign_t *defPat, int numDefPat,
          ngcdcs_key_assign_t *newParam, int *numNewParam,
          int *loops);

  int NumWaitStates_(int *prgCode, int codeAddr, int length, int *ret = NULL); 

  int BreakTimeout_(double *timeout); 
 
  /*
   * Status and monitoring
   */

  unsigned int numTrigger_; 

  unsigned int blindTrigger_; 

  unsigned int lostTrigger_;  

  char statStr_[32]; 

  int stopped_;

  int firstRun_; 

  int Start_(int step = 0); 
};
 
#endif