uldaq.h

Go to the documentation of this file.

/*
 * uldaq.h
 *
 *      Author: Measurement Computing Corporation
 */

#ifndef UL_DAQ_H_
#define UL_DAQ_H_

#ifdef __cplusplus
extern "C"
{
#endif


typedef enum
{
    USB_IFC         = 1 << 0,

    BLUETOOTH_IFC   = 1 << 1,

    ETHERNET_IFC    = 1 << 2,

    ANY_IFC = USB_IFC | BLUETOOTH_IFC | ETHERNET_IFC

}DaqDeviceInterface;

struct DaqDeviceDescriptor
{
    char productName[64];

    unsigned int productId;

    DaqDeviceInterface devInterface;

    char devString[64];

    char uniqueId[64];

    char reserved[512];
};

typedef struct  DaqDeviceDescriptor DaqDeviceDescriptor;

typedef long long DaqDeviceHandle;


struct TransferStatus
{
    unsigned long long currentScanCount;

    unsigned long long currentTotalCount;

    long long currentIndex;

    char reserved[64];
};

typedef struct  TransferStatus TransferStatus;

#define ERR_MSG_LEN             512

typedef enum
{
    ERR_NO_ERROR                    = 0,

    ERR_UNHANDLED_EXCEPTION         = 1,

    ERR_BAD_DEV_HANDLE              = 2,

    ERR_BAD_DEV_TYPE                = 3,

    ERR_USB_DEV_NO_PERMISSION       = 4,

    ERR_USB_INTERFACE_CLAIMED       = 5,

    ERR_DEV_NOT_FOUND               = 6,

    ERR_DEV_NOT_CONNECTED           = 7,

    ERR_DEAD_DEV                    = 8,

    ERR_BAD_BUFFER_SIZE             = 9,

    ERR_BAD_BUFFER                  = 10,

    ERR_BAD_MEM_TYPE                = 11,

    ERR_BAD_MEM_REGION              = 12,

    ERR_BAD_RANGE                   = 13,

    ERR_BAD_AI_CHAN                 = 14,

    ERR_BAD_INPUT_MODE              = 15,

    ERR_ALREADY_ACTIVE              = 16,

    ERR_BAD_TRIG_TYPE               = 17,

    ERR_OVERRUN                     = 18,

    ERR_UNDERRUN                    = 19,

    ERR_TIMEDOUT                    = 20,

    ERR_BAD_OPTION                  = 21,

    ERR_BAD_RATE                    = 22,

    ERR_BAD_BURSTIO_COUNT           = 23,

    ERR_CONFIG_NOT_SUPPORTED        = 24,

    ERR_BAD_CONFIG_VAL              = 25,

    ERR_BAD_AI_CHAN_TYPE            = 26,

    ERR_ADC_OVERRUN                 = 27,

    ERR_BAD_TC_TYPE                 = 28,

    ERR_BAD_UNIT                    = 29,

    ERR_BAD_QUEUE_SIZE              = 30,

    ERR_BAD_CONFIG_ITEM             = 31,

    ERR_BAD_INFO_ITEM               = 32,

    ERR_BAD_FLAG                    = 33,

    ERR_BAD_SAMPLE_COUNT            = 34,

    ERR_INTERNAL                    = 35,

    ERR_BAD_COUPLING_MODE           = 36,

    ERR_BAD_SENSOR_SENSITIVITY      = 37,

    ERR_BAD_IEPE_MODE               = 38,

    ERR_BAD_AI_CHAN_QUEUE           = 39,

    ERR_BAD_AI_GAIN_QUEUE           = 40,

    ERR_BAD_AI_MODE_QUEUE           = 41,

    ERR_FPGA_FILE_NOT_FOUND         = 42,

    ERR_UNABLE_TO_READ_FPGA_FILE    = 43,

    ERR_NO_FPGA                     = 44,

    ERR_BAD_ARG                     = 45,

    ERR_MIN_SLOPE_VAL_REACHED       = 46,

    ERR_MAX_SLOPE_VAL_REACHED       = 47,

    ERR_MIN_OFFSET_VAL_REACHED      = 48,

    ERR_MAX_OFFSET_VAL_REACHED      = 49,

    ERR_BAD_PORT_TYPE               = 50,

    ERR_WRONG_DIG_CONFIG            = 51,

    ERR_BAD_BIT_NUM                 = 52,

    ERR_BAD_PORT_VAL                = 53,

    ERR_BAD_RETRIG_COUNT            = 54,

    ERR_BAD_AO_CHAN                 = 55,

    ERR_BAD_DA_VAL                  = 56,

    ERR_BAD_TMR                     = 57,

    ERR_BAD_FREQUENCY               = 58,

    ERR_BAD_DUTY_CYCLE              = 59,

    ERR_BAD_INITIAL_DELAY           = 60,

    ERR_BAD_CTR                     = 61,

    ERR_BAD_CTR_VAL                 = 62,

    ERR_BAD_DAQI_CHAN_TYPE          = 63,

    ERR_BAD_NUM_CHANS               = 64,

    ERR_BAD_CTR_REG                 = 65,

    ERR_BAD_CTR_MEASURE_TYPE        = 66,

    ERR_BAD_CTR_MEASURE_MODE        = 67,

    ERR_BAD_DEBOUNCE_TIME           = 68,

    ERR_BAD_DEBOUNCE_MODE           = 69,

    ERR_BAD_EDGE_DETECTION          = 70,

    ERR_BAD_TICK_SIZE               = 71,

    ERR_BAD_DAQO_CHAN_TYPE          = 72,

    ERR_NO_CONNECTION_ESTABLISHED   = 73,

    ERR_BAD_EVENT_TYPE              = 74,

    ERR_EVENT_ALREADY_ENABLED       = 75,

    ERR_BAD_EVENT_PARAMETER         = 76,

    ERR_BAD_CALLBACK_FUCNTION       = 77,

    ERR_BAD_MEM_ADDRESS             = 78,

    ERR_MEM_ACCESS_DENIED           = 79,

    ERR_DEV_UNAVAILABLE             = 80,

    ERR_BAD_RETRIG_TRIG_TYPE        = 81,

    ERR_BAD_DEV_VER                 = 82,

    ERR_BAD_DIG_OPERATION           = 83,

    ERR_BAD_PORT_INDEX              = 84,

    ERR_OPEN_CONNECTION             = 85,

    ERR_DEV_NOT_READY               = 86,

    ERR_PACER_OVERRUN               = 87,

    ERR_BAD_TRIG_CHANNEL            = 88,

    ERR_BAD_TRIG_LEVEL              = 89,

    ERR_BAD_CHAN_ORDER              = 90,

    ERR_TEMP_OUT_OF_RANGE           = 91,

    ERR_TRIG_THRESHOLD_OUT_OF_RANGE = 92,

    ERR_INCOMPATIBLE_FIRMWARE       = 93,

    ERR_BAD_NET_IFC                 = 94,

    ERR_BAD_NET_HOST                = 95,

    ERR_BAD_NET_PORT                = 96,

    ERR_NET_IFC_UNAVAILABLE         = 97,

    ERR_NET_CONNECTION_FAILED       = 98,

    ERR_BAD_CONNECTION_CODE         = 99,

    ERR_CONNECTION_CODE_IGNORED     = 100,

    ERR_NET_DEV_IN_USE              = 101,

    ERR_BAD_NET_FRAME               = 102,

    ERR_NET_TIMEOUT                 = 103,

    ERR_DATA_SOCKET_CONNECTION_FAILED = 104,

    ERR_PORT_USED_FOR_ALARM         = 105,

    ERR_BIT_USED_FOR_ALARM          = 106,

    ERR_CMR_EXCEEDED                = 107,

    ERR_NET_BUFFER_OVERRUN          = 108,

    ERR_BAD_NET_BUFFER              = 109
} UlError;

typedef enum
{
    AI_DIFFERENTIAL = 1,

    AI_SINGLE_ENDED = 2,

    AI_PSEUDO_DIFFERENTIAL = 3
}AiInputMode;

typedef enum
{
    AI_VOLTAGE          = 1 << 0,

    AI_TC               = 1 << 1,

    AI_RTD              = 1 << 2,

    AI_THERMISTOR       = 1 << 3,

    AI_SEMICONDUCTOR    = 1 << 4,

    AI_DISABLED         = 1 << 30
}AiChanType;

typedef enum
{
    TC_J                = 1,

    TC_K                = 2,

    TC_T                = 3,

    TC_E                = 4,

    TC_R                = 5,

    TC_S                = 6,

    TC_B                = 7,

    TC_N                = 8
}TcType;

typedef enum
{
    SCT_2_WIRE_1    = 1,

    SCT_2_WIRE_2    = 2,

    SCT_3_WIRE      = 3,

    SCT_4_WIRE      = 4
}SensorConnectionType;

typedef enum
{
    BIP60VOLTS      = 1,

    BIP30VOLTS      = 2,

    BIP15VOLTS      = 3,

    BIP20VOLTS      = 4,

    BIP10VOLTS      = 5,

    BIP5VOLTS       = 6,

    BIP4VOLTS       = 7,

    BIP2PT5VOLTS    = 8,

    BIP2VOLTS       = 9,

    BIP1PT25VOLTS   = 10,

    BIP1VOLTS       = 11,

    BIPPT625VOLTS   = 12,

    BIPPT5VOLTS     = 13,

    BIPPT25VOLTS    = 14,

    BIPPT125VOLTS   = 15,

    BIPPT2VOLTS     = 16,

    BIPPT1VOLTS     = 17,

    BIPPT078VOLTS   = 18,

    BIPPT05VOLTS    = 19,

    BIPPT01VOLTS    = 20,

    BIPPT005VOLTS   = 21,

    BIP3VOLTS       = 22,

    BIPPT312VOLTS   = 23,

    BIPPT156VOLTS   = 24,




    UNI60VOLTS      = 1001,

    UNI30VOLTS      = 1002,

    UNI15VOLTS      = 1003,

    UNI20VOLTS      = 1004,

    UNI10VOLTS      = 1005,

    UNI5VOLTS       = 1006,

    UNI4VOLTS       = 1007,

    UNI2PT5VOLTS    = 1008,

    UNI2VOLTS       = 1009,

    UNI1PT25VOLTS   = 1010,

    UNI1VOLTS       = 1011,

    UNIPT625VOLTS   = 1012,

    UNIPT5VOLTS     = 1013,

    UNIPT25VOLTS    = 1014,

    UNIPT125VOLTS   = 1015,

    UNIPT2VOLTS     = 1016,

    UNIPT1VOLTS     = 1017,

    UNIPT078VOLTS   = 1018,

    UNIPT05VOLTS    = 1019,

    UNIPT01VOLTS    = 1020,

    UNIPT005VOLTS   = 1021,

    MA0TO20 = 2000
}Range;

typedef enum
{
    TU_CELSIUS      = 1,

    TU_FAHRENHEIT   = 2,

    TU_KELVIN       = 3
}TempUnit;

typedef enum
{
    TS_CELSIUS      = TU_CELSIUS,

    TS_FAHRENHEIT   = TU_FAHRENHEIT,

    TS_KELVIN       = TU_KELVIN,

    TS_VOLTS        = 4,

    TS_NOSCALE      = 5
}TempScale;

#ifndef doxy_skip

typedef enum
{
    AZM_NONE = 1,

    AZM_EVERY_SAMPLE = 2,

    AZM_ONCE = 3
}AutoZeroMode;
#endif /* doxy_skip */

#ifndef doxy_skip

typedef enum
{
    ADC_TM_AUTO         = 1,

    ADC_TM_HIGH_RES     = 2,

    ADC_TM_HIGH_SPEED   = 3
}AdcTimingMode;
#endif /* doxy_skip */

typedef enum
{
    IEPE_DISABLED = 1,

    IEPE_ENABLED = 2
}IepeMode;

typedef enum
{
    CM_DC = 1,

    CM_AC = 2
}CouplingMode;

typedef enum
{
    OTD_DISABLED = 1,

    OTD_ENABLED = 2
}OtdMode;

typedef enum
{
    CHAN_QUEUE = 1 << 0,

    GAIN_QUEUE = 1 << 1,

    MODE_QUEUE = 1 << 2
}AiQueueType;

typedef enum
{
    UNIQUE_CHAN = 1 << 0,

    ASCENDING_CHAN = 1 << 1,

    CONSECUTIVE_CHAN = 1 << 2
} AiChanQueueLimitation;

typedef enum
{
    AI_CTT_FACTORY      = 1,

    AI_CTT_FIELD        = 2
}AiCalTableType;

typedef enum
{
    AI_RFT_60HZ     = 1,

    AI_RFT_50HZ     = 2
}AiRejectFreqType;


typedef enum
{
    AUXPORT = 1,

    AUXPORT0 = 1,

    AUXPORT1 = 2,

    AUXPORT2 = 3,

    FIRSTPORTA = 10,

    FIRSTPORTB = 11,

    FIRSTPORTC = 12,

    FIRSTPORTCL = 12,

    FIRSTPORTCH = 13,

    SECONDPORTA = 14,

    SECONDPORTB = 15,

    SECONDPORTCL = 16,

    SECONDPORTCH = 17,

    THIRDPORTA = 18,

    THIRDPORTB = 19,

    THIRDPORTCL = 20,

    THIRDPORTCH = 21,

    FOURTHPORTA = 22,

    FOURTHPORTB = 23,

    FOURTHPORTCL = 24,

    FOURTHPORTCH = 25,

    FIFTHPORTA = 26,

    FIFTHPORTB = 27,

    FIFTHPORTCL = 28,

    FIFTHPORTCH = 29,

    SIXTHPORTA = 30,

    SIXTHPORTB = 31,

    SIXTHPORTCL = 32,

    SIXTHPORTCH = 33,

    SEVENTHPORTA = 34,

    SEVENTHPORTB = 35,

    SEVENTHPORTCL = 36,

    SEVENTHPORTCH = 37,

    EIGHTHPORTA = 38,

    EIGHTHPORTB = 39,

    EIGHTHPORTCL = 40,

    EIGHTHPORTCH = 41
}DigitalPortType;

typedef enum
{
    DPIOT_IN = 1,

    DPIOT_OUT = 2,

    DPIOT_IO = 3,

    DPIOT_BITIO = 4,

    DPIOT_NONCONFIG = 5
} DigitalPortIoType;

typedef enum
{
    DD_INPUT = 1,

    DD_OUTPUT = 2
}DigitalDirection;

typedef enum
{
    TMR_STANDARD = 1,

    TMR_ADVANCED = 2
}TimerType;

typedef enum
{
    TMRIS_LOW = 1,

    TMRIS_HIGH = 2
}TmrIdleState;

typedef enum
{
    TMRS_IDLE = 0,

    TMRS_RUNNING = 1
}TmrStatus;

typedef enum
{
    TRIG_NONE = 0,  
    
    TRIG_POS_EDGE =  1 << 0,

    TRIG_NEG_EDGE = 1 << 1,

    TRIG_HIGH = 1 << 2,

    TRIG_LOW = 1 << 3,

    GATE_HIGH = 1 << 4,

    GATE_LOW = 1 << 5,

    TRIG_RISING = 1 << 6,

    TRIG_FALLING = 1 << 7,

    TRIG_ABOVE = 1 << 8,

    TRIG_BELOW = 1 << 9,

    GATE_ABOVE = 1 << 10,

    GATE_BELOW = 1 << 11,

    GATE_IN_WINDOW = 1 << 12,

    GATE_OUT_WINDOW = 1 << 13,

    TRIG_PATTERN_EQ = 1 << 14,

    TRIG_PATTERN_NE = 1 << 15,

    TRIG_PATTERN_ABOVE = 1 << 16,

    TRIG_PATTERN_BELOW = 1 << 17
}TriggerType;

struct AiQueueElement
{
    int channel;

    AiInputMode inputMode;

    Range range;

    char reserved[64];
};

typedef struct  AiQueueElement AiQueueElement;

typedef enum
{
    SS_IDLE = 0,

    SS_RUNNING = 1
}ScanStatus;

#ifndef doxy_skip
#define NOSCALEDATA         1 << 0
#define NOCALIBRATEDATA     1 << 1
#define SIMULTANEOUS        1 << 2
#define NOCLEAR             1 << 3
#endif /*doxy_skip */

typedef enum
{
    SO_DEFAULTIO    = 0,

    SO_SINGLEIO     = 1 << 0,

    SO_BLOCKIO      = 1 << 1,

    SO_BURSTIO      = 1 << 2,

    SO_CONTINUOUS   = 1 << 3,

    SO_EXTCLOCK     = 1 << 4,

    SO_EXTTRIGGER   = 1 << 5,

    SO_RETRIGGER    = 1 << 6,

    SO_BURSTMODE    = 1 << 7,

    SO_PACEROUT     = 1 << 8,

    SO_EXTTIMEBASE  = 1 << 9,

    SO_TIMEBASEOUT  = 1 << 10

}ScanOption;

typedef enum
{
    AINSCAN_FF_DEFAULT              = 0,

    AINSCAN_FF_NOSCALEDATA          = NOSCALEDATA,      

    AINSCAN_FF_NOCALIBRATEDATA      = NOCALIBRATEDATA   
}AInScanFlag;

typedef enum
{
    AIN_FF_DEFAULT = 0,

    AIN_FF_NOSCALEDATA          = NOSCALEDATA,      

    AIN_FF_NOCALIBRATEDATA      = NOCALIBRATEDATA   
}AInFlag;

typedef enum
{
    AOUTSCAN_FF_DEFAULT                 = 0,

    AOUTSCAN_FF_NOSCALEDATA             = NOSCALEDATA,      

    AOUTSCAN_FF_NOCALIBRATEDATA         = NOCALIBRATEDATA   
}AOutScanFlag;

typedef enum
{
    TIN_FF_DEFAULT = 0,

    TIN_FF_WAIT_FOR_NEW_DATA = 1
}TInFlag;

typedef enum
{
    TINARRAY_FF_DEFAULT = 0,

    TINARRAY_FF_WAIT_FOR_NEW_DATA = 1
}TInArrayFlag;

typedef enum
{
    AOUT_FF_DEFAULT = 0,

    AOUT_FF_NOSCALEDATA             = NOSCALEDATA,      

    AOUT_FF_NOCALIBRATEDATA         = NOCALIBRATEDATA   
}AOutFlag;

typedef enum
{
    AOUTARRAY_FF_DEFAULT    = 0,

    AOUTARRAY_FF_NOSCALEDATA            = NOSCALEDATA,

    AOUTARRAY_FF_NOCALIBRATEDATA        = NOCALIBRATEDATA ,

    AOUTARRAY_FF_SIMULTANEOUS           = SIMULTANEOUS
}AOutArrayFlag;

typedef enum
{
    AOSM_SLAVE  = 0,

    AOSM_MASTER = 1
}AOutSyncMode;

typedef enum
{
    AOSM_DISABLED   = 1,

    AOSM_ENABLED        = 2
}AOutSenseMode;



typedef enum
{
    CINSCAN_FF_DEFAULT          = 0,

    CINSCAN_FF_CTR16_BIT        = 1 << 0,

    CINSCAN_FF_CTR32_BIT        = 1 << 1,

    CINSCAN_FF_CTR64_BIT        = 1 << 2,

    CINSCAN_FF_NOCLEAR          = NOCLEAR,

    CINSCAN_FF_CTR48_BIT        = 1 << 4
}CInScanFlag;

typedef enum
{
    DINSCAN_FF_DEFAULT          = 0,
}DInScanFlag;

typedef enum
{
    DOUTSCAN_FF_DEFAULT             = 0,
}DOutScanFlag;

typedef enum
{
    DAQINSCAN_FF_DEFAULT            = 0,

    DAQINSCAN_FF_NOSCALEDATA        = NOSCALEDATA,      

    DAQINSCAN_FF_NOCALIBRATEDATA    = NOCALIBRATEDATA,  

    DAQINSCAN_FF_NOCLEAR            = NOCLEAR           
}DaqInScanFlag;

typedef enum
{
    DAQOUTSCAN_FF_DEFAULT           = 0,

    DAQOUTSCAN_FF_NOSCALEDATA       = NOSCALEDATA,      

    DAQOUTSCAN_FF_NOCALIBRATEDATA   = NOCALIBRATEDATA   
}DaqOutScanFlag;

typedef enum
{
    CMT_COUNT =         1 << 0,

    CMT_PERIOD =        1 << 1,

    CMT_PULSE_WIDTH =   1 << 2,

    CMT_TIMING =        1 << 3,

    CMT_ENCODER =       1 << 4
}CounterMeasurementType;

typedef enum
{
    CMM_DEFAULT =                       0,

    CMM_CLEAR_ON_READ =                 1 << 0,

    CMM_COUNT_DOWN =                    1 << 1,

    CMM_GATE_CONTROLS_DIR =             1 << 2,

    CMM_GATE_CLEARS_CTR =               1 << 3,

    CMM_GATE_TRIG_SRC =                 1 << 4,

    CMM_OUTPUT_ON =                     1 << 5,

    CMM_OUTPUT_INITIAL_STATE_HIGH =     1 << 6,

    CMM_NO_RECYCLE =                    1 << 7,

    CMM_RANGE_LIMIT_ON =                1 << 8,

    CMM_GATING_ON =                     1 << 9,

    CMM_INVERT_GATE =                   1 << 10,

    CMM_PERIOD_X1 =                     0,

    CMM_PERIOD_X10 =                    1 << 11,

    CMM_PERIOD_X100 =                   1 << 12,

    CMM_PERIOD_X1000 =                  1 << 13,

    CMM_PERIOD_GATING_ON =              1 << 14,

    CMM_PERIOD_INVERT_GATE =            1 << 15,

    CMM_PULSE_WIDTH_DEFAULT =           0,

    CMM_PULSE_WIDTH_GATING_ON =         1 << 16,

    CMM_PULSE_WIDTH_INVERT_GATE =       1 << 17,

    CMM_TIMING_DEFAULT  =               0,

    CMM_TIMING_MODE_INVERT_GATE =       1 << 18,

    CMM_ENCODER_X1 =                    0,

    CMM_ENCODER_X2 =                    1 << 19,

    CMM_ENCODER_X4  =                   1 << 20,

    CMM_ENCODER_LATCH_ON_Z =            1 << 21,

    CMM_ENCODER_CLEAR_ON_Z =            1 << 22,

    CMM_ENCODER_NO_RECYCLE =            1 << 23,

    CMM_ENCODER_RANGE_LIMIT_ON  =       1 << 24,

    CMM_ENCODER_Z_ACTIVE_EDGE   =       1 << 25,

    CMM_LATCH_ON_INDEX  =               1 << 26,

    CMM_PHB_CONTROLS_DIR    =           1 << 27,

    CMM_DECREMENT_ON =                  1 << 28
}CounterMeasurementMode;

typedef enum
{
    CDT_DEBOUNCE_0ns =      0,

    CDT_DEBOUNCE_500ns =    1,

    CDT_DEBOUNCE_1500ns =   2,

    CDT_DEBOUNCE_3500ns =   3,

    CDT_DEBOUNCE_7500ns =   4,

    CDT_DEBOUNCE_15500ns =  5,

    CDT_DEBOUNCE_31500ns =  6,

    CDT_DEBOUNCE_63500ns =  7,

    CDT_DEBOUNCE_127500ns = 8,

    CDT_DEBOUNCE_100us =    9,

    CDT_DEBOUNCE_300us =    10,

    CDT_DEBOUNCE_700us =    11,

    CDT_DEBOUNCE_1500us =   12,

    CDT_DEBOUNCE_3100us =   13,

    CDT_DEBOUNCE_6300us =   14,

    CDT_DEBOUNCE_12700us =  15,

    CDT_DEBOUNCE_25500us =  16
}CounterDebounceTime;

typedef enum
{
    CDM_NONE                    = 0,

    CDM_TRIGGER_AFTER_STABLE    = 1,

    CDM_TRIGGER_BEFORE_STABLE   = 2
}CounterDebounceMode;

typedef enum
{
    CED_RISING_EDGE             = 1,

    CED_FALLING_EDGE            = 2
}CounterEdgeDetection;

typedef enum
{
    CTS_TICK_20PT83ns           = 1,

    CTS_TICK_208PT3ns           = 2,

    CTS_TICK_2083PT3ns          = 3,

    CTS_TICK_20833PT3ns         = 4,

    CTS_TICK_20ns               = 11,

    CTS_TICK_200ns              = 12,

    CTS_TICK_2000ns             = 13,

    CTS_TICK_20000ns            = 14
}CounterTickSize;

typedef enum
{
    CF_DEFAULT = 0
}
CConfigScanFlag;

typedef enum
{
    CRT_COUNT       = 1 << 0,

    CRT_LOAD        = 1 << 1,

    CRT_MIN_LIMIT   = 1 << 2,

    CRT_MAX_LIMIT   = 1 << 3,

    CRT_OUTPUT_VAL0 = 1 << 4,

    CRT_OUTPUT_VAL1 = 1 << 5
}CounterRegisterType;

typedef enum
{
    DAQI_ANALOG_DIFF    = 1 << 0,

    DAQI_ANALOG_SE      = 1 << 1,

    DAQI_DIGITAL        = 1 << 2,

    DAQI_CTR16          = 1 << 3,

    DAQI_CTR32          = 1 << 4,

    DAQI_CTR48          = 1 << 5,
    DAQI_DAC            = 1 << 7
}DaqInChanType;

struct DaqInChanDescriptor
{
    int channel;

    DaqInChanType type;

    Range range;

    char reserved[64];
};

typedef struct  DaqInChanDescriptor DaqInChanDescriptor;

typedef enum
{
    DAQO_ANALOG         = 1 << 0,

    DAQO_DIGITAL        = 1 << 1
}DaqOutChanType;


struct DaqOutChanDescriptor
{
    int channel;

    DaqOutChanType type;

    Range range;

    char reserved[64];
};

typedef struct  DaqOutChanDescriptor DaqOutChanDescriptor;

typedef enum
{
    PO_DEFAULT = 0,

    PO_EXTTRIGGER = 1 << 5,

    PO_RETRIGGER = 1 << 6
} PulseOutOption;

typedef enum
{
    DE_NONE                         = 0, 

    DE_ON_DATA_AVAILABLE =          1 << 0,

    DE_ON_INPUT_SCAN_ERROR =        1 << 1,

    DE_ON_END_OF_INPUT_SCAN =       1 << 2,

    DE_ON_OUTPUT_SCAN_ERROR =       1 << 3,

    DE_ON_END_OF_OUTPUT_SCAN =      1 << 4

}DaqEventType;

typedef enum
{
    MR_CAL =        1 << 0,

    MR_USER =       1 << 1,

    MR_SETTINGS =   1 << 2,

    MR_RESERVED0 =  1 << 3
}MemRegion;

typedef enum
{
    MA_READ =       1 << 0,

    MA_WRITE =      1 << 1
}MemAccessType;

typedef void (*DaqEventCallback)(DaqDeviceHandle, DaqEventType, unsigned long long, void*);

typedef enum
{
    WAIT_UNTIL_DONE = 1 << 0
}WaitType;

#ifndef doxy_skip

typedef enum
{
    UL_INFO_VER_STR = 2000
}UlInfoItemStr;

typedef enum
{   
    UL_CFG_USB_XFER_PRIORITY = 1
}UlConfigItem;
#endif /* doxy_skip */

typedef enum
{
    DEV_INFO_HAS_AI_DEV = 1,

    DEV_INFO_HAS_AO_DEV = 2,

    DEV_INFO_HAS_DIO_DEV = 3,

    DEV_INFO_HAS_CTR_DEV = 4,

    DEV_INFO_HAS_TMR_DEV = 5,

    DEV_INFO_HAS_DAQI_DEV = 6,

    DEV_INFO_HAS_DAQO_DEV = 7,

    DEV_INFO_DAQ_EVENT_TYPES = 8,

    DEV_INFO_MEM_REGIONS = 9
}DevInfoItem;

typedef enum
{
    DEV_CFG_HAS_EXP = 1,

    DEV_CFG_CONNECTION_CODE = 2,

    DEV_CFG_MEM_UNLOCK_CODE = 3,

    DEV_CFG_RESET = 4

}DevConfigItem;

typedef enum
{
    DEV_CFG_VER_STR = 2000,

    DEV_CFG_IP_ADDR_STR = 2001,

    DEV_CFG_NET_IFC_STR = 2002
}DevConfigItemStr;

typedef enum
{
    DEV_VER_FW_MAIN = 0,

    DEV_VER_FPGA = 1,

    DEV_VER_RADIO = 2,

    DEV_VER_FW_MEASUREMENT = 3,

    DEV_VER_FW_MEASUREMENT_EXP = 4
}DevVersionType;

typedef enum
{
    AI_INFO_RESOLUTION = 1,

    AI_INFO_NUM_CHANS = 2,

    AI_INFO_NUM_CHANS_BY_MODE = 3,

    AI_INFO_NUM_CHANS_BY_TYPE = 4,

    AI_INFO_CHAN_TYPES = 5,

    AI_INFO_SCAN_OPTIONS = 6,

    AI_INFO_HAS_PACER = 7,

    AI_INFO_NUM_DIFF_RANGES = 8,

    AI_INFO_NUM_SE_RANGES = 9,

    AI_INFO_DIFF_RANGE = 10,

    AI_INFO_SE_RANGE = 11,

    AI_INFO_TRIG_TYPES = 12,

    AI_INFO_MAX_QUEUE_LENGTH_BY_MODE = 13,

    AI_INFO_QUEUE_TYPES = 14,

    AI_INFO_QUEUE_LIMITS = 15,

    AI_INFO_FIFO_SIZE = 16,

    AI_INFO_IEPE_SUPPORTED = 17

}AiInfoItem;

typedef enum
{
    AI_INFO_MIN_SCAN_RATE = 1000,

    AI_INFO_MAX_SCAN_RATE = 1001,

    AI_INFO_MAX_THROUGHPUT = 1002,

    AI_INFO_MAX_BURST_RATE = 1003,

    AI_INFO_MAX_BURST_THROUGHPUT = 1004
}AiInfoItemDbl;

typedef enum
{
    AI_CFG_CHAN_TYPE = 1,

    AI_CFG_CHAN_TC_TYPE = 2,

#ifndef doxy_skip

    AI_CFG_SCAN_CHAN_TEMP_UNIT = 3,
#endif /* doxy_skip */

    AI_CFG_SCAN_TEMP_UNIT = 4,
    
#ifndef doxy_skip

    AI_CFG_ADC_TIMING_MODE = 5,

    AI_CFG_AUTO_ZERO_MODE = 6,

    AI_CFG_CAL_DATE = 7,
#endif /* doxy_skip */

    AI_CFG_CHAN_IEPE_MODE = 8,

    AI_CFG_CHAN_COUPLING_MODE = 9,

    AI_CFG_CHAN_SENSOR_CONNECTION_TYPE = 10,

    AI_CFG_CHAN_OTD_MODE = 11,

    AI_CFG_OTD_MODE = 12,

    AI_CFG_CAL_TABLE_TYPE = 13,

    AI_CFG_REJECT_FREQ_TYPE = 14,

#ifndef doxy_skip

    AI_CFG_EXP_CAL_DATE = 15,
#endif /* doxy_skip */

}AiConfigItem;

typedef enum
{
    AI_CFG_CHAN_SLOPE = 1000,

    AI_CFG_CHAN_OFFSET = 1001,

    AI_CFG_CHAN_SENSOR_SENSITIVITY = 1002,

    AI_CFG_CHAN_DATA_RATE = 1003
}AiConfigItemDbl;

typedef enum
{
    AI_CFG_CAL_DATE_STR = 2000,

    AI_CFG_CHAN_COEFS_STR = 2001,

    AI_CFG_EXP_CAL_DATE_STR = 2002,

}AiConfigItemStr;

typedef enum
{
    AO_INFO_RESOLUTION = 1,

    AO_INFO_NUM_CHANS = 2,

    AO_INFO_SCAN_OPTIONS = 3,

    AO_INFO_HAS_PACER = 4,

    AO_INFO_NUM_RANGES = 5,

    AO_INFO_RANGE = 6,

    AO_INFO_TRIG_TYPES = 7,

    AO_INFO_FIFO_SIZE = 8
}AoInfoItem;

typedef enum
{
    AO_INFO_MIN_SCAN_RATE = 1000,

    AO_INFO_MAX_SCAN_RATE = 1001,

    AO_INFO_MAX_THROUGHPUT = 1002
}AoInfoItemDbl;

typedef enum
{
    AO_CFG_SYNC_MODE = 1,

    AO_CFG_CHAN_SENSE_MODE = 2
}AoConfigItem;

typedef enum
{
    DIO_INFO_NUM_PORTS = 1,

    DIO_INFO_PORT_TYPE = 2,

    DIO_INFO_PORT_IO_TYPE = 3,

    DIO_INFO_NUM_BITS = 4,

    DIO_INFO_HAS_PACER = 5,

    DIO_INFO_SCAN_OPTIONS = 6,

    DIO_INFO_TRIG_TYPES = 7,

    DIO_INFO_FIFO_SIZE = 8
}DioInfoItem;

typedef enum
{
    DIO_INFO_MIN_SCAN_RATE = 1000,

    DIO_INFO_MAX_SCAN_RATE = 1001,

    DIO_INFO_MAX_THROUGHPUT = 1002
}DioInfoItemDbl;

typedef enum
{
    DIO_CFG_PORT_DIRECTION_MASK = 1,

    DIO_CFG_PORT_INITIAL_OUTPUT_VAL = 2,

    DIO_CFG_PORT_ISO_FILTER_MASK = 3,

    DIO_CFG_PORT_LOGIC = 4
}DioConfigItem;

typedef enum
{
    CTR_INFO_NUM_CTRS = 1,

    CTR_INFO_MEASUREMENT_TYPES = 2,

    CTR_INFO_MEASUREMENT_MODES = 3,

    CTR_INFO_REGISTER_TYPES = 4,

    CTR_INFO_RESOLUTION = 5,

    CTR_INFO_HAS_PACER = 6,

    CTR_INFO_SCAN_OPTIONS = 7,

    CTR_INFO_TRIG_TYPES = 8,

    CTR_INFO_FIFO_SIZE = 9
}CtrInfoItem;

typedef enum
{
    CTR_INFO_MIN_SCAN_RATE = 1000,

    CTR_INFO_MAX_SCAN_RATE = 1001,

    CTR_INFO_MAX_THROUGHPUT = 1002
}CtrInfoItemDbl;

typedef enum
{
    CTR_CFG_REG = 1
}CtrConfigItem;

typedef enum
{
    TMR_INFO_NUM_TMRS = 1,

    TMR_INFO_TYPE = 2,
}TmrInfoItem;

typedef enum
{
    TMR_INFO_MIN_FREQ = 1000,

    TMR_INFO_MAX_FREQ = 1001,
}TmrInfoItemDbl;

typedef enum
{
    DAQI_INFO_CHAN_TYPES = 1,

    DAQI_INFO_SCAN_OPTIONS = 2,

    DAQI_INFO_TRIG_TYPES = 3,

    DAQI_INFO_FIFO_SIZE = 4
}DaqIInfoItem;

typedef enum
{
    DAQI_INFO_MIN_SCAN_RATE = 1000,

    DAQI_INFO_MAX_SCAN_RATE = 1001,

    DAQI_INFO_MAX_THROUGHPUT = 1002
}DaqIInfoItemDbl;

typedef enum
{
    DAQO_INFO_CHAN_TYPES = 1,

    DAQO_INFO_SCAN_OPTIONS = 2,

    DAQO_INFO_TRIG_TYPES = 3,

    DAQO_INFO_FIFO_SIZE = 4
}DaqOInfoItem;

typedef enum
{
    DAQO_INFO_MIN_SCAN_RATE = 1000,

    DAQO_INFO_MAX_SCAN_RATE = 1001,

    DAQO_INFO_MAX_THROUGHPUT = 1002
}DaqOInfoItemDbl;

struct MemDescriptor
{
    MemRegion region;

    unsigned int address;

    unsigned int size;

    MemAccessType accessTypes;

    char reserved[64];
};

typedef struct  MemDescriptor MemDescriptor;

UlError ulGetDaqDeviceInventory(DaqDeviceInterface interfaceTypes, DaqDeviceDescriptor daqDevDescriptors[], unsigned int* numDescriptors );

UlError ulGetNetDaqDeviceDescriptor(const char* host, unsigned short port, const char* ifcName, DaqDeviceDescriptor* daqDevDescriptor, double timeout);

DaqDeviceHandle ulCreateDaqDevice(DaqDeviceDescriptor daqDevDescriptor);

UlError ulGetDaqDeviceDescriptor(DaqDeviceHandle daqDeviceHandle, DaqDeviceDescriptor* daqDeviceDescriptor);

UlError ulConnectDaqDevice(DaqDeviceHandle daqDeviceHandle);

UlError ulDisconnectDaqDevice(DaqDeviceHandle daqDeviceHandle);

UlError ulReleaseDaqDevice(DaqDeviceHandle daqDeviceHandle);

UlError ulIsDaqDeviceConnected(DaqDeviceHandle daqDeviceHandle, int* connected);

UlError ulDaqDeviceConnectionCode(DaqDeviceHandle daqDeviceHandle, long long code);


UlError ulFlashLed(DaqDeviceHandle daqDeviceHandle, int flashCount);

UlError ulAIn(DaqDeviceHandle daqDeviceHandle, int channel, AiInputMode inputMode, Range range, AInFlag flags, double* data);

UlError ulAInScan(DaqDeviceHandle daqDeviceHandle, int lowChan, int highChan, AiInputMode inputMode, Range range, int samplesPerChan, double* rate, ScanOption options, AInScanFlag flags, double data[]);

UlError ulAInScanStatus(DaqDeviceHandle daqDeviceHandle, ScanStatus* status, TransferStatus* xferStatus);

UlError ulAInScanStop(DaqDeviceHandle daqDeviceHandle);

UlError ulAInScanWait(DaqDeviceHandle daqDeviceHandle, WaitType waitType, long long waitParam, double timeout);

UlError ulAInLoadQueue(DaqDeviceHandle daqDeviceHandle, AiQueueElement queue[], unsigned int numElements);

UlError ulAInSetTrigger(DaqDeviceHandle daqDeviceHandle, TriggerType type, int trigChan, double level, double variance, unsigned int retriggerSampleCount);

UlError ulTIn(DaqDeviceHandle daqDeviceHandle, int channel, TempScale scale, TInFlag flags, double* data);

UlError ulTInArray(DaqDeviceHandle daqDeviceHandle, int lowChan, int highChan, TempScale scale, TInArrayFlag flags, double data[]);

UlError ulAOut(DaqDeviceHandle daqDeviceHandle, int channel, Range range, AOutFlag flags, double data);

UlError ulAOutArray(DaqDeviceHandle daqDeviceHandle,  int lowChan, int highChan, Range range[], AOutArrayFlag flags, double data[]);

UlError ulAOutScan(DaqDeviceHandle daqDeviceHandle, int lowChan, int highChan, Range range, int samplesPerChan, double* rate, ScanOption options, AOutScanFlag flags, double data[]);

UlError ulAOutScanWait(DaqDeviceHandle daqDeviceHandle, WaitType waitType, long long waitParam, double timeout);

UlError ulAOutScanStatus(DaqDeviceHandle daqDeviceHandle, ScanStatus* status, TransferStatus* xferStatus);

UlError ulAOutScanStop(DaqDeviceHandle daqDeviceHandle);

UlError ulAOutSetTrigger(DaqDeviceHandle daqDeviceHandle, TriggerType type, int trigChan, double level, double variance, unsigned int retriggerSampleCount);

UlError ulDConfigPort(DaqDeviceHandle daqDeviceHandle, DigitalPortType portType, DigitalDirection direction);

UlError ulDConfigBit(DaqDeviceHandle daqDeviceHandle, DigitalPortType portType, int bitNum, DigitalDirection direction);

UlError ulDIn(DaqDeviceHandle daqDeviceHandle, DigitalPortType portType, unsigned long long* data);

UlError ulDOut(DaqDeviceHandle daqDeviceHandle, DigitalPortType portType, unsigned long long data);

UlError ulDInArray(DaqDeviceHandle daqDeviceHandle, DigitalPortType lowPort, DigitalPortType highPort, unsigned long long data[]);

UlError ulDOutArray(DaqDeviceHandle daqDeviceHandle, DigitalPortType lowPort, DigitalPortType highPort, unsigned long long data[]);

UlError ulDBitIn(DaqDeviceHandle daqDeviceHandle, DigitalPortType portType, int bitNum, unsigned int* bitValue);

UlError ulDBitOut(DaqDeviceHandle daqDeviceHandle, DigitalPortType portType, int bitNum, unsigned int bitValue);

UlError ulDInScan(DaqDeviceHandle daqDeviceHandle, DigitalPortType lowPort, DigitalPortType highPort, int samplesPerPort, double* rate, ScanOption options, DInScanFlag flags, unsigned long long data[]);

UlError ulDInScanStatus(DaqDeviceHandle daqDeviceHandle, ScanStatus* status, TransferStatus* xferStatus);

UlError ulDInScanStop(DaqDeviceHandle daqDeviceHandle);

UlError ulDInScanWait(DaqDeviceHandle daqDeviceHandle, WaitType waitType, long long waitParam, double timeout);

UlError ulDInSetTrigger(DaqDeviceHandle daqDeviceHandle, TriggerType type, int trigChan, double level, double variance, unsigned int retriggerSampleCount);

UlError ulDOutScan(DaqDeviceHandle daqDeviceHandle, DigitalPortType lowPort, DigitalPortType highPort, int samplesPerPort, double* rate, ScanOption options, DOutScanFlag flags, unsigned long long data[]);

UlError ulDOutScanStatus(DaqDeviceHandle daqDeviceHandle, ScanStatus* status, TransferStatus* xferStatus);

UlError ulDOutScanStop(DaqDeviceHandle daqDeviceHandle);

UlError ulDOutScanWait(DaqDeviceHandle daqDeviceHandle, WaitType waitType, long long waitParam, double timeout);

UlError ulDOutSetTrigger(DaqDeviceHandle daqDeviceHandle, TriggerType type, int trigChan, double level, double variance, unsigned int retriggerSampleCount);

UlError ulDClearAlarm(DaqDeviceHandle daqDeviceHandle, DigitalPortType portType, unsigned long long mask);

UlError ulCIn(DaqDeviceHandle daqDeviceHandle, int counterNum, unsigned long long* data);

UlError ulCRead(DaqDeviceHandle daqDeviceHandle, int counterNum, CounterRegisterType regType, unsigned long long* data);

UlError ulCLoad(DaqDeviceHandle daqDeviceHandle, int counterNum, CounterRegisterType registerType, unsigned long long loadValue);

UlError ulCClear(DaqDeviceHandle daqDeviceHandle, int counterNum);

UlError ulCConfigScan(DaqDeviceHandle daqDeviceHandle, int counterNum, CounterMeasurementType type,  CounterMeasurementMode mode,
                      CounterEdgeDetection edgeDetection, CounterTickSize tickSize,
                      CounterDebounceMode debounceMode, CounterDebounceTime debounceTime, CConfigScanFlag flags);

UlError ulCInScan(DaqDeviceHandle daqDeviceHandle, int lowCounterNum, int highCounterNum, int samplesPerCounter, double* rate, ScanOption options, CInScanFlag flags, unsigned long long data[]);

UlError ulCInSetTrigger(DaqDeviceHandle daqDeviceHandle, TriggerType type, int trigChan, double level, double variance, unsigned int retriggerSampleCount);

UlError ulCInScanStatus(DaqDeviceHandle daqDeviceHandle, ScanStatus* status, TransferStatus* xferStatus);

UlError ulCInScanStop(DaqDeviceHandle daqDeviceHandle);

UlError ulCInScanWait(DaqDeviceHandle daqDeviceHandle, WaitType waitType, long long waitParam, double timeout);

UlError ulTmrPulseOutStart(DaqDeviceHandle daqDeviceHandle, int timerNum, double* frequency, double* dutyCycle, unsigned long long pulseCount, double* initialDelay, TmrIdleState idleState, PulseOutOption options);

UlError ulTmrPulseOutStop(DaqDeviceHandle daqDeviceHandle, int timerNum);

UlError ulTmrPulseOutStatus(DaqDeviceHandle daqDeviceHandle, int timerNum, TmrStatus* status);

UlError ulTmrSetTrigger(DaqDeviceHandle daqDeviceHandle, TriggerType type, int trigChan, double level, double variance, unsigned int retriggerSampleCount);

UlError ulDaqInScan(DaqDeviceHandle daqDeviceHandle, DaqInChanDescriptor chanDescriptors[], int numChans, int samplesPerChan, double* rate, ScanOption options, DaqInScanFlag flags, double data[]);

UlError ulDaqInScanStatus(DaqDeviceHandle daqDeviceHandle, ScanStatus* status, TransferStatus* xferStatus);

UlError ulDaqInScanStop(DaqDeviceHandle daqDeviceHandle);

UlError ulDaqInScanWait(DaqDeviceHandle daqDeviceHandle, WaitType waitType, long long waitParam, double timeout);

UlError ulDaqInSetTrigger(DaqDeviceHandle daqDeviceHandle, TriggerType type, DaqInChanDescriptor trigChanDescriptor, double level, double variance, unsigned int retriggerSampleCount);

UlError ulDaqOutScan(DaqDeviceHandle daqDeviceHandle, DaqOutChanDescriptor chanDescriptors[], int numChans, int samplesPerChan, double* rate, ScanOption options, DaqOutScanFlag flags, double data[]);

UlError ulDaqOutScanStatus(DaqDeviceHandle daqDeviceHandle, ScanStatus* status, TransferStatus* xferStatus);

UlError ulDaqOutScanStop(DaqDeviceHandle daqDeviceHandle);

UlError ulDaqOutScanWait(DaqDeviceHandle daqDeviceHandle, WaitType waitType, long long waitParam, double timeout);

UlError ulDaqOutSetTrigger(DaqDeviceHandle daqDeviceHandle, TriggerType type, DaqInChanDescriptor trigChanDescriptor, double level, double variance, unsigned int retriggerSampleCount);

UlError ulEnableEvent(DaqDeviceHandle daqDeviceHandle, DaqEventType eventTypes, unsigned long long eventParameter, DaqEventCallback eventCallbackFunction, void* userData);

UlError ulDisableEvent(DaqDeviceHandle daqDeviceHandle, DaqEventType eventTypes);

UlError ulMemRead(DaqDeviceHandle daqDeviceHandle, MemRegion memRegion, unsigned int address, unsigned char* buffer, unsigned int count);

UlError ulMemWrite(DaqDeviceHandle daqDeviceHandle, MemRegion memRegion, unsigned int address, unsigned char* buffer, unsigned int count);

UlError ulGetErrMsg(UlError errCode, char errMsg[ERR_MSG_LEN]);

#ifndef doxy_skip

UlError ulGetInfoStr(UlInfoItemStr infoItem, unsigned int index, char* infoStr, unsigned int* maxConfigLen);


UlError ulSetConfig(UlConfigItem configItem, unsigned int index, long long configValue);


UlError ulGetConfig(UlConfigItem configItem, unsigned int index, long long* configValue);
#endif /* doxy_skip */

UlError ulDevGetInfo(DaqDeviceHandle daqDeviceHandle, DevInfoItem infoItem, unsigned int index, long long* infoValue);

UlError ulDevSetConfig(DaqDeviceHandle daqDeviceHandle, DevConfigItem configItem, unsigned int index, long long configValue);

UlError ulDevGetConfig(DaqDeviceHandle daqDeviceHandle, DevConfigItem configItem, unsigned int index, long long* configValue);

UlError ulDevGetConfigStr(DaqDeviceHandle daqDeviceHandle, DevConfigItemStr configItem, unsigned int index, char* configStr, unsigned int* maxConfigLen);

UlError ulAIGetInfo(DaqDeviceHandle daqDeviceHandle, AiInfoItem infoItem, unsigned int index, long long* infoValue);

UlError ulAIGetInfoDbl(DaqDeviceHandle daqDeviceHandle, AiInfoItemDbl infoItem, unsigned int index, double* infoValue);

UlError ulAISetConfig(DaqDeviceHandle daqDeviceHandle, AiConfigItem configItem, unsigned int index, long long configValue);

UlError ulAIGetConfig(DaqDeviceHandle daqDeviceHandle, AiConfigItem configItem, unsigned int index, long long* configValue);

UlError ulAISetConfigDbl(DaqDeviceHandle daqDeviceHandle, AiConfigItemDbl configItem, unsigned int index, double configValue);

UlError ulAIGetConfigDbl(DaqDeviceHandle daqDeviceHandle, AiConfigItemDbl configItem, unsigned int index, double* configValue);

UlError ulAIGetConfigStr(DaqDeviceHandle daqDeviceHandle, AiConfigItemStr configItem, unsigned int index, char* configStr, unsigned int* maxConfigLen);

UlError ulAOGetInfo(DaqDeviceHandle daqDeviceHandle, AoInfoItem infoItem, unsigned int index, long long* infoValue);

UlError ulAOGetInfoDbl(DaqDeviceHandle daqDeviceHandle, AoInfoItemDbl infoItem, unsigned int index, double* infoValue);

UlError ulAOSetConfig(DaqDeviceHandle daqDeviceHandle, AoConfigItem configItem, unsigned int index, long long configValue);

UlError ulAOGetConfig(DaqDeviceHandle daqDeviceHandle, AoConfigItem configItem, unsigned int index, long long* configValue);

UlError ulDIOGetInfo(DaqDeviceHandle daqDeviceHandle, DioInfoItem infoItem, unsigned int index, long long* infoValue);

UlError ulDIOGetInfoDbl(DaqDeviceHandle daqDeviceHandle, DioInfoItemDbl infoItem, unsigned int index, double* infoValue);

UlError ulDIOSetConfig(DaqDeviceHandle daqDeviceHandle, DioConfigItem configItem, unsigned int index, long long configValue);

UlError ulDIOGetConfig(DaqDeviceHandle daqDeviceHandle, DioConfigItem configItem, unsigned int index, long long* configValue);

UlError ulCtrGetInfo(DaqDeviceHandle daqDeviceHandle, CtrInfoItem infoItem, unsigned int index, long long* infoValue);

UlError ulCtrGetInfoDbl(DaqDeviceHandle daqDeviceHandle, CtrInfoItemDbl infoItem, unsigned int index, double* infoValue);

UlError ulCtrGetConfig(DaqDeviceHandle daqDeviceHandle, CtrConfigItem configItem, unsigned int index, long long* configValue);

UlError ulCtrSetConfig(DaqDeviceHandle daqDeviceHandle, CtrConfigItem configItem, unsigned int index, long long configValue);

UlError ulTmrGetInfo(DaqDeviceHandle daqDeviceHandle, TmrInfoItem infoItem, unsigned int index, long long* infoValue);

UlError ulTmrGetInfoDbl(DaqDeviceHandle daqDeviceHandle, TmrInfoItemDbl infoItem, unsigned int index, double* infoValue);

UlError ulDaqIGetInfo(DaqDeviceHandle daqDeviceHandle, DaqIInfoItem infoItem, unsigned int index, long long* infoValue);

UlError ulDaqIGetInfoDbl(DaqDeviceHandle daqDeviceHandle, DaqIInfoItemDbl infoItem, unsigned int index, double* infoValue);

UlError ulDaqOGetInfo(DaqDeviceHandle daqDeviceHandle, DaqOInfoItem infoItem, unsigned int index, long long* infoValue);

UlError ulDaqOGetInfoDbl(DaqDeviceHandle daqDeviceHandle, DaqOInfoItemDbl infoItem, unsigned int index, double* infoValue);

UlError ulMemGetInfo(DaqDeviceHandle daqDeviceHandle, MemRegion memRegion, MemDescriptor* memDescriptor);

#ifndef doxy_skip

DaqDeviceHandle ulCreateDaqDevicePtr(DaqDeviceDescriptor* daqDevDescriptor);

#endif /* doxy_skip */

#ifdef __cplusplus
}
#endif

#endif /* UL_DAQ_H_ */