FERSlib.h

Go to the documentation of this file.

 
 
#ifndef _FERSLIB_H
#define _FERSLIB_H              // Protect against multiple inclusion
 
#include <stdint.h>
#include <stdlib.h>  // for min/max definition
#include <stdio.h>
#include <math.h>
#include "ExportTypes.h"
 
#include "FERS_Registers_520X.h"
#include "FERS_Registers_5215.h"
 
//#include "FERS_MultiPlatform.h"
 
#ifndef WIN32
#include <stdbool.h>
#endif
 
 
#define FERSLIB_STR_HELPER_(S)          #S
#define FERSLIB_STR(S)                  FERSLIB_STR_HELPER_(S)
 
 
#define f_sprintf   sprintf_s
#define f_fopen     fopen_s
 









#define FERSLIB_VERSION_MAJOR           1
#define FERSLIB_VERSION_MINOR           3
#define FERSLIB_VERSION_PATCH           0
#define FERSLIB_RELEASE_NUM             (FERSLIB_VERSION_MAJOR * 10000) + (FERSLIB_VERSION_MINOR * 100) + (FERSLIB_VERSION_PATCH)   
#define FERSLIB_RELEASE_STRING          FERSLIB_STR(FERSLIB_VERSION_MAJOR) "." FERSLIB_STR(FERSLIB_VERSION_MINOR) "." FERSLIB_STR(FERSLIB_VERSION_PATCH) 
#define FERSLIB_RELEASE_DATE            "14/01/2026"
 
#define THROUGHPUT_METER            0       
 
#define INVALID_TEMP                999     

#define FERSLIB_MAX_NCNC          4     
#define FERSLIB_MAX_NBRD          128   
#define FERSLIB_MAX_NCH           128   
#define FERSLIB_MAX_NCH_5202      64    
#define FERSLIB_MAX_NCH_5203      128   
#define FERSLIB_MAX_NCH_5204      64    
#define PICOTDC_NCH               64    
#define FERSLIB_MAX_NTDL          8     
#define FERSLIB_MAX_NNODES        16    
 

#define DBLOG_FERSLIB_MSG        0x0001 
#define DBLOG_RAW_DATA_OUTFILE   0x0002 
#define DBLOG_LL_DATADUMP        0x0004 
#define DBLOG_LL_MSGDUMP         0x0008 
#define DBLOG_QUEUES             0x0010 
#define DBLOG_RAW_DECODE         0x0020 
#define DBLOG_LL_READDUMP        0x0040 
#define DBLOG_PARAMS             0x0080 
#define DBLOG_CONFIG             0x0100 
#define ENABLE_FERSLIB_LOGMSG    1      

typedef enum {
    RXSTATUS_OFF = 0,
    RXSTATUS_IDLE = 1,
    RXSTATUS_RUNNING = 2,
    RXSTATUS_EMPTYING = 3
} FERSLIB_RxThreadSatatus;

typedef enum {
    ROSTATUS_IDLE = 0, 
    ROSTATUS_RUNNING = 1,   
    ROSTATUS_EMPTYING = 2, 
    ROSTATUS_FLUSHING = 3, 
    RAWDATA_REPROCESS_FINISHED = 4    
} FERSLIB_ReadoutStatus;

typedef enum {
    FERSLIB_SUCCESS = 0,                 
    FERSLIB_ERR_GENERIC = -1,                
    FERSLIB_ERR_COMMUNICATION = -2,            
    FERSLIB_ERR_MAX_NBOARD_REACHED = -3,  
    FERSLIB_ERR_DEVICE_ALREADY_OPENED = -4, 
    FERSLIB_ERR_INVALID_PATH = -5,          
    FERSLIB_ERR_INVALID_HANDLE = -6,      
    FERSLIB_ERR_READOUT_ERROR = -7,            
    FERSLIB_ERR_MALLOC_BUFFERS = -8,      
    FERSLIB_ERR_INVALID_BIC = -9,            
    FERSLIB_ERR_READOUT_NOT_INIT = -10,     
    FERSLIB_ERR_CALIB_NOT_FOUND = -11,       
    FERSLIB_ERR_PEDCALIB_NOT_FOUND = -11, 
    FERSLIB_ERR_INVALID_FWFILE = -12,     
    FERSLIB_ERR_UPGRADE_ERROR = -13,       
    FERSLIB_ERR_INVALID_PARAM = -14,       
    FERSLIB_ERR_NOT_APPLICABLE = -15,     
    FERSLIB_ERR_TDL_ERROR = -16,           
    FERSLIB_ERR_QUEUE_OVERRUN = -17,       
    FERSLIB_ERR_START_STOP_ERROR = -18,     
    FERSLIB_ERR_OPER_NOT_ALLOWED = -19,     
    FERSLIB_ERR_INVALID_CLK_SETTING = -20,   
    FERSLIB_ERR_TDL_CHAIN_BROKEN = -21,     
    FERSLIB_ERR_TDL_CHAIN_DOWN = -22,     
    FERSLIB_ERR_I2C_NACK = -23,             
    FERSLIB_ERR_CALIB_FAIL = -24,         
    FERSLIB_ERR_INVALID_FW = -25,         
    FERSLIB_ERR_INVALID_PARAM_VALUE = -26,   
    FERSLIB_ERR_INVALID_PARAM_UNIT = -27  
} FERSLIB_ErrorCodes;

#define ACQMODE_SPECT             0x01  
#define ACQMODE_TSPECT            0x03  
#define ACQMODE_TIMING_CSTART     0x02  
#define ACQMODE_TIMING_GATED      0x02  
#define ACQMODE_TIMING_CSTOP      0x12  
#define ACQMODE_TIMING_STREAMING  0x22  
#define ACQMODE_COMMON_START      0x02  
#define ACQMODE_COMMON_STOP       0x12  
#define ACQMODE_STREAMING         0x22  
#define ACQMODE_TRG_MATCHING      0x32  
#define ACQMODE_TEST_MODE         0x01  
#define ACQMODE_COUNT             0x04  
#define ACQMODE_WAVE              0x08  

#define DTQ_SPECT   0x01  
#define DTQ_TIMING  0x02  
#define DTQ_COUNT   0x04  
#define DTQ_WAVE    0x08  
#define DTQ_TSPECT  0x03  
#define DTQ_SERVICE 0x2F  
#define DTQ_TEST    0xFF  
#define DTQ_START   0x0F  

typedef enum {
    ROMODE_DISABLE_SORTING = 0x0000,  
    ROMODE_TRGTIME_SORTING = 0x0001,  
    ROMODE_TRGID_SORTING = 0x0002   
} FERSLIB_EvtBuildingModes;

typedef enum {
    SE_HV = 1,  
    SE_COUNT = 2,  
    SE_ALL = 3  
} FERSLIB_ServEventsMode;
 

#define NODATA_TIMEOUT              100     
#define STOP_TIMEOUT                500     
#define FERS_CONNECT_TIMEOUT        3       

#define TDL_COMMAND_DELAY           1000000 
#define CLK_PERIOD_5202             8       
#define CLK_PERIOD_5203             12.8    
#define CLK_PERIOD_5204             12.8    

#define TDC_CLK_PERIOD              (CLK_PERIOD_5203*2)             
#define TDC_PULSER_CLK_PERIOD       (TDC_CLK_PERIOD / 32)           
#define TDC_LSB_ps                  (TDC_CLK_PERIOD / 8 / 1.024)    
#define CLK2LSB                     4096
// ---------------------

#define MAX_WAVEFORM_LENGTH         2048    
#define MAX_LIST_SIZE               2048    
#define MAX_TEST_NWORDS             4       
#define MAX_SERV_NWORDS             6       
 

#define MEASMODE_LEAD_ONLY          0x01    
#define MEASMODE_LEAD_TRAIL         0x03    
#define MEASMODE_LEAD_TOT8          0x05    
#define MEASMODE_LEAD_TOT11         0x09    
#define MEASMODE_OWLT(m)            (((m) == MEASMODE_LEAD_TOT8) || ((m) == MEASMODE_LEAD_TOT11))  
 
#define EDGE_LEAD                   1
#define EDGE_TRAIL                  0

typedef enum {
    STARTRUN_ASYNC = 0,   
    STARTRUN_CHAIN_T0 = 1, 
    STARTRUN_CHAIN_T1 = 2, 
    STARTRUN_TDL = 3,   
} FERSLIB_StartMode;
 
#define STOPRUN_MANUAL          0   
#define STOPRUN_PRESET_TIME     1   
#define STOPRUN_PRESET_COUNTS   2   
 
#define EVBLD_DISABLED              0   // Event Building disabled */
#define EVBLD_TRGTIME_SORTING       1   // Sorting events by timestamp of the trigger */
#define EVBLD_TRGID_SORTING         2   // Sorting events by the trigger ID */
 
// Citiroc Configuration
#define CITIROC_CFG_FROM_REGS       0
#define CITIROC_CFG_FROM_FILE       1
 

#define ENERGY_NBIT                 14  
#define TOA_NBIT                    16  
#define TOA_LSB_ns                  0.5 
#define TOT_NBIT                    9   
 
 
// Parameter Options
typedef enum {
    GLITCHFILTERMODE_DISABLED  = 0,
    GLITCHFILTERMODE_TRAILING  = 1,
    GLITCHFILTERMODE_LEADING    = 2,
    GLITCHFILTERMODE_BOTH      = 3
} FERSLIB_GlitchFilterModes;

typedef enum {
    HRCLK_DISABLED                = 0,
    HRCLK_DAISY_CHAIN          = 1,
    HRCLK_FAN_OUT              = 2
} FERSLIB_HRClockModes;

#define EEPROM_BIC_SIZE             44      
#define EEPROM_BIC_PAGE             0       
#define EEPROM_CAL_PAGE             256     
#define EEPROM_CAL_SIZE             256     

#define FLASH_PAGE_SIZE             528 
#define FLASH_BIC_PAGE              0   
                                         
#define FLASH_PEDCALIB_PAGE         4   
#define FLASH_PEDCALIB_BCK_PAGE     5   
                                         
#define FLASH_THR_OFFS_PAGE         4   
#define FLASH_THR_OFFS_BCK_PAGE     5   
 

#define A5203_FLASH                 0       
#define A5256_EEPROM                1       
 
// Handles and indexing
#define FERS_INDEX(handle)              ((handle) & 0xFF)       
#define FERS_CONNECTIONTYPE(handle)     ((handle) & 0xF0000)    
#define FERS_CONNECTIONTYPE_ETH         0x00000 
#define FERS_CONNECTIONTYPE_USB         0x10000 
#define FERS_CONNECTIONTYPE_TDL         0x20000 
#define FERS_CONNECTIONTYPE_CNC         0x80000 
#define FERS_NODE(handle)               ((handle >> 20) & 0xF)  
#define FERS_CHAIN(handle)              ((handle >> 24) & 0xF)  
#define FERS_CNCINDEX(handle)           ((handle >> 30) & 0xF)  
#define FERS_CNC_HANDLE(handle)         (0x80000 | ((handle >> 30) & 0xF)) 
 
// Fimrware upgrade via TDL
#define FUP_BA                          0xFF000000
#define FUP_CONTROL_REG                 1023
#define FUP_PARAM_REG                   1022
#define FUP_RESULT_REG                  1021
#define FUP_CMD_READ_VERSION            0xFF
#define POLY                            0x82f63b78
 
 
// Definition of limits and sizes
#define FERSLIB_MAX_GW                  20   
 
#define OUTFILE_RAW_LL                  0x0001  // Can be a Janus parameter

#define CFG_HARD    0   
#define CFG_SOFT    1   
 
 
// Other macros
#ifndef max
#define max(a,b) ((a) > (b) ? (a) : (b))
#endif
#ifndef min 
#define min(a,b) ((a) < (b) ? (a) : (b))
#endif
 
//******************************************************************
// TDL-chain Info Struct
//******************************************************************
typedef struct {
    uint16_t Status;      
    uint16_t BoardCount;  
    float rrt;               
    uint64_t EventCount;  
    uint64_t ByteCount;        
    float EventRate;       
    float Mbps;             
} FERS_TDL_ChainInfo_t;
 
//******************************************************************
// Concentrator Info Struct 
//******************************************************************
typedef struct {
    uint32_t pid;            
    char PCBrevision[16];    
    char ModelCode[16];        
    char ModelName[16];        
    char FPGA_FWrev[20];  
    char SW_rev[20];      
    char MACaddr_10GbE[20];    
    uint16_t NumLink;        
    FERS_TDL_ChainInfo_t ChainInfo[8]; 
} FERS_CncInfo_t;
 
//******************************************************************
// FERS Board Info Struct 
//******************************************************************
typedef struct {
    uint32_t pid;            
    uint16_t FERSCode;      
    uint8_t PCBrevision; 
    char ModelCode[16];        
    char ModelName[16];        
    uint8_t FormFactor;       
    uint16_t NumCh;            
    uint32_t FPGA_FWrev;  
    uint32_t uC_FWrev;      
} FERS_BoardInfo_t;
 
//******************************************************************
// A5256 Adapter Info Struct 
//******************************************************************
typedef struct {
    uint32_t pid;            
    uint16_t AdapterCode;        
    uint8_t PCBrevision; 
    char ModelCode[16];        
    char ModelName[16];        
    uint16_t NumCh;            
} FERS_A5256_Info_t;
 
//******************************************************************
// Event Data Structures
//******************************************************************
// Spectroscopy Event (with or without timing)
typedef struct {
    double tstamp_us;      
    double rel_tstamp_us;  
    uint64_t tstamp_clk;  
    uint64_t Tref_tstamp;    
    uint64_t trigger_id;  
    uint64_t chmask;      
    uint64_t qdmask;      
    uint16_t energyHG[64];  
    uint16_t energyLG[64];  
    uint32_t tstamp[64];  
    uint16_t ToT[64];        
} SpectEvent_t;
 
// Counting Event
typedef struct {
    double tstamp_us;      
    double rel_tstamp_us;  
    uint64_t trigger_id;  
    uint64_t chmask;      
    uint32_t counts[64];  
    uint32_t t_or_counts;    
    uint32_t q_or_counts;    
} CountingEvent_t;
 
// Waveform Event
typedef struct {
    double tstamp_us;      
    uint64_t trigger_id;  
    uint16_t ns;          
    uint16_t *wave_hg;       
    uint16_t *wave_lg;       
    uint8_t *dig_probes;  
} WaveEvent_t;

typedef struct {
    double tstamp_us;      
    uint64_t Tref_tstamp;    
    uint64_t tstamp_clk;  
    uint64_t trigger_id;  
    uint16_t nhits;            
    uint32_t header1[8]; 
    uint32_t header2[8]; 
    uint32_t ow_trailer;  
    uint32_t trailer[8]; 
    uint8_t  channel[MAX_LIST_SIZE];    
    uint8_t  edge[MAX_LIST_SIZE];      
    uint32_t tstamp[MAX_LIST_SIZE];      
    uint32_t ToA[MAX_LIST_SIZE];        
    uint16_t ToT[MAX_LIST_SIZE];        
} ListEvent_t; // 5202 + 5203

typedef struct {
    double tstamp_us;          
    uint64_t update_time;        
    uint16_t pkt_size;          
    uint8_t version;         
    uint8_t format;               
    uint32_t ch_trg_cnt[FERSLIB_MAX_NCH_5202];  // Channel trigger counts 
    uint32_t q_or_cnt;          
    uint32_t t_or_cnt;          
    float tempFPGA;             
    float tempBoard;           
    float tempTDC[2];            
    float tempHV;             
    float tempDetector;         
    float hv_Vmon;               
    float hv_Imon;               
    uint8_t hv_status_on;       
    uint8_t hv_status_ramp;       
    uint8_t hv_status_ovv;     
    uint8_t hv_status_ovc;     
    uint16_t Status;          
    uint16_t TDCROStatus;        
    uint64_t ChAlmFullFlags[2];   
    uint32_t ReadoutFlags;      
    uint32_t TotTrg_cnt;      
    uint32_t RejTrg_cnt;      
    uint32_t SupprTrg_cnt;      
} ServEvent_t; // 5202 + 5203
 
 
// Test Mode Event (fixed data patterns)
typedef struct {
    double tstamp_us;      
    uint64_t trigger_id;  
    uint16_t nwords;      
    uint32_t test_data[MAX_TEST_NWORDS];    
} TestEvent_t;
 

#define A5256_CH0_POSITIVE              0  
#define A5256_CH0_NEGATIVE              1  
#define A5256_CH0_DUAL                  2  
 
 
#define ADAPTER_NONE                    0x0000  
#define ADAPTER_A5255                   0x0000  
#define ADAPTER_A5256                   0x0002  
#define ADAPTER_A5256_REV0_POS          0x0100  
#define ADAPTER_A5256_REV0_NEG          0x0101  
 
 
#define NC -1   // DNIN=?
 
#define A5256_DAC_LSB               ((float)2500/4095)                                  
#define A5256_mV_to_DAC(mV)         (uint32_t)round((1250 - (mV)) / A5256_DAC_LSB)      
#define A5256_DAC_to_mV(lsb)        (1250 - (float)((lsb) * A5256_DAC_LSB))             
 
#ifdef __cplusplus
extern "C" {
#endif
    // *****************************************************************
    // External Variables (defined in FERlib.c)
    // *****************************************************************
    extern uint16_t PedestalLG[FERSLIB_MAX_NBRD][FERSLIB_MAX_NCH_5202]; 
    extern uint16_t PedestalHG[FERSLIB_MAX_NBRD][FERSLIB_MAX_NCH_5202]; 
    extern uint16_t CommonPedestal;                                     
    extern int EnablePedCal;                                            
    extern uint32_t TDL_NumNodes[FERSLIB_MAX_NCNC][FERSLIB_MAX_NTDL];   
 
    //extern uint8_t EnableRawData;                             //!< Flag to enable Low Level data saving
    extern uint8_t ProcessRawData;                              
    //extern uint8_t EnableMaxSizeFile;                         //!< Flag to enable the maximum size eforcement for Raw Data file saving
    extern uint8_t EnableSubRun;                                
    //extern float MaxSizeRawDataFile;                          //!< Maximum size for saving low-level data
    extern char RawDataFilename[FERSLIB_MAX_NBRD][500];         
    extern char RawDataFilenameTdl[FERSLIB_MAX_NBRD][500];      
    extern int FERS_Offline;                                    
 
    extern int FERS_RunningCnt;                                 
    extern int FERS_ReadoutStatus;                              
    extern int FERS_TotalAllocatedMem;                          
    extern uint32_t DebugLogs;                                      
 
    //extern mutex_t FERS_mutex;                                    //!< Mutex for access to shared resources (FERScfg, InitBuffers ...)
    
    // *****************************************************************
    // Funtion Prototypes
    // *****************************************************************
    
    CAEN_FERS_DLLAPI int ConfigureProbe(int handle);
 
    // -----------------------------------------------------------------
    // Get FERSlib info
    // -----------------------------------------------------------------
    CAEN_FERS_DLLAPI char* FERS_GetLibReleaseNum();

    CAEN_FERS_DLLAPI char* FERS_GetLibReleaseDate();
 
    // -----------------------------------------------------------------
    // Messaging and errors
    // -----------------------------------------------------------------


    CAEN_FERS_DLLAPI int FERS_LibMsg(char* fmt, ...);

    CAEN_FERS_DLLAPI int FERS_GetLastError(char description[1024]);
 
    // Not exported
    void _setLastLocalError(const char* description, ...);
 
    // -----------------------------------------------------------------
    // Raw Data Save and Load
    // -----------------------------------------------------------------
    // DNIN: Is it better to have an API to enable both RawData and LimitFileSize
    //       and then do the open directly inside the StartAcquisition?
 
    //CAEN_FERS_DLLAPI int FERS_EnableRawdataWriteFile(uint8_t RawDataEnable, char* DataOutputPath, int RunNumber);
 
    //CAEN_FERS_DLLAPI int FERS_EnableLimitRawdataFileSize(uint8_t LimitSizeEnable, float MaxSizeRawOutputFile);
 
    //CAEN_FERS_DLLAPI int FERS_SetRawdataReadFile(char DataRawFilePath[500], int brd);


    CAEN_FERS_DLLAPI int FERS_OpenRawDataFile(int* handle, int RunNum, int NumBrd);

    CAEN_FERS_DLLAPI int FERS_CloseRawDataFile(int* handle, int NumBrd);
    
    CAEN_FERS_DLLAPI float FERS_GetClockPeriod(int handle);
    //CAEN_FERS_DLLAPI int FERS_SetPedestalOffline(uint16_t PedLG[FERSLIB_MAX_NCH_5202], uint16_t PedHG[FERSLIB_MAX_NCH_5202], int handle);
    
    // -----------------------------------------------------------------
    // Open/Close
    // -----------------------------------------------------------------

    CAEN_FERS_DLLAPI int FERS_OpenDevice(char* path, int* handle);

    CAEN_FERS_DLLAPI int FERS_IsOpen(char* path);

    CAEN_FERS_DLLAPI int FERS_IsOpenByHandle(int handle, char* path);

    CAEN_FERS_DLLAPI int FERS_CloseDevice(int handle);

    CAEN_FERS_DLLAPI int FERS_TotalAllocatedMemory();

    CAEN_FERS_DLLAPI int FERS_Reset_IPaddress(int handle);

    CAEN_FERS_DLLAPI int FERS_Get_CncPath(char* dev_path, char* cnc_path);

    CAEN_FERS_DLLAPI int FERS_InitTDLchains(int handle, float DelayAdjust[FERSLIB_MAX_NTDL][FERSLIB_MAX_NNODES]);

    CAEN_FERS_DLLAPI bool FERS_TDLchainsInitialized(int handle);
 
    //CAEN_FERS_DLLAPI int FERS_SetOffline(int offline);
    //CAEN_FERS_DLLAPI int FERS_SetBoardInfo(FERS_BoardInfo_t* BrdInfo, int b);
    //CAEN_FERS_DLLAPI int FERS_SetConcentratorInfo(int handle, FERS_CncInfo_t* cinfo);

    CAEN_FERS_DLLAPI uint16_t FERS_GetNumBrdConnected();
 
 
    // -----------------------------------------------------------------
    // Register Read/Write
    // -----------------------------------------------------------------

    CAEN_FERS_DLLAPI int FERS_ReadRegister(int handle, uint32_t address, uint32_t* data);

    CAEN_FERS_DLLAPI int FERS_WriteRegister(int handle, uint32_t address, uint32_t data);

    CAEN_FERS_DLLAPI int FERS_WriteRegisterSlice(int handle, uint32_t address, uint32_t start_bit, uint32_t stop_bit, uint32_t data);

    CAEN_FERS_DLLAPI int FERS_SendCommand(int handle, uint32_t cmd);

    CAEN_FERS_DLLAPI int FERS_SendCommandBroadcast(int* handle, uint32_t cmd, uint32_t delay);

    CAEN_FERS_DLLAPI int FERS_I2C_ReadRegister(int handle, uint32_t i2c_dev_addr, uint32_t reg_addr, uint32_t* reg_data);

    CAEN_FERS_DLLAPI int FERS_I2C_WriteRegister(int handle, uint32_t i2c_dev_addr, uint32_t reg_addr, uint32_t reg_data);

    CAEN_FERS_DLLAPI int FERS_I2C_WriteRegisterSlice(int handle, uint32_t i2c_dev_addr, uint32_t address, uint32_t start_bit, uint32_t stop_bit, uint32_t data);
    //CAEN_FERS_DLLAPI int FERS_ReadBoardInfo(int handle, FERS_BoardInfo_t* binfo);
 
    // -----------------------------------------------------------------
    // Flash Read/Write
    // -----------------------------------------------------------------
    CAEN_FERS_DLLAPI int FERS_ReadFlashPage(int handle, int pagenum, int size, uint8_t* data);

    CAEN_FERS_DLLAPI int FERS_WriteFlashPage(int handle, int pagenum, int size, uint8_t* data);
 
 
    // -----------------------------------------------------------------
    // XROC Register Read/Write
    // -----------------------------------------------------------------
    CAEN_FERS_DLLAPI int FERS_XROC_WriteRegister(int handle, int page_addr, int sub_addr, uint8_t data);

    CAEN_FERS_DLLAPI int FERS_XROC_ReadRegister(int handle, int page_addr, int sub_addr, uint8_t* data);

    CAEN_FERS_DLLAPI int FERS_XROC_WriteRegisterSilce(int handle, int page_addr, int sub_addr, uint32_t start_bit, uint32_t stop_bit, uint8_t data);
 

    CAEN_FERS_DLLAPI int FERS_ReadConcentratorInfo(int handle, FERS_CncInfo_t* cinfo);

    CAEN_FERS_DLLAPI int FERS_WriteBoardInfo(int handle, FERS_BoardInfo_t binfo);


    CAEN_FERS_DLLAPI int FERS_WritePedestals(int handle, uint16_t* PedLG, uint16_t* PedHG, uint16_t* dco);

    CAEN_FERS_DLLAPI int FERS_ReadPedestalsFromFlash(int handle, char* date, uint16_t* PedLG, uint16_t* PedHG, uint16_t* dco);

    CAEN_FERS_DLLAPI int FERS_PedestalBackupPage(int handle, int EnBckPage);

    CAEN_FERS_DLLAPI int FERS_SetCommonPedestal(int handle, uint16_t Pedestal);

    CAEN_FERS_DLLAPI int FERS_EnablePedestalCalibration(int handle, int enable);
 
    int FERS_GetChannelPedestalBeforeCalib(int handle, int ch, uint16_t* PedLG, uint16_t* PedHG);
 
    CAEN_FERS_DLLAPI int FERS_SetEnergyBitsRange(uint16_t EnergyRange);
    //CAEN_FERS_DLLAPI int FERS_Model(int handle);              // ((FERS_INDEX(handle) >= 0) ? FERS_BoardInfo[FERS_INDEX(handle)]->Model : 0)
 


    CAEN_FERS_DLLAPI int FERS_GetBoardInfo(int handle, FERS_BoardInfo_t* BrdInfo);

    CAEN_FERS_DLLAPI int FERS_GetCncInfo(int handle, FERS_CncInfo_t* BrdInfo);

    CAEN_FERS_DLLAPI uint32_t FERS_pid(int handle);             // ((FERS_INDEX(handle) >= 0) ? FERS_BoardInfo[FERS_INDEX(handle)]->pid : 0)
    
    CAEN_FERS_DLLAPI uint16_t FERS_Code(int handle);           // ((FERS_INDEX(handle) >= 0) ? FERS_BoardInfo[FERS_INDEX(handle)]->FERSCode : 0)

    CAEN_FERS_DLLAPI char* FERS_ModelName(int handle);            // ((FERS_INDEX(handle) >= 0) ? FERS_BoardInfo[FERS_INDEX(handle)]->ModelName : "")

    CAEN_FERS_DLLAPI uint32_t FERS_FPGA_FWrev(int handle);       // ((FERS_INDEX(handle) >= 0) ? FERS_BoardInfo[FERS_INDEX(handle)]->FPGA_FWrev : 0)

    CAEN_FERS_DLLAPI uint32_t FERS_FPGA_FW_MajorRev(int handle);// ((FERS_INDEX(handle) >= 0) ? ((FERS_BoardInfo[FERS_INDEX(handle)]->FPGA_FWrev) >> 8) & 0xFF : 0)

    CAEN_FERS_DLLAPI uint32_t FERS_FPGA_FW_MinorRev(int handle);// ((FERS_INDEX(handle) >= 0) ? (FERS_BoardInfo[FERS_INDEX(handle)]->FPGA_FWrev) & 0xFF : 0)

    CAEN_FERS_DLLAPI uint32_t FERS_uC_FWrev(int handle);       // ((FERS_INDEX(handle) >= 0) ? FERS_BoardInfo[FERS_INDEX(handle)]->uC_FWrev : 0)

    CAEN_FERS_DLLAPI uint16_t FERS_NumChannels(int handle);     // ((FERS_INDEX(handle) >= 0) ? FERS_BoardInfo[FERS_INDEX(handle)]->NumCh : 0)

    CAEN_FERS_DLLAPI uint8_t FERS_PCB_Rev(int handle);          // ((FERS_INDEX(handle) >= 0) ? FERS_BoardInfo[FERS_INDEX(handle)]->PCBrevision : 0)

    CAEN_FERS_DLLAPI bool FERS_IsXROC(int handle);
 
    // DNIN: Ideally, these 2 should be intern function. The user should only set the DebugLogMask
    CAEN_FERS_DLLAPI int FERS_DumpBoardRegister(int handle);

    CAEN_FERS_DLLAPI int FERS_DumpCfgSaved(int handle);
 


    CAEN_FERS_DLLAPI int FERS_Get_TDC0_Temp(int handle, float* temp);

    CAEN_FERS_DLLAPI int FERS_Get_TDC1_Temp(int handle, float* temp);

    CAEN_FERS_DLLAPI int FERS_Get_FPGA_Temp(int handle, float* temp);
 

    CAEN_FERS_DLLAPI int FERS_Get_Board_Temp(int handle, float* temp);
 
 
 
 
    // -----------------------------------------------------------------
    // High Voltage Control
    // -----------------------------------------------------------------


    CAEN_FERS_DLLAPI int FERS_HV_Init(int handle);

    CAEN_FERS_DLLAPI int FERS_HV_WriteReg(int handle, uint32_t reg_addr, uint32_t dtype, uint32_t reg_data);

    CAEN_FERS_DLLAPI int FERS_HV_ReadReg(int handle, uint32_t reg_addr, uint32_t dtype, uint32_t* reg_data);

    CAEN_FERS_DLLAPI int FERS_HV_Set_OnOff(int handle, int OnOff);

    CAEN_FERS_DLLAPI int FERS_HV_Get_Status(int handle, int* OnOff, int* Ramping, int* OvC, int* OvV);

    CAEN_FERS_DLLAPI int FERS_HV_Get_FWVer(int handle, uint32_t* FWver);

    CAEN_FERS_DLLAPI int FERS_HV_Get_SerNum(int handle, int* sernum);

    CAEN_FERS_DLLAPI int FERS_HV_Set_Vbias(int handle, float vbias);

    CAEN_FERS_DLLAPI int FERS_HV_Get_Vbias(int handle, float* vbias);

    CAEN_FERS_DLLAPI int FERS_HV_Get_Vmon(int handle, float* vmon);

    CAEN_FERS_DLLAPI int FERS_HV_Set_Imax(int handle, float imax);

    CAEN_FERS_DLLAPI int FERS_HV_Get_Imax(int handle, float* imax);

    CAEN_FERS_DLLAPI int FERS_HV_Get_Imon(int handle, float* imon);

    CAEN_FERS_DLLAPI int FERS_HV_Get_IntTemp(int handle, float* temp);

    CAEN_FERS_DLLAPI int FERS_HV_Get_DetectorTemp(int handle, float* temp);

    CAEN_FERS_DLLAPI int FERS_HV_Set_Tsens_Coeff(int handle, float Tsens_coeff[3]);

    CAEN_FERS_DLLAPI int FERS_HV_Set_TempFeedback(int handle, int enable, float Tsens_coeff);
 
 
    // -----------------------------------------------------------------
    // TDC Config and readout (for test)
    // -----------------------------------------------------------------
    CAEN_FERS_DLLAPI int FERS_TDC_WriteReg(int handle, int tdc_id, uint32_t addr, uint32_t data);
    CAEN_FERS_DLLAPI int FERS_TDC_ReadReg(int handle, int tdc_id, uint32_t addr, uint32_t* data);
    CAEN_FERS_DLLAPI int FERS_TDC_Config(int handle, int tdc_id, int StartSrc, int StopSrc);
    CAEN_FERS_DLLAPI int FERS_TDC_DoStartStopMeasurement(int handle, int tdc_id, double* tof_ns);
 
 
    // -----------------------------------------------------------------
    // Set/Get param, parse file and configure FERS
    // -----------------------------------------------------------------
    

    CAEN_FERS_DLLAPI int FERS_configure(int handle, int mode);

    CAEN_FERS_DLLAPI int FERS_LoadConfigFile(char* filepath);

    CAEN_FERS_DLLAPI int FERS_SetParam(int handle, const char* param_name, const char* value_original);

    CAEN_FERS_DLLAPI int FERS_GetParam(int handle, const char* param_name, char* value);
 
 
    // -----------------------------------------------------------------
    // Data Readout
    // -----------------------------------------------------------------
    

    CAEN_FERS_DLLAPI int FERS_InitReadout(int handle, int ROmode, int* AllocatedSize);

    CAEN_FERS_DLLAPI int FERS_CloseReadout(int handle);

    CAEN_FERS_DLLAPI int FERS_FlushData(int handle);

    CAEN_FERS_DLLAPI int FERS_GetCrcErrorCnt(int cnc_handle, uint32_t* errcnt);

    CAEN_FERS_DLLAPI int FERS_StartAcquisition(int* handle, int NumBrd, int StartMode, int RunNum);

    CAEN_FERS_DLLAPI int FERS_StopAcquisition(int* handle, int NumBrd, int StartMode, int RunNum);

    CAEN_FERS_DLLAPI int FERS_GetEvent(int* handle, int* bindex, int* DataQualifier, double* tstamp_us, void** Event, int* nb);

    CAEN_FERS_DLLAPI int FERS_GetEventFromBoard(int handle, int* DataQualifier, double* tstamp_us, void** Event, int* nb);
 
 
    // -----------------------------------------------------------------
    // Firmware Upgrade
    // -----------------------------------------------------------------


    CAEN_FERS_DLLAPI int FERS_FirmwareUpgrade(int handle, char filen[200], void(*ptr)(char* msg, int progress));

    CAEN_FERS_DLLAPI int FERS_FirmwareBootApplication_ethusb(int handle);

    CAEN_FERS_DLLAPI int FERS_FirmwareBootApplication_tdl(int* handle);

    int FERS_CheckBootloaderVersion(int handle, int* isInBootloader, uint32_t* version, uint32_t* release);
 
    // -----------------------------------------------------------------
    // EEPROM 5256
    // -----------------------------------------------------------------



    CAEN_FERS_DLLAPI int FERS_ReadA5256EEPROMInfo(int handle, FERS_A5256_Info_t* binfo);

    CAEN_FERS_DLLAPI int FERS_WriteA5256EEPROMInfo(int handle, FERS_A5256_Info_t binfo);

    int FERS_ReadEEPROMBlock(int handle, int start_address, int size, uint8_t* data);

    int FERS_WriteEEPROMBlock(int handle, int start_address, int size, uint8_t* data);

    CAEN_FERS_DLLAPI int FERS_checkA5256presence(int handle, FERS_A5256_Info_t* tinfo);

 
 

    CAEN_FERS_DLLAPI int FERS_ChIndex_ada2tdc(int Adapter_ch, int* TDC_ch, int brd);

    CAEN_FERS_DLLAPI int FERS_ChIndex_tdc2ada(int TDC_ch, int* Adapter_ch, int brd);
 


    CAEN_FERS_DLLAPI int FERS_FindMemThrDest(int handle);

    CAEN_FERS_DLLAPI int FERS_ReadThrCalib(int handle, int npts, int MemThrDest, char* date, float* ThrOffset);

    CAEN_FERS_DLLAPI int FERS_AdapterNch(int brd);

    int FERS_DisableThrCalib(int handle);

    int FERS_Set_DiscrThreshold(int handle, int Adapter_ch, float thr_mv, int brd);

    int FERS_ChMask_ada2tdc(uint32_t AdapterMask, uint32_t* ChMask0, uint32_t* ChMask1, int brd);

    CAEN_FERS_DLLAPI int FERS_CalibThresholdOffset(int handle, float min_thr, float max_thr, int* done, float* ThrOffset, float* RMSnoise, void(*ptr)(char* msg, int progress));

    CAEN_FERS_DLLAPI int FERS_WriteThrCalib(int handle, int npts, int MemThrDest, float* ThrOffset);

    // * @ingroup calib
    // * @brief             Read BIC from the EEPROM of the Adapter (if present)
    // * @param[in]  handle Board handle 
    // * @param[out] binfo  Board info struct
    // * @return                0 in case of success, or a negative error code specified in #FERSLIB_ErrorCodes
    // */ 
    //CAEN_FERS_DLLAPI int FERS_ReadAdapterBIC(int handle, FERS_A5256_Info_t* binfo);

    // * @ingroup calib
    // * @brief             Write BIC into the EEPROM of the Adapter (if present)
    // * @param[in]  handle Board handle
    // * @param[out] binfo  Board info struct
    // * @return                0 in case of success, or a negative error code specified in #FERSLIB_ErrorCodes
    // */
    //CAEN_FERS_DLLAPI int FERS_WriteAdapterBIC(int handle, FERS_A5256_Info_t binfo);
 
 
#ifdef __cplusplus
 }
#endif
 
#endif