ngcdcsACQ_DATA.hpp

Go to the documentation of this file.

#ifndef ngcdcsACQ_DATA_H
#define ngcdcsACQ_DATA_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/ngcbDrv.h>
#include <ngc/core/ngcbOBJ.hpp>
#include <ngc/core/ngcppInt.h>
#include <ngc/core/ngcdcsFINFO.hpp>

struct ngcdcs_acq_cfg_t {
  int cmdPort;

  int dataPort;

  int errPort; 

  int numDataClient; 

  int joinerDelay; 

  int transferMode;

  int connect;

  int exp;  

  char host[64];   

  char dev[ngcppMAX_DEV][128]; 

  int seqIdx; 

  char name[64];

  char spec[64];       

  ngcdcs_acq_cfg_t() {
    char *evar;
    int i;
 
    dataPort = 0;      // chosen by system
    cmdPort = 0;       // chosen by system
    errPort = 0;       // chosen by system
    numDataClient = 2; // two clients (RTD and SERVER)
    joinerDelay = -1;  // use system default
    transferMode = ngcppTMODE_SCIENCE; // oldest frame in queue
    connect = 1;       // data connection enabled
    exp = 1;           // exposures enabled
    seqIdx = 0;        // associated to first sequencer
 
    evar = getenv("HOSTNAME");
    if (evar != NULL) str2str(host, evar, sizeof(host) - 1);
    else strcpy(host, "localhost");
 
    name[0] = '\0';
    spec[0] = '\0';
 
    sprintf(dev[0], ngcbDMA_DEFAULT_DEVICE);
    for (i=1;i<ngcppMAX_DEV;i++) dev[i][0] = '\0';
  }
};

struct ngcdcs_acqreq_t {
  int type;

  int sx;
  
  int sy;

  int nx;

  int ny;
  
  ngcdcs_acqreq_t() {
    type = ngcppFRAME_ANY;
    sx = 1; sy = 1; nx = 0; ny = 0;
  }
};

struct ngcdcs_framedef_t {
  int type;

  char name[64];

  char paramName[64]; 

  int defined;

  int gen;

  int store;

  int expCnt;

  int breakCnt;

  int first;

  int last;

  int breakCond; 

  int local; 

  int sx; 

  int sy;

  int nx;

  int ny; 

  ngcbSEM *sem;          

  ngcdcsCUBE cube;
       
  int store_x;

  int gen_x;   

  int breakCond_x;       

  int export2Shm;       

  ngcdcs_framedef_t() {
    type = 0;
    name[0] = '\0';
    paramName[0] = '\0';
    sem = NULL;
    defined = 0;
    gen = 0;
    store = 0;
    expCnt = 0;          // always initialize to zero at exposure start
    breakCnt = 0;        // always initialize to zero at exposure start
    first = 0;           // always initialize to zero at exposure start
    last = 0;            // always initialize to zero at exposure start
    breakCond = 0;       // no break condition (take all until exp.-end)
    local = 0;           // do not store to locla media
    sx = 1;              // take frame as it is
    sy = 1;              // take frame as it is
    nx = 0;              // take frame as it is
    ny = 0;              // take frame as it is
    store_x = -1;        // invalidate
    gen_x = -1;          // invalidate
    breakCond_x = -1;    // invalidate
    export2Shm = 1;      // export to shared memory
  }
};

class ngcdcsACQ_DATA: public ngcbOBJ
{
public:
  ngcdcsACQ_DATA();

  explicit ngcdcsACQ_DATA(const ngcdcs_acq_cfg_t &cfg);

  virtual ~ngcdcsACQ_DATA();     

  int ioError;  

  int numDet; 

  int protocolVersion;

  int scale2float;

  void Configure(const ngcdcs_acq_cfg_t &newConf);

  ngcdcs_acq_cfg_t *Cfg();           

  int Initialize();

 
  int Open();

  int Close();  

  int Kill(int id);

  int Fd();
  
  int BitPix(int dataType);

  int FrameDef(ngcdcs_framedef_t *frameDef);

  int AvailableFrames(); 

  int FrameType(const char *name);

  int FrameIdx(int ftype); 

  void FrameName(char *name, int ftype); 

  void FrameParam(char *paramName, int ftype);
  
  void FrameParam(char *paramName, const char *name); 

  void SetRequest(int ftype);

  void SetRequest(int sx, int sy, int nx, int ny); 

  void SetRequest(int ftype, int sx, int sy, int nx, int ny);

  int Request();

  int Request(int ftype); 

  int Request(int sx, int sy, int nx, int ny); 

  int Request(int ftype, int sx, int sy, int nx, int ny);

  int Retransmit();

  int Retransmit(int sx, int sy, int nx, int ny);

  int Cancel(); 

  int Wait();  

  int Skip();  

  int GetFrame(void *buffer, int chipPid = 0); 

  int GetFrame(void *buffer, int sx, int sy, int nx, int ny, 
           int chipId = 0);

  int GetFrame(ngcpp_frame_t *frame, int chipId = 0); 

  int GetFrame(ngcpp_frame_t *frame, int sx, int sy, int nx, int ny, 
           int chipId = 0);
  

  int Accept(int flags=0);

  int Accept(int sx, int sy, int nx, int ny, int flags=0);

  int Receive(void *buffer, size_t offset, size_t size);

  int Receive(ngcpp_frame_t *frame, size_t offset, size_t size);    

  void Scale(ngcpp_frame_t *frame); 

  void Scale(void *buffer, int nx, int ny, int *dataType, int *divisor);

  void Scale(void *buffer, ngcdcs_finfo_t *f); 

  void Scale(void *buffer);

  void Cv16(void *buffer);  

  void Cv16(void *buffer, ngcdcs_finfo_t *f);        

  int Valid();

  int FrameType(); 

  int FrameIdx();   

  void FrameName(char *);

  int DataType(); 

  int Divisor(); 

  int BZERO(); 

  double ExpFactor(); 

  int FrameCounter(); 

  int FrameCounter0(); 

  int SetupId();

  int StartX();

  int StartY(); 

  int NX(); 

  int NY(); 

  int Error();

  size_t NumPix(); 

  size_t FrameSize();

  int DatumSize();

  int BitPix();

  double TimeStamp();

  int Transferring();

  int Term();

  int AppDataSize();

  char *AppData();
 
protected:
 
private:
  void Init_();
          
  ngcdcs_acq_cfg_t cfg_;
  
  int fdData_; 

  int pending_;

  ngcdcs_acqreq_t req_;

  ngcpp_hdr_t header_;  
  
  ngcpp_ftype ftype_[ngcppMAX_FRAME_TYPES]; 

  int numTypes_;

  int types_;             
};
 
#endif