ngcppInt.h

Go to the documentation of this file.

#ifndef ngcppInt_h
#define ngcppInt_h
 
 
#include <ngc/core/ngcb.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef NO_VERBOSE
 
#define ngcppLog(...) ngcbLog(__VA_ARGS__)
 
#else
 
#define ngcppLog(...)
 
#endif

#define ngcppNUM_ELE(x) ((sizeof x) / (sizeof x[0]))

#define ngcppMAX_DATA_CON 16

#define ngcppCI_MAX_CON 4 

#define ngcppCOM_PROT_ENDIAN ngcbBIG_ENDIAN

#define ngcppDATA_PROTOCOL 0x1

#define ngcppDATA_PROT_ENDIAN ngcbBIG_ENDIAN

typedef int ngcpp_link_t;

typedef struct {
  short id;
  
  int pLen;

  char *pBuf;
} ngcpp_cmd_t;

typedef struct {
  short errorId;

  short errorPt;

  int pLen;

  char *pBuf;
} ngcpp_rep_t;

#define ngcppCOM_H_SIZE 8 

#define ngcppREP_H_SIZE 10 

#define ngcppMAX_COMBUFSIZE (8 * 1024) 
 
/*
 * Command/reply message-id
 */
#define ngcppMES_COMMAND   0xffff       
#define ngcppMES_DATA      0x0002       
#define ngcppMES_BACKREPLY 0x0003       
#define ngcppMES_MESSAGE   0x0004       

#define ngcppENV_COMMAND_PORT  "NGCPP_CMD"

#define ngcppENV_DATA_PORT     "NGCPP_DATA"

#define ngcppENV_DATA_PATH     "NGCPP_DPATH"

#define ngcppENV_ERR_PORT      "NGCPP_ERR"

#define ngcppENV_HOST          "NGCPP_HOST"

#define ngcppENV_DEVNAME       "NGCPP_DEV"

#define ngcppCOMMAND_PORT 8001

#define ngcppDATA_PORT 0

#define ngcppERR_PORT  0

#define ngcppNO_TIMEOUT 0

#define ngcppDEFAULT_TIMEOUT ngcppNO_TIMEOUT
 
/*
 * Status definitions
 */
#define ngcppSTAT_IDLE        0  
#define ngcppSTAT_WAITING     1  
#define ngcppSTAT_PROCESSING  2  
#define ngcppSTAT_READY       3  
#define ngcppSTAT_FAILURE     4  

typedef unsigned short ngcpp_t;

#define ngcppRAW_RTD SHORT
 
/*
 * Data types
 */
#define ngcppDTYPE_BYTE    0    
#define ngcppDTYPE_REAL32  1    
#define ngcppDTYPE_REAL64  2    
#define ngcppDTYPE_INT16   3    
#define ngcppDTYPE_INT32   4    
#define ngcppDTYPE_INT64   5    
#define ngcppDTYPE_STRING  6    
#define ngcppDTYPE_UINT16  7    

#define ngcppMAX_FRAME_TYPES         32
 
/*
 * Frame types
 */
#define ngcppFRAME_ANY              0xffffffff 
#define ngcppFRAME_NO_FRAME         0x00000000 
#define ngcppFRAME_SNAPSHOT         0x00000001 
#define ngcppFRAME_DIT              0x00000002 
#define ngcppFRAME_INT              0x00000004 
#define ngcppFRAME_INTERMEDIATE_INT 0x00000008 
#define ngcppFRAME_INTERMEDIATE_DIT 0x00000010 
#define ngcppFRAME_SDV              0x00000020 
#define ngcppFRAME_SAMPLE           0x00000040 
#define ngcppFRAME_HCYCLE1          0x00000080 
#define ngcppFRAME_HCYCLE2          0x00000100 
#define ngcppFRAME_TRACK            0x00000200 
#define ngcppFRAME_NOTIFY           0x00000400 
#define ngcppFRAME_APP              0x00000800 
 
/*
 * Frame names
 */
#define ngcppFRAME_NAME_ANY              "ANY_FRAME"
#define ngcppFRAME_NAME_NO_FRAME         "NO_FRAME"
#define ngcppFRAME_NAME_SNAPSHOT         "SNAPSHOT"
#define ngcppFRAME_NAME_DIT              "DIT"
#define ngcppFRAME_NAME_INT              "INT"
#define ngcppFRAME_NAME_INTERMEDIATE_INT "INTERM-INT"
#define ngcppFRAME_NAME_INTERMEDIATE_DIT "INTERM-DIT"
#define ngcppFRAME_NAME_SDV              "STDEV"
#define ngcppFRAME_NAME_SAMPLE           "SAMPLE"
#define ngcppFRAME_NAME_TRACK            "TRACK"
#define ngcppFRAME_NAME_HCYCLE1          "HCYCLE1"
#define ngcppFRAME_NAME_HCYCLE2          "HCYCLE2"
#define ngcppFRAME_NAME_NOTIFY           "NOTIFY"
#define ngcppFRAME_NAME_APP              "APP"

#define ngcppMAX_PARAMSIZE 256
 
 
/*
 * Parameter types
 */
#define ngcppPARAM_TYPE_LOGICAL 0  
#define ngcppPARAM_TYPE_INT     4  
#define ngcppPARAM_TYPE_FLOAT   1  

typedef char ngcppPARAM_NAMES[ngcppMAX_PARAMSIZE][256];

typedef int ngcppPARAM_VALUES[ngcppMAX_PARAMSIZE];

#define ngcppCOM_TIMEOUT -3
 
/*
 * Command codes
 */
#define ngcppCOM_NOP         400   
#define ngcppCOM_START       401   
#define ngcppCOM_STOP        402   
#define ngcppCOM_STAT        403   
#define ngcppCOM_TIME        404   
#define ngcppCOM_MSET        405   
#define ngcppCOM_PSET        406   
#define ngcppCOM_PSTAT       407   
#define ngcppCOM_PSYNC       408   
#define ngcppCOM_MSYNC       409   
#define ngcppCOM_EXIT        410   
#define ngcppCOM_ICONF       411   
#define ngcppCOM_PCONF       412   
#define ngcppCOM_DYNCMD      413   
#define ngcppCOM_VERBOSE     414   
#define ngcppCOM_SIMTIME     415   
#define ngcppCOM_MCLOSE      416   
#define ngcppCOM_FLUSHOUT    417   
#define ngcppCOM_RSTCNT      418   
#define ngcppCOM_END         419   
#define ngcppCOM_FILEBASE    420   
#define ngcppCOM_FILEPATH    421   
#define ngcppCOM_ERRPORT     422   
#define ngcppCOM_USRCMD      423   
#define ngcppCOM_DATAPORT    424   
#define ngcppCOM_CHIPOFFSET  425   
#define ngcppCOM_PAUSE       426   
#define ngcppCOM_ABORT       427   
#define ngcppCOM_CHAN        428   
#define ngcppCOM_SETDPATH    429   
#define ngcppCOM_GETDPATH    430   
#define ngcppCOM_REV         431   
#define ngcppCOM_SIMDELAY    432   
#define ngcppNUM_COM        (433 - ngcppCOM_NOP)
 
/*
 * Error definitions
 */
#define ngcppERR_NO_ERR              0  
#define ngcppERR_IO_ERROR           -1  
#define ngcppERR_IO_OVERRUN         -2  
#define ngcppERR_IO_OVERFLOW        -3  
#define ngcppERR_GENERAL           400  
#define ngcppERR_NO_VALID_COMMAND  401  
#define ngcppERR_OUT_OF_RANGE      402  
#define ngcppERR_OPEN              405  
#define ngcppERR_ALLOC             406  
#define ngcppERR_TERM              407  
#define ngcppERR_UNKNOWN           408  
#define ngcppERR_STARTED           409  
#define ngcppERR_NOT_STARTED       410  
#define ngcppERR_SYSTEM            411  
#define ngcppERR_TIMEOUT           412  
#define ngcppERR_INIT              413  
#define ngcppERR_CMD               414  
#define ngcppERR_FILIO             415  

#define ngcppERR_HANDSHAKE_REQ     451 

#define ngcppERR_HANDSHAKE_FRAME   452

#define ngcppFAILURE -1

#define ngcppQUEUE_SKIP 0 

#define ngcppQUEUE_BLOCK 1 

#define ngcppQUEUE_SETERR 2  

#define ngcppMAX_DEV 12 
 
/*
 * Input modes
 */
#define ngcppMODE_SIM      1     
#define ngcppMODE_NORMAL   2     
#define ngcppMODE_STREAM   3     
#define ngcppMODE_PLAYBACK 4     

#define ngcppMAX_USRCMD_LEN 1024 
 
/*
 * Dynamic command codes
 */
#define ngcppDYN_CMD_IVLD         0  
#define ngcppDYN_CMD_RESET        1     
#define ngcppDYN_CMD_RESERVED   100  
 
 
/*
 * Pre-defined data-sets (bit-values can be or'ed)
 */
#define ngcppFLATFIELD   1   
#define ngcppBADPIXMASK  2                 
#define ngcppDARK        4                 
 
 
/*
 * Data services
 */
#define ngcppDATA_SERVICE_EXIT      0     
#define ngcppDATA_SERVICE_PING      1     
#define ngcppDATA_SERVICE_CONNECT   2     
#define ngcppDATA_SERVICE_ABORT     3     
#define ngcppDATA_SERVICE_TYPES     4     
#define ngcppDATA_SERVICE_PROCNAME  5     
#define ngcppDATA_SERVICE_TYPEDEF   6     
#define ngcppDATA_SERVICE_EXPORT    7     
#define ngcppDATA_SERVICE_PROTOCOL  8     
#define ngcppDATA_SERVICE_KILL      9     
 
 
/*
 * Transfer modes
 */
#define ngcppTMODE_NOTRANS    0x00  
#define ngcppTMODE_SCIENCE    0x01  
#define ngcppTMODE_VIDEO      0x02   
#define ngcppTMODE_INTR       0x10   
 
/*
 * Transfer flags
 */
#define ngcppTFLAG_SKIP     0x00000000  
#define ngcppTFLAG_TRANSFER 0x00000001  
#define ngcppTFLAG_HOLD     0x00000002  
#define ngcppTFLAG_LOCAL    0x00000004   
 
/*
 * Header FSTAT
 */
#define ngcppFSTAT_TRANSFERRING 0x1  
#define ngcppFSTAT_EXP_END      0x2  
#define ngcppFSTAT_ROT90        0x4  

typedef struct {
  int sx;           
  int sy;           
  int nx;           
  int ny;           
  int bytes;        
} ngcpp_win_t;

typedef struct {
  int bitPix;       
  int nx;           
  int ny;           
  int ftype;        
  int data[16];     
} ngcpp_hdr_simple;

typedef struct {
  int serviceId;    
  int clientId;     
  int tmode;             
} ngcpp_data_service;

typedef struct {
  int type;         
  int blocking;     
  int retransmit;   
  int start_x;      
  int start_y;      
  int nx;           
  int ny;              
} ngcpp_req_t;

typedef struct {
  int transfer;     
  int start_x;      
  int start_y;       
  int nx;           
  int ny;                     
} ngcpp_reqack_t;

#define ngcppAPP_HDR_SIZE 128

typedef struct {
  int dtype;                       
  int ftype;                       
  int start_x;                     
  int start_y;                     
  int nx;                          
  int ny;                          
  int scal;                        
  int cnt;                          
  int setupId;                     
  int err;                         
  int overrun;                     
  int frames;                      
  uint64_t ts;                                   
  float expFactor;                 
  int fstat;                       
  int reserved1;                   
  int appDataSize;                 
  int cnt0;                        
  int bzero;                       
  char appData[ngcppAPP_HDR_SIZE]; 
} ngcpp_hdr_t;

#define ngcppFRAME_H_SIZE (int)(sizeof(ngcpp_hdr_t) - ngcppAPP_HDR_SIZE)
  
#define ngcppFRAME_HX_SIZE 24

typedef struct {
  ngcpp_hdr_t  h;   
  char *fbuf;       
} ngcpp_frame_t; 

typedef struct {
  int type;           
  char name[64];      
  char paramName[64]; 
} ngcpp_ftype;

typedef struct {
  int numDev;                            
  int inputMode[ngcppMAX_DEV];              
  unsigned int dmaStat[ngcppMAX_DEV];        
  int bufSize[ngcppMAX_DEV];              
  int maxDataClients;                    
  int dataClients;                       
  int rcnt[ngcppMAX_DATA_CON];           
  int fcnt[ngcppMAX_DATA_CON];           
  char dataHost[ngcppMAX_DATA_CON][256]; 
  int numFilePub;                        
  int maxCmdClients;                     
  int cmdClients;                        
  char cmdHost[ngcppCI_MAX_CON][256];    
  int frameTypes;                        
  int simTime;                           
} ngcpp_cfg_t;

typedef struct {
  int id;           
  char time[128];   
  char erms[256];   
} ngcpp_error_t;
 
/*
 * Protoypes
 */

int ngcppExec(const char *host, const char *cmd, int xt, int debugPort, 
          int *pid, char *erms);

int ngcppKill(const char *host, int pid, char *erms);

int ngcppComExec(ngcpp_link_t *link, const char *srvName, const char *cmd,
         int xt, int debugPort, int *pid, int *cmdPortReal, 
         char *erms);

int ngcppComKill(const char *host, int pid, char *erms);

int ngcppSelectCom(const char *comType, char *erms);

int ngcppAllocCom(char *erms);

int ngcppOpenComLine(const char *srvName, ngcpp_link_t *link, char *erms);

int ngcppCloseComLine(ngcpp_link_t link);

int ngcppTimeout(ngcpp_link_t link, int seconds, char *erms);

int ngcppSendCommand(ngcpp_link_t link, ngcpp_cmd_t command, char *erms);

int ngcppGetReply(ngcpp_link_t link, ngcpp_rep_t *reply, char *erms);

void ngcppErr(char *erms, int errorId);

int ngcppGetParamSetup(ngcpp_link_t link, int *numParame, 
               ngcppPARAM_NAMES paramName, ngcppPARAM_VALUES paramBuf,
               char *erms);

int ngcppGetParamType(ngcpp_link_t link, const char *paramName, int *type,
              char *erms);

int ngcppSetParam(ngcpp_link_t link, const char *paramName, int value, 
          char *erms);

int ngcppSetParamBuf(ngcpp_link_t link, int *paramBuf, char *erms);

int ngcppGetParam(ngcpp_link_t link, const char *paramName, int *value, 
          char *erms);

int ngcppGetParamBuf(ngcpp_link_t link, int *paramBuf, char *erms);

int ngcppParamSync(ngcpp_link_t link, int timeout, char *erms);

int ngcppSetChipOffset(ngcpp_link_t link, int startX, int startY, 
               char *erms);

int ngcppChanSelect(ngcpp_link_t link, int chan, char *erms);

int ngcppStart(ngcpp_link_t link, char *erms);

int ngcppResetCnt(ngcpp_link_t link, char *erms);

int ngcppEnd(ngcpp_link_t link, char *erms);

int ngcppStop(ngcpp_link_t link, char *erms);

int ngcppPause(ngcpp_link_t link, int pauseFlag, char *erms);

int ngcppAbort(ngcpp_link_t link, char *erms);

int ngcppExitComServer(ngcpp_link_t link, char *erms);

int ngcppConnect(ngcpp_link_t * link, const char *srvName, char *erms);

int ngcppPing(ngcpp_link_t link, char *erms);

int ngcppGetStatus(ngcpp_link_t link, int *status, char *erms);

  int ngcppGetRev(ngcpp_link_t link, int *rev1, int *rev2, char *erms);

int ngcppGetTime(ngcpp_link_t link, double *loopTime, double *calcTime,
         char *erms);

int ngcppSetSimTime(ngcpp_link_t link, int simTime, char *erms);

int ngcppSetSimStartDelay(ngcpp_link_t link, int simTime, char *erms);

int ngcppVerbose(ngcpp_link_t link, int vflag, char *erms);

int ngcppGetConfig(ngcpp_link_t link, ngcpp_cfg_t *config, char *erms);

int ngcppGetErrPort(ngcpp_link_t link, int *errPort, char *erms);

int ngcppGetDataPort(ngcpp_link_t link, int *dataPort, char *erms);

int ngcppGetDataPath(ngcpp_link_t link, char *path, char *erms);

int ngcppSetDataPath(ngcpp_link_t link, const char *path, char *erms);

int ngcppSendDynCmd(ngcpp_link_t link, int cmdCode, int timeout, char *erms);

int ngcppExecUsrCmd(ngcpp_link_t link, const char *usrCommand, 
            char *usrReply, char *erms);

int ngcppMemClose(ngcpp_link_t link, char *erms);

int ngcppMemSync(ngcpp_link_t link, int id, char *erms);

int ngcppUploadBuf(ngcpp_link_t link, char *buf, int id, int size,
           int blockSize, char *erms);

int ngcppFlushOutputQueue(ngcpp_link_t link, char *erms);

int ngcppSetFilePubBase(ngcpp_link_t link, char *baseName, char *erms);

int ngcppSetFilePubPath(ngcpp_link_t link, int id, char *path, char *erms);
 
/*
 * For LCU test
 */

int ngcppLcuRdAddr(ngcpp_link_t link, unsigned int addr, 
           unsigned int *value, char *erms);

int ngcppLcuWrAddr(ngcpp_link_t link, unsigned int addr, 
           unsigned int value, char *erms);

int ngcppLcuRdPci(ngcpp_link_t link, unsigned int addr, 
          unsigned int *value, char *erms);

int ngcppLcuWrPci(ngcpp_link_t link, unsigned int addr, 
          unsigned int value, char *erms);
 
/*
 * Data transfer prototypes
 */

void ngcppDataInit(void);

void ngcppHdrInit(ngcpp_hdr_t *hdr);

int ngcppDataConnect(const char *srvName, int *socket, int transferMode, 
             int processId, char *erms); 

int ngcppDataDisconnect(int socket);

int ngcppPingDataSrv(const char *srvName, char *procName, char *erms);

int ngcppKillDataClient(const char *srvName, int id, char *erms);

int ngcppDataProtocol(const char *srvName, int *version, char *erms);

int ngcppAbortReq(const char *srvName, int processId, char *erms);

int ngcppCancelReq(int socket, int processId, char *erms);

int ngcppSendDataRequest(int socket, ngcpp_req_t request, char *erms);

int ngcppWaitDataReply(int socket, ngcpp_hdr_t *header, char *erms);

int ngcppWaitNextFrame(int socket, ngcpp_req_t request, 
               ngcpp_hdr_t *header, char *erms);

int ngcppPollNextFrame(int socket, ngcpp_req_t request, 
               ngcpp_hdr_t *header, char *erms);

int ngcppSkipFrame(int socket, char *erms);

int ngcppAcceptFrame(int socket, ngcpp_req_t request, ngcpp_frame_t *frame, 
             char *erms);

int ngcppAcceptFrameN(int socket, ngcpp_req_t request, ngcpp_frame_t *frame,
              int partNo, int numDiv, char *erms);

int ngcppAckFrame(int socket, ngcpp_req_t request, ngcpp_hdr_t *header, 
          char *erms);

int ngcppGetFrameBuf(int socket, ngcpp_frame_t *frame, size_t offset, 
             size_t size, char *erms);

int ngcppGetTypeDef(const char *srvName, int *nTypes, ngcpp_ftype *frameType,
            char *erms);

int ngcppGetFrameTypes(const char *srvName, int *types, char *erms);

void ngcppScale(ngcpp_frame_t *frame);

void ngcppScale2Real(ngcpp_frame_t *frame);

void ngcppScaleBuf(void *dest, ngcpp_frame_t *frame);

void ngcppScaleBuf2Real(void *dest, ngcpp_frame_t *frame);
  
int ngcppGetFrameTypeByName(int *type, const char *name, char *erms);

int ngcppGetFrameNameByType(int type, char *name, char *erms);

int ngcppAttachData(char *srvName, size_t bufferSize, char *erms);

int ngcppDetachData(char *srvName);

ngcpp_hdr_simple *ngcppImportData(void **buffer, char *erms);

int ngcppReturnData(char *erms);

typedef struct {
  int numParam;                    
  ngcppPARAM_NAMES paramName;      
  char format[ngcppMAX_PARAMSIZE]; 
  ngcppPARAM_VALUES paramBuf;      
  int timeout;                     
  int status;                      
  void *applData;                  
} ngcpp_link_cfg_t;

typedef int (*ngcppMSG_OPEN)(const char *name, ngcpp_link_cfg_t *cfg, char *erms);

typedef int (*ngcppMSG_CLOSE)(int link, ngcpp_link_cfg_t *cfg);

typedef int (*ngcppMSG_CMD)(int link, ngcpp_cmd_t command, char *erms);

typedef int (*ngcppMSG_REPLY)(int link, ngcpp_rep_t *reply, char *erms);

typedef struct {
  unsigned int cmdBufSize;    
  unsigned int replyBufSize;  
  ngcppMSG_OPEN open;         
  ngcppMSG_CLOSE close;       
  ngcppMSG_CMD sendCommand;   
  ngcppMSG_REPLY getReply;    
} ngcpp_cmd_client_api;
 
 
/*
 * Global variables
 */

extern int ngcppEndian;

extern ngcpp_cmd_client_api *ngcppSys;      

extern ngcpp_cmd_client_api ngcppCmdTcpClient;      

extern ngcb_sig_t ngcppSigMask;
 
#ifdef __cplusplus
}
#endif
 
#endif