ngcpp.h

Go to the documentation of this file.

#ifndef ngcpp_h
#define ngcpp_h
 
 
 
#ifndef _REENTRANT
#define _REENTRANT    
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
 
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
 
#include <ngc/core/ngcbDrv.h>
#include <ngc/core/ngcbSched.h>
#include <ngc/core/ngcbSocket.h>
#include <ngc/core/ngcppInt.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#define ngcppREV 1

#define ngcppIM_DEFAULT "normal"

#define ngcppMIN_RINGBUFSIZE (1024 * 1024 * 2)

#define ngcppMAX_RINGBUFELE 2048

#define ngcppNUMBUF_AUTO 0

#define ngcppNUMBUF_MAX -1

#define ngcppERR_STACK_SIZE 32
 
/*
 * Realtime scheduling
 */
#define ngcppPRI_CI       20  
#define ngcppPRI_CAPTURE  19  
#define ngcppPRI_PROC     10  
#define ngcppPRI_FILE     10  
 
/*
 * Pixel map operations
 */
#define ngcppMAP_NOP     0  
#define ngcppMAP_FLIPX   1  
#define ngcppMAP_FLIPY   2  
#define ngcppMAP_ROT90   3  
#define ngcppMAP_ROT270  4  

typedef int (*ngcpp_ci_t)(ngcpp_cmd_t, ngcpp_rep_t *, char *);
 
/*
 * Command handler result codes
 */
#define ngcppCMD_FAILURE -1  
#define ngcppCMD_SUCCESS  0  
#define ngcppCMD_EXIT     1  
#define ngcppCMD_ABORT    2  
#define ngcppCMD_DATA     3  

typedef int (*ngcppPCHECK)(int *, int, int *);

typedef void (*ngcppEXT_CMD)(const char *, char *);

extern ngcppPCHECK ngcppParamCheck;

#define ngcppPARAM_IDX(a,b) (int)(((unsigned long)&a-(unsigned long)b)/sizeof(int))
   
typedef void (*ngcppSIM)(ngcpp_t **buf, int size, int num, int *p);
   
typedef void (*ngcppSIM64)(ngcpp_t **buf, size_t size, int num, int *p);

extern ngcppEXT_CMD ngcppUsrCmdHandler;
   
extern ngcppSIM ngcppSimBuf;
   
extern ngcppSIM64 ngcppSimBuf64;

#define ngcppCHOP_ZERO 1          

#define ngcppFS_PORT 8067

#define ngcppFS_DEFAULT_BOOK_ID 1

#define ngcppMIN_COR_TIME 20

#define ngcppPI 3.14159265358979323846

#define ngcppWRAP_CNT 0xffffffff

#define ngcppWRAP_INC(x) if(*x==ngcppWRAP_CNT){*x=0;}else{(*x)++;}

#define ngcppWRAP_DEC(x) if(*x==0){*x=ngcppWRAP_CNT;}else{(*x)--;}

#define ngcppWRAP_DIFF(x,a,b) if(b<a){*x=(ngcppWRAP_CNT-a)+b;}else{*x=b-a;}

typedef struct {
  double alpha;  
  double delta;  
} ngcpp_fs_angle_t;

typedef struct {
  int bookId;              
  int relative;            
  ngcpp_fs_angle_t angle;  
} ngcpp_fs_t;

typedef struct {
  int id;                           
  unsigned char **buf;           
  uint64_t *ts;                          
  int idxProc;                           
  int idxIn;                     
  int num;                           
  size_t size;                   
  ngcb_dma_t dma;                         
  unsigned int last;                   
  unsigned int next;                    
  size_t dmaSize;                                
  int allocated;                 
  int mode;                      
  char devName[256];                     
  int semLckId;                              
  int simFd[2];                  
  ngcb_thread_t captureThreadId; 
  int initialized;                           
  char erms[256];                            
  ngcb_sema_t semStart;                 
  ngcb_sema_t semStartAck;         
  ngcb_sema_t semCap;                  
  ngcb_sema_t semCapAck;             
  ngcb_sema_t semInit;                
  ngcb_sema_t semClient;              
  ngcb_sema_t semClientStart;    
  ngcb_sema_t semClientInit;      
  int streamSocket;              
} ngcpp_dma_t;

typedef struct {
  const char **id;    
  int num;            
} ngcpp_param_t;

typedef struct {
  char *name;   
  int code;     
} ngcpp_dcmd_t;
 

typedef struct {
  int fd;       
  off_t offset; 
  size_t size;   
} ngcpp_dmbuf_t;

typedef struct {
  ngcpp_hdr_t  h;          
  ngcpp_hdr_t  *hr;       
  char **fbuf;          
  char **fbuf_;           
  int qptr;             
  int dptr;                  
  int nbuf;             
  int nbuf_;            
  int *oreq;                 
  int *oreq1;           
  int priority;         
  unsigned int *cnt;    
  ngcb_lock_t *lck;     
  int init;                
  int noSort;               
  int noWin;            
  int fileId;           
  int transfer;         
  int map;              
  unsigned int txSize;  
  ngcb_sema_t txSig;    
  int vidQ;             
} ngcppFRAME;

typedef struct {
  int bufIdx;           
  int frameIdx;         
  int waiting;          
  int abortReq;         
  int flushed;          
  ngcb_sema_t semFrame;   
} ngcppDATA_XFER;

typedef struct {
  int freeCon;          
  unsigned int port;     
  int clientId;         
  uint32_t hostId;      
  int clientSocket;      
  int transferMode;     
  ngcb_thread_t thid;     
  ngcb_sema_t semData;  
  ngcb_sema_t semInit;   
} ngcppDATA_CON;

typedef struct {
  int ndit;             
  int ncycles;          
  int hcyc;             
  int sdv;              
  int iint;             
  int cycSkip;          
  int cycSync;          
  int cycSum;           
  int startSkip;        
  int setupId;           
  uint64_t ts;           
} ngcpp_dit_t;
 
 
/* 
 * Prototype functions 
 */

int ngcppUnsigned(void);

int ngcppGetLocHostAddr(char *addr, char *erms);
 
 
/*
 * Memory handling
 */

void *ngcppMalloc(size_t size);

void *ngcppMalloc2(void *ptr, size_t size);

void ngcppFree(void *ptr);

int ngcppReAlloc(size_t bufsize, int n, char *erms);

void *ngcppBurstAlloc(size_t size);

void ngcppBurstFree(void *buffer, size_t size);

void *ngcppAttachBuf(void *buffer, off_t offset, size_t size, 
             size_t *mapSize);

void ngcppDetachBuf(void *buffer, size_t size);
 
 
/*
 * Startup/shutdown frame-work
 */

int ngcppStartup(int argc, char **argv, size_t defaultBufsize, char *erms);

void ngcppCmdLineHelp(const char *paramStr, const char *helpStr, 
              const char *defaultStr);

void ngcppDivide(int num);

void ngcppShutdown(int sigFlag);

void ngcppExit(int stat);

void ngcppSignalHandler(int sig);

int ngcppSemWaitTmo(ngcb_sema_t *sem, int tmo);

void ngcppChanMap(int *cm, int n);
 
/*
 * DMA device
 */

int ngcppOpen(ngcpp_dma_t *dev, char *erms);

int ngcppClose(ngcpp_dma_t *dev, int term, char *erms);

int ngcppInit(ngcpp_dma_t *dev, unsigned int *doneCount, char *erms);

int ngcppTerm(ngcpp_dma_t *dev, char *erms);

char ngcppOverrun(ngcpp_dma_t *dev);
 
 
/*
 * Data capture
 */

void ngcppInitFilter(int devIdx, int *chan, int n);

ngcpp_t *ngcppFilter(int devIdx, ngcpp_t *data, int n);

void *ngcppCapture(void *arg);

void ngcppAppInit(void);

#define ngcppInitClient() ngcppAppInit()

int ngcppWaitStart(void);

int ngcppStartCapture(void);

char ngcppCheckStop(void);

int ngcppWaitData(ngcpp_t **res);

void ngcppAckData(void);

int ngcppFlushInput(void);

void ngcppTermProcessing(void);
 
/*
 * Configure interrupt post-processing task.
 */
void ngcppIppCfg(int id, void *param, int n);
 
/*
 * Apply interrupt post-processing task configuration.
 */
int ngcppIppApply(int id, void *param, int n, char *erms);
 
/*
 * Parameters
 */

int *ngcppSetupDynParam(size_t numParam, const char **id, size_t numCmd,
            char *erms);

int ngcppPSync(int alarmtTime, char *erms);

int ngcppDynComHandle(ngcpp_dcmd_t *cmdSet);

int *ngcppParamPtr(void);

void ngcppParamDefault(void);

const char *ngcppProperty(const char *name);
 
/*
 * Error stack
 */

void ngcppSigFailure(const char *erms);

void ngcppErrStackAdd(int id, const char *erms); 

void *ngcppErrStack(void *argp);
 

typedef int (*ngcppCI_OPEN)(const char *name, int *port, char *erms);

typedef int (*ngcppCI_CLOSE)(int handle);

typedef int (*ngcppCI_CONNECT)(int handle, char *hostInfo, char *erms);

typedef int (*ngcppCI_DISCONNECT)(int client);

typedef int (*ngcppCI_CMD)(int client, ngcpp_cmd_t *command, char *erms);

typedef int (*ngcppCI_REPLY)(int client, ngcpp_rep_t reply, char *erms);

typedef struct {
  int cmdBufSize;                
  int replyBufSize;              
  ngcppCI_OPEN open;             
  ngcppCI_CLOSE close;           
  ngcppCI_CONNECT connect;       
  ngcppCI_DISCONNECT disconnect; 
  ngcppCI_CMD getCommand;        
  ngcppCI_REPLY sendReply;       
} ngcpp_cmd_srv_api;
 
/*
 * Command controller prototypes
 */

extern ngcpp_cmd_srv_api *ngcppCiSys;      

extern ngcpp_cmd_srv_api ngcppCiTcp;      

void *ngcppCommandProcess(void *argp);
 
void ngcppCiInitErr(void);

int ngcppCiParamInit(void);

int ngcppCiParamSync(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiParamSet(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiParamStat(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiParamConf(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiChanSelect(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiAbort(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiStart(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiStop(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiPause(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiGetStatus(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiGetConfig(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiGetRev(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiGetErrPort(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiGetDataPort(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiGetDataPath(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiSetDataPath(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiTime(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiSimTime(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiSimStartDelay(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiVerbose(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiDynCmd(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiMemSet(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiMemClose(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiMemSync(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiFlushOutput(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiMemRecv(char *erms);

int ngcppCiResetCnt(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiEnd(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiSetFilePubPath(ngcpp_cmd_t command, ngcpp_rep_t *reply, 
              char *erms);

int ngcppCiSetFilePubBase(ngcpp_cmd_t command, ngcpp_rep_t *reply, 
              char *erms);

int ngcppCiUsrCmd(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);

int ngcppCiChipOffset(ngcpp_cmd_t command, ngcpp_rep_t *reply, char *erms);
 
 
/*
 * Data transfer prototypes
 */

typedef void *(*ngcpp_ds_t)(void *arg);

extern ngcpp_ds_t ngcppDataServer;

extern void (*ngcppDataServerExit)(void);

int ngcppStartDataServer(unsigned int n, char *erms);

int ngcppCloseDataServer(void);

void ngcppDataServerStatus(int flag, const char *erms);
 

void ngcppDataTransferReset(int n);

void *ngcppDataServerTcp(void *argp);

int ngcppDataReq(int n, ngcpp_req_t request, int transferMode, 
         ngcpp_frame_t *frame, int *noSort, int *noWin, 
         int *attach, ngcb_sema_t **txSig);

void ngcppDataResetReq(int n);

void ngcppDataAck(int n);

void ngcppDataAckPending(int n);

int ngcppAddFrameType(int type, const char *name, const char *paraName, 
              char *erms);

void ngcppInitFrame(ngcppFRAME *frame, char **array, int n);

void ngcppReInitFrame(ngcppFRAME *frame, char **array);

void ngcppReInitFrameN(ngcppFRAME *frame, char **array, int n);

int ngcppPublish(int syncMode, ngcppFRAME *frame);

void ngcppSetTimeStamp(uint64_t ts);

void ngcppResetTimeStamp();

#define ngcppReqOut(a,b) ngcppPublish(a,b)

void ngcppAddFrame(int type);

void ngcppRemoveFrame(int type);

#define ngcppAddOutputFrame(t) ngcppAddFrame(t)

#define ngcppRemoveOutputFrame(t) ngcppRemoveFrame(t)

int ngcppExportRequest(int shmId, int semId, char *erms);

void ngcppExport(void *buffer, int ftype, int bitPix, int nx, int ny);

int ngcppFlushOutput(void);

void ngcppSyncOutput(void);

void ngcppSetQueue(void);

void ngcppSetTransferringState(void);

void ngcppResetTransferringState(void);
 
/*
 * File output prototypes
 */

int ngcppFilePublisherInit(const char *name, char *erms);

int ngcppInitFileDump(char *erms);

int ngcppFilePublish(ngcppFRAME *frame, int bufIdx, int sync, char *erms);

void ngcppFileSync(void);

int ngcppFilePublisherPath(int id, const char *path, char *erms);

void ngcppFilePublisherBase(const char *base);
 
 
/*
 * Shared data interface prototypes
 */

int ngcppShDataAttach(int shared, int n, size_t size, char *erms);

int ngcppShDataClose(void);

char *ngcppShDataSetPtr(int id, int *len, char *erms);

int ngcppShDataGetPtr(char **ptr, int id, int len, char *erms);

void ngcppShDataSwap(int id);

int ngcppShDataValid(int id);

int ngcppShDataInvalid(int id);

int ngcppShDataIsValid (int id);
 
 
/*
 * Calculation tools
 */

int ngcppGetShift(char *first, int  *data, char *bpx, int nx, int tx, int ty,
          int txw, int tyw, int *sx, int *sy, int *posX, int *posY);

int ngcppGetShiftFloat(char *first, float *data, char *bpx, int nx, int tx, 
               int ty, int txw, int tyw, int *sx, int *sy, 
               int *posX, int *posY);

int ngcppGetShiftCen(char *first, int  *data, char *bpx, int nx, int tx, 
             int ty, int txw, int tyw, int * sx, int *sy, 
             int *posX, int *posY);

int ngcppGetShiftCenFloat(char *first, float *data, char *bpx, int nx, int tx,
              int ty, int txw, int tyw, int *sx, int *sy, 
              int *posX, int *posY);

int ngcppShiftAddInt(int *sum, int *data, int nx, int ny, int shx, int shy);

int ngcppShiftAddFloat(float *sum, float *data, int nx, int ny, int shx, 
               int shy);
int ngcppShiftAddIntN(int *sum, int *data, int nx, int ny, int shx, int shy,
              int n, int np);

int ngcppShiftAddFloatN(float *sum, float *data, int nx, int ny, int shx, 
            int shy, int n, int np);

int ngcppWinCpy(char *frm, int fx, int fy, char *win, int sx0, int sy0, 
        int nx, int ny, int bytes, int assemble, int noSort);

void ngcppApplyPixMap(char *in, char *out, size_t numPix, int bound);

void ngcppDim(int nx, int ny);

int ngcppSwapXY(void);

void ngcppFrameScale16(void *buffer, size_t size, int n);

void ngcppFrameScaleReal16(void *buffer, size_t size, int n);

void ngcppFlipX(int *map, int nx, int ny);

void ngcppFlipY(int *map, int nx, int ny);

void ngcppR90(int *map, int nx, int ny);

void ngcppR270(int *map, int nx, int ny);

void ngcppApplyMapOp(int nx, int ny);
 
/*
 * Centroiding algorithms
 */

int ngcppBgThreshold(float *data, float *bg, int nx, int ny, int nbg,
             double k1, int nLoop, double k2, double *thrMin, 
             double *sigma, double badPixLevel);

int ngcppCog(double *cx, double *cy, float *data, int nx, int ny, double thr);

int ngcppCogX(double *cx, float *data, int nx, int ny, double thr);

int ngcppCogY(double *cy, float *data, int nx, int ny, double thr);

int ngcppCogLR(double *cx, double *cy, float *data, int nx, int ny,
           int slx1, int slx2, double thr, double sigma, int min);

int ngcppCogSymXP(double *cx, double *cy, float *data, int nx, int ny,
          int slx1, int slx2, double thr, double sigma, int min);

int ngcppCenCircle(double *cx, double *cy, float *data, int nx, int ny,
           int slx1, int slx2, double thr, double sigma, int min);
 
/*
 * Field stabilisation routines
 */

int ngcppFsConnect(char *host, char *erms);

int ngcppFsDisconnect(int fd);

int ngcppFsSend(int fd, ngcpp_fs_t *correction, char *erms);
 
 
/*
 * Convenience handlers
 */

int ngcppDitHandler(ngcppFRAME *ditFrame, ngcppFRAME *intFrame, 
            ngcppFRAME *iintFrame, ngcppFRAME *sdvFrame,
            ngcppFRAME *hcyc1Frame, ngcppFRAME *hcyc2Frame, 
            double *sumSquare, ngcpp_dit_t *param, char *doInit);
 

int ngcppCntHandler(ngcppFRAME *hcyc, int setupId, int phases, int ndit,
            int cycSkip, int sdv, int *ditCnt, int *cycCnt,
                    char *initFlag, char *sdvOn, char *first);


extern ngcpp_dma_t *ngcppDev;                  

extern int ngcppNumDev;                        

extern char ngcppStatus;                       

extern char ngcppRunning;                      

extern int ngcppMaxComBufSize;

extern int ngcppMaxRepBufSize;

extern char ngcppCiInitFlag;                   

extern char ngcppErrInitFlag;                  

extern char ngcppDataInitFlag;                

extern char ngcppDataSrvName[256];             

extern char **ngcppPublisherName;                

extern int ngcppNumPublishers;                    

extern int ngcppNumDataClients;                

extern int ngcppPid;

extern int ngcppNumFilePub;                    

extern int ngcppFileDump;                         

extern int ngcppFileId;                         

extern char ngcppBaseName[256];

extern char ngcppLocalPath[256];

extern int ngcppNumDataFiles;                  

extern int *ngcppDynPtr;                       

extern int ngcppParamBuf[3][ngcppMAX_PARAMSIZE]; 

extern ngcpp_param_t ngcppDynParam;            

extern double ngcppTime[2];

extern uint64_t ngcppTimeStamp;

extern int ngcppAutoTimeStamp;

extern ngcb_ma_t ngcppTimeFilter[2];

extern int ngcppDynCmd;                        

extern int ngcppDynCmdAck;                     

extern int ngcppNumDynCmd;                     

extern char ngcppMapFile[256];             
 
/*
 * CPUs
 */
extern int ngcppCPU;             

extern int ngcppSimTime;                       

extern int ngcppSimStartDelay;                       

extern int ngcppSimRt;                         

extern int ngcppSimNoise;                         

extern int ngcppSim32;                         

extern int ngcppRtCheck;                         

extern int ngcppCmdClients;                    

extern int ngcppKeyVal;                        

extern int ngcppTransferTypes;                 

extern char ngcppPrintPars;                    

extern char ngcppProcName[128];                

extern int ngcppRemoteFd;                      

extern char ngcppRstCnt;                       

extern char ngcppRstCnt_;                       

extern char ngcppQRstCnt;                       

extern char ngcppQRstCnt_;                       

extern char ngcppEndFlg;                       
 
extern char ngcppTransferring;                       
 
extern char ngcppDitX;                       

extern int ngcppCmdPort;                       

extern int ngcppErrPort;                       

extern int ngcppDataPort;                      

extern int ngcppStartX;                        

extern int ngcppStartY;                        

extern char *ngcppErmsCi;                      

extern char *ngcppErmsData;                    

extern int ngcppNumTypes;                      

extern ngcpp_ftype ngcppFrameType[32];         

extern int *ngcppPixMap;                       

extern size_t *ngcppPixMap64;                       

extern int ngcppMapOp[4];                       

extern int ngcppNoSort;                       

extern char ngcppPauseFlag;                    

extern char ngcppSyncInput;                    

extern int ngcppNumDiv;                        

extern int ngcppNumDet;                       

extern int ngcppDmaChan;                       

extern unsigned int ngcppDmaIPPMode;                       

extern int ngcppIppTaskId;                       

extern int ngcppIppParam[NGCDRV_MAX_PARAM];                       

extern unsigned int ngcppIppNumParam;                       

extern int ngcppNumBuf;                 

extern int ngcppDmaPacketSize;                 

extern int ngcppDmaResync;                 

extern int ngcppAdcPacketSize;                 

extern size_t ngcppFrameSize;                     

extern int ngcppDetSetup;                      

extern int ngcppTestCnt;                       

extern int ngcppNQ;                         

extern int ngcppQSize;                         

extern size_t ngcppQBufSize;                      

extern int ngcppQType;                         

extern int ngcppQCnt;                          

extern int ngcppQEnd;                          

extern ngcpp_win_t ngcppQWin;                          

extern int ngcppPayloadSize;                       

extern int ngcppUnitSize;                       

extern int ngcppJoinerDelay;                       

extern int ngcppDiskMem;                       

extern int ngcppDiskMemIdx;                    

extern char ngcppDiskMemPath[256];             

extern int ngcppChopZero;                      

extern char ngcppDataHost[ngcppMAX_DATA_CON][256];

extern int ngcppDataFcnt[ngcppMAX_DATA_CON];

extern int ngcppDataRcnt[ngcppMAX_DATA_CON];

extern char ngcppCmdHost[ngcppCI_MAX_CON][256];

extern int ngcppDmaDiag;

extern int ngcppDmaMon;

extern int ngcppSimDma;

extern int ngcppSimHiRes;

extern int ngcppRevApp;

extern char **ngcppArgv; 
 
extern int ngcppArgc;
 
/*
 * Semaphores
 */

extern ngcb_sema_t semRun;
      
extern ngcb_sema_t semStat;

extern ngcb_sema_t semParam;
    
extern ngcb_sema_t semParamLock;
    
extern ngcb_sema_t semCmd;

extern ngcb_sema_t semCmdAck;

extern ngcb_sema_t semBuf;

extern ngcb_sema_t semCiInit;

extern ngcb_sema_t semErrInit;

extern ngcb_sema_t semDataInit;

extern ngcb_sema_t semAppInit;

extern ngcb_sema_t semMem;

extern ngcb_sema_t semTerm;         
 
/*
 * Thread id's (only for internal tests, debugging, ...)
 */
ngcb_thread_t ngcppDPUB_THID(int idx);  
ngcb_thread_t ngcppDSRV_THID();         
ngcb_thread_t ngcppCI_THID();           
ngcb_thread_t ngcppERR_THID();          
 
#ifdef __cplusplus
}
#endif
 
#endif