#if defined(__cplusplus) && !defined(_BDAQ_NO_NAMESPACE) && !defined(_BDAQ_C_INTERFACE)
# ifndef BEGIN_NAMEAPCE_AUTOMATION_BDAQ
# define BEGIN_NAMEAPCE_AUTOMATION_BDAQ namespace Automation { namespace BDaq {
# define END_NAMEAPCE_AUTOMATION_BDAQ } /*BDaq*/ } /*Automation*/
# endif
#else
# ifndef BEGIN_NAMEAPCE_AUTOMATION_BDAQ
# define BEGIN_NAMEAPCE_AUTOMATION_BDAQ
# define END_NAMEAPCE_AUTOMATION_BDAQ
# endif
#endif
/**********************************************************/
/*Bionic DAQ types */
/**********************************************************/
#ifndef _BDAQ_TYPES_DEFINED
#define _BDAQ_TYPES_DEFINED
BEGIN_NAMEAPCE_AUTOMATION_BDAQ
#define DAQ_NAVI_VER 0x400
#define MAX_DEVICE_DESC_LEN 64
#define MAX_VRG_DESC_LEN 256
#define MAX_SIG_DROP_DESC_LEN 256
#define MAX_AI_CH_COUNT 128
#define MAX_AO_CH_COUNT 128
#define MAX_DIO_PORT_COUNT 32
#define MAX_CNTR_CH_COUNT 8
typedef signed char int8;
typedef signed short int16;
typedef unsigned char uint8;
typedef unsigned short uint16;
#if defined(_WIN32) || defined(WIN32)
# define BDAQCALL WINAPI
# ifndef _WIN64
typedef signed int int32;
typedef unsigned int uint32;
# else
typedef signed long int32;
typedef unsigned long uint32;
# endif
typedef signed __int64 int64;
typedef unsigned __int64 uint64;
#else
# define BDAQCALL
typedef signed int int32;
typedef unsigned int uint32;
typedef signed long long int64;
typedef unsigned long long uint64;
typedef void * HANDLE;
#endif
#ifdef __cplusplus
# define BDAQINL __inline
#else
# define BDAQINL static
#endif
typedef enum TerminalBoard {
WiringBoard = 0,
PCLD8710,
PCLD789,
PCLD8115,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
BoardUnknown = 0xffffffff,
} TerminalBoard;
typedef enum ModuleType {
DaqGroup = 1,
DaqDevice,
DaqAi,
DaqAo,
DaqDio,
DaqCounter,
DaqCali,
DaqFw,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
DaqAny = 0xffffffff,
} ModuleType;
typedef enum CaliState {
CaliSuccess = 0,
CaliFailed,
CaliBusy,
CaliIdle,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
CaliUnknown = 0xffffffff,
} CaliState;
typedef enum FwAction {
FwNormal = 1,
FwMandatory,
FwAbort = 0xffffffff,
} FwAction;
/*Firmware update progress code*/
typedef enum ProgressCode {
// [0, 100]: The operation is in progressing
OperationReady = 0,
OperationFinished = 100,
// [-100, -1]: The operation will probably succeed if try it again( nothing need to be changed)!
UnexpectedTermination = -1, // The operation is terminated due to some unknown reason, such as disconnect, power off, etc.
// [-1000, -101]: The material is correct, but software check finds some problem,
FileVersionTooSmall = -101, // Firmware File version is less than the HW's firmware version.
ModuleTypeNotMatch = -102, // The target module type of firmware file does not match with the current one.
// [-2000, -1001]: Parameter error, or device error, and CAN NOT execute the required command
NoFile = -1001, // The firmware file had not been loaded.
DeviceBusy = -1002, // The device is busy.
ActivationCodeError = -1003, // The activation code of firmware update is error.
FileDemaged = -1004, // The file is damaged and the update failed.
} ProgressCode;
typedef enum AccessMode {
ModeRead = 0,
ModeWrite,
ModeWriteWithReset,
ModeWriteShared,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
ModeUnknown = 0xffffffff,
} AccessMode;
typedef enum Depository {
DepositoryNone = 0,
DepositoryOnSystem,
DepositoryOnDevice,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
DepositoryUnknown = 0xffffffff,
} Depository;
typedef enum MathIntervalType {
/* Right boundary definition, define the maximum value state, use the bit 0,1 */
RightOpenSet = 0x0, /* No maximum value limitation. */
RightClosedBoundary = 0x1, /* The maximum value is included. */
RightOpenBoundary = 0x2, /* The maximum value is not included. */
/* Left boundary definition, define the minimum value state, used the bit 2, 3 */
LeftOpenSet = 0x0, /* No minimum value limitation. */
LeftClosedBoundary = 0x4, /* The minimum value is included. */
LeftOpenBoundary = 0x8, /* The minimum value is not included */
/* The signality expression */
Boundless = 0x0, /* Boundless set. (LeftOpenSet | RightOpenSet) */
/* The combination notation */
LOSROS = 0x0, /* (LeftOpenSet | RightOpenSet), algebra notation: (un-limit, max) */
LOSRCB = 0x1, /* (LeftOpenSet | RightClosedBoundary), algebra notation: (un-limit, max ] */
LOSROB = 0x2, /* (LeftOpenSet | RightOpenBoundary), algebra notation: (un-limit, max) */
LCBROS = 0x4, /* (LeftClosedBoundary | RightOpenSet), algebra notation: [min, un-limit) */
LCBRCB = 0x5, /* (LeftClosedBoundary | RightClosedBoundary), algebra notation: [ min, right ] */
LCBROB = 0x6, /* (LeftClosedBoundary | RightOpenBoundary), algebra notation: [ min, right) */
LOBROS = 0x8, /* (LeftOpenBoundary | RightOpenSet), algebra notation: (min, un-limit) */
LOBRCB = 0x9, /* (LeftOpenBoundary | RightClosedBoundary), algebra notation: (min, right ] */
LOBROB = 0xA, /* (LeftOpenBoundary | RightOpenBoundary), algebra notation: (min, right) */
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
IntervalUnknown = 0xffffffff,
} MathIntervalType;
typedef enum AiChannelType {
AllSingleEnded = 0,
AllDifferential,
AllSeDiffAdj,
MixedSeDiffAdj,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
ChannelUnknown = 0xffffffff,
} AiChannelType;
typedef enum AiSignalType {
SingleEnded = 0,
Differential,
PseudoDifferential,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
AiSignalUnknown = 0xffffffff,
} AiSignalType;
typedef enum CouplingType {
DCCoupling = 0,
ACCoupling,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
CouplingUnknown = 0xffffffff,
} CouplingType;
typedef enum ImpedanceType {
Ipd1Momh = 0,
Ipd50omh,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
ImpedanceUnknown = 0xffffffff,
} ImpedanceType;
typedef enum IepeType {
IEPENone = 0,
IEPE4mA = 1,
IEPE10mA = 2,
IEPE2mA = 3,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
IepeUnknown = 0xffffffff,
} IepeType;
typedef enum MeasureType {
VoltageType = 0,
CurrentType = 1,
FullBridge = 2,
HalfBridge = 3,
QuadBridge = 4,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
MeasureUnknown = 0xffffffff,
} MeasureType;
typedef enum SensorType {
StrainGage = 0,
ForceCell = 1,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
SensorUnknown = 0xffffffff,
} SensorType;
typedef enum FilterType {
FilterNone = 0,
LowPass,
HighPass,
BandPass,
BandStop,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
FilterUnknown = 0xffffffff,
} FilterType;
typedef enum DioPortType {
PortDi = 0, /*the port number references to a DI port*/
PortDo, /*the port number references to a DO port*/
PortDio, /*the port number references to a DI port and a DO port*/
Port8255A, /*the port number references to a PPI port A mode DIO port.*/
Port8255C, /*the port number references to a PPI port C mode DIO port.*/
PortIndvdlDio, /*the port number references to a port whose each channel can be configured as in or out.*/
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
PortUnknown = 0xffffffff,
} DioPortType;
typedef enum DioPortDir {
Input = 0x00,
LoutHin = 0x0F,
LinHout = 0xF0,
Output = 0xFF,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
DirUnknown = 0xffffffff,
} DioPortDir;
typedef enum DiOpenState {
PullHigh = 0x00,
PullLow = 0x11,
TriState = 0x33,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
OpenStateUnknown = 0xffffffff,
} DiOpenState;
typedef enum DoCircuitType {
TTL = 0,
Sink = 1,
Source = 2,
Relay = 3,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
TypeUnknown = 0xffffffff,
} DoCircuitType;
typedef enum SamplingMethod {
EqualTimeSwitch = 0,
Simultaneous,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
SamplingUnknown = 0xffffffff,
} SamplingMethod;
typedef enum TemperatureDegree {
Celsius = 0,
Fahrenheit,
Rankine,
Kelvin,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
DegreeUnknown = 0xffffffff,
} TemperatureDegree;
typedef enum BurnoutRetType {
Current = 0,
ParticularValue,
UpLimit,
LowLimit,
LastCorrectValue,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
ReturnUnknown = 0xffffffff,
} BurnoutRetType;
typedef enum ValueUnit {
Kilovolt, /* KV */
Volt, /* V */
Millivolt, /* mV */
Microvolt, /* uV */
Kiloampere, /* KA */
Ampere, /* A */
Milliampere, /* mA */
Microampere, /* uA */
CelsiusUnit, /* Celsius */
Kilogram, /* Kg */
Strain,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
UnitUnknown = 0xffffffff,
} ValueUnit;
typedef enum ValueRange {
V_Neg15To15 = 0, /* +/- 15 V */
V_Neg10To10, /* +/- 10 V */
V_Neg5To5, /* +/- 5 V */
V_Neg2pt5To2pt5, /* +/- 2.5 V */
V_Neg1pt25To1pt25, /* +/- 1.25 V */
V_Neg1To1, /* +/- 1 V */
V_0To15, /* 0~15 V */
V_0To10, /* 0~10 V */
V_0To5, /* 0~5 V */
V_0To2pt5, /* 0~2.5 V */
V_0To1pt25, /* 0~1.25 V */
V_0To1, /* 0~1 V */
mV_Neg625To625, /* +/- 625mV */
mV_Neg500To500, /* +/- 500 mV */
mV_Neg312pt5To312pt5, /* +/- 312.5 mV */
mV_Neg200To200, /* +/- 200 mV */
mV_Neg150To150, /* +/- 150 mV */
mV_Neg100To100, /* +/- 100 mV */
mV_Neg50To50, /* +/- 50 mV */
mV_Neg30To30, /* +/- 30 mV */
mV_Neg20To20, /* +/- 20 mV */
mV_Neg15To15, /* +/- 15 mV */
mV_Neg10To10, /* +/- 10 mV */
mV_Neg5To5, /* +/- 5 mV */
mV_0To625, /* 0 ~ 625 mV */
mV_0To500, /* 0 ~ 500 mV */
mV_0To150, /* 0 ~ 150 mV */
mV_0To100, /* 0 ~ 100 mV */
mV_0To50, /* 0 ~ 50 mV */
mV_0To20, /* 0 ~ 20 mV */
mV_0To15, /* 0 ~ 15 mV */
mV_0To10, /* 0 ~ 10 mV */
mA_Neg20To20, /* +/- 20mA */
mA_0To20, /* 0 ~ 20 mA */
mA_4To20, /* 4 ~ 20 mA */
mA_0To24, /* 0 ~ 24 mA */
/* For USB4702_4704 */
V_Neg2To2, /* +/- 2 V */
V_Neg4To4, /* +/- 4 V */
V_Neg20To20, /* +/- 20 V */
Jtype_0To760C = 0x8000, /* T/C J type 0~760 'C */
Ktype_0To1370C, /* T/C K type 0~1370 'C */
Ttype_Neg100To400C, /* T/C T type -100~400 'C */
Etype_0To1000C, /* T/C E type 0~1000 'C */
Rtype_500To1750C, /* T/C R type 500~1750 'C */
Stype_500To1750C, /* T/C S type 500~1750 'C */
Btype_500To1800C, /* T/C B type 500~1800 'C */
Pt392_Neg50To150, /* Pt392 -50~150 'C */
Pt385_Neg200To200, /* Pt385 -200~200 'C */
Pt385_0To400, /* Pt385 0~400 'C */
Pt385_Neg50To150, /* Pt385 -50~150 'C */
Pt385_Neg100To100, /* Pt385 -100~100 'C */
Pt385_0To100, /* Pt385 0~100 'C */
Pt385_0To200, /* Pt385 0~200 'C */
Pt385_0To600, /* Pt385 0~600 'C */
Pt392_Neg100To100, /* Pt392 -100~100 'C */
Pt392_0To100, /* Pt392 0~100 'C */
Pt392_0To200, /* Pt392 0~200 'C */
Pt392_0To600, /* Pt392 0~600 'C */
Pt392_0To400, /* Pt392 0~400 'C */
Pt392_Neg200To200, /* Pt392 -200~200 'C */
Pt1000_Neg40To160, /* Pt1000 -40~160 'C */
Balcon500_Neg30To120, /* Balcon500 -30~120 'C */
Ni518_Neg80To100, /* Ni518 -80~100 'C */
Ni518_0To100, /* Ni518 0~100 'C */
Ni508_0To100, /* Ni508 0~100 'C */
Ni508_Neg50To200, /* Ni508 -50~200 'C */
Thermistor_3K_0To100, /* Thermistor 3K 0~100 'C */
Thermistor_10K_0To100, /* Thermistor 10K 0~100 'C */
Jtype_Neg210To1200C, /* T/C J type -210~1200 'C */
Ktype_Neg270To1372C, /* T/C K type -270~1372 'C */
Ttype_Neg270To400C, /* T/C T type -270~400 'C */
Etype_Neg270To1000C, /* T/C E type -270~1000 'C */
Rtype_Neg50To1768C, /* T/C R type -50~1768 'C */
Stype_Neg50To1768C, /* T/C S type -50~1768 'C */
Btype_40To1820C, /* T/C B type 40~1820 'C */
Jtype_Neg210To870C, /* T/C J type -210~870 'C */
Rtype_0To1768C, /* T/C R type 0~1768 'C */
Stype_0To1768C, /* T/C S type 0~1768 'C */
Ttype_Neg20To135C, /* T/C T type -20~135 'C */
V_0To30, /* 0 ~ 30 V */
A_0To3, /* 0 ~ 3 A */
Pt100_Neg50To150, /* Pt100 -50~150 'C */
Pt100_Neg200To200, /* Pt100 -200~200 'C */
Pt100_0To100, /* Pt100 0~100 'C */
Pt100_0To200, /* Pt100 0~200 'C */
Pt100_0To400, /* Pt100 0~400 'C */
Btype_300To1820C, /* T/C B type 300~1820 'C */
V_Neg12pt5To12pt5,
V_Neg6To6, /* +/- 6 V */
V_Neg3To3, /* +/- 3 V */
V_Neg1pt5To1pt5, /* +/- 1.5 V */
mV_Neg750To750, /* +/- 750 mV */
mV_Neg375To375, /* +/- 375 mV */
mV_Neg187pt5To187pt5, /* +/- 187.5 mV */
Pt100_385_3Wire, /* Pt100 Mode:3 Wire Type:0.385 */
Pt100_385_24Wire, /* Pt100 Mode:2/4 Wire Type:0.385 */
Pt100_392_3Wire, /* Pt100 Mode:3 Wire Type:0.392 */
Pt100_392_24Wire, /* Pt100 Mode:2/4 Wire Type:0.392 */
Pt1000_385_3Wire, /* Pt1000 Mode:3 Wire Type:0.385 */
Pt1000_385_24Wire, /* Pt1000 Mode:2/4 Wire Type:0.385 */
NiFe604_518_3Wire, /* NiFe604 Mode:3 Wire Type:0.518 */
NiFe604_518_24Wire, /* NiFe604 Mode:2/4 Wire Type:0.518 */
Balco500_518_3Wire, /* Balco500 Mode:3 Wire Type:0.518 */
Balco500_518_24Wire, /* Balco500 Mode:2/4 Wire Type:0.518 */
V_Neg12To12, /* +/- 12 V */
Ntype_Neg270To1300C, /* T/C N type -270~1300 'C, Voltage Range: -4.345mV~47.513mV */
/* 0xC000 ~ 0xF000 : user customized value range type */
UserCustomizedVrgStart = 0xC000,
UserCustomizedVrgEnd = 0xF000,
/* AO external reference type */
V_ExternalRefBipolar = 0xF001, /* External reference voltage unipolar */
V_ExternalRefUnipolar = 0xF002, /* External reference voltage bipolar */
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
V_OMIT = 0xffffffff, /* Unknown when get, ignored when set */
} ValueRange;
typedef enum SignalPolarity {
Negative = 0,
Positive,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
PolarityUnknown = 0xffffffff,
} SignalPolarity;
typedef enum CountingType {
CountingNone = 0,
DownCount, /* counter value decreases on each clock */
UpCount, /* counter value increases on each clock */
PulseDirection, /* counting direction is determined by two signals, one is clock, the other is direction signal */
TwoPulse, /* counting direction is determined by two signals, one is up-counting signal, the other is down-counting signal */
AbPhaseX1, /* AB phase, 1x rate up/down counting */
AbPhaseX2, /* AB phase, 2x rate up/down counting */
AbPhaseX4, /* AB phase, 4x rate up/down counting */
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
CountingUnknown = 0xffffffff,
} CountingType;
/*for compatible*/
typedef CountingType SignalCountingType;
typedef enum OutSignalType{
SignalOutNone = 0, /* no output or output is 'disabled' */
ChipDefined, /* hardware chip defined */
NegChipDefined, /* hardware chip defined, negative logical */
PositivePulse, /* a low-to-high pulse */
NegativePulse, /* a high-to-low pulse */
ToggledFromLow, /* the level toggled from low to high */
ToggledFromHigh, /* the level toggled from high to low */
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
OutSignalUnknown = 0xffffffff,
} OutSignalType;
typedef enum CounterCapability {
Primary = 1,
InstantEventCount,
OneShot,
TimerPulse,
InstantFreqMeter,
InstantPwmIn,
InstantPwmOut,
UpDownCount,
BufferedEventCount,
BufferedPwmIn,
BufferedPwmOut,
BufferedUpDownCount,
InstantEdgeSeparation,
AbsoluteCount,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
CapabilityUnknown = 0xffffffff,
} CounterCapability;
typedef enum CounterOperationMode {
C8254_M0 = 0, /*8254 mode 0, interrupt on terminal count */
C8254_M1, /*8254 mode 1, hardware retriggerable one-shot */
C8254_M2, /*8254 mode 2, rate generator */
C8254_M3, /*8254 mode 3, square save mode */
C8254_M4, /*8254 mode 4, software triggered strobe */
C8254_M5, /*8254 mode 5, hardware triggered strobe */
C1780_MA, /* Mode A level & pulse out, Software-Triggered without Hardware Gating */
C1780_MB, /* Mode B level & pulse out, Software-Triggered with Level Gating, = 8254_M0 */
C1780_MC, /* Mode C level & pulse out, Hardware-triggered strobe level */
C1780_MD, /* Mode D level & Pulse out, Rate generate with no hardware gating */
C1780_ME, /* Mode E level & pulse out, Rate generator with level Gating */
C1780_MF, /* Mode F level & pulse out, Non-retriggerable One-shot (Pulse type = 8254_M1) */
C1780_MG, /* Mode G level & pulse out, Software-triggered delayed pulse one-shot */
C1780_MH, /* Mode H level & pulse out, Software-triggered delayed pulse one-shot with hardware gating */
C1780_MI, /* Mode I level & pulse out, Hardware-triggered delay pulse strobe */
C1780_MJ, /* Mode J level & pulse out, Variable Duty Cycle Rate Generator with No Hardware Gating */
C1780_MK, /* Mode K level & pulse out, Variable Duty Cycle Rate Generator with Level Gating */
C1780_ML, /* Mode L level & pulse out, Hardware-Triggered Delayed Pulse One-Shot */
C1780_MO, /* Mode O level & pulse out, Hardware-Triggered Strobe with Edge Disarm */
C1780_MR, /* Mode R level & pulse out, Non-Retriggerbale One-Shot with Edge Disarm */
C1780_MU, /* Mode U level & pulse out, Hardware-Triggered Delayed Pulse Strobe with Edge Disarm */
C1780_MX, /* Mode X level & pulse out, Hardware-Triggered Delayed Pulse One-Shot with Edge Disarm */
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
OpModeUnknown = 0xffffffff,
} CounterOperationMode;
typedef enum CounterValueRegister {
CntLoad,
CntPreset = CntLoad,
CntHold,
CntOverCompare,
CntUnderCompare,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
RegisterUnknown = 0xffffffff,
} CounterValueRegister;
typedef enum CounterCascadeGroup {
GroupNone = 0, /* no cascade*/
Cnt0Cnt1, /* Counter 0 as first, counter 1 as second. */
Cnt2Cnt3, /* Counter 2 as first, counter 3 as second */
Cnt4Cnt5, /* Counter 4 as first, counter 5 as second */
Cnt6Cnt7, /* Counter 6 as first, counter 7 as second */
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
CascadeUnknown = 0xffffffff,
} CounterCascadeGroup;
typedef enum FreqMeasureMethod {
AutoAdaptive = 0, /* Intelligently select the measurement method according to the input signal. */
CountingPulseBySysTime, /* Using system timing clock to calculate the frequency */
CountingPulseByDevTime, /* Using the device timing clock to calculate the frequency */
PeriodInverse, /* Calculate the frequency from the period of the signal */
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
MethodUnknown = 0xffffffff,
} FreqMeasureMethod;
typedef enum ActiveSignal {
ActiveNone = 0,
RisingEdge,
FallingEdge,
BothEdge,
HighLevel,
LowLevel,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
ActSignalUnknown = 0xffffffff,
} ActiveSignal;
typedef enum TriggerAction {
ActionNone = 0, /* No action to take even if the trigger condition is satisfied */
DelayToStart, /* Begin to start after the specified time is elapsed if the trigger condition is satisfied */
DelayToStop, /* Stop execution after the specified time is elapsed if the trigger condition is satisfied */
Mark, /* Generate a mark data*/
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
ActionUnknown = 0xffffffff,
} TriggerAction;
typedef enum SignalPosition {
InternalSig = 0,
OnConnector,
OnAmsi,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
PositionUnknown = 0xffffffff,
} SignalPosition;
typedef enum SignalDirection {
SigInput,
SigOutput,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
SigDirUnknown = 0xffffffff,
} SignalDirection;
typedef enum SignalDrop {
SignalNone = 0, /* No connection */
/*Internal signal connector*/
SigInternalClock, /* Device built-in clock, If the device has several built-in clock, this represent the highest freq one. */
SigInternal1KHz, /* Device built-in clock, 1KHz */
SigInternal10KHz, /* Device built-in clock, 10KHz */
SigInternal100KHz, /* Device built-in clock, 100KHz */
SigInternal1MHz, /* Device built-in clock, 1MHz */
SigInternal10MHz, /* Device built-in clock, 10MHz */
SigInternal20MHz, /* Device built-in clock, 20MHz */
SigInternal30MHz, /* Device built-in clock, 30MHz */
SigInternal40MHz, /* Device built-in clock, 40MHz */
SigInternal50MHz, /* Device built-in clock, 50MHz */
SigInternal60MHz, /* Device built-in clock, 60MHz */
SigDiPatternMatch, /* When DI pattern match occurred */
SigDiStatusChange, /* When DI status change occurred */
/*Function pin on connector*/
SigExtAnaClock, /* Analog clock pin of connector */
SigExtAnaScanClock, /* scan clock pin of connector */
SigExtAnaTrigger, /* external analog trigger pin of connector */
SigExtAnaTrigger0 = SigExtAnaTrigger, /* external analog trigger pin of connector 0*/
SigExtDigClock, /* digital clock pin of connector */
SigExtDigTrigger0, /* external digital trigger 0 pin(or DI start trigger pin) of connector */
SigExtDigTrigger1, /* external digital trigger 1 pin(or DI stop trigger pin) of connector */
SigExtDigTrigger2, /* external digital trigger 2 pin(or DO start trigger pin) of connector */
SigExtDigTrigger3, /* external digital trigger 3 pin(or DO stop trigger pin) of connector */
SigCHFrzDo, /* Channel freeze DO ports pin */
/*Signal source or target on the connector*/
/*AI channel pins*/
SigAi0, SigAi1, SigAi2, SigAi3, SigAi4, SigAi5, SigAi6, SigAi7,
SigAi8, SigAi9, SigAi10, SigAi11, SigAi12, SigAi13, SigAi14, SigAi15,
SigAi16, SigAi17, SigAi18, SigAi19, SigAi20, SigAi21, SigAi22, SigAi23,
SigAi24, SigAi25, SigAi26, SigAi27, SigAi28, SigAi29, SigAi30, SigAi31,
SigAi32, SigAi33, SigAi34, SigAi35, SigAi36, SigAi37, SigAi38, SigAi39,
SigAi40, SigAi41, SigAi42, SigAi43, SigAi44, SigAi45, SigAi46, SigAi47,
SigAi48, SigAi49, SigAi50, SigAi51, SigAi52, SigAi53, SigAi54, SigAi55,
SigAi56, SigAi57, SigAi58, SigAi59, SigAi60, SigAi61, SigAi62, SigAi63,
/*AO channel pins*/
SigAo0, SigAo1, SigAo2, SigAo3, SigAo4, SigAo5, SigAo6, SigAo7,
SigAo8, SigAo9, SigAo10, SigAo11, SigAo12, SigAo13, SigAo14, SigAo15,
SigAo16, SigAo17, SigAo18, SigAo19, SigAo20, SigAo21, SigAo22, SigAo23,
SigAo24, SigAo25, SigAo26, SigAo27, SigAo28, SigAo29, SigAo30, SigAo31,
/*DI pins*/
SigDi0, SigDi1, SigDi2, SigDi3, SigDi4, SigDi5, SigDi6, SigDi7,
SigDi8, SigDi9, SigDi10, SigDi11, SigDi12, SigDi13, SigDi14, SigDi15,
SigDi16, SigDi17, SigDi18, SigDi19, SigDi20, SigDi21, SigDi22, SigDi23,
SigDi24, SigDi25, SigDi26, SigDi27, SigDi28, SigDi29, SigDi30, SigDi31,
SigDi32, SigDi33, SigDi34, SigDi35, SigDi36, SigDi37, SigDi38, SigDi39,
SigDi40, SigDi41, SigDi42, SigDi43, SigDi44, SigDi45, SigDi46, SigDi47,
SigDi48, SigDi49, SigDi50, SigDi51, SigDi52, SigDi53, SigDi54, SigDi55,
SigDi56, SigDi57, SigDi58, SigDi59, SigDi60, SigDi61, SigDi62, SigDi63,
SigDi64, SigDi65, SigDi66, SigDi67, SigDi68, SigDi69, SigDi70, SigDi71,
SigDi72, SigDi73, SigDi74, SigDi75, SigDi76, SigDi77, SigDi78, SigDi79,
SigDi80, SigDi81, SigDi82, SigDi83, SigDi84, SigDi85, SigDi86, SigDi87,
SigDi88, SigDi89, SigDi90, SigDi91, SigDi92, SigDi93, SigDi94, SigDi95,
SigDi96, SigDi97, SigDi98, SigDi99, SigDi100, SigDi101, SigDi102, SigDi103,
SigDi104, SigDi105, SigDi106, SigDi107, SigDi108, SigDi109, SigDi110, SigDi111,
SigDi112, SigDi113, SigDi114, SigDi115, SigDi116, SigDi117, SigDi118, SigDi119,
SigDi120, SigDi121, SigDi122, SigDi123, SigDi124, SigDi125, SigDi126, SigDi127,
SigDi128, SigDi129, SigDi130, SigDi131, SigDi132, SigDi133, SigDi134, SigDi135,
SigDi136, SigDi137, SigDi138, SigDi139, SigDi140, SigDi141, SigDi142, SigDi143,
SigDi144, SigDi145, SigDi146, SigDi147, SigDi148, SigDi149, SigDi150, SigDi151,
SigDi152, SigDi153, SigDi154, SigDi155, SigDi156, SigDi157, SigDi158, SigDi159,
SigDi160, SigDi161, SigDi162, SigDi163, SigDi164, SigDi165, SigDi166, SigDi167,
SigDi168, SigDi169, SigDi170, SigDi171, SigDi172, SigDi173, SigDi174, SigDi175,
SigDi176, SigDi177, SigDi178, SigDi179, SigDi180, SigDi181, SigDi182, SigDi183,
SigDi184, SigDi185, SigDi186, SigDi187, SigDi188, SigDi189, SigDi190, SigDi191,
SigDi192, SigDi193, SigDi194, SigDi195, SigDi196, SigDi197, SigDi198, SigDi199,
SigDi200, SigDi201, SigDi202, SigDi203, SigDi204, SigDi205, SigDi206, SigDi207,
SigDi208, SigDi209, SigDi210, SigDi211, SigDi212, SigDi213, SigDi214, SigDi215,
SigDi216, SigDi217, SigDi218, SigDi219, SigDi220, SigDi221, SigDi222, SigDi223,
SigDi224, SigDi225, SigDi226, SigDi227, SigDi228, SigDi229, SigDi230, SigDi231,
SigDi232, SigDi233, SigDi234, SigDi235, SigDi236, SigDi237, SigDi238, SigDi239,
SigDi240, SigDi241, SigDi242, SigDi243, SigDi244, SigDi245, SigDi246, SigDi247,
SigDi248, SigDi249, SigDi250, SigDi251, SigDi252, SigDi253, SigDi254, SigDi255,
/*DIO pins*/
SigDio0, SigDio1, SigDio2, SigDio3, SigDio4, SigDio5, SigDio6, SigDio7,
SigDio8, SigDio9, SigDio10, SigDio11, SigDio12, SigDio13, SigDio14, SigDio15,
SigDio16, SigDio17, SigDio18, SigDio19, SigDio20, SigDio21, SigDio22, SigDio23,
SigDio24, SigDio25, SigDio26, SigDio27, SigDio28, SigDio29, SigDio30, SigDio31,
SigDio32, SigDio33, SigDio34, SigDio35, SigDio36, SigDio37, SigDio38, SigDio39,
SigDio40, SigDio41, SigDio42, SigDio43, SigDio44, SigDio45, SigDio46, SigDio47,
SigDio48, SigDio49, SigDio50, SigDio51, SigDio52, SigDio53, SigDio54, SigDio55,
SigDio56, SigDio57, SigDio58, SigDio59, SigDio60, SigDio61, SigDio62, SigDio63,
SigDio64, SigDio65, SigDio66, SigDio67, SigDio68, SigDio69, SigDio70, SigDio71,
SigDio72, SigDio73, SigDio74, SigDio75, SigDio76, SigDio77, SigDio78, SigDio79,
SigDio80, SigDio81, SigDio82, SigDio83, SigDio84, SigDio85, SigDio86, SigDio87,
SigDio88, SigDio89, SigDio90, SigDio91, SigDio92, SigDio93, SigDio94, SigDio95,
SigDio96, SigDio97, SigDio98, SigDio99, SigDio100, SigDio101, SigDio102, SigDio103,
SigDio104, SigDio105, SigDio106, SigDio107, SigDio108, SigDio109, SigDio110, SigDio111,
SigDio112, SigDio113, SigDio114, SigDio115, SigDio116, SigDio117, SigDio118, SigDio119,
SigDio120, SigDio121, SigDio122, SigDio123, SigDio124, SigDio125, SigDio126, SigDio127,
SigDio128, SigDio129, SigDio130, SigDio131, SigDio132, SigDio133, SigDio134, SigDio135,
SigDio136, SigDio137, SigDio138, SigDio139, SigDio140, SigDio141, SigDio142, SigDio143,
SigDio144, SigDio145, SigDio146, SigDio147, SigDio148, SigDio149, SigDio150, SigDio151,
SigDio152, SigDio153, SigDio154, SigDio155, SigDio156, SigDio157, SigDio158, SigDio159,
SigDio160, SigDio161, SigDio162, SigDio163, SigDio164, SigDio165, SigDio166, SigDio167,
SigDio168, SigDio169, SigDio170, SigDio171, SigDio172, SigDio173, SigDio174, SigDio175,
SigDio176, SigDio177, SigDio178, SigDio179, SigDio180, SigDio181, SigDio182, SigDio183,
SigDio184, SigDio185, SigDio186, SigDio187, SigDio188, SigDio189, SigDio190, SigDio191,
SigDio192, SigDio193, SigDio194, SigDio195, SigDio196, SigDio197, SigDio198, SigDio199,
SigDio200, SigDio201, SigDio202, SigDio203, SigDio204, SigDio205, SigDio206, SigDio207,
SigDio208, SigDio209, SigDio210, SigDio211, SigDio212, SigDio213, SigDio214, SigDio215,
SigDio216, SigDio217, SigDio218, SigDio219, SigDio220, SigDio221, SigDio222, SigDio223,
SigDio224, SigDio225, SigDio226, SigDio227, SigDio228, SigDio229, SigDio230, SigDio231,
SigDio232, SigDio233, SigDio234, SigDio235, SigDio236, SigDio237, SigDio238, SigDio239,
SigDio240, SigDio241, SigDio242, SigDio243, SigDio244, SigDio245, SigDio246, SigDio247,
SigDio248, SigDio249, SigDio250, SigDio251, SigDio252, SigDio253, SigDio254, SigDio255,
/*Counter clock pins*/
SigCntClk0, SigCntClk1, SigCntClk2, SigCntClk3, SigCntClk4, SigCntClk5, SigCntClk6, SigCntClk7,
/*counter gate pins*/
SigCntGate0, SigCntGate1, SigCntGate2, SigCntGate3, SigCntGate4, SigCntGate5, SigCntGate6, SigCntGate7,
/*counter out pins*/
SigCntOut0, SigCntOut1, SigCntOut2, SigCntOut3, SigCntOut4, SigCntOut5, SigCntOut6, SigCntOut7,
/*counter frequency out pins*/
SigCntFout0, SigCntFout1, SigCntFout2, SigCntFout3, SigCntFout4, SigCntFout5, SigCntFout6, SigCntFout7,
/*AMSI pins*/
SigAmsiPin0, SigAmsiPin1, SigAmsiPin2, SigAmsiPin3, SigAmsiPin4, SigAmsiPin5, SigAmsiPin6, SigAmsiPin7,
SigAmsiPin8, SigAmsiPin9, SigAmsiPin10, SigAmsiPin11, SigAmsiPin12, SigAmsiPin13, SigAmsiPin14, SigAmsiPin15,
SigAmsiPin16, SigAmsiPin17, SigAmsiPin18, SigAmsiPin19,
/*new clocks*/
SigInternal2Hz, /* Device built-in clock, 2Hz */
SigInternal20Hz, /* Device built-in clock, 20Hz */
SigInternal200Hz, /* Device built-in clock, 200KHz */
SigInternal2KHz, /* Device built-in clock, 2KHz */
SigInternal20KHz, /* Device built-in clock, 20KHz */
SigInternal200KHz, /* Device built-in clock, 200KHz */
SigInternal2MHz, /* Device built-in clock, 2MHz */
/*New Function pin on connector*/
SigExtAnaTrigger1, /* external analog trigger pin of connector 1 */
/*Reference clock*/
SigExtDigRefClock, /* digital clock pin of connector */
SigInternal100MHz,
SigAiConvClock,
/*digital trigger from master after ADC latency*/
SigExtDigTrgAdcLatency,
SigExtDigTrg0AdcLatency = SigExtDigTrgAdcLatency,
SigExtDigTrg1AdcLatency,
/*digital trigger from master/MSDI pin after ADC latency*/
SigMDSITrg0,
SigMDSITrg1,
SigMDSITrg0AdcLatency,
SigMDSITrg1AdcLatency,
/*reference clock source from master/MDSI pin*/
SigMDSIRefClock,
SigMDSIClock,
/*When DI Port x pattern match occurred*/
SigDiPatternMatch0, SigDiPatternMatch1, SigDiPatternMatch2, SigDiPatternMatch3, SigDiPatternMatch4,
SigDiPatternMatch5, SigDiPatternMatch6, SigDiPatternMatch7, SigDiPatternMatch8, SigDiPatternMatch9,
SigDiPatternMatch10, SigDiPatternMatch11, SigDiPatternMatch12, SigDiPatternMatch13, SigDiPatternMatch14,
SigDiPatternMatch15, SigDiPatternMatch16, SigDiPatternMatch17, SigDiPatternMatch18, SigDiPatternMatch19,
SigDiPatternMatch20, SigDiPatternMatch21, SigDiPatternMatch22, SigDiPatternMatch23, SigDiPatternMatch24,
SigDiPatternMatch25, SigDiPatternMatch26, SigDiPatternMatch27, SigDiPatternMatch28, SigDiPatternMatch29,
SigDiPatternMatch30, SigDiPatternMatch31,
/*device internal clock*/
SigInternal16384KHz, /* Device built-in clock, 16.384MHz */
/*signals for fusion device*/
SigSyncJunction,
SigConvClkJunction,
SigClkDivJunction,
SigTrgStrJunction,
SigTrgStpJunction,
SigAcqStaJunction,
SigClkDiv0, SigClkDiv1, SigClkDiv2, SigClkDiv3, SigClkDiv4, SigClkDiv5, SigClkDiv6, SigClkDiv7,
SigClkDiv8, SigClkDiv9, SigClkDiv10, SigClkDiv11, SigClkDiv12, SigClkDiv13, SigClkDiv14, SigClkDiv15,
SigAcqEng0, SigAcqEng1, SigAcqEng2, SigAcqEng3, SigAcqEng4, SigAcqEng5, SigAcqEng6, SigAcqEng7,
SigAcqEng8, SigAcqEng9, SigAcqEng10, SigAcqEng11, SigAcqEng12, SigAcqEng13, SigAcqEng14, SigAcqEng15,
SigSwTrg0, SigSwTrg1, SigSwTrg2, SigSwTrg3, SigSwTrg4, SigSwTrg5, SigSwTrg6, SigSwTrg7,
SigSwTrg8, SigSwTrg9, SigSwTrg10, SigSwTrg11, SigSwTrg12, SigSwTrg13, SigSwTrg14, SigSwTrg15,
SigSwTrg16, SigSwTrg17, SigSwTrg18, SigSwTrg19, SigSwTrg20, SigSwTrg21, SigSwTrg22, SigSwTrg23,
SigSwTrg24, SigSwTrg25, SigSwTrg26, SigSwTrg27, SigSwTrg28, SigSwTrg29, SigSwTrg30, SigSwTrg31,
SigBpSlotIn0, SigBpSlotIn1, SigBpSlotIn2, SigBpSlotIn3, SigBpSlotIn4, SigBpSlotIn5, SigBpSlotIn6, SigBpSlotIn7,
SigBpSlotIn8, SigBpSlotIn9, SigBpSlotIn10, SigBpSlotIn11, SigBpSlotIn12, SigBpSlotIn13, SigBpSlotIn14, SigBpSlotIn15,
SigSlotOut,
SigPFP0, SigPFP1, SigPFP2, SigPFP3, SigPFP4, SigPFP5, SigPFP6, SigPFP7,
SigClkGen0, SigClkGen1, SigClkGen2, SigClkGen3,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
SigDropUnknown = 0xffffffff,
} SignalDrop;
/*
* Event Id
*/
typedef enum EventId {
EvtDeviceRemoved = 0, /* The device was removed from system */
EvtDeviceReconnected, /* The device is reconnected */
EvtPropertyChanged, /* Some properties of the device were changed */
/*-----------------------------------------------------------------
* AI events
*-----------------------------------------------------------------*/
EvtBufferedAiDataReady,
EvtBufferedAiOverrun,
EvtBufferedAiCacheOverflow,
EvtBufferedAiStopped,
/*-----------------------------------------------------------------
* AO event IDs
*-----------------------------------------------------------------*/
EvtBufferedAoDataTransmitted,
EvtBufferedAoUnderrun,
EvtBufferedAoCacheEmptied,
EvtBufferedAoTransStopped,
EvtBufferedAoStopped,
/*-----------------------------------------------------------------
* DIO event IDs
*-----------------------------------------------------------------*/
EvtDiInterrupt, EvtDiintChannel000 = EvtDiInterrupt,
EvtDiintChannel001, EvtDiintChannel002, EvtDiintChannel003,
EvtDiintChannel004, EvtDiintChannel005, EvtDiintChannel006, EvtDiintChannel007,
EvtDiintChannel008, EvtDiintChannel009, EvtDiintChannel010, EvtDiintChannel011,
EvtDiintChannel012, EvtDiintChannel013, EvtDiintChannel014, EvtDiintChannel015,
EvtDiintChannel016, EvtDiintChannel017, EvtDiintChannel018, EvtDiintChannel019,
EvtDiintChannel020, EvtDiintChannel021, EvtDiintChannel022, EvtDiintChannel023,
EvtDiintChannel024, EvtDiintChannel025, EvtDiintChannel026, EvtDiintChannel027,
EvtDiintChannel028, EvtDiintChannel029, EvtDiintChannel030, EvtDiintChannel031,
EvtDiintChannel032, EvtDiintChannel033, EvtDiintChannel034, EvtDiintChannel035,
EvtDiintChannel036, EvtDiintChannel037, EvtDiintChannel038, EvtDiintChannel039,
EvtDiintChannel040, EvtDiintChannel041, EvtDiintChannel042, EvtDiintChannel043,
EvtDiintChannel044, EvtDiintChannel045, EvtDiintChannel046, EvtDiintChannel047,
EvtDiintChannel048, EvtDiintChannel049, EvtDiintChannel050, EvtDiintChannel051,
EvtDiintChannel052, EvtDiintChannel053, EvtDiintChannel054, EvtDiintChannel055,
EvtDiintChannel056, EvtDiintChannel057, EvtDiintChannel058, EvtDiintChannel059,
EvtDiintChannel060, EvtDiintChannel061, EvtDiintChannel062, EvtDiintChannel063,
EvtDiintChannel064, EvtDiintChannel065, EvtDiintChannel066, EvtDiintChannel067,
EvtDiintChannel068, EvtDiintChannel069, EvtDiintChannel070, EvtDiintChannel071,
EvtDiintChannel072, EvtDiintChannel073, EvtDiintChannel074, EvtDiintChannel075,
EvtDiintChannel076, EvtDiintChannel077, EvtDiintChannel078, EvtDiintChannel079,
EvtDiintChannel080, EvtDiintChannel081, EvtDiintChannel082, EvtDiintChannel083,
EvtDiintChannel084, EvtDiintChannel085, EvtDiintChannel086, EvtDiintChannel087,
EvtDiintChannel088, EvtDiintChannel089, EvtDiintChannel090, EvtDiintChannel091,
EvtDiintChannel092, EvtDiintChannel093, EvtDiintChannel094, EvtDiintChannel095,
EvtDiintChannel096, EvtDiintChannel097, EvtDiintChannel098, EvtDiintChannel099,
EvtDiintChannel100, EvtDiintChannel101, EvtDiintChannel102, EvtDiintChannel103,
EvtDiintChannel104, EvtDiintChannel105, EvtDiintChannel106, EvtDiintChannel107,
EvtDiintChannel108, EvtDiintChannel109, EvtDiintChannel110, EvtDiintChannel111,
EvtDiintChannel112, EvtDiintChannel113, EvtDiintChannel114, EvtDiintChannel115,
EvtDiintChannel116, EvtDiintChannel117, EvtDiintChannel118, EvtDiintChannel119,
EvtDiintChannel120, EvtDiintChannel121, EvtDiintChannel122, EvtDiintChannel123,
EvtDiintChannel124, EvtDiintChannel125, EvtDiintChannel126, EvtDiintChannel127,
EvtDiintChannel128, EvtDiintChannel129, EvtDiintChannel130, EvtDiintChannel131,
EvtDiintChannel132, EvtDiintChannel133, EvtDiintChannel134, EvtDiintChannel135,
EvtDiintChannel136, EvtDiintChannel137, EvtDiintChannel138, EvtDiintChannel139,
EvtDiintChannel140, EvtDiintChannel141, EvtDiintChannel142, EvtDiintChannel143,
EvtDiintChannel144, EvtDiintChannel145, EvtDiintChannel146, EvtDiintChannel147,
EvtDiintChannel148, EvtDiintChannel149, EvtDiintChannel150, EvtDiintChannel151,
EvtDiintChannel152, EvtDiintChannel153, EvtDiintChannel154, EvtDiintChannel155,
EvtDiintChannel156, EvtDiintChannel157, EvtDiintChannel158, EvtDiintChannel159,
EvtDiintChannel160, EvtDiintChannel161, EvtDiintChannel162, EvtDiintChannel163,
EvtDiintChannel164, EvtDiintChannel165, EvtDiintChannel166, EvtDiintChannel167,
EvtDiintChannel168, EvtDiintChannel169, EvtDiintChannel170, EvtDiintChannel171,
EvtDiintChannel172, EvtDiintChannel173, EvtDiintChannel174, EvtDiintChannel175,
EvtDiintChannel176, EvtDiintChannel177, EvtDiintChannel178, EvtDiintChannel179,
EvtDiintChannel180, EvtDiintChannel181, EvtDiintChannel182, EvtDiintChannel183,
EvtDiintChannel184, EvtDiintChannel185, EvtDiintChannel186, EvtDiintChannel187,
EvtDiintChannel188, EvtDiintChannel189, EvtDiintChannel190, EvtDiintChannel191,
EvtDiintChannel192, EvtDiintChannel193, EvtDiintChannel194, EvtDiintChannel195,
EvtDiintChannel196, EvtDiintChannel197, EvtDiintChannel198, EvtDiintChannel199,
EvtDiintChannel200, EvtDiintChannel201, EvtDiintChannel202, EvtDiintChannel203,
EvtDiintChannel204, EvtDiintChannel205, EvtDiintChannel206, EvtDiintChannel207,
EvtDiintChannel208, EvtDiintChannel209, EvtDiintChannel210, EvtDiintChannel211,
EvtDiintChannel212, EvtDiintChannel213, EvtDiintChannel214, EvtDiintChannel215,
EvtDiintChannel216, EvtDiintChannel217, EvtDiintChannel218, EvtDiintChannel219,
EvtDiintChannel220, EvtDiintChannel221, EvtDiintChannel222, EvtDiintChannel223,
EvtDiintChannel224, EvtDiintChannel225, EvtDiintChannel226, EvtDiintChannel227,
EvtDiintChannel228, EvtDiintChannel229, EvtDiintChannel230, EvtDiintChannel231,
EvtDiintChannel232, EvtDiintChannel233, EvtDiintChannel234, EvtDiintChannel235,
EvtDiintChannel236, EvtDiintChannel237, EvtDiintChannel238, EvtDiintChannel239,
EvtDiintChannel240, EvtDiintChannel241, EvtDiintChannel242, EvtDiintChannel243,
EvtDiintChannel244, EvtDiintChannel245, EvtDiintChannel246, EvtDiintChannel247,
EvtDiintChannel248, EvtDiintChannel249, EvtDiintChannel250, EvtDiintChannel251,
EvtDiintChannel252, EvtDiintChannel253, EvtDiintChannel254, EvtDiintChannel255,
EvtDiStatusChange, EvtDiCosintPort000 = EvtDiStatusChange,
EvtDiCosintPort001, EvtDiCosintPort002, EvtDiCosintPort003,
EvtDiCosintPort004, EvtDiCosintPort005, EvtDiCosintPort006, EvtDiCosintPort007,
EvtDiCosintPort008, EvtDiCosintPort009, EvtDiCosintPort010, EvtDiCosintPort011,
EvtDiCosintPort012, EvtDiCosintPort013, EvtDiCosintPort014, EvtDiCosintPort015,
EvtDiCosintPort016, EvtDiCosintPort017, EvtDiCosintPort018, EvtDiCosintPort019,
EvtDiCosintPort020, EvtDiCosintPort021, EvtDiCosintPort022, EvtDiCosintPort023,
EvtDiCosintPort024, EvtDiCosintPort025, EvtDiCosintPort026, EvtDiCosintPort027,
EvtDiCosintPort028, EvtDiCosintPort029, EvtDiCosintPort030, EvtDiCosintPort031,
EvtDiPatternMatch, EvtDiPmintPort000 = EvtDiPatternMatch,
EvtDiPmintPort001, EvtDiPmintPort002, EvtDiPmintPort003,
EvtDiPmintPort004, EvtDiPmintPort005, EvtDiPmintPort006, EvtDiPmintPort007,
EvtDiPmintPort008, EvtDiPmintPort009, EvtDiPmintPort010, EvtDiPmintPort011,
EvtDiPmintPort012, EvtDiPmintPort013, EvtDiPmintPort014, EvtDiPmintPort015,
EvtDiPmintPort016, EvtDiPmintPort017, EvtDiPmintPort018, EvtDiPmintPort019,
EvtDiPmintPort020, EvtDiPmintPort021, EvtDiPmintPort022, EvtDiPmintPort023,
EvtDiPmintPort024, EvtDiPmintPort025, EvtDiPmintPort026, EvtDiPmintPort027,
EvtDiPmintPort028, EvtDiPmintPort029, EvtDiPmintPort030, EvtDiPmintPort031,
EvtBufferedDiDataReady,
EvtBufferedDiOverrun,
EvtBufferedDiCacheOverflow,
EvtBufferedDiStopped,
EvtBufferedDoDataTransmitted,
EvtBufferedDoUnderrun,
EvtBufferedDoCacheEmptied,
EvtBufferedDoTransStopped,
EvtBufferedDoStopped,
EvtReflectWdtOccured,
/*-----------------------------------------------------------------
* Counter/Timer event IDs
*-----------------------------------------------------------------*/
EvtCntTerminalCount0, EvtCntTerminalCount1, EvtCntTerminalCount2, EvtCntTerminalCount3,
EvtCntTerminalCount4, EvtCntTerminalCount5, EvtCntTerminalCount6, EvtCntTerminalCount7,
EvtCntOverCompare0, EvtCntOverCompare1, EvtCntOverCompare2, EvtCntOverCompare3,
EvtCntOverCompare4, EvtCntOverCompare5, EvtCntOverCompare6, EvtCntOverCompare7,
EvtCntUnderCompare0, EvtCntUnderCompare1, EvtCntUnderCompare2, EvtCntUnderCompare3,
EvtCntUnderCompare4, EvtCntUnderCompare5, EvtCntUnderCompare6, EvtCntUnderCompare7,
EvtCntEcOverCompare0, EvtCntEcOverCompare1, EvtCntEcOverCompare2, EvtCntEcOverCompare3,
EvtCntEcOverCompare4, EvtCntEcOverCompare5, EvtCntEcOverCompare6, EvtCntEcOverCompare7,
EvtCntEcUnderCompare0, EvtCntEcUnderCompare1, EvtCntEcUnderCompare2, EvtCntEcUnderCompare3,
EvtCntEcUnderCompare4, EvtCntEcUnderCompare5, EvtCntEcUnderCompare6, EvtCntEcUnderCompare7,
EvtCntOneShot0, EvtCntOneShot1, EvtCntOneShot2, EvtCntOneShot3,
EvtCntOneShot4, EvtCntOneShot5, EvtCntOneShot6, EvtCntOneShot7,
EvtCntTimer0, EvtCntTimer1, EvtCntTimer2, EvtCntTimer3,
EvtCntTimer4, EvtCntTimer5, EvtCntTimer6, EvtCntTimer7,
EvtCntPwmInOverflow0, EvtCntPwmInOverflow1, EvtCntPwmInOverflow2, EvtCntPwmInOverflow3,
EvtCntPwmInOverflow4, EvtCntPwmInOverflow5, EvtCntPwmInOverflow6, EvtCntPwmInOverflow7,
EvtUdIndex0, EvtUdIndex1, EvtUdIndex2, EvtUdIndex3,
EvtUdIndex4, EvtUdIndex5, EvtUdIndex6, EvtUdIndex7,
EvtCntPatternMatch0, EvtCntPatternMatch1, EvtCntPatternMatch2, EvtCntPatternMatch3,
EvtCntPatternMatch4, EvtCntPatternMatch5, EvtCntPatternMatch6, EvtCntPatternMatch7,
EvtCntCompareTableEnd0, EvtCntCompareTableEnd1, EvtCntCompareTableEnd2, EvtCntCompareTableEnd3,
EvtCntCompareTableEnd4, EvtCntCompareTableEnd5, EvtCntCompareTableEnd6, EvtCntCompareTableEnd7,
/*##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
/*v1.1: new event of AI */
/*##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
EvtBufferedAiBurnOut,
EvtBufferedAiTimeStampOverrun,
EvtBufferedAiTimeStampCacheOverflow,
EvtBufferedAiMarkOverrun,
EvtBufferedAiConvStopped, /* Reserved for later using */
/*##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
/*v1.2: new event of Buffered Counter */
/*##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
EvtCiDataReady, EvtCiDataReady0 = EvtCiDataReady, EvtCiDataReady1, EvtCiDataReady2,
EvtCiDataReady3, EvtCiDataReady4, EvtCiDataReady5, EvtCiDataReady6, EvtCiDataReady7,
EvtCiOverrun, EvtCiOverrun0 = EvtCiOverrun, EvtCiOverrun1, EvtCiOverrun2,
EvtCiOverrun3, EvtCiOverrun4, EvtCiOverrun5, EvtCiOverrun6, EvtCiOverrun7,
EvtCiCacheOverflow, EvtCiCacheOverflow0 = EvtCiCacheOverflow, EvtCiCacheOverflow1, EvtCiCacheOverflow2,
EvtCiCacheOverflow3, EvtCiCacheOverflow4, EvtCiCacheOverflow5, EvtCiCacheOverflow6, EvtCiCacheOverflow7,
EvtCoDataTransmitted, EvtCoDataTransmitted0 = EvtCoDataTransmitted, EvtCoDataTransmitted1, EvtCoDataTransmitted2,
EvtCoDataTransmitted3, EvtCoDataTransmitted4, EvtCoDataTransmitted5, EvtCoDataTransmitted6, EvtCoDataTransmitted7,
EvtCoUnderrun, EvtCoUnderrun0 = EvtCoUnderrun, EvtCoUnderrun1, EvtCoUnderrun2,
EvtCoUnderrun3, EvtCoUnderrun4, EvtCoUnderrun5, EvtCoUnderrun6, EvtCoUnderrun7,
EvtCoCacheEmptied, EvtCoCacheEmptied0 = EvtCoCacheEmptied, EvtCoCacheEmptied1, EvtCoCacheEmptied2,
EvtCoCacheEmptied3, EvtCoCacheEmptied4, EvtCoCacheEmptied5, EvtCoCacheEmptied6, EvtCoCacheEmptied7,
EvtCoTransStopped, EvtCoTransStopped0 = EvtCoTransStopped, EvtCoTransStopped1, EvtCoTransStopped2,
EvtCoTransStopped3, EvtCoTransStopped4, EvtCoTransStopped5, EvtCoTransStopped6, EvtCoTransStopped7,
EvtCntrStopped, EvtCntrStopped0 = EvtCntrStopped, EvtCntrStopped1, EvtCntrStopped2,
EvtCntrStopped3, EvtCntrStopped4, EvtCntrStopped5, EvtCntrStopped6, EvtCntrStopped7,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
EventUnknown = 0xffffffff,
} EventId ;
#define BioFailed(c) ((unsigned)(c) >= (unsigned)0xC0000000)
typedef enum ErrorCode {
///
/// The operation is completed successfully.
///
Success = 0,
///************************************************************************
/// warning
///************************************************************************
///
/// The interrupt resource is not available.
///
WarningIntrNotAvailable = 0xA0000000,
///
/// The parameter is out of the range.
///
WarningParamOutOfRange = 0xA0000001,
///
/// The property value is out of range.
///
WarningPropValueOutOfRange = 0xA0000002,
///
/// The property value is not supported.
///
WarningPropValueNotSpted = 0xA0000003,
///
/// The property value conflicts with the current state.
///
WarningPropValueConflict = 0xA0000004,
///
/// The value range of all channels in a group should be same,
/// such as 4~20mA of PCI-1724.
///
WarningVrgOfGroupNotSame = 0xA0000005,
///
/// Some properties of a property set are failed to be written into device.
///
///
WarningPropPartialFailed = 0xA0000006,
///
/// The operation had been stopped.
///
///
WarningFuncStopped = 0xA0000007,
///
/// The operation is time-out.
///
///
WarningFuncTimeout = 0xA0000008,
///
/// The cache is over-run.
///
///
WarningCacheOverflow = 0xA0000009,
///
/// The channel is burn-out.
///
///
WarningBurnout = 0xA000000A,
///
/// The current data record is end.
///
///
WarningRecordEnd = 0xA000000B,
///
/// The specified profile is not valid.
///
///
WarningProfileNotValid = 0xA000000C,
///
/// firmware version is not newer than the FW in Device.
///
///
WarningFileMismatch = 0xA000000D,
///***********************************************************************
/// error
///***********************************************************************
///
/// The handle is NULL or its type doesn't match the required operation.
///
ErrorHandleNotValid = 0xE0000000,
///
/// The parameter value is out of range.
///
ErrorParamOutOfRange = 0xE0000001,
///
/// The parameter value is not supported.
///
ErrorParamNotSpted = 0xE0000002,
///
/// The parameter value format is not the expected.
///
ErrorParamFmtUnexpted = 0xE0000003,
///
/// Not enough memory is available to complete the operation.
///
ErrorMemoryNotEnough = 0xE0000004,
///
/// The data buffer is null.
///
ErrorBufferIsNull = 0xE0000005,
///
/// The data buffer is too small for the operation.
///
ErrorBufferTooSmall = 0xE0000006,
///
/// The data length exceeded the limitation.
///
ErrorDataLenExceedLimit = 0xE0000007,
///
/// The required function is not supported.
///
ErrorFuncNotSpted = 0xE0000008,
///
/// The required event is not supported.
///
ErrorEventNotSpted = 0xE0000009,
///
/// The required property is not supported.
///
ErrorPropNotSpted = 0xE000000A,
///
/// The required property is read-only.
///
ErrorPropReadOnly = 0xE000000B,
///
/// The specified property value conflicts with the current state.
///
ErrorPropValueConflict = 0xE000000C,
///
/// The specified property value is out of range.
///
ErrorPropValueOutOfRange = 0xE000000D,
///
/// The specified property value is not supported.
///
ErrorPropValueNotSpted = 0xE000000E,
///
/// The handle hasn't own the privilege of the operation the user wanted.
///
ErrorPrivilegeNotHeld = 0xE000000F,
///
/// The required privilege is not available because someone else had own it.
///
ErrorPrivilegeNotAvailable = 0xE0000010,
///
/// The driver of specified device was not found.
///
ErrorDriverNotFound = 0xE0000011,
///
/// The driver version of the specified device mismatched.
///
ErrorDriverVerMismatch = 0xE0000012,
///
/// The loaded driver count exceeded the limitation.
///
ErrorDriverCountExceedLimit = 0xE0000013,
///
/// The device is not opened.
///
ErrorDeviceNotOpened = 0xE0000014,
///
/// The required device does not exist.
///
ErrorDeviceNotExist = 0xE0000015,
///
/// The required device is unrecognized by driver.
///
ErrorDeviceUnrecognized = 0xE0000016,
///
/// The configuration data of the specified device is lost or unavailable.
///
ErrorConfigDataLost = 0xE0000017,
///
/// The function is not initialized and can't be started.
///
ErrorFuncNotInited = 0xE0000018,
///
/// The function is busy.
///
ErrorFuncBusy = 0xE0000019,
///
/// The interrupt resource is not available.
///
ErrorIntrNotAvailable = 0xE000001A,
///
/// The DMA channel is not available.
///
ErrorDmaNotAvailable = 0xE000001B,
///
/// Time out when reading/writing the device.
///
ErrorDeviceIoTimeOut = 0xE000001C,
///
/// The given signature does not match with the device current one.
///
ErrorSignatureNotMatch = 0xE000001D,
///
/// The function cannot be executed while the buffered AI is running.
///
ErrorFuncConflictWithBfdAi = 0xE000001E,
///
/// The value range is not available in single-ended mode.
///
ErrorVrgNotAvailableInSeMode = 0xE000001F,
///
/// The value range is not available in 50omh input impedance mode..
///
ErrorVrgNotAvailableIn50ohmMode = 0xE0000020,
///
/// The coupling type is not available in 50omh input impedance mode..
///
ErrorCouplingNotAvailableIn50ohmMode = 0xE0000021,
///
/// The coupling type is not available in IEPE mode.
///
ErrorCouplingNotAvailableInIEPEMode = 0xE0000022,
///
/// The Communication is failed when reading/writing the device.
///
ErrorDeviceCommunicationFailed = 0xE0000023,
///
/// The device's 'fix number' conflicted with other device's
///
ErrorFixNumberConflict = 0xE0000024,
///
/// The Trigger source conflicted with other trigger configuration
///
ErrorTrigSrcConflict = 0xE0000025,
///
/// All properties of a property set are failed to be written into device.
///
ErrorPropAllFailed = 0xE0000026,
///
/// These devices can not be merged as a Fusion Device.
///
ErrorDeviceNotFusionable = 0xE0000027,
///Open File error
ErrorFileOpenFailed = 0xE0000028,
//File is not for the device
ErrorNotCompatible = 0xE0000029,
///
/// Undefined error
///
ErrorUndefined = 0xE000FFFF,
} ErrorCode;
// Advantech CardType ID
typedef enum ProductId {
BD_DEMO = 0x00, // demo board
BD_PCL818 = 0x05, // PCL-818 board
BD_PCL818H = 0x11, // PCL-818H
BD_PCL818L = 0x21, // PCL-818L
BD_PCL818HG = 0x22, // PCL-818HG
BD_PCL818HD = 0x2b, // PCL-818HD
BD_PCM3718 = 0x37, // PCM-3718
BD_PCM3724 = 0x38, // PCM-3724
BD_PCM3730 = 0x5a, // PCM-3730
BD_PCI1750 = 0x5e, // PCI-1750
BD_PCI1751 = 0x5f, // PCI-1751
BD_PCI1710 = 0x60, // PCI-1710
BD_PCI1712 = 0x61, // PCI-1712
BD_PCI1710HG = 0x67, // PCI-1710HG
BD_PCI1711 = 0x73, // PCI-1711
BD_PCI1711L = 0x75, // PCI-1711L
BD_PCI1713 = 0x68, // PCI-1713
BD_PCI1753 = 0x69, // PCI-1753
BD_PCI1760 = 0x6a, // PCI-1760
BD_PCI1720 = 0x6b, // PCI-1720
BD_PCM3718H = 0x6d, // PCM-3718H
BD_PCM3718HG = 0x6e, // PCM-3718HG
BD_PCI1716 = 0x74, // PCI-1716
BD_PCI1731 = 0x75, // PCI-1731
BD_PCI1754 = 0x7b, // PCI-1754
BD_PCI1752 = 0x7c, // PCI-1752
BD_PCI1756 = 0x7d, // PCI-1756
BD_PCM3725 = 0x7f, // PCM-3725
BD_PCI1762 = 0x80, // PCI-1762
BD_PCI1721 = 0x81, // PCI-1721
BD_PCI1761 = 0x82, // PCI-1761
BD_PCI1723 = 0x83, // PCI-1723
BD_PCI1730 = 0x87, // PCI-1730
BD_PCI1733 = 0x88, // PCI-1733
BD_PCI1734 = 0x89, // PCI-1734
BD_PCI1710L = 0x90, // PCI-1710L
BD_PCI1710HGL = 0x91, // PCI-1710HGL
BD_PCM3712 = 0x93, // PCM-3712
BD_PCM3723 = 0x94, // PCM-3723
BD_PCI1780 = 0x95, // PCI-1780
BD_MIC3756 = 0x96, // MIC-3756
BD_PCI1755 = 0x97, // PCI-1755
BD_PCI1714 = 0x98, // PCI-1714
BD_PCI1757 = 0x99, // PCI-1757
BD_MIC3716 = 0x9A, // MIC-3716
BD_MIC3761 = 0x9B, // MIC-3761
BD_MIC3753 = 0x9C, // MIC-3753
BD_MIC3780 = 0x9D, // MIC-3780
BD_PCI1724 = 0x9E, // PCI-1724
BD_PCI1758UDI = 0xA3, // PCI-1758UDI
BD_PCI1758UDO = 0xA4, // PCI-1758UDO
BD_PCI1747 = 0xA5, // PCI-1747
BD_PCM3780 = 0xA6, // PCM-3780
BD_MIC3747 = 0xA7, // MIC-3747
BD_PCI1758UDIO = 0xA8, // PCI-1758UDIO
BD_PCI1712L = 0xA9, // PCI-1712L
BD_PCI1763UP = 0xAC, // PCI-1763UP
BD_PCI1736UP = 0xAD, // PCI-1736UP
BD_PCI1714UL = 0xAE, // PCI-1714UL
BD_MIC3714 = 0xAF, // MIC-3714
BD_PCM3718HO = 0xB1, // PCM-3718HO
BD_PCI1741U = 0xB3, // PCI-1741U
BD_MIC3723 = 0xB4, // MIC-3723
BD_PCI1718HDU = 0xB5, // PCI-1718HDU
BD_MIC3758DIO = 0xB6, // MIC-3758DIO
BD_PCI1727U = 0xB7, // PCI-1727U
BD_PCI1718HGU = 0xB8, // PCI-1718HGU
BD_PCI1715U = 0xB9, // PCI-1715U
BD_PCI1716L = 0xBA, // PCI-1716L
BD_PCI1735U = 0xBB, // PCI-1735U
BD_USB4711 = 0xBC, // USB4711
BD_PCI1737U = 0xBD, // PCI-1737U
BD_PCI1739U = 0xBE, // PCI-1739U
BD_PCI1742U = 0xC0, // PCI-1742U
BD_USB4718 = 0xC6, // USB-4718
BD_MIC3755 = 0xC7, // MIC3755
BD_USB4761 = 0xC8, // USB4761
BD_PCI1784 = 0XCC, // PCI-1784
BD_USB4716 = 0xCD, // USB4716
BD_PCI1752U = 0xCE, // PCI-1752U
BD_PCI1752USO = 0xCF, // PCI-1752USO
BD_USB4751 = 0xD0, // USB4751
BD_USB4751L = 0xD1, // USB4751L
BD_USB4750 = 0xD2, // USB4750
BD_MIC3713 = 0xD3, // MIC-3713
BD_USB4711A = 0xD8, // USB4711A
BD_PCM3753P = 0xD9, // PCM3753P
BD_PCM3784 = 0xDA, // PCM3784
BD_PCM3761I = 0xDB, // PCM-3761I
BD_MIC3751 = 0xDC, // MIC-3751
BD_PCM3730I = 0xDD, // PCM-3730I
BD_PCM3813I = 0xE0, // PCM-3813I
BD_PCIE1744 = 0xE1, // PCIE-1744
BD_PCI1730U = 0xE2, // PCI-1730U
BD_PCI1760U = 0xE3, // PCI-1760U
BD_MIC3720 = 0xE4, // MIC-3720
BD_PCM3810I = 0xE9, // PCM-3810I
BD_USB4702 = 0xEA, // USB4702
BD_USB4704 = 0xEB, // USB4704
BD_PCM3810I_HG = 0xEC, // PCM-3810I_HG
BD_PCI1713U = 0xED, // PCI-1713U
// !!!BioDAQ only Product ID starts from here!!!
BD_PCI1706U = 0x800,
BD_PCI1706MSU = 0x801,
BD_PCI1706UL = 0x802,
BD_PCIE1752 = 0x803,
BD_PCIE1754 = 0x804,
BD_PCIE1756 = 0x805,
BD_MIC1911 = 0x806,
BD_MIC3750 = 0x807,
BD_MIC3711 = 0x808,
BD_PCIE1730 = 0x809,
BD_PCI1710_ECU = 0x80A,
BD_PCI1720_ECU = 0x80B,
BD_PCIE1760 = 0x80C,
BD_PCIE1751 = 0x80D,
BD_ECUP1706 = 0x80E,
BD_PCIE1753 = 0x80F,
BD_PCIE1810 = 0x810,
BD_ECUP1702L = 0x811,
BD_PCIE1816 = 0x812,
BD_PCM27D24DI = 0x813,
BD_PCIE1816H = 0x814,
BD_PCIE1840 = 0x815,
BD_PCL725 = 0x816,
BD_PCI176E = 0x817,
BD_PCIE1802 = 0x818,
BD_AIISE730 = 0x819,
BD_PCIE1812 = 0x81A,
BD_MIC1810 = 0x81B,
BD_PCIE1802L = 0x81C,
BD_PCIE1813 = 0x81D,
BD_PCIE1840L = 0x81E,
BD_PCIE1730H = 0x81F,
BD_PCIE1756H = 0x820,
BD_PCIERXM01 = 0x821, // PCIe-RXM01
BD_MIC1816 = 0x822,
BD_USB5830 = 0x823,
BD_USB5850 = 0x824,
BD_USB5860 = 0x825,
BD_VPX1172 = 0x826,
BD_USB5855 = 0x827,
BD_USB5856 = 0x828,
BD_USB5862 = 0x829,
BD_PCIE1840T = 0x82A,
BD_AudioCard = 0x82B,
BD_AIIS1750 = 0x82C,
BD_PCIE1840HL = 0x82D,
BD_PCIE1765 = 0x82E,
BD_PCIE1761H = 0x82F,
BD_PCIE1762H = 0x830,
BD_PCIE1884 = 0x831,
BD_PCIE1758DIO = 0x832,
BD_PCIE1758DI = 0x833,
BD_PCIE1758DO = 0x834,
//
BD_USB5817 = 0x835,
BD_USB5801 = 0x836,
BD_PCM2731 = 0x837,
BD_MOS1110 = 0x838,
BD_PCIE1750UH = 0x839,
BD_PCIE1750U = 0x83A,
BD_USB5820 = 0x83B,
//
BD_THK1710R = 0x83C,
BD_PCIE1803 = 0x83D,
BD_PCIE1824 = 0x83E,
BD_PCIE1805 = 0x83F,
//
BD_MIOE1747 = 0x840,
BD_ECUP1710 = 0x841,
BD_PCIE1824L = 0x842,
//
BD_PCIE1763AH = 0x843,
BD_PCIE1763DH = 0x844,
//
BD_MIC1816B = 0x845,
//
BD_SUSIGPIO = 0x846,
//
BD_MIC1810B = 0x847,
// iDAQ series
BD_IDAQ731 = 0x848,
BD_IDAQ763D = 0x849,
BD_IDAQ817 = 0x84A,
BD_IDAQ821 = 0x84B,
//
BD_EAPIGPIO = 0x84C,
// iDAQ series
BD_IDAQ841 = 0x84D,
BD_IDAQ801 = 0x84E,
BD_IDAQ815 = 0x84F,
//
BD_PCIE1842 = 0x850,
BD_MIOE3842 = 0x851,
BD_USB4716B = 0x852,
// iDAQ Fusion (Virtual Fusion Device, iDAQSyncBpInternal)
BD_IDAQ1CHASSYNC = 0x853, // Fused device of modules from same chassis
BD_USB4711B = 0x854,
BD_IDAQ751 = 0x855,
BD_FusionAuto = 0x856,
BD_AIIS1882 = 0x857,
BD_MIOE3842L = 0x858,
BD_PCI1716B = 0x859,
BD_USB4750B = 0x85A,
BD_USB4761B = 0x85B,
BD_PCI1716LB = 0x85C,
BD_PCI1716H = 0x85D,
BD_PCIE1816B = 0x85E,
BD_PCIE1816HB = 0x85F,
BD_ECUP1710T = 0x860,
BD_PCI1712B = 0x861,
BD_PCI1715B = 0x862,
BD_PCI1721B = 0x863,
BD_USB4751B = 0x864,
BD_USB4751LB = 0x865,
BD_PCIE1841 = 0x866,
BD_PCIE1841L = 0x867,
BD_PCIE1810B = 0x868,
BD_PCIE1812B = 0x869,
BD_PCIE1760B = 0x86A,
BD_PCIE1751B = 0x86B,
BD_PCIE1753B = 0x86C,
BD_IDAQ871 = 0x86D,
BD_IDAQ784 = 0x86E,
// WISE-5000 starts from here
BD_WISE5051 = 0x901,
BD_WISE5056 = 0x902,
BD_WISE5056SO = 0x903,
BD_WISE5015 = 0x904,
BD_WISE5017 = 0x905,
BD_WISE5018 = 0x906,
BD_WISE5024 = 0x907,
BD_WISE5080 = 0x908,
BD_WISE5074 = 0x909,
BD_WISE5001 = 0x90A,
BD_WISE5052 = 0x90B,
BD_WISE5057 = 0x90C,
BD_WISE5057SO = 0x90D,
BD_WISE5017C = 0x90E,
BD_WISE5017V = 0x90F,
BD_WISE5079 = 0x910,
BD_AMAX5051 = 0x911,
BD_AMAX5056 = 0x912,
BD_AMAX5056SO = 0x913,
BD_AMAX5015 = 0x914,
BD_AMAX5017 = 0x915,
BD_AMAX5018 = 0x916,
BD_AMAX5024 = 0x917,
BD_AMAX5080 = 0x918,
BD_AMAX5074 = 0x919,
BD_AMAX5001 = 0x91A,
BD_AMAX5052 = 0x91B,
BD_AMAX5057 = 0x91C,
BD_AMAX5057SO = 0x91D,
BD_AMAX5017C = 0x91E,
BD_AMAX5017V = 0x91F,
BD_AMAX5079 = 0x920,
BD_AMAX5017H = 0x921,
BD_AMAX5082 = 0x923,
BD_AMAX5060 = 0x924,
} ProductId;
typedef struct MathInterval {
int32 Type;
double Min;
double Max;
} MathInterval, * PMathInterval;
typedef MathInterval const *PCMathInterval;
typedef struct MapFuncPiece {
int32 Size; /* the size of the structure */
int32 Degree; /* the polynomial degree */
double UpperLimit; /* the upper limit for this scaling polynomial. */
double Coef[2]; /* variable length array for the coefficient of polynomial, in increasing degree. */
} MapFuncPiece, * PMapFuncPiece;
typedef MapFuncPiece const *PCMapFuncPiece;
typedef struct DataMark {
int64 DataIndex;
int32 SrcId;
int32 _reserved_;
} DataMark;
typedef struct CalibrationData {
int32 Size;
int32 ShuntResistance;
}CalibrationData;
/*Absolute counter related definitions*/
typedef enum Baudrate {
Baudrate2000KHz = 2000000, //2MHz
Baudrate1500KHz = 1500000, //1.5MHz
Baudrate1000KHz = 1000000, //1MHz
Baudrate500KHz = 500000, //500KHz
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
BaudrateUnknown = 0xffffffff,
} Baudrate;
typedef enum CodingType {
BinaryCode = 0,
GrayCode,
/*----------------------------------------------------------------------*/
/*Dummy ID, to ensure the type is compiled as 'int' by various compiler */
CodingUnknown = 0xffffffff,
} CodingType;
typedef enum BurnoutRetType ErrorRetType;
/*HW Specific Property*/
#define HWSPEC_WDT_DO_ENABLED L"HwSpec.Wdt.DoEnabled"
#define HWSPEC_WDT_DO_PATTERN L"HwSpec.Wdt.DoPattern"
#define HWSPEC_WDT_TIME L"HwSpec.Wdt.Time"
#define HWSPEC_WDT_FLAG L"HwSpec.Wdt.Flag"
END_NAMEAPCE_AUTOMATION_BDAQ
#endif /*_BDAQ_TYPES_DEFINED*/
/**********************************************************/
/*Bionic DAQ COM style class library */
/**********************************************************/
#if !defined(_BDAQ_TYPES_ONLY) && !defined(_BDAQ_COM_STYLE_CLASS_LIB)
#define _BDAQ_COM_STYLE_CLASS_LIB
#include
#if defined(_WIN32) || defined(WIN32)
# include
#endif
BEGIN_NAMEAPCE_AUTOMATION_BDAQ
/**********************************************************/
/*CSCL types definition */
/**********************************************************/
typedef enum ControlState {
Idle = 0,
Ready,
Running,
Stopped,
Uninited = -1,
} ControlState;
typedef enum Scenario {
SceInstantAi = 1 << 0,
SceBufferedAi = 1 << 1,
SceWaveformAi = 1 << 2,
SceInstantAo = 1 << 3,
SceBufferedAo = 1 << 4,
SceInstantDi = 1 << 5,
SceInstantDo = 1 << 6,
SceEventCounter = 1 << 7,
SceFreqMeter = 1 << 8,
SceOneShot = 1 << 9,
SceTimerPulse = 1 << 10,
ScePwMeter = 1 << 11,
ScePwModulator = 1 << 12,
SceUdCounter = 1 << 13,
SceBufferedEventCounter = 1 << 14,
SceBufferedPwMeter = 1 << 15,
SceBufferedPwModulator = 1 << 16,
SceBufferedUdCounter = 1 << 17,
SceEdgeSeparation = 1 << 18,
SceBufferedDi = 1 << 19,
SceBufferedDo = 1 << 20,
SceCalibration = 1 << 21,
SceFirmware = 1 << 22,
SceAbsCounter = 1 << 23,
} Scenario;
typedef struct DeviceInformation{
int32 DeviceNumber;
AccessMode DeviceMode;
int32 ModuleIndex;
wchar_t Description[MAX_DEVICE_DESC_LEN];
#if defined(__cplusplus)
explicit DeviceInformation(int32 deviceNumber = -1, AccessMode mode = ModeWrite, int32 moduleIndex = 0)
{
Init(deviceNumber, NULL, mode, moduleIndex);
}
explicit DeviceInformation(wchar_t const *deviceDesc, AccessMode mode = ModeWrite, int32 moduleIndex = 0)
{
Init(-1, deviceDesc, mode, moduleIndex);
}
void Init(int32 deviceNumber, wchar_t const *deviceDesc, AccessMode mode, int32 moduleIndex)
{
DeviceNumber = deviceNumber;
DeviceMode = mode;
ModuleIndex = moduleIndex;
if (deviceDesc == NULL) Description[0] = L'\0';
else {
for (int i = 0; i < MAX_DEVICE_DESC_LEN && (Description[i] = *deviceDesc++) != 0; ++i){}
Description[MAX_DEVICE_DESC_LEN - 1] = L'\0';
}
}
#endif
} DeviceInformation;
typedef struct DeviceTreeNode {
int32 DeviceNumber;
int32 ModulesIndex[8];
wchar_t Description[MAX_DEVICE_DESC_LEN];
} DeviceTreeNode;
typedef struct DeviceEventArgs {
EventId Id;
} DeviceEventArgs;
typedef struct BfdAiEventArgs {
EventId Id;
int32 Offset; /*offset of the new data*/
int32 Count; /*amount of the new data*/
int32 MarkCount; /*amount of the new marks*/
} BfdAiEventArgs;
typedef struct BfdAoEventArgs {
EventId Id;
int32 Offset; /*offset of blank area*/
int32 Count; /*amount of blank area*/
} BfdAoEventArgs;
typedef struct DiSnapEventArgs {
EventId Id;
int32 SrcNum;
int32 Length;
uint8 PortData[MAX_DIO_PORT_COUNT];
} DiSnapEventArgs;
typedef struct BfdDiEventArgs {
EventId Id;
int32 Offset; /*offset of the new data*/
int32 Count; /*amount of the new data*/
int32 MarkCount; /*amount of the new marks*/
} BfdDiEventArgs;
typedef struct BfdDoEventArgs {
EventId Id;
int32 Offset; /*offset of blank area*/
int32 Count; /*amount of blank area*/
} BfdDoEventArgs;
typedef struct CntrEventArgs {
EventId Id;
int32 Channel;
} CntrEventArgs;
typedef struct UdCntrEventArgs {
EventId Id;
int32 Length;
union {
int32 Data[MAX_CNTR_CH_COUNT];
struct {
int32 MatchedCount;
int32 MatchedValue;
};
};
} UdCntrEventArgs;
typedef struct BfdCntrEventArgs {
EventId Id;
int32 Channel;
int32 Offset; /*offset of the new data*/
int32 Count; /*amount of the new data*/
} BfdCntrEventArgs;
typedef struct PulseWidth {
double HiPeriod;
double LoPeriod;
} PulseWidth;
typedef void * DAQ_FN;
typedef struct DaqNaviLib {
int32 Version;
int32 Revision;
DAQ_FN const * Global;
DAQ_FN const * Base;
DAQ_FN const * Ai;
DAQ_FN const * Ao;
DAQ_FN const * Dio;
DAQ_FN const * Cntr;
} DaqNaviLib;
typedef struct IArray IArray;
typedef struct ICounterIndexer ICounterIndexer;
#if !defined(__cplusplus) || defined(_BDAQ_C_INTERFACE)
typedef struct ScanChannel ScanChannel;
typedef struct ConvertClock ConvertClock;
typedef struct ScanClock ScanClock;
typedef struct Trigger Trigger;
typedef struct Conversion Conversion;
typedef struct Record Record;
typedef struct NosFltChannel NosFltChannel;
typedef struct DeviceCtrl DeviceCtrl;
typedef struct DaqCtrlBase DaqCtrlBase;
typedef struct CjcSetting CjcSetting;
typedef struct AiChannel AiChannel;
typedef struct AiFeatures AiFeatures;
typedef struct AiCtrlBase AiCtrlBase;
typedef struct InstantAiCtrl InstantAiCtrl;
typedef struct BufferedAiCtrl BufferedAiCtrl;
typedef struct WaveformAiCtrl WaveformAiCtrl;
typedef struct AoChannel AoChannel;
typedef struct AoFeatures AoFeatures;
typedef struct AoCtrlBase AoCtrlBase;
typedef struct InstantAoCtrl InstantAoCtrl;
typedef struct BufferedAoCtrl BufferedAoCtrl;
typedef struct DioPort DioPort;
typedef struct ScanPort ScanPort;
typedef struct DiintChannel DiintChannel;
typedef struct DiCosintPort DiCosintPort;
typedef struct DiPmintPort DiPmintPort;
typedef struct DioFeatures DioFeatures;
typedef struct DioCtrlBase DioCtrlBase;
typedef struct InstantDiCtrl InstantDiCtrl;
typedef struct InstantDoCtrl InstantDoCtrl;
typedef struct BufferedDiCtrl BufferedDiCtrl;
typedef struct BufferedDoCtrl BufferedDoCtrl;
typedef struct CntrFeatures CntrFeatures;
typedef struct CntrCtrlBase CntrCtrlBase;
typedef struct EcChannel EcChannel;
typedef struct EventCounterCtrl EventCounterCtrl;
typedef struct FmChannel FmChannel;
typedef struct FreqMeterCtrl FreqMeterCtrl;
typedef struct OsChannel OsChannel;
typedef struct OneShotCtrl OneShotCtrl;
typedef struct TmrChannel TmrChannel;
typedef struct TimerPulseCtrl TimerPulseCtrl;
typedef struct PiChannel PiChannel;
typedef struct PwMeterCtrl PwMeterCtrl;
typedef struct PoChannel PoChannel;
typedef struct PwModulatorCtrl PwModulatorCtrl;
typedef struct UdChannel UdChannel;
typedef struct UdCounterCtrl UdCounterCtrl;
typedef struct AbsChannel AbsChannel;
typedef struct AbsCounterCtrl AbsCounterCtrl;
typedef struct EsChannel EsChannel;
typedef struct EdgeSeparationCtrl EdgeSeparationCtrl;
typedef struct BufferedEventCounterCtrl BufferedEventCounterCtrl;
typedef struct BufferedPwMeterCtrl BufferedPwMeterCtrl;
typedef struct BufferedUdCounterCtrl BufferedUdCounterCtrl;
typedef struct BufferedPwModulatorCtrl BufferedPwModulatorCtrl;
typedef struct CaliSubject CaliSubject;
typedef struct CaliSection CaliSection;
typedef struct CaliSolution CaliSolution;
typedef struct CalibrationCtrl CalibrationCtrl;
typedef struct FirmwareCtrl FirmwareCtrl;
typedef struct FirmwareCtrls FirmwareCtrls;
#else
class ScanChannel;
class ConvertClock;
class ScanClock;
class Trigger;
class Conversion;
class Record;
class NosFltChannel;
class DeviceCtrl;
class DaqCtrlBase;
class CjcSetting;
class AiChannel;
class AiFeatures;
class AiCtrlBase;
class InstantAiCtrl;
class BufferedAiCtrl;
class WaveformAiCtrl;
class AoChannel;
class AoFeatures;
class AoCtrlBase;
class InstantAoCtrl;
class BufferedAoCtrl;
class DioPort;
class ScanPort;
class DiintChannel;
class DiCosintPort;
class DiPmintPort;
class DioFeatures;
class DioCtrlBase;
class InstantDiCtrl;
class InstantDoCtrl;
class BufferedDiCtrl;
class BufferedDoCtrl;
class CntrFeatures;
class CntrCtrlBase;
class EcChannel;
class EventCounterCtrl;
class FmChannel;
class FreqMeterCtrl;
class OsChannel;
class OneShotCtrl;
class TmrChannel;
class TimerPulseCtrl;
class PiChannel;
class PwMeterCtrl;
class PoChannel;
class PwModulatorCtrl;
class UdChannel;
class UdCounterCtrl;
class AbsChannel;
class AbsCounterCtrl;
class EsChannel;
class EdgeSeparationCtrl;
class BufferedEventCounterCtrl;
class BufferedPwMeterCtrl;
class BufferedUdCounterCtrl;
class BufferedPwModulatorCtrl;
class CaliSubject;
class CaliSection;
class CaliSolution;
class CalibrationCtrl;
class FirmwareCtrl;
class FirmwareCtrls;
#endif
/*Callback function prototype*/
typedef void (BDAQCALL * DeviceEventProc)(void *sender, DeviceEventArgs *args, void *userParam);
typedef void (BDAQCALL * BfdAiEventProc )(void *sender, BfdAiEventArgs *args, void *userParam);
typedef void (BDAQCALL * BfdAoEventProc )(void *sender, BfdAoEventArgs *args, void *userParam);
typedef void (BDAQCALL * DiSnapEventProc)(void *sender, DiSnapEventArgs *args, void *userParam);
typedef void (BDAQCALL * CntrEventProc )(void *sender, CntrEventArgs *args, void *userParam);
typedef void (BDAQCALL * UdCntrEventProc)(void *sender, UdCntrEventArgs *args, void *userParam);
typedef void (BDAQCALL * BfdCntrEventProc)(void *sender, BfdCntrEventArgs *args, void *userParam);
typedef void (BDAQCALL * BfdDiEventProc )(void *sender, BfdDiEventArgs *args, void *userParam);
typedef void (BDAQCALL * BfdDoEventProc )(void *sender, BfdDoEventArgs *args, void *userParam);
/**********************************************************/
/* */
/* DAQNAVI CSCL ANSI-C APIs */
/* */
/**********************************************************/
#ifndef DAQNAVI_CORE
/* ----------------------------------------------------------*/
/* Helper Macros & Methods */
/* ----------------------------------------------------------*/
BDAQINL DaqNaviLib const ** DNL_PPtr()
{
static DaqNaviLib const * lib = NULL;
return &lib;
}
#if defined(_WIN32) || defined(WIN32)
BDAQINL HMODULE DNL_Instance()
{
static HMODULE instance = NULL;
if (instance == NULL) {
instance = LoadLibrary(TEXT("biodaq.dll"));
}
return instance;
}
BDAQINL int32 DNL_Initialize()
{
if (*DNL_PPtr() == NULL) {
#ifdef _WIN32_WCE
FARPROC fn = GetProcAddressA(DNL_Instance(), "AdxDaqNaviLibInitialize");
#else
FARPROC fn = GetProcAddress(DNL_Instance(), "AdxDaqNaviLibInitialize");
#endif
*DNL_PPtr() = ((DaqNaviLib const *( BDAQCALL *)(void))fn)();
}
return *DNL_PPtr() != NULL;
}
#else /*Non-Win32*/
#ifdef __cplusplus
extern "C" {
#endif
DaqNaviLib const * AdxDaqNaviLibInitialize();
#ifdef __cplusplus
}
#endif
BDAQINL int32 DNL_Initialize()
{
if (*DNL_PPtr() == NULL) { *DNL_PPtr() = AdxDaqNaviLibInitialize(); }
return *DNL_PPtr() != NULL;
}
#endif
#define DNLAPI_GBL (*DNL_PPtr())->Global
#define DNLAPI_BASE (*DNL_PPtr())->Base
#define DNLAPI_AI (*DNL_PPtr())->Ai
#define DNLAPI_AO (*DNL_PPtr())->Ao
#define DNLAPI_DIO (*DNL_PPtr())->Dio
#define DNLAPI_CNTR (*DNL_PPtr())->Cntr
#define DAQFN_VV(Apis, n) ((void (BDAQCALL *)(void *))Apis[n])
#define DAQFN_VT(Apis, n, t1) ((void (BDAQCALL *)(void *, t1))Apis[n])
#define DAQFN_VTT(Apis, n, t1, t2) ((void (BDAQCALL *)(void *, t1, t2))Apis[n])
#define DAQFN_VTTT(Apis, n, t1, t2, t3) ((void (BDAQCALL *)(void *, t1, t2, t3))Apis[n])
#define DAQFN_TV(Apis, n, rt) ((rt (BDAQCALL *)(void *))Apis[n])
#define DAQFN_TT(Apis, n, rt, t1) ((rt (BDAQCALL *)(void *, t1))Apis[n])
#define DAQFN_TTT(Apis, n, rt, t1, t2) ((rt (BDAQCALL *)(void *, t1, t2))Apis[n])
#define DAQFN_TTTT(Apis, n, rt, t1, t2, t3) ((rt (BDAQCALL *)(void *, t1, t2, t3))Apis[n])
#define DAQFN_EV(Apis, n) ((ErrorCode (BDAQCALL *)(void *))Apis[n])
#define DAQFN_ET(Apis, n, t1) ((ErrorCode (BDAQCALL *)(void *, t1))Apis[n])
#define DAQFN_ETT(Apis, n, t1, t2) ((ErrorCode (BDAQCALL *)(void *, t1, t2))Apis[n])
#define DAQFN_ETTT(Apis, n, t1, t2, t3) ((ErrorCode (BDAQCALL *)(void *, t1, t2, t3))Apis[n])
#define DAQFN_ETTTT(Apis, n, t1, t2, t3, t4) ((ErrorCode (BDAQCALL *)(void *, t1, t2, t3, t4))Apis[n])
#define DAQFN_ETTTTT(Apis, n, t1, t2, t3, t4, t5) ((ErrorCode (BDAQCALL *)(void *, t1, t2, t3, t4, t5))Apis[n])
#define DAQFN_GBL_T(Apis, n, rt) ((rt (BDAQCALL *)())Apis[n])
#define DAQFN_GBL_TT(Apis, n, rt, t1) ((rt (BDAQCALL *)(t1))Apis[n])
#define DAQFN_GBL_TTT(Apis, n, rt, t1, t2) ((rt (BDAQCALL *)(t1, t2))Apis[n])
#define DAQFN_GBL_TTTT(Apis, n, rt, t1, t2, t3) ((rt (BDAQCALL *)(t1, t2, t3))Apis[n])
#define DAQFN_GBL_ET(Apis, n, t1) ((ErrorCode (BDAQCALL *)(t1))Apis[n])
#define DAQFN_GBL_ETTT(Apis, n, t1, t2, t3) ((ErrorCode (BDAQCALL *)(t1, t2, t3))Apis[n])
#define DAQFN_GBL_ETTTT(Apis, n, t1, t2, t3, t4) ((ErrorCode (BDAQCALL *)(t1, t2, t3, t4))Apis[n])
#define DAQFN_GBL_ETTTTT(Apis, n, t1, t2, t3, t4, t5) ((ErrorCode (BDAQCALL *)(t1, t2, t3, t4, t5))Apis[n])
#define DAQFN_GBL_ETTTTTT(Apis, n, t1, t2, t3, t4, t5, t6) ((ErrorCode (BDAQCALL *)(t1, t2, t3, t4, t5, t6))Apis[n])
/* ----------------------------------------------------------*/
/*Global APIs */
/* ----------------------------------------------------------*/
BDAQINL ErrorCode AdxGetValueRangeInformation(ValueRange vrg, int32 sizeofDesc, wchar_t *description, MathInterval *range, ValueUnit *unit)
{
DNL_Initialize();
return DAQFN_GBL_ETTTTT(DNLAPI_GBL, 0, ValueRange, int32, wchar_t *, MathInterval *, ValueUnit *)(vrg, sizeofDesc, description, range, unit);
}
BDAQINL ErrorCode AdxGetSignalConnectionInformation(SignalDrop signalType, int32 sizeofDesc, wchar_t *description, SignalPosition *position)
{
DNL_Initialize();
return DAQFN_GBL_ETTTT(DNLAPI_GBL, 1, SignalDrop, int32, wchar_t *, SignalPosition *)(signalType, sizeofDesc, description, position);
}
BDAQINL double AdxTranslateTemperatureScale(TemperatureDegree degreeType, double degreeCelsius )
{
DNL_Initialize();
return DAQFN_GBL_TTT(DNLAPI_GBL, 2, double, TemperatureDegree, double)(degreeType, degreeCelsius);
}
BDAQINL ErrorCode AdxEnumToString(wchar_t const *enumName, int32 enumValue, int32 strLength, wchar_t *strBuffer)
{
DNL_Initialize();
return DAQFN_GBL_ETTTT(DNLAPI_GBL, 3, wchar_t const *, int32, int32, wchar_t *)(enumName, enumValue, strLength, strBuffer);
}
BDAQINL ErrorCode AdxStringToEnum(wchar_t const *enumName, wchar_t const *enumString, int32 *enumValue)
{
DNL_Initialize();
return DAQFN_GBL_ETTT(DNLAPI_GBL, 4, wchar_t const *, wchar_t const *, int32 *)(enumName, enumString, enumValue);
}
BDAQINL ErrorCode AdxDeviceGetLinkageInfo(int32 parent, int32 index, int32 *devNumber, wchar_t *description, int32 *subCount)
{
DNL_Initialize();
return DAQFN_GBL_ETTTTT(DNLAPI_GBL, 5, int32, int32, int32 *, wchar_t *, int32 *)(parent, index, devNumber, description, subCount);
}
BDAQINL ErrorCode AdxEventClearFlag(HANDLE handle, int32 id, int32 flagLParam, int32 flagRParam)
{
return DAQFN_GBL_ETTTT(DNLAPI_GBL, 6, HANDLE, int32, int32, int32)(handle, id, flagLParam, flagRParam);
}
BDAQINL ErrorCode AdxFusionDeviceCreate(int32 count, int32 children[], int32 *fusionNumber)
{
DNL_Initialize();
return DAQFN_GBL_ETTT(DNLAPI_GBL, 9, int32, int32 *, int32 *)(count, children, fusionNumber);
}
BDAQINL ErrorCode AdxFusionDeviceAddChildren(int32 fusionNumber, int32 count, int32 children[])
{
DNL_Initialize();
return DAQFN_GBL_ETTT(DNLAPI_GBL, 10, int32, int32, int32 *)(fusionNumber, count, children);
}
BDAQINL ErrorCode AdxFusionDeviceDeleteChildren(int32 fusionNumber, int32 count, int32 children[])
{
DNL_Initialize();
return DAQFN_GBL_ETTT(DNLAPI_GBL, 11, int32, int32, int32 *)(fusionNumber, count, children);
}
BDAQINL ErrorCode AdxFusionDeviceGetChildren(int32 fusionNumber, int32 *count, int32 children[])
{
DNL_Initialize();
return DAQFN_GBL_ETTT(DNLAPI_GBL, 12, int32, int32 *, int32 *)(fusionNumber, count, children);
}
BDAQINL ErrorCode AdxDeviceFusionableCheck(int32 fusionNumber, int32 count, int32 children[])
{
DNL_Initialize();
return DAQFN_GBL_ETTT(DNLAPI_GBL, 13, int32, int32, int32 *)(fusionNumber, count, children);
}
BDAQINL ErrorCode AdxIsFusionDevice(int32 fusionNumber)
{
DNL_Initialize();
return DAQFN_GBL_ET(DNLAPI_GBL, 14, int32)(fusionNumber);
}
/* ----------------------------------------------------------*/
/*common classes : Array */
/* ----------------------------------------------------------*/
BDAQINL void Array_Dispose(IArray * obj) { DAQFN_VV(DNLAPI_BASE, 0)(obj); }
BDAQINL int32 Array_getLength(IArray * obj) { return DAQFN_TV(DNLAPI_BASE, 1, int32)(obj); }
BDAQINL void* Array_getItem(IArray * obj, int32 index) { return DAQFN_TT(DNLAPI_BASE, 2, void *, int32)(obj, index); }
/* ----------------------------------------------------------*/
/*common classes : ScanChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 ScanChannel_getChannelStart(ScanChannel *obj) { return DAQFN_TV(DNLAPI_BASE, 3, int32)(obj); }
BDAQINL ErrorCode ScanChannel_setChannelStart(ScanChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 4, int32)(obj, value); }
BDAQINL int32 ScanChannel_getChannelCount(ScanChannel *obj) { return DAQFN_TV(DNLAPI_BASE, 5, int32)(obj); }
BDAQINL ErrorCode ScanChannel_setChannelCount(ScanChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 6, int32)(obj, value); }
BDAQINL int32 ScanChannel_getIntervalCount(ScanChannel *obj) { return DAQFN_TV(DNLAPI_BASE, 7, int32)(obj); }
BDAQINL ErrorCode ScanChannel_setIntervalCount(ScanChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 8, int32)(obj, value); }
BDAQINL int32 ScanChannel_getSamples(ScanChannel *obj) { return DAQFN_TV(DNLAPI_BASE, 9, int32)(obj); }
BDAQINL ErrorCode ScanChannel_setSamples(ScanChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 10, int32)(obj, value); }
/* ----------------------------------------------------------*/
/*common classes : ConvertClock */
/* ----------------------------------------------------------*/
BDAQINL SignalDrop ConvertClock_getSource(ConvertClock *obj) { return DAQFN_TV(DNLAPI_BASE, 11, SignalDrop)(obj); }
BDAQINL ErrorCode ConvertClock_setSource(ConvertClock *obj, SignalDrop value) { return DAQFN_ET(DNLAPI_BASE, 12, SignalDrop)(obj, value);}
BDAQINL double ConvertClock_getRate(ConvertClock *obj) { return DAQFN_TV(DNLAPI_BASE, 13, double)(obj); }
BDAQINL ErrorCode ConvertClock_setRate(ConvertClock *obj, double value) { return DAQFN_ET(DNLAPI_BASE, 14, double)(obj, value); }
/* ----------------------------------------------------------*/
/*common classes : ScanClock */
/* ----------------------------------------------------------*/
BDAQINL SignalDrop ScanClock_getSource(ScanClock *obj) { return DAQFN_TV(DNLAPI_BASE, 15, SignalDrop)(obj); }
BDAQINL ErrorCode ScanClock_setSource(ScanClock *obj, SignalDrop value) { return DAQFN_ET(DNLAPI_BASE, 16, SignalDrop)(obj, value); }
BDAQINL double ScanClock_getRate(ScanClock *obj) { return DAQFN_TV(DNLAPI_BASE, 17, double)(obj); }
BDAQINL ErrorCode ScanClock_setRate(ScanClock *obj, double value) { return DAQFN_ET(DNLAPI_BASE, 18, double)(obj, value); }
BDAQINL int32 ScanClock_getScanCount(ScanClock *obj) { return DAQFN_TV(DNLAPI_BASE, 19, int32)(obj); }
BDAQINL ErrorCode ScanClock_setScanCount(ScanClock *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 20, int32)(obj, value); }
/* ----------------------------------------------------------*/
/*common classes : Trigger */
/* ----------------------------------------------------------*/
BDAQINL SignalDrop Trigger_getSource(Trigger *obj) { return DAQFN_TV(DNLAPI_BASE, 21, SignalDrop)(obj); }
BDAQINL ErrorCode Trigger_setSource(Trigger *obj, SignalDrop value) { return DAQFN_ET(DNLAPI_BASE, 22, SignalDrop)(obj, value); }
BDAQINL ActiveSignal Trigger_getEdge(Trigger *obj) { return DAQFN_TV(DNLAPI_BASE, 23, ActiveSignal)(obj); }
BDAQINL ErrorCode Trigger_setEdge(Trigger *obj, ActiveSignal value) { return DAQFN_ET(DNLAPI_BASE, 24, ActiveSignal)(obj, value); }
BDAQINL double Trigger_getLevel(Trigger *obj) { return DAQFN_TV(DNLAPI_BASE, 25, double)(obj); }
BDAQINL ErrorCode Trigger_setLevel(Trigger *obj, double value) { return DAQFN_ET(DNLAPI_BASE, 26, double)(obj, value); }
BDAQINL TriggerAction Trigger_getAction(Trigger *obj) { return DAQFN_TV(DNLAPI_BASE, 27, TriggerAction)(obj); }
BDAQINL ErrorCode Trigger_setAction(Trigger *obj, TriggerAction value) { return DAQFN_ET(DNLAPI_BASE, 28, TriggerAction)(obj, value); }
BDAQINL int32 Trigger_getDelayCount(Trigger *obj) { return DAQFN_TV(DNLAPI_BASE, 29, int32)(obj); }
BDAQINL ErrorCode Trigger_setDelayCount(Trigger *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 30, int32)(obj, value); }
BDAQINL double Trigger_getHysteresisIndex(Trigger *obj) { return DAQFN_TV(DNLAPI_BASE, 31, double)(obj); }
BDAQINL ErrorCode Trigger_setHysteresisIndex(Trigger *obj, double value) { return DAQFN_ET(DNLAPI_BASE, 32, double)(obj, value); }
BDAQINL FilterType Trigger_getFilterType(Trigger *obj) { return DAQFN_TV(DNLAPI_BASE, 94, FilterType)(obj); }
BDAQINL ErrorCode Trigger_setFilterType(Trigger *obj, FilterType value) { return DAQFN_ET(DNLAPI_BASE, 95, FilterType)(obj, value); }
BDAQINL double Trigger_getFilterCutoffFreq(Trigger *obj) { return DAQFN_TV(DNLAPI_BASE, 96, double)(obj); }
BDAQINL ErrorCode Trigger_setFilterCutoffFreq(Trigger *obj, double value) { return DAQFN_ET(DNLAPI_BASE, 97, double)(obj, value); }
/* ----------------------------------------------------------*/
/*common classes : Conversion */
/* ----------------------------------------------------------*/
BDAQINL SignalDrop Conversion_getClockSource(Conversion *obj) { return DAQFN_TV(DNLAPI_BASE, 33, SignalDrop)(obj); }
BDAQINL ErrorCode Conversion_setClockSource(Conversion *obj, SignalDrop value) { return DAQFN_ET(DNLAPI_BASE, 34, SignalDrop)(obj, value); }
BDAQINL double Conversion_getClockRate(Conversion *obj) { return DAQFN_TV(DNLAPI_BASE, 35, double)(obj); }
BDAQINL ErrorCode Conversion_setClockRate(Conversion *obj, double value) { return DAQFN_ET(DNLAPI_BASE, 36, double)(obj, value); }
BDAQINL int32 Conversion_getChannelStart(Conversion *obj) { return DAQFN_TV(DNLAPI_BASE, 37, int32)(obj); }
BDAQINL ErrorCode Conversion_setChannelStart(Conversion *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 38, int32)(obj, value); }
BDAQINL int32 Conversion_getChannelCount(Conversion *obj) { return DAQFN_TV(DNLAPI_BASE, 39, int32)(obj); }
BDAQINL ErrorCode Conversion_setChannelCount(Conversion *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 40, int32)(obj, value); }
BDAQINL void Conversion_getChannelMap(Conversion *obj, int32 count, int8 *chMap) { DAQFN_VTT(DNLAPI_BASE, 41, int32, int8 *)(obj, count, chMap); }
BDAQINL ErrorCode Conversion_setChannelMap(Conversion *obj, int32 count, int8 *chMap) { return DAQFN_ETT(DNLAPI_BASE, 42, int32, int8 *)(obj, count, chMap); }
/* ----------------------------------------------------------*/
/*common classes : Record */
/* ----------------------------------------------------------*/
BDAQINL int32 Record_getSectionLength(Record *obj) { return DAQFN_TV(DNLAPI_BASE, 43, int32)(obj); }
BDAQINL ErrorCode Record_setSectionLength(Record *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 44, int32)(obj, value); }
BDAQINL int32 Record_getSectionCount(Record *obj) { return DAQFN_TV(DNLAPI_BASE, 45, int32)(obj); }
BDAQINL ErrorCode Record_setSectionCount(Record *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 46, int32)(obj, value); }
BDAQINL int32 Record_getCycles(Record *obj) { return DAQFN_TV(DNLAPI_BASE, 47, int32)(obj); }
BDAQINL ErrorCode Record_setCycles(Record *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 48, int32)(obj, value); }
/* ----------------------------------------------------------*/
/* common classes : NosFltChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 NosFltChannel_getChannel(NosFltChannel *obj) { return DAQFN_TV(DNLAPI_BASE, 49, int32)(obj); }
BDAQINL int8 NosFltChannel_getEnabled(NosFltChannel *obj) { return DAQFN_TV(DNLAPI_BASE, 50, int8)(obj); }
BDAQINL ErrorCode NosFltChannel_setEnabled(NosFltChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_BASE, 51, int8)(obj, value);}
/*************************************************************/
/* ctrl class : device ctrl class */
/* ----------------------------------------------------------*/
/* Event */
BDAQINL void DeviceCtrl_addEventHandler(DeviceCtrl *obj, EventId id, DeviceEventProc proc, void *userParam) { DAQFN_VTTT(DNLAPI_BASE, 52, EventId, DeviceEventProc, void *)(obj, id, proc, userParam);}
BDAQINL void DeviceCtrl_removeEventHandler(DeviceCtrl *obj, EventId id, DeviceEventProc proc, void *userParam) { DAQFN_VTTT(DNLAPI_BASE, 53, EventId, DeviceEventProc, void *)(obj, id, proc, userParam);}
/* Method */
BDAQINL ErrorCode DeviceCtrl_Refresh(DeviceCtrl *obj) { return DAQFN_EV(DNLAPI_BASE, 54)(obj); }
BDAQINL ErrorCode DeviceCtrl_ReadRegister(DeviceCtrl *obj, int32 space, int32 offset, int32 length, void *data) { return DAQFN_ETTTT(DNLAPI_BASE, 55, int32, int32, int32, void *)(obj, space, offset, length, data); }
BDAQINL ErrorCode DeviceCtrl_WriteRegister(DeviceCtrl *obj, int32 space, int32 offset, int32 length, void *data) { return DAQFN_ETTTT(DNLAPI_BASE, 56, int32, int32, int32, void *)(obj, space, offset, length, data); }
BDAQINL ErrorCode DeviceCtrl_ReadPrivateRegion(DeviceCtrl *obj, int32 signature, int32 length, uint8 *data) { return DAQFN_ETTT(DNLAPI_BASE, 57, int32, int32, uint8*)(obj, signature, length, data); }
BDAQINL ErrorCode DeviceCtrl_WritePrivateRegion(DeviceCtrl *obj, int32 signature, int32 length, uint8 *data) { return DAQFN_ETTT(DNLAPI_BASE, 58, int32, int32, uint8*)(obj, signature, length, data); }
BDAQINL ErrorCode DeviceCtrl_SynchronizeTimebase(DeviceCtrl *obj) { return DAQFN_EV(DNLAPI_BASE, 101)(obj); }
BDAQINL double DeviceCtrl_CalculateAbsoluteTime(DeviceCtrl *obj, double relativeTime) { return DAQFN_TT(DNLAPI_BASE, 102, double, double)(obj, relativeTime); }
BDAQINL void DeviceCtrl_Dispose(DeviceCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 79)(obj); }
/* Property */
BDAQINL int32 DeviceCtrl_getDeviceNumber(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 59, int32)(obj); }
BDAQINL ErrorCode DeviceCtrl_getDescription(DeviceCtrl *obj, int32 length, wchar_t *desc) { return DAQFN_ETT(DNLAPI_BASE, 60, int32, wchar_t *)(obj, length, desc);}
BDAQINL ErrorCode DeviceCtrl_setDescription(DeviceCtrl *obj, int32 length, wchar_t *desc) { return DAQFN_ETT(DNLAPI_BASE, 76, int32, wchar_t *)(obj, length, desc);}
BDAQINL AccessMode DeviceCtrl_getAccessMode(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 61, AccessMode)(obj); }
BDAQINL ProductId DeviceCtrl_getProductId(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 62, ProductId)(obj); }
BDAQINL int32 DeviceCtrl_getBoardId(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 63, int32)(obj); }
BDAQINL ErrorCode DeviceCtrl_setBoardId(DeviceCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 77, int32)(obj, value); }
BDAQINL ErrorCode DeviceCtrl_getBoardVersion(DeviceCtrl *obj, int32 length, wchar_t *ver) { return DAQFN_ETT(DNLAPI_BASE, 64, int32, wchar_t *)(obj, length, ver); }
BDAQINL ErrorCode DeviceCtrl_getDriverVersion(DeviceCtrl *obj, int32 length, wchar_t *ver) { return DAQFN_ETT(DNLAPI_BASE, 65, int32, wchar_t *)(obj, length, ver); }
BDAQINL ErrorCode DeviceCtrl_getDllVersion(DeviceCtrl *obj, int32 length, wchar_t *ver) { return DAQFN_ETT(DNLAPI_BASE, 66, int32, wchar_t *)(obj, length, ver); }
BDAQINL ErrorCode DeviceCtrl_getLocation(DeviceCtrl *obj, int32 length, wchar_t *loc) { return DAQFN_ETT(DNLAPI_BASE, 67, int32, wchar_t *)(obj, length, loc); }
BDAQINL int32 DeviceCtrl_getPrivateRegionLength(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 68, int32)(obj); }
BDAQINL int32 DeviceCtrl_getHotResetPreventable(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 69, int32)(obj); }
BDAQINL int32 DeviceCtrl_getBusSlot(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 147, int32)(obj); }
BDAQINL IArray * DeviceCtrl_getBaseAddresses(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 70, IArray *)(obj); }
BDAQINL IArray * DeviceCtrl_getInterrupts(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 71, IArray *)(obj); }
BDAQINL IArray * DeviceCtrl_getSupportedTerminalBoard(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 72, IArray *)(obj); }
BDAQINL IArray * DeviceCtrl_getSupportedEvents(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 73, IArray *)(obj); }
BDAQINL TerminalBoard DeviceCtrl_getTerminalBoard(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 74, TerminalBoard)(obj); }
BDAQINL ErrorCode DeviceCtrl_setTerminalBoard(DeviceCtrl *obj, TerminalBoard value) { return DAQFN_ET(DNLAPI_BASE, 75, TerminalBoard)(obj, value); }
BDAQINL ErrorCode DeviceCtrl_setLocateEnabled(DeviceCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_BASE, 99, int32)(obj, value); }
BDAQINL int32 DeviceCtrl_getSupportedScenarios(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 78, int32)(obj); }
BDAQINL HANDLE DeviceCtrl_getDevice(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 92, HANDLE)(obj); }
BDAQINL ErrorCode DeviceCtrl_getHwSpecific(DeviceCtrl *obj, wchar_t *name, int32 *size, void *buffer) { return DAQFN_ETTT(DNLAPI_BASE, 103, wchar_t *, int32 *, void*)(obj, name, size, buffer); }
BDAQINL ErrorCode DeviceCtrl_setHwSpecific(DeviceCtrl *obj, wchar_t *name, int32 size, void *buffer) { return DAQFN_ETTT(DNLAPI_BASE, 104, wchar_t *, int32, void*)(obj, name, size, buffer); }
BDAQINL IArray * DeviceCtrl_getSupportedFusionTypes(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 138, IArray *)(obj); }
BDAQINL IArray * DeviceCtrl_getProgrammableSignals(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 139, IArray *)(obj); }
BDAQINL ErrorCode DeviceCtrl_getProgrammableSignalsDirection(DeviceCtrl *obj, int32 length, SignalDirection dir[]) { return DAQFN_ETT(DNLAPI_BASE, 140, int32, SignalDirection *)(obj, length, dir); }
BDAQINL ErrorCode DeviceCtrl_setProgrammableSignalsDirection(DeviceCtrl *obj, int32 length, SignalDirection dir[]) { return DAQFN_ETT(DNLAPI_BASE, 141, int32, SignalDirection *)(obj, length, dir); }
BDAQINL double DeviceCtrl_getSignalNoiseFilterBlockTime(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 150, double)(obj); }
BDAQINL ErrorCode DeviceCtrl_setSignalNoiseFilterBlockTime(DeviceCtrl *obj, double blkTime) { return DAQFN_ET(DNLAPI_BASE, 151, double)(obj, blkTime); }
BDAQINL IArray * DeviceCtrl_getRtSignalEndpoints(DeviceCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 142, IArray *)(obj); }
BDAQINL IArray * DeviceCtrl_getRtEndpointXSupportedSources(DeviceCtrl *obj, SignalDrop rep) { return DAQFN_TT(DNLAPI_BASE, 143, IArray *, SignalDrop)(obj, rep); }
BDAQINL SignalDrop DeviceCtrl_getRtEndpointXSource(DeviceCtrl *obj, SignalDrop rep) { return DAQFN_TT(DNLAPI_BASE, 144, SignalDrop, SignalDrop)(obj, rep); }
BDAQINL ErrorCode DeviceCtrl_setRtEndpointXSource(DeviceCtrl *obj, SignalDrop rep, SignalDrop source) { return DAQFN_ETT(DNLAPI_BASE,145, SignalDrop, SignalDrop)(obj, rep, source);}
/*Creator*/
BDAQINL DeviceCtrl * DeviceCtrl_Create(int32 devNumber, wchar_t const *desc, AccessMode mode) { DNL_Initialize(); return DAQFN_GBL_TTTT(DNLAPI_BASE, 80, DeviceCtrl *, int32, wchar_t const *, AccessMode)(devNumber, desc, mode); }
BDAQINL IArray * DeviceCtrl_getInstalledDevices() { DNL_Initialize(); return DAQFN_GBL_T(DNLAPI_BASE, 100, IArray *)(); }
/*Helpers*/
BDAQINL void DeviceCtrl_addRemovedHandler(DeviceCtrl *obj, DeviceEventProc proc, void *userParam) { DeviceCtrl_addEventHandler (obj, EvtDeviceRemoved, proc, userParam); }
BDAQINL void DeviceCtrl_removeRemovedHandler(DeviceCtrl *obj, DeviceEventProc proc, void *userParam) { DeviceCtrl_removeEventHandler(obj, EvtDeviceRemoved, proc, userParam); }
BDAQINL void DeviceCtrl_addReconnectedHandler(DeviceCtrl *obj, DeviceEventProc proc, void *userParam) { DeviceCtrl_addEventHandler (obj, EvtDeviceReconnected, proc, userParam); }
BDAQINL void DeviceCtrl_removeReconnectedHandler(DeviceCtrl *obj, DeviceEventProc proc, void *userParam) { DeviceCtrl_removeEventHandler(obj, EvtDeviceReconnected, proc, userParam); }
BDAQINL void DeviceCtrl_addPropertyChangedHandler(DeviceCtrl *obj, DeviceEventProc proc, void *userParam) { DeviceCtrl_addEventHandler (obj, EvtPropertyChanged, proc, userParam); }
BDAQINL void DeviceCtrl_removePropertyChangedHandler(DeviceCtrl *obj, DeviceEventProc proc, void *userParam) { DeviceCtrl_removeEventHandler(obj, EvtPropertyChanged, proc, userParam); }
/*************************************************************/
/* ctrl class : daq ctrl base class */
/* ----------------------------------------------------------*/
/* Event */
typedef void (BDAQCALL * DaqEventProc)(void *sender, void *args, void *userParam);
BDAQINL void DaqCtrlBase_addEventHandler(DaqCtrlBase *obj, EventId id, DaqEventProc proc, void *userParam) { DAQFN_VTTT(DNLAPI_BASE, 81, EventId, DaqEventProc, void *)(obj, id, proc, userParam); }
BDAQINL void DaqCtrlBase_removeEventHandler(DaqCtrlBase *obj, EventId id, DaqEventProc proc, void *userParam) { DAQFN_VTTT(DNLAPI_BASE, 82, EventId, DaqEventProc, void *)(obj, id, proc, userParam); }
BDAQINL DaqCtrlBase * DaqCtrlBase_Create(Scenario type) { DNL_Initialize(); return DAQFN_GBL_TT(DNLAPI_BASE, 91, DaqCtrlBase *, Scenario)(type);}
/*************************************************************/
/* ctrl class : AI related */
/* ----------------------------------------------------------*/
/* CjcSetting */
/* ----------------------------------------------------------*/
BDAQINL int32 CjcSetting_getChannel(CjcSetting *obj) { return DAQFN_TV(DNLAPI_AI, 0, int32) (obj); }
BDAQINL ErrorCode CjcSetting_setChannel(CjcSetting *obj, int32 ch) { return DAQFN_ET(DNLAPI_AI, 1, int32) (obj, ch); }
BDAQINL double CjcSetting_getValue(CjcSetting *obj) { return DAQFN_TV(DNLAPI_AI, 2, double)(obj); }
BDAQINL ErrorCode CjcSetting_setValue(CjcSetting *obj, double value) { return DAQFN_ET(DNLAPI_AI, 3, double)(obj, value);}
BDAQINL double CjcSetting_getUpdateFreq(CjcSetting *obj) { return DAQFN_TV(DNLAPI_AI, 4, double)(obj); }
BDAQINL ErrorCode CjcSetting_setUpdateFreq(CjcSetting *obj, double value) { return DAQFN_ET(DNLAPI_AI, 5, double)(obj, value);}
/* ----------------------------------------------------------*/
/* AiChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 AiChannel_getChannel(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 6, int32)(obj); }
BDAQINL ValueRange AiChannel_getValueRange(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 7, ValueRange)(obj); }
BDAQINL ErrorCode AiChannel_setValueRange(AiChannel *obj, ValueRange value) { return DAQFN_ET(DNLAPI_AI, 8, ValueRange)(obj, value); }
BDAQINL AiSignalType AiChannel_getSignalType(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 9, AiSignalType)(obj); }
BDAQINL ErrorCode AiChannel_setSignalType(AiChannel *obj, AiSignalType value) { return DAQFN_ET(DNLAPI_AI, 10, AiSignalType)(obj, value); }
BDAQINL BurnoutRetType AiChannel_getBurnoutRetType(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 11, BurnoutRetType)(obj); }
BDAQINL ErrorCode AiChannel_setBurnoutRetType(AiChannel *obj, BurnoutRetType value) { return DAQFN_ET(DNLAPI_AI, 12, BurnoutRetType)(obj, value);}
BDAQINL double AiChannel_getBurnoutRetValue(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 13, double)(obj); }
BDAQINL ErrorCode AiChannel_setBurnoutRetValue(AiChannel *obj, double value) { return DAQFN_ET(DNLAPI_AI, 14, double)(obj, value); }
BDAQINL double AiChannel_getBurnShortRetValue(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 115, double)(obj); }
BDAQINL ErrorCode AiChannel_setBurnShortRetValue(AiChannel *obj, double value) { return DAQFN_ET(DNLAPI_AI, 116, double)(obj, value); }
BDAQINL FilterType AiChannel_getFilterType(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 15, FilterType) (obj); }
BDAQINL ErrorCode AiChannel_setFilterType(AiChannel *obj, FilterType value) { return DAQFN_ET(DNLAPI_AI, 16, FilterType) (obj, value); }
BDAQINL double AiChannel_getFilterCutoffFreq(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 17, double)(obj); }
BDAQINL ErrorCode AiChannel_setFilterCutoffFreq(AiChannel *obj, double value) { return DAQFN_ET(DNLAPI_AI, 18, double)(obj, value); }
BDAQINL double AiChannel_getFilterCutoffFreq1(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 19, double)(obj); }
BDAQINL ErrorCode AiChannel_setFilterCutoffFreq1(AiChannel *obj, double value) { return DAQFN_ET(DNLAPI_AI, 20, double)(obj, value); }
BDAQINL int32 AiChannel_getLogicalNumber(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 21, int32)(obj); }
BDAQINL CouplingType AiChannel_getCouplingType(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 95, CouplingType)(obj); }
BDAQINL ErrorCode AiChannel_setCouplingType(AiChannel *obj, CouplingType value) { return DAQFN_ET(DNLAPI_AI, 96, CouplingType)(obj, value); }
BDAQINL IepeType AiChannel_getIepeType(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 97, IepeType)(obj); }
BDAQINL ErrorCode AiChannel_setIepeType(AiChannel *obj, IepeType value) { return DAQFN_ET(DNLAPI_AI, 98, IepeType)(obj, value); }
BDAQINL ImpedanceType AiChannel_getImpedanceType(AiChannel *obj) { return DAQFN_TV(DNLAPI_AI, 99, ImpedanceType)(obj); }
BDAQINL ErrorCode AiChannel_setImpedanceType(AiChannel *obj, ImpedanceType value) { return DAQFN_ET(DNLAPI_AI, 100, ImpedanceType)(obj, value);}
BDAQINL ErrorCode AiChannel_getSensorDescription(AiChannel *obj, int32 *size, wchar_t desc[]) { return DAQFN_ETT(DNLAPI_AI, 109, int32 *, wchar_t *)(obj, size, desc); }
BDAQINL ErrorCode AiChannel_setSensorDescription(AiChannel *obj, int32 size, wchar_t desc[]) { return DAQFN_ETT(DNLAPI_AI, 110, int32 , wchar_t *)(obj, size, desc); }
BDAQINL ErrorCode AiChannel_getScaleTable(AiChannel *obj, int32 *size, MapFuncPiece table[]) { return DAQFN_ETT(DNLAPI_AI, 53, int32 *, MapFuncPiece *)(obj, size, table); }
BDAQINL ErrorCode AiChannel_setScaleTable(AiChannel *obj, int32 size, MapFuncPiece table[]) { return DAQFN_ETT(DNLAPI_AI, 54, int32 , MapFuncPiece *)(obj, size, table); }
/* ----------------------------------------------------------*/
/* AI features */
/* ----------------------------------------------------------*/
/*ADC features*/
BDAQINL int32 AiFeatures_getResolution(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 22, int32)(obj); }
BDAQINL int32 AiFeatures_getDataSize(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 23, int32)(obj); }
BDAQINL int32 AiFeatures_getDataMask(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 24, int32)(obj); }
BDAQINL double AiFeatures_getTimestampResolution(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 108, int32)(obj); }
/*channel features*/
BDAQINL int32 AiFeatures_getChannelCountMax(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 25, int32)(obj); }
BDAQINL AiChannelType AiFeatures_getChannelType(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 26, AiChannelType)(obj); }
BDAQINL int8 AiFeatures_getOverallValueRange(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 27, int8)(obj); }
BDAQINL IArray * AiFeatures_getValueRanges(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 28, IArray *)(obj); }
BDAQINL IArray * AiFeatures_getBurnoutReturnTypes(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 29, IArray *)(obj); }
BDAQINL IArray * AiFeatures_getConnectionTypes(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 106, IArray *)(obj); }
BDAQINL int8 AiFeatures_getOverallConnection(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 107, int8)(obj); }
BDAQINL IArray * AiFeatures_getCouplingTypes(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 101, IArray *)(obj); }
BDAQINL IArray * AiFeatures_getIepeTypes(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 102, IArray *)(obj); }
BDAQINL IArray * AiFeatures_getImpedanceTypes(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 103, IArray *)(obj); }
/*filter*/
BDAQINL IArray * AiFeatures_getFilterTypes(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 30, IArray *)(obj); }
BDAQINL void AiFeatures_getFilterCutoffFreqRange(AiFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_AI, 31, MathInterval *)(obj, x);}
BDAQINL void AiFeatures_getFilterCutoffFreq1Range(AiFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_AI, 32, MathInterval *)(obj, x);}
/*CJC features */
BDAQINL int8 AiFeatures_getThermoSupported(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 33, int8)(obj); }
BDAQINL IArray * AiFeatures_getCjcChannels(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 34, IArray *)(obj);}
/*buffered ai->basic features*/
BDAQINL int8 AiFeatures_getBufferedAiSupported(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 35, int8)(obj); }
BDAQINL SamplingMethod AiFeatures_getSamplingMethod(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 36, SamplingMethod)(obj); }
BDAQINL int32 AiFeatures_getChannelStartBase(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 37, int32)(obj); }
BDAQINL int32 AiFeatures_getChannelCountBase(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 38, int32)(obj); }
/*buffered ai->conversion clock features*/
BDAQINL IArray * AiFeatures_getConvertClockSources(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 39, IArray *)(obj); }
BDAQINL void AiFeatures_getConvertClockRange(AiFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_AI, 40, MathInterval *)(obj, x);}
/*buffered ai->burst scan*/
BDAQINL int8 AiFeatures_getBurstScanSupported(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 41, int8)(obj); }
BDAQINL IArray * AiFeatures_getScanClockSources(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 42, IArray *)(obj); }
BDAQINL void AiFeatures_getScanClockRange(AiFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_AI, 43, MathInterval *)(obj, x); }
BDAQINL int32 AiFeatures_getScanCountMax(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 44, int32)(obj); }
/*buffered ai->trigger features*/
BDAQINL int8 AiFeatures_getRetriggerable(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 45, int8)(obj); }
BDAQINL int32 AiFeatures_getTriggerCount(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 46, int32)(obj); }
BDAQINL IArray * AiFeatures_getTriggerFilterTypes(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 104, IArray *, int32)(obj, 0); }
BDAQINL void AiFeatures_getTriggerFilterCutoffFreq(AiFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_AI, 105, int32, MathInterval *)(obj, 0, x);}
/*buffered ai->trigger0 features*/
BDAQINL IArray * AiFeatures_getTriggerActions(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 47, IArray *, int32)(obj, 0); }
BDAQINL void AiFeatures_getTriggerDelayRange(AiFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_AI, 48, int32, MathInterval *)(obj, 0, x);}
BDAQINL IArray * AiFeatures_getTriggerSources(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 49, IArray *, int32)(obj, 0); }
BDAQINL ValueRange AiFeatures_getTriggerSourceVrg(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 50, ValueRange, int32)(obj, 0); }
BDAQINL double AiFeatures_getTriggerHysteresisIndexMax(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 51, double, int32)(obj, 0); }
BDAQINL int32 AiFeatures_getTriggerHysteresisIndexStep(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 52, int32, int32)(obj, 0); }
/*buffered ai->trigger1 features*/
BDAQINL IArray * AiFeatures_getTrigger1Actions(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 47, IArray *, int32)(obj, 1); }
BDAQINL void AiFeatures_getTrigger1DelayRange(AiFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_AI, 48, int32, MathInterval *)(obj, 1, x);}
BDAQINL IArray * AiFeatures_getTrigger1Sources(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 49, IArray *, int32)(obj, 1); }
BDAQINL ValueRange AiFeatures_getTrigger1SourceVrg(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 50, ValueRange, int32)(obj, 1); }
BDAQINL double AiFeatures_getTrigger1HysteresisIndexMax(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 51, double, int32)(obj, 1); }
BDAQINL int32 AiFeatures_getTrigger1HysteresisIndexStep(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 52, int32, int32)(obj, 1); }
/*buffered ai->trigger2 features*/
BDAQINL IArray * AiFeatures_getTrigger2Actions(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 47, IArray *, int32)(obj, 2); }
BDAQINL void AiFeatures_getTrigger2DelayRange(AiFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_AI, 48, int32, MathInterval *)(obj, 2, x);}
BDAQINL IArray * AiFeatures_getTrigger2Sources(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 49, IArray *, int32)(obj, 2); }
BDAQINL ValueRange AiFeatures_getTrigger2SourceVrg(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 50, ValueRange, int32)(obj, 2); }
BDAQINL double AiFeatures_getTrigger2HysteresisIndexMax(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 51, double, int32)(obj, 2); }
BDAQINL int32 AiFeatures_getTrigger2HysteresisIndexStep(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 52, int32, int32)(obj, 2); }
/*buffered ai->trigger3 features*/
BDAQINL IArray * AiFeatures_getTrigger3Actions(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 47, IArray *, int32)(obj, 3); }
BDAQINL void AiFeatures_getTrigger3DelayRange(AiFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_AI, 48, int32, MathInterval *)(obj, 3, x);}
BDAQINL IArray * AiFeatures_getTrigger3Sources(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 49, IArray *, int32)(obj, 3); }
BDAQINL ValueRange AiFeatures_getTrigger3SourceVrg(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 50, ValueRange, int32)(obj, 3); }
BDAQINL double AiFeatures_getTrigger3HysteresisIndexMax(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 51, double, int32)(obj, 3); }
BDAQINL int32 AiFeatures_getTrigger3HysteresisIndexStep(AiFeatures *obj) { return DAQFN_TT(DNLAPI_AI, 52, int32, int32)(obj, 3); }
/*sensor features*/
BDAQINL IArray * AiFeatures_getMeasureTypes(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 112, IArray *)(obj); }
BDAQINL IArray * AiFeatures_getBridgeResistances(AiFeatures *obj) { return DAQFN_TV(DNLAPI_AI, 113, IArray *)(obj); }
BDAQINL void AiFeatures_getExcitingVoltageRange(AiFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_AI, 114, MathInterval *)(obj, x); }
/* ----------------------------------------------------------*/
/*InstantAiCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode InstantAiCtrl_LoadProfile(InstantAiCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void InstantAiCtrl_Cleanup(InstantAiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void InstantAiCtrl_Dispose(InstantAiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void InstantAiCtrl_getSelectedDevice(InstantAiCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode InstantAiCtrl_setSelectedDevice(InstantAiCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState InstantAiCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * InstantAiCtrl_getDevice(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * InstantAiCtrl_getSupportedDevices(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * InstantAiCtrl_getSupportedModes(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL AiFeatures * InstantAiCtrl_getFeatures(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 58, AiFeatures *)(obj); }
BDAQINL IArray * InstantAiCtrl_getChannels(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 59, IArray * )(obj); }
BDAQINL int32 InstantAiCtrl_getChannelCount(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 60, int32 )(obj); }
BDAQINL ErrorCode InstantAiCtrl_runSensorCalibration(InstantAiCtrl *obj, int32 ch, CalibrationData const *data) { return DAQFN_ETT(DNLAPI_AI, 111, int32, CalibrationData const*)(obj, ch, data); }
/* InstantAiCtrl Methods & Properties*/
BDAQINL ErrorCode InstantAiCtrl_ReadAny(InstantAiCtrl *obj, int32 chStart, int32 chCount, void *dataRaw, double *dataScaled) { return DAQFN_ETTTT(DNLAPI_AI, 61, int32, int32, void *, double *)(obj, chStart, chCount, dataRaw, dataScaled); }
BDAQINL CjcSetting * InstantAiCtrl_getCjc(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 62, CjcSetting *)(obj); }
BDAQINL double InstantAiCtrl_getAutoConvertClockRate(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 63, double)(obj); }
BDAQINL ErrorCode InstantAiCtrl_setAutoConvertClockRate(InstantAiCtrl *obj, double value) { return DAQFN_ET(DNLAPI_AI, 64, double)(obj, value); }
BDAQINL int32 InstantAiCtrl_getAutoConvertChannelStart(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 65, int32)(obj); }
BDAQINL ErrorCode InstantAiCtrl_setAutoConvertChannelStart(InstantAiCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_AI, 66, int32)(obj, value); }
BDAQINL int32 InstantAiCtrl_getAutoConvertChannelCount(InstantAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 67, int32)(obj); }
BDAQINL ErrorCode InstantAiCtrl_setAutoConvertChannelCount(InstantAiCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_AI, 68, int32)(obj, value); }
/*creator*/
BDAQINL InstantAiCtrl * InstantAiCtrl_Create(void) { return (InstantAiCtrl*)DaqCtrlBase_Create(SceInstantAi); }
/* ----------------------------------------------------------*/
/*BufferedAiCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode BufferedAiCtrl_LoadProfile(BufferedAiCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void BufferedAiCtrl_Cleanup(BufferedAiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void BufferedAiCtrl_Dispose(BufferedAiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void BufferedAiCtrl_getSelectedDevice(BufferedAiCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode BufferedAiCtrl_setSelectedDevice(BufferedAiCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState BufferedAiCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj);}
BDAQINL DeviceCtrl * BufferedAiCtrl_getDevice(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj);}
BDAQINL IArray * BufferedAiCtrl_getSupportedDevices(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * BufferedAiCtrl_getSupportedModes(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL AiFeatures * BufferedAiCtrl_getFeatures(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 58, AiFeatures *)(obj);}
BDAQINL IArray * BufferedAiCtrl_getChannels(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 59, IArray *)(obj); }
BDAQINL int32 BufferedAiCtrl_getChannelCount(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 60, int32 )(obj); }
BDAQINL ErrorCode BufferedAiCtrl_runSensorCalibration(BufferedAiCtrl *obj, int32 ch, CalibrationData const *data) { return DAQFN_ETT(DNLAPI_AI, 111, int32, CalibrationData const*)(obj, ch, data); }
/* BufferedAiCtrl Methods & Properties */
BDAQINL ErrorCode BufferedAiCtrl_Prepare(BufferedAiCtrl *obj) { return DAQFN_EV(DNLAPI_AI, 69)(obj); }
BDAQINL ErrorCode BufferedAiCtrl_RunOnce(BufferedAiCtrl *obj) { return DAQFN_EV(DNLAPI_AI, 70)(obj); }
BDAQINL ErrorCode BufferedAiCtrl_Start(BufferedAiCtrl *obj) { return DAQFN_EV(DNLAPI_AI, 71)(obj); }
BDAQINL ErrorCode BufferedAiCtrl_Stop(BufferedAiCtrl *obj) { return DAQFN_EV(DNLAPI_AI, 72)(obj); }
BDAQINL void BufferedAiCtrl_Release(BufferedAiCtrl *obj) { DAQFN_VV(DNLAPI_AI, 73)(obj); }
BDAQINL int8 BufferedAiCtrl_GetBufferStatus(BufferedAiCtrl *obj, int32 *count, int32 *offset) { return DAQFN_TTT(DNLAPI_AI, 74, int8, int32 *, int32 *)(obj, count, offset); }
BDAQINL ErrorCode BufferedAiCtrl_GetDataI16(BufferedAiCtrl *obj, int32 count, int16 rawData[]) { return DAQFN_ETTT(DNLAPI_AI, 75, int32, int32, void*)(obj, sizeof(int16), count, rawData); }
BDAQINL ErrorCode BufferedAiCtrl_GetDataI32(BufferedAiCtrl *obj, int32 count, int32 rawData[]) { return DAQFN_ETTT(DNLAPI_AI, 75, int32, int32, void*)(obj, sizeof(int32), count, rawData); }
BDAQINL ErrorCode BufferedAiCtrl_GetDataF64(BufferedAiCtrl *obj, int32 count, double scaledData[]) { return DAQFN_ETTT(DNLAPI_AI, 75, int32, int32, void*)(obj, sizeof(double),count, scaledData); }
BDAQINL void* BufferedAiCtrl_getBuffer(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 76, void*)(obj); }
BDAQINL int32 BufferedAiCtrl_getBufferCapacity(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 77, int32)(obj); }
BDAQINL ScanChannel * BufferedAiCtrl_getScanChannel(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 78, ScanChannel *)(obj); }
BDAQINL ConvertClock * BufferedAiCtrl_getConvertClock(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 79, ConvertClock *)(obj); }
BDAQINL ScanClock * BufferedAiCtrl_getScanClock(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 80, ScanClock *)(obj); }
BDAQINL Trigger * BufferedAiCtrl_getTrigger(BufferedAiCtrl *obj) { return DAQFN_TT(DNLAPI_AI, 81, Trigger *, int32)(obj, 0); }
BDAQINL Trigger * BufferedAiCtrl_getTrigger1(BufferedAiCtrl *obj) { return DAQFN_TT(DNLAPI_AI, 81, Trigger *, int32)(obj, 1); }
BDAQINL Trigger * BufferedAiCtrl_getTrigger2(BufferedAiCtrl *obj) { return DAQFN_TT(DNLAPI_AI, 81, Trigger *, int32)(obj, 2); }
BDAQINL Trigger * BufferedAiCtrl_getTrigger3(BufferedAiCtrl *obj) { return DAQFN_TT(DNLAPI_AI, 81, Trigger *, int32)(obj, 3); }
BDAQINL int8 BufferedAiCtrl_getStreaming(BufferedAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 82, int8)(obj); }
BDAQINL ErrorCode BufferedAiCtrl_setStreaming(BufferedAiCtrl *obj, int8 value) { return DAQFN_ET(DNLAPI_AI, 83, int8)(obj, value); }
/*creator*/
BDAQINL BufferedAiCtrl * BufferedAiCtrl_Create(void) { return (BufferedAiCtrl *)DaqCtrlBase_Create(SceBufferedAi); }
/*Helpers*/
BDAQINL void BufferedAiCtrl_addDataReadyHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedAiCtrl_removeDataReadyHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedAiCtrl_addOverrunHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedAiCtrl_removeOverrunHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedAiCtrl_addCacheOverflowHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedAiCtrl_removeCacheOverflowHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedAiCtrl_addStoppedHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiStopped, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedAiCtrl_removeStoppedHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiStopped, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedAiCtrl_addBurnOutHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiBurnOut, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedAiCtrl_removeBurnOutHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiBurnOut, (DaqEventProc)proc, userParam);}
/* ----------------------------------------------------------*/
/*WaveformAiCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode WaveformAiCtrl_LoadProfile(WaveformAiCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void WaveformAiCtrl_Cleanup(WaveformAiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void WaveformAiCtrl_Dispose(WaveformAiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void WaveformAiCtrl_getSelectedDevice(WaveformAiCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode WaveformAiCtrl_setSelectedDevice(WaveformAiCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState WaveformAiCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj);}
BDAQINL DeviceCtrl * WaveformAiCtrl_getDevice(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj);}
BDAQINL IArray * WaveformAiCtrl_getSupportedDevices(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * WaveformAiCtrl_getSupportedModes(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL AiFeatures * WaveformAiCtrl_getFeatures(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 58, AiFeatures *)(obj);}
BDAQINL IArray * WaveformAiCtrl_getChannels(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 59, IArray *)(obj); }
BDAQINL int32 WaveformAiCtrl_getChannelCount(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 60, int32 )(obj); }
BDAQINL ErrorCode WaveformAiCtrl_runSensorCalibration(WaveformAiCtrl *obj, int32 ch, CalibrationData const *data) { return DAQFN_ETT(DNLAPI_AI, 111, int32, CalibrationData const*)(obj, ch, data); }
/* WaveformAiCtrl Methods & Properties */
BDAQINL ErrorCode WaveformAiCtrl_Prepare(WaveformAiCtrl *obj) { return DAQFN_EV(DNLAPI_AI, 84)(obj); }
BDAQINL ErrorCode WaveformAiCtrl_Start(WaveformAiCtrl *obj) { return DAQFN_EV(DNLAPI_AI, 85)(obj); }
BDAQINL ErrorCode WaveformAiCtrl_Stop(WaveformAiCtrl *obj) { return DAQFN_EV(DNLAPI_AI, 86)(obj); }
BDAQINL void WaveformAiCtrl_Release(WaveformAiCtrl *obj) { DAQFN_VV(DNLAPI_AI, 87)(obj); }
BDAQINL int8 WaveformAiCtrl_GetBufferStatus(WaveformAiCtrl *obj, int32 *count, int32 *offset) { return DAQFN_TTT(DNLAPI_AI, 88, int8, int32 *, int32 *)(obj, count, offset); }
BDAQINL ErrorCode WaveformAiCtrl_GetDataI16(WaveformAiCtrl *obj, int32 count, int16 dataBuf[],
int32 timeout, int32 *returned, double * startTime, int32 *markCount, DataMark *markBuf)
{
typedef ErrorCode (BDAQCALL *FNGETDATA)(void *, int32, int32, void *, int32, int32 *, double *, int32 *, DataMark *);
return ((FNGETDATA)DNLAPI_AI[89])(obj, sizeof(int16), count, dataBuf, timeout, returned, startTime, markCount, markBuf);
}
BDAQINL ErrorCode WaveformAiCtrl_GetDataI32(WaveformAiCtrl *obj, int32 count, int32 dataBuf[],
int32 timeout, int32 *returned, double * startTime, int32 *markCount, DataMark *markBuf)
{
typedef ErrorCode (BDAQCALL *FNGETDATA)(void *, int32, int32, void *, int32, int32 *, double *, int32 *, DataMark *);
return ((FNGETDATA)DNLAPI_AI[89])(obj, sizeof(int32), count, dataBuf, timeout, returned, startTime, markCount, markBuf);
}
BDAQINL ErrorCode WaveformAiCtrl_GetDataF64(WaveformAiCtrl *obj, int32 count, double dataBuf[],
int32 timeout, int32 *returned, double * startTime, int32 *markCount, DataMark *markBuf)
{
typedef ErrorCode (BDAQCALL *FNGETDATA)(void *, int32, int32, void *, int32, int32 *, double *, int32 *, DataMark *);
return ((FNGETDATA)DNLAPI_AI[89])(obj, sizeof(double), count, dataBuf, timeout, returned, startTime, markCount, markBuf);
}
BDAQINL void* WaveformAiCtrl_getBuffer(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 90, void*)(obj); }
BDAQINL int32 WaveformAiCtrl_getBufferCapacity(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 91, int32)(obj); }
BDAQINL Conversion * WaveformAiCtrl_getConversion(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 92, Conversion *)(obj); }
BDAQINL Record * WaveformAiCtrl_getRecord(WaveformAiCtrl *obj) { return DAQFN_TV(DNLAPI_AI, 93, Record *)(obj); }
BDAQINL Trigger * WaveformAiCtrl_getTrigger(WaveformAiCtrl *obj) { return DAQFN_TT(DNLAPI_AI, 94, Trigger *, int32)(obj, 0); }
BDAQINL Trigger * WaveformAiCtrl_getTrigger1(WaveformAiCtrl *obj) { return DAQFN_TT(DNLAPI_AI, 94, Trigger *, int32)(obj, 1); }
BDAQINL Trigger * WaveformAiCtrl_getTrigger2(WaveformAiCtrl *obj) { return DAQFN_TT(DNLAPI_AI, 94, Trigger *, int32)(obj, 2); }
BDAQINL Trigger * WaveformAiCtrl_getTrigger3(WaveformAiCtrl *obj) { return DAQFN_TT(DNLAPI_AI, 94, Trigger *, int32)(obj, 3); }
/*creator*/
BDAQINL WaveformAiCtrl * WaveformAiCtrl_Create(void) { return (WaveformAiCtrl *)DaqCtrlBase_Create(SceWaveformAi); }
/*Helpers*/
BDAQINL void WaveformAiCtrl_addDataReadyHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_removeDataReadyHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_addOverrunHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_removeOverrunHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_addCacheOverflowHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_removeCacheOverflowHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_addStoppedHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiStopped, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_removeStoppedHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiStopped, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_addBurnOutHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiBurnOut, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_removeBurnOutHandler(WaveformAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiBurnOut, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_addTimeStampOverrunHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiTimeStampOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_removeTimeStampOverrunHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiTimeStampOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_addTimeStampCacheOverflowHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiTimeStampCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_removeTimeStampCacheOverflowHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiTimeStampCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_addMarkOverrunHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAiMarkOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void WaveformAiCtrl_removeMarkOverrunHandler(BufferedAiCtrl *obj, BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAiMarkOverrun, (DaqEventProc)proc, userParam);}
/*************************************************************/
/* ctrl class : AO related */
/* ----------------------------------------------------------*/
/*AoChannel*/
/* ----------------------------------------------------------*/
BDAQINL int32 AoChannel_getChannel(AoChannel *obj) { return DAQFN_TV(DNLAPI_AO, 0, int32)(obj); }
BDAQINL ValueRange AoChannel_getValueRange(AoChannel *obj) { return DAQFN_TV(DNLAPI_AO, 1, ValueRange)(obj); }
BDAQINL ErrorCode AoChannel_setValueRange(AoChannel *obj, ValueRange value) { return DAQFN_ET(DNLAPI_AO, 2, ValueRange)(obj, value);}
BDAQINL double AoChannel_getExtRefBipolar(AoChannel *obj) { return DAQFN_TV(DNLAPI_AO, 47, double)(obj); }
BDAQINL ErrorCode AoChannel_setExtRefBipolar(AoChannel *obj, double value) { return DAQFN_ET(DNLAPI_AO, 48, double)(obj, value); }
BDAQINL double AoChannel_getExtRefUnipolar(AoChannel *obj) { return DAQFN_TV(DNLAPI_AO, 49, double)(obj); }
BDAQINL ErrorCode AoChannel_setExtRefUnipolar(AoChannel *obj, double value) { return DAQFN_ET(DNLAPI_AO, 50, double)(obj, value); }
BDAQINL ErrorCode AoChannel_getScaleTable(AoChannel *obj, int32 *size, MapFuncPiece table[]) { return DAQFN_ETT(DNLAPI_AO, 22, int32 *, MapFuncPiece *)(obj, size, table); }
BDAQINL ErrorCode AoChannel_setScaleTable(AoChannel *obj, int32 size, MapFuncPiece table[]) { return DAQFN_ETT(DNLAPI_AO, 23, int32 , MapFuncPiece *)(obj, size, table); }
/* ----------------------------------------------------------*/
/*AO features */
/* ----------------------------------------------------------*/
/*DAC features */
BDAQINL int32 AoFeatures_getResolution(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 5, int32)(obj); }
BDAQINL int32 AoFeatures_getDataSize(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 6, int32)(obj); }
BDAQINL int32 AoFeatures_getDataMask(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 7, int32)(obj); }
/*channel features */
BDAQINL int32 AoFeatures_getChannelCountMax(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 8, int32)(obj); }
BDAQINL IArray * AoFeatures_getValueRanges(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 9, IArray *)(obj);}
BDAQINL int8 AoFeatures_getExternalRefAntiPolar(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 10, int8)(obj); }
BDAQINL void AoFeatures_getExternalRefRange(AoFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_AO, 11, MathInterval *)(obj, x); }
/*buffered ao->basic features */
BDAQINL int8 AoFeatures_getBufferedAoSupported(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 12, int8)(obj); }
BDAQINL SamplingMethod AoFeatures_getSamplingMethod(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 13, SamplingMethod)(obj); }
BDAQINL int32 AoFeatures_getChannelStartBase(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 14, int32)(obj); }
BDAQINL int32 AoFeatures_getChannelCountBase(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 15, int32)(obj); }
/*buffered ao->conversion clock features*/
BDAQINL IArray * AoFeatures_getConvertClockSources(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 16, IArray *)(obj); }
BDAQINL void AoFeatures_getConvertClockRange(AoFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_AO, 17, MathInterval *)(obj, x);}
/*buffered ao->trigger features*/
BDAQINL int32 AoFeatures_getTriggerCount(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 18, int32)(obj); }
BDAQINL int8 AoFeatures_getRetriggerable(AoFeatures *obj) { return DAQFN_TV(DNLAPI_AO, 51, int8)(obj); }
/*buffered ao->trigger0 features */
BDAQINL IArray * AoFeatures_getTriggerSources(AoFeatures *obj) { return DAQFN_TT(DNLAPI_AO, 19, IArray *, int32)(obj, 0); }
BDAQINL IArray * AoFeatures_getTriggerActions(AoFeatures *obj) { return DAQFN_TT(DNLAPI_AO, 20, IArray *, int32)(obj, 0); }
BDAQINL void AoFeatures_getTriggerDelayRange(AoFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_AO, 21, int32, MathInterval *)(obj, 0, x); }
/*buffered ao->trigger1 features */
BDAQINL IArray * AoFeatures_getTrigger1Sources(AoFeatures *obj) { return DAQFN_TT(DNLAPI_AO, 19, IArray *, int32)(obj, 1); }
BDAQINL IArray * AoFeatures_getTrigger1Actions(AoFeatures *obj) { return DAQFN_TT(DNLAPI_AO, 20, IArray *, int32)(obj, 1); }
BDAQINL void AoFeatures_getTrigger1DelayRange(AoFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_AO, 21, int32, MathInterval *)(obj, 1, x); }
/* ----------------------------------------------------------*/
/*InstantAoCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode InstantAoCtrl_LoadProfile(InstantAoCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void InstantAoCtrl_Cleanup(InstantAoCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void InstantAoCtrl_Dispose(InstantAoCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void InstantAoCtrl_getSelectedDevice(InstantAoCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode InstantAoCtrl_setSelectedDevice(InstantAoCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState InstantAoCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj);}
BDAQINL DeviceCtrl * InstantAoCtrl_getDevice(InstantAoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj);}
BDAQINL IArray * InstantAoCtrl_getSupportedDevices(InstantAoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * InstantAoCtrl_getSupportedModes(InstantAoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/* base2*/
BDAQINL AoFeatures * InstantAoCtrl_getFeatures(InstantAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 25, AoFeatures *)(obj); }
BDAQINL IArray * InstantAoCtrl_getChannels(InstantAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 26, IArray *)(obj); }
BDAQINL int32 InstantAoCtrl_getChannelCount(InstantAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 27, int32 )(obj); }
BDAQINL double InstantAoCtrl_getExtRefValueForUnipolar(InstantAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 28, double)(obj); }
BDAQINL ErrorCode InstantAoCtrl_setExtRefValueForUnipolar(InstantAoCtrl *obj, double value) { return DAQFN_ET(DNLAPI_AO, 29, double)(obj, value);}
BDAQINL double InstantAoCtrl_getExtRefValueForBipolar(InstantAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 30, double)(obj); }
BDAQINL ErrorCode InstantAoCtrl_setExtRefValueForBipolar(InstantAoCtrl *obj, double value) { return DAQFN_ET(DNLAPI_AO, 31, double)(obj, value);}
/* InstantAoCtrl methods */
BDAQINL ErrorCode InstantAoCtrl_WriteAny(InstantAoCtrl *obj, int32 chStart, int32 chCount, void *dataRaw, double *dataScaled) { return DAQFN_ETTTT(DNLAPI_AO, 32, int32, int32, void *, double *)(obj, chStart, chCount, dataRaw, dataScaled); }
/*creator*/
BDAQINL InstantAoCtrl * InstantAoCtrl_Create(void) { return (InstantAoCtrl *)DaqCtrlBase_Create(SceInstantAo); }
/* ----------------------------------------------------------*/
/*BufferedAoCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode BufferedAoCtrl_LoadProfile(BufferedAoCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void BufferedAoCtrl_Cleanup(BufferedAoCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void BufferedAoCtrl_Dispose(BufferedAoCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void BufferedAoCtrl_getSelectedDevice(BufferedAoCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode BufferedAoCtrl_setSelectedDevice(BufferedAoCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState BufferedAoCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj);}
BDAQINL DeviceCtrl * BufferedAoCtrl_getDevice(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj);}
BDAQINL IArray * BufferedAoCtrl_getSupportedDevices(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * BufferedAoCtrl_getSupportedModes(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/* base2*/
BDAQINL AoFeatures * BufferedAoCtrl_getFeatures(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 25, AoFeatures *)(obj); }
BDAQINL IArray * BufferedAoCtrl_getChannels(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 26, IArray *)(obj); }
BDAQINL int32 BufferedAoCtrl_getChannelCount(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 27, int32 )(obj); }
BDAQINL double BufferedAoCtrl_getExtRefValueForUnipolar(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 28, double)(obj); }
BDAQINL ErrorCode BufferedAoCtrl_setExtRefValueForUnipolar(BufferedAoCtrl *obj, double value) { return DAQFN_ET(DNLAPI_AO, 29, double)(obj, value);}
BDAQINL double BufferedAoCtrl_getExtRefValueForBipolar(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 30, double)(obj); }
BDAQINL ErrorCode BufferedAoCtrl_setExtRefValueForBipolar(BufferedAoCtrl *obj, double value) { return DAQFN_ET(DNLAPI_AO, 31, double)(obj, value);}
/* BufferedAoCtrl Methods & Properties */
BDAQINL ErrorCode BufferedAoCtrl_Prepare(BufferedAoCtrl *obj) { return DAQFN_EV(DNLAPI_AO, 33)(obj); }
BDAQINL ErrorCode BufferedAoCtrl_RunOnce(BufferedAoCtrl *obj) { return DAQFN_EV(DNLAPI_AO, 34)(obj); }
BDAQINL ErrorCode BufferedAoCtrl_Start(BufferedAoCtrl *obj) { return DAQFN_EV(DNLAPI_AO, 35)(obj); }
BDAQINL ErrorCode BufferedAoCtrl_Stop(BufferedAoCtrl *obj, int32 action) { return DAQFN_ET(DNLAPI_AO, 36, int32)(obj, action); }
BDAQINL void BufferedAoCtrl_Release(BufferedAoCtrl *obj) { DAQFN_VV(DNLAPI_AO, 37)(obj); }
BDAQINL int8 BufferedAoCtrl_GetBufferStatus(BufferedAoCtrl *obj, int32 *count, int32 *offset) { return DAQFN_TTT(DNLAPI_AO, 38, int8, int32 *, int32 *)(obj, count, offset); }
BDAQINL ErrorCode BufferedAoCtrl_SetDataI16(BufferedAoCtrl *obj, int32 count, int16 rawData[]) { return DAQFN_ETTT(DNLAPI_AO, 39, int32, int32, void*)(obj, sizeof(int16), count, rawData); }
BDAQINL ErrorCode BufferedAoCtrl_SetDataI32(BufferedAoCtrl *obj, int32 count, int32 rawData[]) { return DAQFN_ETTT(DNLAPI_AO, 39, int32, int32, void*)(obj, sizeof(int32), count, rawData); }
BDAQINL ErrorCode BufferedAoCtrl_SetDataF64(BufferedAoCtrl *obj, int32 count, double scaledData[]) { return DAQFN_ETTT(DNLAPI_AO, 39, int32, int32, void*)(obj, sizeof(double), count, scaledData); }
BDAQINL void* BufferedAoCtrl_getBuffer(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 40, void*)(obj); }
BDAQINL int32 BufferedAoCtrl_getBufferCapacity(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 41, int32)(obj); }
BDAQINL ScanChannel * BufferedAoCtrl_getScanChannel(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 42, ScanChannel *)(obj); }
BDAQINL ConvertClock * BufferedAoCtrl_getConvertClock(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 43, ConvertClock *)(obj); }
BDAQINL Trigger * BufferedAoCtrl_getTrigger(BufferedAoCtrl *obj) { return DAQFN_TT(DNLAPI_AO, 44, Trigger *, int32)(obj, 0); }
BDAQINL Trigger * BufferedAoCtrl_getTrigger1(BufferedAoCtrl *obj) { return DAQFN_TT(DNLAPI_AO, 44, Trigger *, int32)(obj, 1); }
BDAQINL int8 BufferedAoCtrl_getStreaming(BufferedAoCtrl *obj) { return DAQFN_TV(DNLAPI_AO, 45, int8)(obj); }
BDAQINL ErrorCode BufferedAoCtrl_setStreaming(BufferedAoCtrl *obj, int8 value) { return DAQFN_ET(DNLAPI_AO, 46, int8)(obj, value); }
/*creator*/
BDAQINL BufferedAoCtrl * BufferedAoCtrl_Create(void) { return (BufferedAoCtrl *)DaqCtrlBase_Create(SceBufferedAo); }
/*Helpers*/
BDAQINL void BufferedAoCtrl_addDataTransmittedHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAoDataTransmitted, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedAoCtrl_removeDataTransmittedHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAoDataTransmitted, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedAoCtrl_addUnderrunHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAoUnderrun, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedAoCtrl_removeUnderrunHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAoUnderrun, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedAoCtrl_addCacheEmptiedHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAoCacheEmptied, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedAoCtrl_removeCacheEmptiedHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAoCacheEmptied, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedAoCtrl_addTransitStoppedHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAoTransStopped, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedAoCtrl_removeTransitStoppedHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAoTransStopped, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedAoCtrl_addStoppedHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedAoStopped, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedAoCtrl_removeStoppedHandler(BufferedAoCtrl *obj, BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedAoStopped, (DaqEventProc)proc, userParam); }
/*************************************************************/
/*ctrl class : DIO related classes */
/* ----------------------------------------------------------*/
/*DioPort*/
/* ----------------------------------------------------------*/
BDAQINL int32 DioPort_getPort(DioPort *obj) { return DAQFN_TV(DNLAPI_DIO, 0, int32)(obj); }
BDAQINL uint8 DioPort_getDirectionMask(DioPort *obj) { return (uint8)DAQFN_TV(DNLAPI_DIO, 1, int32)(obj); }
BDAQINL ErrorCode DioPort_setDirectionMask(DioPort *obj, uint8 value) { return DAQFN_ET(DNLAPI_DIO, 2, int32)(obj, value); }
/*DI port property*/
BDAQINL uint8 DioPort_getDiInversePort(DioPort *obj) { return DAQFN_TV(DNLAPI_DIO, 3, uint8)(obj); }
BDAQINL ErrorCode DioPort_setDiInversePort(DioPort *obj, uint8 value) { return DAQFN_ET(DNLAPI_DIO, 4, uint8)(obj, value); }
BDAQINL uint8 DioPort_getDiOpenState(DioPort *obj) { return DAQFN_TV(DNLAPI_DIO, 133, uint8)(obj); }
BDAQINL ErrorCode DioPort_setDiOpenState(DioPort *obj, uint8 value) { return DAQFN_ET(DNLAPI_DIO, 134, uint8)(obj, value); }
/*DO port property*/
BDAQINL uint8 DioPort_getDoPresetValue(DioPort *obj) { return DAQFN_TV(DNLAPI_DIO, 64, uint8)(obj); }
BDAQINL ErrorCode DioPort_setDoPresetValue(DioPort *obj, uint8 value) { return DAQFN_ET(DNLAPI_DIO, 65, uint8)(obj, value);}
BDAQINL DoCircuitType DioPort_getDoCircuitType(DioPort *obj) { return DAQFN_TV(DNLAPI_DIO, 67, DoCircuitType)(obj); }
BDAQINL ErrorCode DioPort_setDoCircuitType(DioPort *obj, DoCircuitType value) { return DAQFN_ET(DNLAPI_DIO, 68, DoCircuitType)(obj, value);}
// For compatible
#define DioPort_getDirection(obj) (DioPortDir)DioPort_getDirectionMask(obj)
#define DioPort_setDirection(obj, value) DioPort_setDirectionMask(obj, (uint8)value)
/* ----------------------------------------------------------*/
/*DiintChannel*/
/* ----------------------------------------------------------*/
BDAQINL int32 DiintChannel_getChannel(DiintChannel *obj) { return DAQFN_TV(DNLAPI_DIO, 7 , int32)(obj); }
BDAQINL int8 DiintChannel_getEnabled(DiintChannel *obj) { return DAQFN_TV(DNLAPI_DIO, 8 , int8)(obj); }
BDAQINL ErrorCode DiintChannel_setEnabled(DiintChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_DIO, 9 , int8)(obj, value); }
BDAQINL int8 DiintChannel_getGated(DiintChannel *obj) { return DAQFN_TV(DNLAPI_DIO, 10, int8)(obj); }
BDAQINL ErrorCode DiintChannel_setGated(DiintChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_DIO, 11, int8)(obj, value); }
BDAQINL ActiveSignal DiintChannel_getTrigEdge(DiintChannel *obj) { return DAQFN_TV(DNLAPI_DIO, 12, ActiveSignal)(obj);}
BDAQINL ErrorCode DiintChannel_setTrigEdge(DiintChannel *obj, ActiveSignal value) { return DAQFN_ET(DNLAPI_DIO, 13, ActiveSignal)(obj, value);}
/* ----------------------------------------------------------*/
/*DiCosintPort */
/* ----------------------------------------------------------*/
BDAQINL int32 DiCosintPort_getPort(DiCosintPort *obj) { return DAQFN_TV(DNLAPI_DIO, 14, int32)(obj); }
BDAQINL uint8 DiCosintPort_getMask(DiCosintPort *obj) { return DAQFN_TV(DNLAPI_DIO, 15, uint8)(obj); }
BDAQINL ErrorCode DiCosintPort_setMask(DiCosintPort *obj, uint8 value) { return DAQFN_ET(DNLAPI_DIO, 16, uint8)(obj, value);}
/* ----------------------------------------------------------*/
/*DiPmintPort */
/* ----------------------------------------------------------*/
BDAQINL int32 DiPmintPort_getPort(DiPmintPort *obj) { return DAQFN_TV(DNLAPI_DIO, 17, int32)(obj); }
BDAQINL uint8 DiPmintPort_getMask(DiPmintPort *obj) { return DAQFN_TV(DNLAPI_DIO, 18, uint8)(obj); }
BDAQINL ErrorCode DiPmintPort_setMask(DiPmintPort *obj, uint8 value) { return DAQFN_ET(DNLAPI_DIO, 19, uint8)(obj, value);}
BDAQINL uint8 DiPmintPort_getPattern(DiPmintPort *obj) { return DAQFN_TV(DNLAPI_DIO, 20, uint8)(obj); }
BDAQINL ErrorCode DiPmintPort_setPattern(DiPmintPort *obj, uint8 value) { return DAQFN_ET(DNLAPI_DIO, 21, uint8)(obj, value);}
/* ----------------------------------------------------------*/
/*DIO features */
/* ----------------------------------------------------------*/
/*Common*/
BDAQINL int8 DioFeatures_getPortProgrammable(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 22, int8)(obj); }
BDAQINL int32 DioFeatures_getChannelCountMax(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 23, int32)(obj); }
BDAQINL int32 DioFeatures_getPortCount(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 24, int32)(obj); }
BDAQINL IArray * DioFeatures_getPortsType(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 25, IArray *)(obj); }
BDAQINL int8 DioFeatures_getDiSupported(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 26, int8)(obj); }
BDAQINL int8 DioFeatures_getDoSupported(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 27, int8)(obj); }
/*DI Features*/
BDAQINL IArray * DioFeatures_getDiDataMask(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 28, IArray *)(obj); }
/*di noise filter features*/
BDAQINL int8 DioFeatures_getDiNoiseFilterSupported(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 29, int8)(obj); }
BDAQINL IArray * DioFeatures_getDiNoiseFilterOfChannels(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 30, IArray *)(obj); }
BDAQINL void DioFeatures_getDiNoiseFilterBlockTimeRange(DioFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_DIO, 31, MathInterval *)(obj, x); }
/*di interrupt features*/
BDAQINL int8 DioFeatures_getDiintSupported(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 32, int8)(obj); }
BDAQINL int8 DioFeatures_getDiintGateSupported(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 33, int8)(obj); }
BDAQINL int8 DioFeatures_getDiCosintSupported(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 34, int8)(obj); }
BDAQINL int8 DioFeatures_getDiPmintSupported(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 35, int8)(obj); }
BDAQINL IArray * DioFeatures_getDiintTriggerEdges(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 36, IArray *)(obj); }
BDAQINL IArray * DioFeatures_getDiintOfChannels(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 37, IArray *)(obj); }
BDAQINL IArray * DioFeatures_getDiintGateOfChannels(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 38, IArray *)(obj); }
BDAQINL IArray * DioFeatures_getDiCosintOfPorts(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 39, IArray *)(obj); }
BDAQINL IArray * DioFeatures_getDiPmintOfPorts(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 40, IArray *)(obj); }
BDAQINL IArray * DioFeatures_getDiSnapEventSources(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 41, IArray *)(obj); }
/*DO features */
BDAQINL IArray * DioFeatures_getDoDataMask(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 42, IArray *)(obj); }
BDAQINL IArray * DioFeatures_getDoFreezeSignalSources(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 43, IArray *)(obj); }
BDAQINL void DioFeatures_getDoReflectWdtFeedIntervalRange(DioFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_DIO, 44, MathInterval *)(obj, x);}
BDAQINL Depository DioFeatures_getDoPresetValueDepository(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 63, Depository)(obj); }
BDAQINL IArray * DioFeatures_getDoCircuitSelectableTypes(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 66, IArray *)(obj); }
/*For compatible*/
BDAQINL IArray * DioFeatures_getDataMask(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 62, IArray *)(obj); }
/*buffered di->basic features*/
BDAQINL int8 DioFeatures_getBufferedDiSupported(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 69, int8)(obj); }
BDAQINL SamplingMethod DioFeatures_getDiSamplingMethod(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 70, SamplingMethod)(obj); }
/*buffered di->conversion clock features*/
BDAQINL IArray * DioFeatures_getDiConvertClockSources(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 71, IArray *)(obj); }
BDAQINL void DioFeatures_getDiConvertClockRange(DioFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_DIO, 72, MathInterval *)(obj, x);}
/*buffered di->trigger features*/
BDAQINL int8 DioFeatures_getDiRetriggerable(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 73, int8)(obj); }
BDAQINL int32 DioFeatures_getDiTriggerCount(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 74, int32)(obj); }
/*buffered di->trigger0 features*/
BDAQINL IArray * DioFeatures_getDiTriggerActions(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 75, IArray *, int32)(obj, 0); }
BDAQINL void DioFeatures_getDiTriggerDelayRange(DioFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_DIO, 76, int32, MathInterval *)(obj, 0, x);}
BDAQINL IArray * DioFeatures_getDiTriggerSources(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 77, IArray *, int32)(obj, 0); }
BDAQINL ValueRange DioFeatures_getDiTriggerSourceVrg(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 78, ValueRange, int32)(obj, 0); }
BDAQINL double DioFeatures_getDiTriggerHysteresisIndexMax(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 79, double, int32)(obj, 0); }
BDAQINL int32 DioFeatures_getDiTriggerHysteresisIndexStep(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 80, int32, int32)(obj, 0); }
/*buffered di->trigger1 features*/
BDAQINL IArray * DioFeatures_getDiTrigger1Actions(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 75, IArray *, int32)(obj, 1); }
BDAQINL void DioFeatures_getDiTrigger1DelayRange(DioFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_DIO, 76, int32, MathInterval *)(obj, 1, x);}
BDAQINL IArray * DioFeatures_getDiTrigger1Sources(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 77, IArray *, int32)(obj, 1); }
BDAQINL ValueRange DioFeatures_getDiTrigger1SourceVrg(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 78, ValueRange, int32)(obj, 1); }
BDAQINL double DioFeatures_getDiTrigger1HysteresisIndexMax(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 79, double, int32)(obj, 1); }
BDAQINL int32 DioFeatures_getDiTrigger1HysteresisIndexStep(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 80, int32, int32)(obj, 1); }
/*buffered di & buffered do*/
BDAQINL int32 DioFeatures_getDataSize(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 92, int32)(obj); }
BDAQINL int32 DioFeatures_getResolution(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 93, int32)(obj); }
/*buffered do->basic features*/
BDAQINL int8 DioFeatures_getBufferedDoSupported(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 94, int8)(obj); }
BDAQINL SamplingMethod DioFeatures_getDoSamplingMethod(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 95, SamplingMethod)(obj); }
/*buffered do->conversion clock features*/
BDAQINL IArray * DioFeatures_getDoConvertClockSources(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 96, IArray *)(obj); }
BDAQINL void DioFeatures_getDoConvertClockRange(DioFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_DIO, 97, MathInterval *)(obj, x);}
/*buffered do->trigger features*/
BDAQINL int8 DioFeatures_getDoRetriggerable(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 98, int8)(obj); }
BDAQINL int32 DioFeatures_getDoTriggerCount(DioFeatures *obj) { return DAQFN_TV(DNLAPI_DIO, 99, int32)(obj); }
/*buffered do->trigger0 features*/
BDAQINL IArray * DioFeatures_getDoTriggerActions(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 100, IArray *, int32)(obj, 0); }
BDAQINL void DioFeatures_getDoTriggerDelayRange(DioFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_DIO, 101, int32, MathInterval *)(obj, 0, x);}
BDAQINL IArray * DioFeatures_getDoTriggerSources(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 102, IArray *, int32)(obj, 0); }
BDAQINL ValueRange DioFeatures_getDoTriggerSourceVrg(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 103, ValueRange, int32)(obj, 0); }
BDAQINL double DioFeatures_getDoTriggerHysteresisIndexMax(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 104, double, int32)(obj, 0); }
BDAQINL int32 DioFeatures_getDoTriggerHysteresisIndexStep(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 105, int32, int32)(obj, 0); }
/*buffered do->trigger1 features*/
BDAQINL IArray * DioFeatures_getDoTrigger1Actions(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 100, IArray *, int32)(obj, 1); }
BDAQINL void DioFeatures_getDoTrigger1DelayRange(DioFeatures *obj, MathInterval *x) { DAQFN_VTT(DNLAPI_DIO, 101, int32, MathInterval *)(obj, 1, x);}
BDAQINL IArray * DioFeatures_getDoTrigger1Sources(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 102, IArray *, int32)(obj, 1); }
BDAQINL ValueRange DioFeatures_getDoTrigger1SourceVrg(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 103, ValueRange, int32)(obj, 1); }
BDAQINL double DioFeatures_getDoTrigger1HysteresisIndexMax(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 104, double, int32)(obj, 1); }
BDAQINL int32 DioFeatures_getDoTrigger1HysteresisIndexStep(DioFeatures *obj) { return DAQFN_TT(DNLAPI_DIO, 105, int32, int32)(obj, 1); }
/* ----------------------------------------------------------*/
/*InstantDiCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode InstantDiCtrl_LoadProfile(InstantDiCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void InstantDiCtrl_Cleanup(InstantDiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void InstantDiCtrl_Dispose(InstantDiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void InstantDiCtrl_getSelectedDevice(InstantDiCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode InstantDiCtrl_setSelectedDevice(InstantDiCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState InstantDiCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * InstantDiCtrl_getDevice(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * InstantDiCtrl_getSupportedDevices(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * InstantDiCtrl_getSupportedModes(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL DioFeatures * InstantDiCtrl_getFeatures(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 45, DioFeatures *)(obj); }
BDAQINL int32 InstantDiCtrl_getPortCount(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 46, int32)(obj); }
BDAQINL IArray * InstantDiCtrl_getPorts(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 47, IArray *)(obj); }
/* Instant DI Methods & Properties */
BDAQINL ErrorCode InstantDiCtrl_ReadAny(InstantDiCtrl *obj, int32 portStart, int32 portCount, uint8 data[]) { return DAQFN_ETTT(DNLAPI_DIO, 48, int32, int32, uint8 *)(obj, portStart, portCount, data);}
BDAQINL ErrorCode InstantDiCtrl_ReadBit(InstantDiCtrl *obj, int32 port, int32 bit, uint8* data) { return DAQFN_ETTT(DNLAPI_DIO, 49, int32, int32, uint8 *)(obj, port, bit, data); }
BDAQINL ErrorCode InstantDiCtrl_SnapStart(InstantDiCtrl *obj) { return DAQFN_EV(DNLAPI_DIO, 50)(obj); }
BDAQINL ErrorCode InstantDiCtrl_SnapStop(InstantDiCtrl *obj) { return DAQFN_EV(DNLAPI_DIO, 51)(obj); }
BDAQINL double InstantDiCtrl_getNoiseFilterBlockTime(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 52, double)(obj); }
BDAQINL ErrorCode InstantDiCtrl_setNoiseFilterBlockTime(InstantDiCtrl *obj, double value) { return DAQFN_ET(DNLAPI_DIO, 53, double)(obj, value); }
BDAQINL IArray * InstantDiCtrl_getNoiseFilter(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 54, IArray *)(obj); }
BDAQINL IArray * InstantDiCtrl_getDiintChannels(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 55, IArray *)(obj); }
BDAQINL IArray * InstantDiCtrl_getDiCosintPorts(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 56, IArray *)(obj); }
BDAQINL IArray * InstantDiCtrl_getDiPmintPorts(InstantDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 57, IArray *)(obj); }
/*creator*/
BDAQINL InstantDiCtrl * InstantDiCtrl_Create(void) { return (InstantDiCtrl *)DaqCtrlBase_Create(SceInstantDi); }
/*Helpers*/
BDAQINL void InstantDiCtrl_addInterruptHandler(InstantDiCtrl *obj,DiSnapEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtDiInterrupt, (DaqEventProc)proc, userParam);}
BDAQINL void InstantDiCtrl_removeInterruptHandler(InstantDiCtrl *obj,DiSnapEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtDiInterrupt, (DaqEventProc)proc, userParam);}
BDAQINL void InstantDiCtrl_addChangeOfStateHandler(InstantDiCtrl *obj,DiSnapEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtDiStatusChange, (DaqEventProc)proc, userParam);}
BDAQINL void InstantDiCtrl_removeChangeOfStateHandler(InstantDiCtrl *obj,DiSnapEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtDiStatusChange, (DaqEventProc)proc, userParam);}
BDAQINL void InstantDiCtrl_addPatternMatchHandler(InstantDiCtrl *obj,DiSnapEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtDiPatternMatch, (DaqEventProc)proc, userParam);}
BDAQINL void InstantDiCtrl_removePatternMatchHandler(InstantDiCtrl *obj,DiSnapEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtDiPatternMatch, (DaqEventProc)proc, userParam);}
/* ----------------------------------------------------------*/
/*BufferedDiCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode BufferedDiCtrl_LoadProfile(BufferedDiCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void BufferedDiCtrl_Cleanup(BufferedDiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void BufferedDiCtrl_Dispose(BufferedDiCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void BufferedDiCtrl_getSelectedDevice(BufferedDiCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode BufferedDiCtrl_setSelectedDevice(BufferedDiCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState BufferedDiCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj);}
BDAQINL DeviceCtrl * BufferedDiCtrl_getDevice(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj);}
BDAQINL IArray * BufferedDiCtrl_getSupportedDevices(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * BufferedDiCtrl_getSupportedModes(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL DioFeatures * BufferedDiCtrl_getFeatures(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 45, DioFeatures *)(obj); }
BDAQINL int32 BufferedDiCtrl_getPortCount(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 46, int32)(obj); }
BDAQINL IArray * BufferedDiCtrl_getPorts(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 47, IArray *)(obj); }
/* BufferedDiCtrl Methods & Properties */
BDAQINL ErrorCode BufferedDiCtrl_Prepare(BufferedDiCtrl *obj) { return DAQFN_EV(DNLAPI_DIO, 81)(obj); }
BDAQINL ErrorCode BufferedDiCtrl_Start(BufferedDiCtrl *obj) { return DAQFN_EV(DNLAPI_DIO, 82)(obj); }
BDAQINL ErrorCode BufferedDiCtrl_Stop(BufferedDiCtrl *obj) { return DAQFN_EV(DNLAPI_DIO, 83)(obj); }
BDAQINL void BufferedDiCtrl_Release(BufferedDiCtrl *obj) { DAQFN_VV(DNLAPI_DIO, 84)(obj); }
BDAQINL int8 BufferedDiCtrl_GetBufferStatus(BufferedDiCtrl *obj, int32 *count, int32 *offset) { return DAQFN_TTT(DNLAPI_DIO, 85, int8, int32 *, int32 *)(obj, count, offset); }
BDAQINL ErrorCode BufferedDiCtrl_GetData(BufferedDiCtrl *obj, int32 count, int8 dataBuf[],
int32 timeout, int32 *returned, double * startTime, int32 *markCount, DataMark *markBuf)
{
typedef ErrorCode (BDAQCALL *FNGETDATA)(void *, int32, void *, int32, int32 *, double *, int32 *, DataMark *);
return ((FNGETDATA)DNLAPI_DIO[86])(obj, count, dataBuf, timeout, returned, startTime, markCount, markBuf);
}
BDAQINL void* BufferedDiCtrl_getBuffer(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 87, void*)(obj); }
BDAQINL int32 BufferedDiCtrl_getBufferCapacity(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 88, int32)(obj); }
BDAQINL ScanPort * BufferedDiCtrl_getScanPort(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 89, ScanPort *)(obj); }
BDAQINL ConvertClock* BufferedDiCtrl_getConvertClock(BufferedDiCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 90, ConvertClock *)(obj); }
BDAQINL Trigger * BufferedDiCtrl_getTrigger(BufferedDiCtrl *obj) { return DAQFN_TT(DNLAPI_DIO, 91, Trigger *, int32)(obj, 0); }
BDAQINL Trigger * BufferedDiCtrl_getTrigger1(BufferedDiCtrl *obj) { return DAQFN_TT(DNLAPI_DIO, 91, Trigger *, int32)(obj, 1); }
BDAQINL BufferedDiCtrl * BufferedDiCtrl_Create(void) { return (BufferedDiCtrl *)DaqCtrlBase_Create(SceBufferedDi); }
/*Helpers*/
BDAQINL void BufferedDiCtrl_addDataReadyHandler(BufferedDiCtrl *obj, BfdDiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedDiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedDiCtrl_removeDataReadyHandler(BufferedDiCtrl *obj, BfdDiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedDiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedDiCtrl_addOverrunHandler(BufferedDiCtrl *obj, BfdDiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedDiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedDiCtrl_removeOverrunHandler(BufferedDiCtrl *obj, BfdDiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedDiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedDiCtrl_addCacheOverflowHandler(BufferedDiCtrl *obj, BfdDiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedDiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedDiCtrl_removeCacheOverflowHandler(BufferedDiCtrl *obj, BfdDiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedDiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedDiCtrl_addStoppedHandler(BufferedDiCtrl *obj, BfdDiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedDiStopped, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedDiCtrl_removeStoppedHandler(BufferedDiCtrl *obj, BfdDiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedDiStopped, (DaqEventProc)proc, userParam);}
/* ----------------------------------------------------------*/
/*InstantDoCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode InstantDoCtrl_LoadProfile(InstantDoCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void InstantDoCtrl_Cleanup(InstantDoCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void InstantDoCtrl_Dispose(InstantDoCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void InstantDoCtrl_getSelectedDevice(InstantDoCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode InstantDoCtrl_setSelectedDevice(InstantDoCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState InstantDoCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * InstantDoCtrl_getDevice(InstantDoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * InstantDoCtrl_getSupportedDevices(InstantDoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * InstantDoCtrl_getSupportedModes(InstantDoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL DioFeatures * InstantDoCtrl_getFeatures(InstantDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 45, DioFeatures *)(obj); }
BDAQINL int32 InstantDoCtrl_getPortCount(InstantDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 46, int32)(obj); }
BDAQINL IArray * InstantDoCtrl_getPorts(InstantDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 47, IArray *)(obj); }
/* Instant DO methods */
BDAQINL ErrorCode InstantDoCtrl_WriteAny(InstantDoCtrl *obj, int32 portStart, int32 portCount, uint8 data[]) { return DAQFN_ETTT(DNLAPI_DIO, 58, int32, int32, uint8 *)(obj, portStart, portCount, data); }
BDAQINL ErrorCode InstantDoCtrl_ReadAny(InstantDoCtrl *obj, int32 portStart, int32 portCount, uint8 data[]) { return DAQFN_ETTT(DNLAPI_DIO, 59, int32, int32, uint8 *)(obj, portStart, portCount, data); }
BDAQINL ErrorCode InstantDoCtrl_WriteBit(InstantDoCtrl *obj, int32 port, int32 bit, uint8 data) { return DAQFN_ETTT(DNLAPI_DIO, 60, int32, int32, uint8 )(obj, port, bit, data); }
BDAQINL ErrorCode InstantDoCtrl_ReadBit(InstantDoCtrl *obj, int32 port, int32 bit, uint8* data) { return DAQFN_ETTT(DNLAPI_DIO, 61, int32, int32, uint8 *)(obj, port, bit, data); }
/*creator*/
BDAQINL InstantDoCtrl * InstantDoCtrl_Create(void) { return (InstantDoCtrl *)DaqCtrlBase_Create(SceInstantDo); }
/* ----------------------------------------------------------*/
/*BufferedDoCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode BufferedDoCtrl_LoadProfile(BufferedDoCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void BufferedDoCtrl_Cleanup(BufferedDoCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void BufferedDoCtrl_Dispose(BufferedDoCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void BufferedDoCtrl_getSelectedDevice(BufferedDoCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode BufferedDoCtrl_setSelectedDevice(BufferedDoCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState BufferedDoCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj);}
BDAQINL DeviceCtrl * BufferedDoCtrl_getDevice(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj);}
BDAQINL IArray * BufferedDoCtrl_getSupportedDevices(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * BufferedDoCtrl_getSupportedModes(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/* base2*/
BDAQINL DioFeatures * BufferedDoCtrl_getFeatures(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 45, DioFeatures *)(obj); }
BDAQINL int32 BufferedDoCtrl_getPortCount(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 46, int32)(obj); }
BDAQINL IArray * BufferedDoCtrl_getPorts(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 47, IArray *)(obj); }
/* BufferedDoCtrl Methods & Properties */
BDAQINL ErrorCode BufferedDoCtrl_Prepare(BufferedDoCtrl *obj) { return DAQFN_EV(DNLAPI_DIO, 106)(obj); }
BDAQINL ErrorCode BufferedDoCtrl_RunOnce(BufferedDoCtrl *obj) { return DAQFN_EV(DNLAPI_DIO, 107)(obj); }
BDAQINL ErrorCode BufferedDoCtrl_Start(BufferedDoCtrl *obj) { return DAQFN_EV(DNLAPI_DIO, 108)(obj); }
BDAQINL ErrorCode BufferedDoCtrl_Stop(BufferedDoCtrl *obj, int32 action) { return DAQFN_ET(DNLAPI_DIO, 109, int32)(obj, action); }
BDAQINL void BufferedDoCtrl_Release(BufferedDoCtrl *obj) { DAQFN_VV(DNLAPI_DIO, 110)(obj); }
BDAQINL int8 BufferedDoCtrl_GetBufferStatus(BufferedDoCtrl *obj, int32 *count, int32 *offset) { return DAQFN_TTT(DNLAPI_DIO, 111, int8, int32 *, int32 *)(obj, count, offset); }
BDAQINL ErrorCode BufferedDoCtrl_SetData(BufferedDoCtrl *obj, int32 count, int8 rawData[]) { return DAQFN_ETT(DNLAPI_DIO, 112, int32, void*)(obj, count, rawData); }
BDAQINL void* BufferedDoCtrl_getBuffer(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 113, void*)(obj); }
BDAQINL int32 BufferedDoCtrl_getBufferCapacity(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 114, int32)(obj); }
BDAQINL ScanPort * BufferedDoCtrl_getScanPort(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 115, ScanPort *)(obj); }
BDAQINL ConvertClock* BufferedDoCtrl_getConvertClock(BufferedDoCtrl *obj) { return DAQFN_TV(DNLAPI_DIO, 116, ConvertClock *)(obj); }
BDAQINL Trigger * BufferedDoCtrl_getTrigger(BufferedDoCtrl *obj) { return DAQFN_TT(DNLAPI_DIO, 117, Trigger *, int32)(obj, 0); }
BDAQINL Trigger * BufferedDoCtrl_getTrigger1(BufferedDoCtrl *obj) { return DAQFN_TT(DNLAPI_DIO, 117, Trigger *, int32)(obj, 1); }
/* ----------------------------------------------------------*/
/*common classes : ScanPort new for buffered dio */
/* ----------------------------------------------------------*/
BDAQINL int32 ScanPort_getPortStart(ScanPort *obj) { return DAQFN_TV(DNLAPI_DIO, 121, int32)(obj); }
BDAQINL ErrorCode ScanPort_setPortStart(ScanPort *obj, int32 value) { return DAQFN_ET(DNLAPI_DIO, 122, int32)(obj, value); }
BDAQINL int32 ScanPort_getPortCount(ScanPort *obj) { return DAQFN_TV(DNLAPI_DIO, 123, int32)(obj); }
BDAQINL ErrorCode ScanPort_setPortCount(ScanPort *obj, int32 value) { return DAQFN_ET(DNLAPI_DIO, 124, int32)(obj, value); }
BDAQINL void ScanPort_getPortMap(ScanPort *obj, int32 count, int8 *portMap) { DAQFN_VTT(DNLAPI_DIO, 125, int32, int8 *)(obj, count, portMap); }
BDAQINL ErrorCode ScanPort_setPortMap(ScanPort *obj, int32 count, int8 *portMap) { return DAQFN_ETT(DNLAPI_DIO, 126, int32, int8 *)(obj, count, portMap); }
BDAQINL int32 ScanPort_getSectionLength(ScanPort *obj) { return DAQFN_TV(DNLAPI_DIO, 127, int32)(obj); }
BDAQINL ErrorCode ScanPort_setSectionLength(ScanPort *obj, int32 value) { return DAQFN_ET(DNLAPI_DIO, 128, int32)(obj, value); }
BDAQINL int32 ScanPort_getSectionCount(ScanPort *obj) { return DAQFN_TV(DNLAPI_DIO, 129, int32)(obj); }
BDAQINL ErrorCode ScanPort_setSectionCount(ScanPort *obj, int32 value) { return DAQFN_ET(DNLAPI_DIO, 130, int32)(obj, value); }
BDAQINL int32 ScanPort_getCycles(ScanPort *obj) { return DAQFN_TV(DNLAPI_DIO, 131, int32)(obj); }
BDAQINL ErrorCode ScanPort_setCycles(ScanPort *obj, int32 value) { return DAQFN_ET(DNLAPI_DIO, 132, int32)(obj, value); }
/*creator*/
BDAQINL BufferedDoCtrl * BufferedDoCtrl_Create(void) { return (BufferedDoCtrl *)DaqCtrlBase_Create(SceBufferedDo); }
/*Helpers*/
BDAQINL void BufferedDoCtrl_addDataTransmittedHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedDoDataTransmitted, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedDoCtrl_removeDataTransmittedHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedDoDataTransmitted, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedDoCtrl_addUnderrunHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedDoUnderrun, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedDoCtrl_removeUnderrunHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedDoUnderrun, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedDoCtrl_addCacheEmptiedHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedDoCacheEmptied, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedDoCtrl_removeCacheEmptiedHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedDoCacheEmptied, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedDoCtrl_addTransitStoppedHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedDoTransStopped, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedDoCtrl_removeTransitStoppedHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedDoTransStopped, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedDoCtrl_addStoppedHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtBufferedDoStopped, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedDoCtrl_removeStoppedHandler(BufferedDoCtrl *obj, BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtBufferedDoStopped, (DaqEventProc)proc, userParam); }
/*************************************************************/
/*ctrl class : Counter related */
/* ----------------------------------------------------------*/
/*Counter Indexer*/
/* ----------------------------------------------------------*/
BDAQINL void CounterIndexer_Dispose(ICounterIndexer *obj) { DAQFN_VV(DNLAPI_CNTR, 0)(obj); }
BDAQINL int32 CounterIndexer_getLength(ICounterIndexer *obj) { return DAQFN_TV(DNLAPI_CNTR, 1, int32)(obj); }
BDAQINL IArray * CounterIndexer_getItem(ICounterIndexer *obj, int32 channel) { return DAQFN_TT(DNLAPI_CNTR, 2, IArray *, int32)(obj, channel); }
/* ----------------------------------------------------------*/
/*Counter features */
/* ----------------------------------------------------------*/
/*Channel features*/
BDAQINL int32 CntrFeatures_getChannelCountMax(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 3, int32)(obj); }
BDAQINL int32 CntrFeatures_getResolution(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 4, int32)(obj); }
BDAQINL int32 CntrFeatures_getDataSize(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 5, int32)(obj); }
BDAQINL ICounterIndexer * CntrFeatures_getCapabilities(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 6, ICounterIndexer *)(obj); }
/*noise filter features*/
BDAQINL int8 CntrFeatures_getNoiseFilterSupported(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 7, int8)(obj); }
BDAQINL IArray * CntrFeatures_getNoiseFilterOfChannels(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 8, IArray *)(obj); }
BDAQINL void CntrFeatures_getNoiseFilterBlockTimeRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 9, MathInterval *)(obj, x); }
/*new: measurement timeout range*/
BDAQINL void CntrFeatures_getMeasurementTimeoutRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 129, MathInterval *)(obj, x); }
/*event counting features*/
BDAQINL ICounterIndexer * CntrFeatures_getEcClockSources(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 193, ICounterIndexer *)(obj);}
BDAQINL IArray * CntrFeatures_getEcClockPolarities(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 10, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getEcGatePolarities(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 11, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getEcGateControlOfChannels(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 12, IArray *)(obj); }
/*frequency measurement features*/
BDAQINL IArray * CntrFeatures_getFmMethods(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 13, IArray *)(obj); }
/*one-shot features*/
BDAQINL ICounterIndexer * CntrFeatures_getOsClockSources(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 14, ICounterIndexer *)(obj);}
BDAQINL IArray * CntrFeatures_getOsClockPolarities(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 15, IArray *)(obj); }
BDAQINL ICounterIndexer * CntrFeatures_getOsGateSources(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 16, ICounterIndexer *)(obj);}
BDAQINL IArray * CntrFeatures_getOsGatePolarities(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 17, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getOsOutSignals(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 18, IArray *)(obj); }
BDAQINL void CntrFeatures_getOsDelayCountRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 19, MathInterval *)(obj, x); }
/*timer/pulse features */
BDAQINL IArray * CntrFeatures_getTmrGateControlOfChannels(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 20, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getTmrGatePolarities(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 21, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getTmrOutSignals(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 22, IArray *)(obj); }
BDAQINL void CntrFeatures_getTmrFrequencyRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 23, MathInterval *)(obj, x); }
/*pulse width measurement features*/
BDAQINL IArray * CntrFeatures_getPiCascadeGroup(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 24, IArray *)(obj); }
/*pulse width modulation features*/
BDAQINL IArray * CntrFeatures_getPoGateControlOfChannels(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 25, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getPoGatePolarities(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 26, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getPoOutSignals(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 27, IArray *)(obj); }
BDAQINL void CntrFeatures_getPoHiPeriodRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 28, MathInterval *)(obj, x); }
BDAQINL void CntrFeatures_getPoLoPeriodRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 29, MathInterval *)(obj, x); }
BDAQINL void CntrFeatures_getPoOutCountRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 30, MathInterval *)(obj, x); }
/* new trigger features for pulse width modulation*/
BDAQINL int32 CntrFeatures_getPoTriggerCount(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 212, int32)(obj); }
BDAQINL ICounterIndexer * CntrFeatures_getPoTriggerSources(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 213, ICounterIndexer *)(obj);}
BDAQINL IArray * CntrFeatures_getPoTriggerActions(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 214, IArray *)(obj); }
BDAQINL void CntrFeatures_getPoTriggerDelayRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 215, MathInterval *)(obj, x);}
/*up-down counter features */
BDAQINL IArray * CntrFeatures_getUdCountingTypes(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 31, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getUdInitialValues(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 32, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getUdSnapEventSources(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 33, IArray *)(obj); }
BDAQINL void CntrFeatures_getUdValueResetTimes(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 192, MathInterval *)(obj, x); }
// new features for Counter continue comparing: outputting pulse settings
BDAQINL IArray * CntrFeatures_getCcpGateControlOfChannels(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 196, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getCcpGatePolarities(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 197, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getCcpOutSignals(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 198, IArray *)(obj); }
BDAQINL void CntrFeatures_getCcpHiPeriodRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 199, MathInterval *)(obj, x); }
BDAQINL void CntrFeatures_getCcpLoPeriodRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 200, MathInterval *)(obj, x); }
BDAQINL void CntrFeatures_getCcpOutCountRange(CntrFeatures *obj, MathInterval *x) { DAQFN_VT(DNLAPI_CNTR, 201, MathInterval *)(obj, x); }
BDAQINL int8 CntrFeatures_getCcpDataCtrlCodeSupported(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 262, int8)(obj); }
/*buffered counter*/
BDAQINL int32 CntrFeatures_getTriggerCount(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 132, int32)(obj); }
BDAQINL IArray * CntrFeatures_getTriggerSources(CntrFeatures *obj) { return DAQFN_TT(DNLAPI_CNTR, 133, IArray *, int32)(obj, 0); }
BDAQINL IArray * CntrFeatures_getTriggerActions(CntrFeatures *obj) { return DAQFN_TT(DNLAPI_CNTR, 134, IArray *, int32)(obj, 0); }
BDAQINL ICounterIndexer * CntrFeatures_getEcSampleClockSources(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 135, ICounterIndexer *)(obj); }
BDAQINL ICounterIndexer * CntrFeatures_getPiSampleClockSources(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 136, ICounterIndexer *)(obj); }
BDAQINL ICounterIndexer * CntrFeatures_getPoSampleClockSources(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 137, ICounterIndexer *)(obj); }
BDAQINL ICounterIndexer * CntrFeatures_getUdSampleClockSources(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 138, ICounterIndexer *)(obj); }
/*absolute counter*/
BDAQINL IArray * CntrFeatures_getAbsCodingTypes(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 228, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getAbsBaudrates(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 229, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getAbsErrorRetTypes(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 230, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getAbsOutSignals(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 231, IArray *)(obj); }
BDAQINL IArray * CntrFeatures_getAbsLatchSignalEdges(CntrFeatures *obj) { return DAQFN_TV(DNLAPI_CNTR, 232, IArray *)(obj); }
/* ----------------------------------------------------------*/
/*EcChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 EcChannel_getChannel(EcChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 45, int32)(obj); }
BDAQINL int8 EcChannel_getNoiseFiltered(EcChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 46, int8)(obj); }
BDAQINL ErrorCode EcChannel_setNoiseFiltered(EcChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 47, int8)(obj, value); }
BDAQINL SignalDrop EcChannel_getClockSource(EcChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 194, SignalDrop)(obj); }
BDAQINL ErrorCode EcChannel_setClockSource(EcChannel *obj, SignalDrop value) { return DAQFN_ET(DNLAPI_CNTR, 195, SignalDrop)(obj, value); }
BDAQINL SignalPolarity EcChannel_getClockPolarity(EcChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 48, SignalPolarity)(obj); }
BDAQINL ErrorCode EcChannel_setClockPolarity(EcChannel *obj, SignalPolarity value) { return DAQFN_ET(DNLAPI_CNTR, 49, SignalPolarity)(obj, value); }
BDAQINL SignalPolarity EcChannel_getGatePolarity(EcChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 50, SignalPolarity)(obj); }
BDAQINL ErrorCode EcChannel_setGatePolarity(EcChannel *obj, SignalPolarity value) { return DAQFN_ET(DNLAPI_CNTR, 51, SignalPolarity)(obj, value); }
BDAQINL int8 EcChannel_getGated(EcChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 52, int8)(obj); }
BDAQINL ErrorCode EcChannel_setGated(EcChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 53, int8)(obj, value); }
/* ----------------------------------------------------------*/
/*EventCounterCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode EventCounterCtrl_LoadProfile(EventCounterCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void EventCounterCtrl_Cleanup(EventCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void EventCounterCtrl_Dispose(EventCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void EventCounterCtrl_getSelectedDevice(EventCounterCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode EventCounterCtrl_setSelectedDevice(EventCounterCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState EventCounterCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * EventCounterCtrl_getDevice(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * EventCounterCtrl_getSupportedDevices(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * EventCounterCtrl_getSupportedModes(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * EventCounterCtrl_getFeatures(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 EventCounterCtrl_getChannelStart(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode EventCounterCtrl_setChannelStart(EventCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 EventCounterCtrl_getChannelCount(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode EventCounterCtrl_setChannelCount(EventCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 EventCounterCtrl_getEnabled(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode EventCounterCtrl_setEnabled(EventCounterCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 EventCounterCtrl_getRunning(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double EventCounterCtrl_getNoiseFilterBlockTime(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode EventCounterCtrl_setNoiseFilterBlockTime(EventCounterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * EventCounterCtrl_getNoiseFilter(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
BDAQINL double EventCounterCtrl_getMeasurementTimeout(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 130, double)(obj); }
BDAQINL ErrorCode EventCounterCtrl_setMeasurementTimeout(EventCounterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 131, double)(obj, value); }
/* Event counter methods */
BDAQINL ErrorCode EventCounterCtrl_Read(EventCounterCtrl *obj, int32 count, int32 *buffer) { return DAQFN_ETT(DNLAPI_CNTR, 54, int32, int32 *)(obj, count, buffer); }
BDAQINL IArray * EventCounterCtrl_getChannels(EventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 55, IArray *)(obj); }
/*creator*/
BDAQINL EventCounterCtrl* EventCounterCtrl_Create(void) { return (EventCounterCtrl *)DaqCtrlBase_Create(SceEventCounter); }
/*BufferedEventCounterCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode BufferedEventCounterCtrl_LoadProfile(BufferedEventCounterCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void BufferedEventCounterCtrl_Cleanup(BufferedEventCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void BufferedEventCounterCtrl_Dispose(BufferedEventCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void BufferedEventCounterCtrl_getSelectedDevice(BufferedEventCounterCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode BufferedEventCounterCtrl_setSelectedDevice(BufferedEventCounterCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState BufferedEventCounterCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * BufferedEventCounterCtrl_getDevice(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * BufferedEventCounterCtrl_getSupportedDevices(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * BufferedEventCounterCtrl_getSupportedModes(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * BufferedEventCounterCtrl_getFeatures(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 BufferedEventCounterCtrl_getChannelStart(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode BufferedEventCounterCtrl_setChannelStart(BufferedEventCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 BufferedEventCounterCtrl_getChannelCount(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode BufferedEventCounterCtrl_setChannelCount(BufferedEventCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 BufferedEventCounterCtrl_getEnabled(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode BufferedEventCounterCtrl_setEnabled(BufferedEventCounterCtrl *obj, int8 enable) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enable); }
BDAQINL int8 BufferedEventCounterCtrl_getRunning(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double BufferedEventCounterCtrl_getNoiseFilterBlockTime(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode BufferedEventCounterCtrl_setNoiseFilterBlockTime(BufferedEventCounterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * BufferedEventCounterCtrl_getNoiseFilter(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
BDAQINL double BufferedEventCounterCtrl_getMeasurementTimeout(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 130, double)(obj); }
BDAQINL ErrorCode BufferedEventCounterCtrl_setMeasurementTimeout(BufferedEventCounterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 131, double)(obj, value); }
/* Buffered Event counter methods & properties */
BDAQINL int32 BufferedEventCounterCtrl_getBufferCapacity(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 183, int32)(obj); }
BDAQINL int8 BufferedEventCounterCtrl_getBufferStatus(BufferedEventCounterCtrl *obj, int32 ch, int32 *count, int32 *offset) { return DAQFN_TTTT(DNLAPI_CNTR, 188, int8, int32, int32 *, int32 *)(obj, ch, count, offset); }
BDAQINL Trigger* BufferedEventCounterCtrl_getTrigger(BufferedEventCounterCtrl *obj) { return DAQFN_TT(DNLAPI_CNTR, 141, Trigger *, int32)(obj, 0); }
BDAQINL Record* BufferedEventCounterCtrl_getRecord(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 142, Record *)(obj); }
BDAQINL ErrorCode BufferedEventCounterCtrl_setSampleClkSrc(BufferedEventCounterCtrl *obj, SignalDrop drop) { return DAQFN_ET(DNLAPI_CNTR, 143, SignalDrop)(obj, drop); }
BDAQINL SignalDrop BufferedEventCounterCtrl_getSampleClkSrc(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 144, SignalDrop)(obj); }
BDAQINL void BufferedEventCounterCtrl_getChannelMap(BufferedEventCounterCtrl *obj, int32 count, int8 *chMap) { DAQFN_VTT(DNLAPI_CNTR, 139, int32, int8 *)(obj, count, chMap); }
BDAQINL ErrorCode BufferedEventCounterCtrl_setChannelMap(BufferedEventCounterCtrl *obj, int32 count, int8 *chMap) { return DAQFN_ETT(DNLAPI_CNTR, 140, int32, int8 *)(obj, count, chMap); }
BDAQINL ErrorCode BufferedEventCounterCtrl_Prepare(BufferedEventCounterCtrl *obj) { return DAQFN_EV(DNLAPI_CNTR, 146)(obj); }
BDAQINL void BufferedEventCounterCtrl_Release(BufferedEventCounterCtrl *obj) { DAQFN_VV(DNLAPI_CNTR, 147)(obj); }
BDAQINL IArray * BufferedEventCounterCtrl_getChannels(BufferedEventCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 145, IArray *)(obj); }
BDAQINL ErrorCode BufferedEventCounterCtrl_GetDataI32(BufferedEventCounterCtrl *obj, int32 cntr, int32 count, int32 dataBuf[], int32 timeout, int32 *returned, double *startTime)
{
typedef ErrorCode (BDAQCALL *FNGETDATA)(void *, int32, int32, void*, int32, int32*, double*);
return ((FNGETDATA)DNLAPI_CNTR[148])(obj, cntr, count, dataBuf, timeout, returned, startTime);
}
/*creator*/
BDAQINL BufferedEventCounterCtrl* BufferedEventCounterCtrl_Create(void) { return (BufferedEventCounterCtrl *)DaqCtrlBase_Create(SceBufferedEventCounter); }
/*Helpers*/
BDAQINL void BufferedEventCounterCtrl_addDataReadyHandler(BufferedEventCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedEventCounterCtrl_removeDataReadyHandler(BufferedEventCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedEventCounterCtrl_addOverrunHandler(BufferedEventCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedEventCounterCtrl_removeOverrunHandler(BufferedEventCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedEventCounterCtrl_addCacheOverflowHandler(BufferedEventCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedEventCounterCtrl_removeCacheOverflowHandler(BufferedEventCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedEventCounterCtrl_addStoppedHandler(BufferedEventCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCntrStopped, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedEventCounterCtrl_removeStoppedHandler(BufferedEventCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCntrStopped, (DaqEventProc)proc, userParam);}
/* ----------------------------------------------------------*/
/* ----------------------------------------------------------*/
/*FmChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 FmChannel_getChannel(FmChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 56, int32)(obj); }
BDAQINL int8 FmChannel_getNoiseFiltered(FmChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 57, int8)(obj); }
BDAQINL ErrorCode FmChannel_setNoiseFiltered(FmChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 58, int8)(obj, value); }
BDAQINL FreqMeasureMethod FmChannel_getFmMethod(FmChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 59, FreqMeasureMethod)(obj); }
BDAQINL ErrorCode FmChannel_setFmMethod(FmChannel *obj, FreqMeasureMethod value) { return DAQFN_ET(DNLAPI_CNTR, 60, FreqMeasureMethod)(obj, value);}
BDAQINL double FmChannel_getCollectionPeriod(FmChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 61, double)(obj); }
BDAQINL ErrorCode FmChannel_setCollectionPeriod(FmChannel *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 62, double)(obj, value); }
BDAQINL double FmChannel_getTimeup(FmChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 226,double)(obj); }
BDAQINL ErrorCode FmChannel_setTimeup(FmChannel *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 227,double)(obj, value); }
/* ----------------------------------------------------------*/
/*FreqMeterCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode FreqMeterCtrl_LoadProfile(FreqMeterCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void FreqMeterCtrl_Cleanup(FreqMeterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void FreqMeterCtrl_Dispose(FreqMeterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void FreqMeterCtrl_getSelectedDevice(FreqMeterCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode FreqMeterCtrl_setSelectedDevice(FreqMeterCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState FreqMeterCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * FreqMeterCtrl_getDevice(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * FreqMeterCtrl_getSupportedDevices(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * FreqMeterCtrl_getSupportedModes(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * FreqMeterCtrl_getFeatures(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 FreqMeterCtrl_getChannelStart(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode FreqMeterCtrl_setChannelStart(FreqMeterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 FreqMeterCtrl_getChannelCount(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode FreqMeterCtrl_setChannelCount(FreqMeterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 FreqMeterCtrl_getEnabled(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode FreqMeterCtrl_setEnabled(FreqMeterCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 FreqMeterCtrl_getRunning(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double FreqMeterCtrl_getNoiseFilterBlockTime(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode FreqMeterCtrl_setNoiseFilterBlockTime(FreqMeterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * FreqMeterCtrl_getNoiseFilter(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
BDAQINL double FreqMeterCtrl_getMeasurementTimeout(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 130, double)(obj); }
BDAQINL ErrorCode FreqMeterCtrl_setMeasurementTimeout(FreqMeterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 131, double)(obj, value); }
/* Frequency meter methods */
BDAQINL ErrorCode FreqMeterCtrl_Read(FreqMeterCtrl *obj, int32 count, double *buffer) { return DAQFN_ETT(DNLAPI_CNTR, 63, int32, double *)(obj, count, buffer); }
BDAQINL IArray * FreqMeterCtrl_getChannels(FreqMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 64, IArray *)(obj); }
/*creator*/
BDAQINL FreqMeterCtrl* FreqMeterCtrl_Create(void) { return (FreqMeterCtrl *)DaqCtrlBase_Create(SceFreqMeter); }
/* ----------------------------------------------------------*/
/*OsChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 OsChannel_getChannel(OsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 65, int32)(obj); }
BDAQINL int8 OsChannel_getNoiseFiltered(OsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 66, int8)(obj); }
BDAQINL ErrorCode OsChannel_setNoiseFiltered(OsChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 67, int8)(obj, value); }
BDAQINL int32 OsChannel_getDelayCount(OsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 68, int32)(obj); }
BDAQINL ErrorCode OsChannel_setDelayCount(OsChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 69, int32)(obj, value); }
BDAQINL SignalDrop OsChannel_getClockSource(OsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 70, SignalDrop)(obj); }
BDAQINL ErrorCode OsChannel_setClockSource(OsChannel *obj, SignalDrop value) { return DAQFN_ET(DNLAPI_CNTR, 71, SignalDrop)(obj, value); }
BDAQINL SignalPolarity OsChannel_getClockPolarity(OsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 72, SignalPolarity)(obj); }
BDAQINL ErrorCode OsChannel_setClockPolarity(OsChannel *obj, SignalPolarity value) { return DAQFN_ET(DNLAPI_CNTR, 73, SignalPolarity)(obj, value); }
BDAQINL SignalDrop OsChannel_getGateSource(OsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 74, SignalDrop)(obj); }
BDAQINL ErrorCode OsChannel_setGateSource(OsChannel *obj, SignalDrop value) { return DAQFN_ET(DNLAPI_CNTR, 75, SignalDrop)(obj, value); }
BDAQINL SignalPolarity OsChannel_getGatePolarity(OsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 76, SignalPolarity)(obj); }
BDAQINL ErrorCode OsChannel_setGatePolarity(OsChannel *obj, SignalPolarity value) { return DAQFN_ET(DNLAPI_CNTR, 77, SignalPolarity)(obj, value); }
BDAQINL OutSignalType OsChannel_getOutSignal(OsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 78, OutSignalType)(obj); }
BDAQINL ErrorCode OsChannel_setOutSignal(OsChannel *obj, OutSignalType value) { return DAQFN_ET(DNLAPI_CNTR, 79, OutSignalType)(obj, value); }
/* ----------------------------------------------------------*/
/*OneShotCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode OneShotCtrl_LoadProfile(OneShotCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void OneShotCtrl_Cleanup(OneShotCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void OneShotCtrl_Dispose(OneShotCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void OneShotCtrl_getSelectedDevice(OneShotCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode OneShotCtrl_setSelectedDevice(OneShotCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState OneShotCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * OneShotCtrl_getDevice(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * OneShotCtrl_getSupportedDevices(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * OneShotCtrl_getSupportedModes(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * OneShotCtrl_getFeatures(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 OneShotCtrl_getChannelStart(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode OneShotCtrl_setChannelStart(OneShotCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 OneShotCtrl_getChannelCount(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode OneShotCtrl_setChannelCount(OneShotCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 OneShotCtrl_getEnabled(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode OneShotCtrl_setEnabled(OneShotCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 OneShotCtrl_getRunning(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double OneShotCtrl_getNoiseFilterBlockTime(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode OneShotCtrl_setNoiseFilterBlockTime(OneShotCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * OneShotCtrl_getNoiseFilter(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
/* one shot methods */
BDAQINL IArray * OneShotCtrl_getChannels(OneShotCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 80, IArray *)(obj); }
/*creator*/
BDAQINL OneShotCtrl* OneShotCtrl_Create(void) { return (OneShotCtrl *)DaqCtrlBase_Create(SceOneShot); }
/*Helpers*/
BDAQINL void OneShotCtrl_addOneShotHandler(OneShotCtrl *obj, CntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCntOneShot0, (DaqEventProc)proc, userParam);}
BDAQINL void OneShotCtrl_removeOneShotHandler(OneShotCtrl *obj, CntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCntOneShot0, (DaqEventProc)proc, userParam);}
/* ----------------------------------------------------------*/
/*TmrChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 TmrChannel_getChannel(TmrChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 81, int32)(obj); }
BDAQINL int8 TmrChannel_getNoiseFiltered(TmrChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 82, int8)(obj); }
BDAQINL ErrorCode TmrChannel_setNoiseFiltered(TmrChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 83, int8)(obj, value); }
BDAQINL double TmrChannel_getFrequency(TmrChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 84, double)(obj); }
BDAQINL ErrorCode TmrChannel_setFrequency(TmrChannel *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 85, double)(obj, value); }
BDAQINL int8 TmrChannel_getGated(TmrChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 86, int8)(obj); }
BDAQINL ErrorCode TmrChannel_setGated(TmrChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 87, int8)(obj, value); }
BDAQINL SignalPolarity TmrChannel_getGatePolarity(TmrChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 88, SignalPolarity)(obj); }
BDAQINL ErrorCode TmrChannel_setGatePolarity(TmrChannel *obj, SignalPolarity value) { return DAQFN_ET(DNLAPI_CNTR, 89, SignalPolarity)(obj, value); }
BDAQINL OutSignalType TmrChannel_getOutSignal(TmrChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 90, OutSignalType)(obj); }
BDAQINL ErrorCode TmrChannel_setOutSignal(TmrChannel *obj, OutSignalType value) { return DAQFN_ET(DNLAPI_CNTR, 91, OutSignalType)(obj, value); }
/* ----------------------------------------------------------*/
/*TimerPulseCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode TimerPulseCtrl_LoadProfile(TimerPulseCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void TimerPulseCtrl_Cleanup(TimerPulseCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void TimerPulseCtrl_Dispose(TimerPulseCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void TimerPulseCtrl_getSelectedDevice(TimerPulseCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode TimerPulseCtrl_setSelectedDevice(TimerPulseCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState TimerPulseCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * TimerPulseCtrl_getDevice(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * TimerPulseCtrl_getSupportedDevices(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * TimerPulseCtrl_getSupportedModes(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * TimerPulseCtrl_getFeatures(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 TimerPulseCtrl_getChannelStart(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode TimerPulseCtrl_setChannelStart(TimerPulseCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 TimerPulseCtrl_getChannelCount(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode TimerPulseCtrl_setChannelCount(TimerPulseCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 TimerPulseCtrl_getEnabled(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode TimerPulseCtrl_setEnabled(TimerPulseCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 TimerPulseCtrl_getRunning(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double TimerPulseCtrl_getNoiseFilterBlockTime(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode TimerPulseCtrl_setNoiseFilterBlockTime(TimerPulseCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * TimerPulseCtrl_getNoiseFilter(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
/* Timer/Pulse methods */
BDAQINL IArray * TimerPulseCtrl_getChannels(TimerPulseCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 92, IArray *)(obj); }
/*creator*/
BDAQINL TimerPulseCtrl* TimerPulseCtrl_Create(void) { return (TimerPulseCtrl *)DaqCtrlBase_Create(SceTimerPulse); }
/*Helper*/
BDAQINL void TimerPulseCtrl_addTimerTickHandler(TimerPulseCtrl *obj, CntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCntTimer0, (DaqEventProc)proc, userParam); }
BDAQINL void TimerPulseCtrl_removeTimerTickHandler(TimerPulseCtrl *obj, CntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCntTimer0, (DaqEventProc)proc, userParam); }
/* ----------------------------------------------------------*/
/*PiChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 PiChannel_getChannel(PiChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 93, int32)(obj); }
BDAQINL int8 PiChannel_getNoiseFiltered(PiChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 94, int8)(obj); }
BDAQINL ErrorCode PiChannel_setNoiseFiltered(PiChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 95, int8)(obj, value); }
BDAQINL double PiChannel_getTimeup(PiChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 260,double)(obj); }
BDAQINL ErrorCode PiChannel_setTimeup(PiChannel *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 261,double)(obj, value);}
/* ----------------------------------------------------------*/
/*PwMeterCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode PwMeterCtrl_LoadProfile(PwMeterCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void PwMeterCtrl_Cleanup(PwMeterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void PwMeterCtrl_Dispose(PwMeterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void PwMeterCtrl_getSelectedDevice(PwMeterCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode PwMeterCtrl_setSelectedDevice(PwMeterCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState PwMeterCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * PwMeterCtrl_getDevice(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * PwMeterCtrl_getSupportedDevices(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * PwMeterCtrl_getSupportedModes(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * PwMeterCtrl_getFeatures(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 PwMeterCtrl_getChannelStart(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode PwMeterCtrl_setChannelStart(PwMeterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 PwMeterCtrl_getChannelCount(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode PwMeterCtrl_setChannelCount(PwMeterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 PwMeterCtrl_getEnabled(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode PwMeterCtrl_setEnabled(PwMeterCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 PwMeterCtrl_getRunning(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double PwMeterCtrl_getNoiseFilterBlockTime(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode PwMeterCtrl_setNoiseFilterBlockTime(PwMeterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * PwMeterCtrl_getNoiseFilter(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
BDAQINL double PwMeterCtrl_getMeasurementTimeout(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 130, double)(obj); }
BDAQINL ErrorCode PwMeterCtrl_setMeasurementTimeout(PwMeterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 131, double)(obj, value); }
/* PwMeterCtrl Method */
BDAQINL IArray * PwMeterCtrl_getChannels(PwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 96, IArray *)(obj); }
BDAQINL ErrorCode PwMeterCtrl_Read(PwMeterCtrl *obj, int32 count, PulseWidth *buffer) { return DAQFN_ETT(DNLAPI_CNTR, 97, int32, PulseWidth *)(obj, count, buffer); }
/*creator*/
BDAQINL PwMeterCtrl* PwMeterCtrl_Create(void) { return (PwMeterCtrl *)DaqCtrlBase_Create(ScePwMeter); }
/*Helpers*/
BDAQINL void PwMeterCtrl_addOverflowHandler(PwMeterCtrl *obj, CntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCntPwmInOverflow0, (DaqEventProc)proc, userParam);}
BDAQINL void PwMeterCtrl_removeOverflowHandler(PwMeterCtrl *obj, CntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCntPwmInOverflow0, (DaqEventProc)proc, userParam);}
/* ----------------------------------------------------------*/
/*BufferedPwMeterCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode BufferedPwMeterCtrl_LoadProfile(BufferedPwMeterCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void BufferedPwMeterCtrl_Cleanup(BufferedPwMeterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void BufferedPwMeterCtrl_Dispose(BufferedPwMeterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void BufferedPwMeterCtrl_getSelectedDevice(BufferedPwMeterCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode BufferedPwMeterCtrl_setSelectedDevice(BufferedPwMeterCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState BufferedPwMeterCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * BufferedPwMeterCtrl_getDevice(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * BufferedPwMeterCtrl_getSupportedDevices(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * BufferedPwMeterCtrl_getSupportedModes(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * BufferedPwMeterCtrl_getFeatures(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 BufferedPwMeterCtrl_getChannelStart(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode BufferedPwMeterCtrl_setChannelStart(BufferedPwMeterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 BufferedPwMeterCtrl_getChannelCount(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode BufferedPwMeterCtrl_setChannelCount(BufferedPwMeterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 BufferedPwMeterCtrl_getEnabled(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode BufferedPwMeterCtrl_setEnabled(BufferedPwMeterCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 BufferedPwMeterCtrl_getRunning(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double BufferedPwMeterCtrl_getNoiseFilterBlockTime(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode BufferedPwMeterCtrl_setNoiseFilterBlockTime(BufferedPwMeterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * BufferedPwMeterCtrl_getNoiseFilter(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
BDAQINL double BufferedPwMeterCtrl_getMeasurementTimeout(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 130, double)(obj); }
BDAQINL ErrorCode BufferedPwMeterCtrl_setMeasurementTimeout(BufferedPwMeterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 131, double)(obj, value); }
/* Buffered PwMeterCtrl Method */
BDAQINL int32 BufferedPwMeterCtrl_getBufferCapacity(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 184, int32)(obj); }
BDAQINL int8 BufferedPwMeterCtrl_getBufferStatus(BufferedPwMeterCtrl *obj, int32 ch, int32 *count, int32 *offset) { return DAQFN_TTTT(DNLAPI_CNTR, 189, int8, int32, int32 *, int32 *)(obj, ch, count, offset); }
BDAQINL Trigger* BufferedPwMeterCtrl_getTrigger(BufferedPwMeterCtrl *obj) { return DAQFN_TT(DNLAPI_CNTR, 151, Trigger *, int32)(obj, 0); }
BDAQINL Record* BufferedPwMeterCtrl_getRecord(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 152, Record *)(obj); }
BDAQINL ErrorCode BufferedPwMeterCtrl_setSampleClkSrc(BufferedPwMeterCtrl *obj, SignalDrop drop) { return DAQFN_ET(DNLAPI_CNTR, 153, SignalDrop)(obj, drop); }
BDAQINL SignalDrop BufferedPwMeterCtrl_getSampleClkSrc(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 154, SignalDrop)(obj); }
BDAQINL void BufferedPwMeterCtrl_getChannelMap(BufferedPwMeterCtrl *obj, int32 count, int8 *chMap) { DAQFN_VTT(DNLAPI_CNTR, 149, int32, int8 *)(obj, count, chMap); }
BDAQINL ErrorCode BufferedPwMeterCtrl_setChannelMap(BufferedPwMeterCtrl *obj, int32 count, int8 *chMap) { return DAQFN_ETT(DNLAPI_CNTR, 150, int32, int8 *)(obj, count, chMap); }
BDAQINL ErrorCode BufferedPwMeterCtrl_Prepare(BufferedPwMeterCtrl *obj) { return DAQFN_EV(DNLAPI_CNTR, 156)(obj); }
BDAQINL void BufferedPwMeterCtrl_Release(BufferedPwMeterCtrl *obj) { DAQFN_VV(DNLAPI_CNTR, 157)(obj); }
BDAQINL IArray * BufferedPwMeterCtrl_getChannels(BufferedPwMeterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 155, IArray *)(obj); }
BDAQINL ErrorCode BufferedPwMeterCtrl_GetData(BufferedPwMeterCtrl *obj, int32 cntr, int32 count, PulseWidth *buffer, int32 timeout, int32 *returned, double *startTime)
{
typedef ErrorCode (BDAQCALL *FNGETDATA)(void *, int32, int32, void*, int32, int32*, double*);
return ((FNGETDATA)DNLAPI_CNTR[158])(obj, cntr, count, buffer, timeout, returned, startTime);
}
/*creator*/
BDAQINL BufferedPwMeterCtrl* BufferedPwMeterCtrl_Create(void) { return (BufferedPwMeterCtrl *)DaqCtrlBase_Create(SceBufferedPwMeter); }
/*Helpers*/
BDAQINL void BufferedPwMeterCtrl_addDataReadyHandler(BufferedPwMeterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedPwMeterCtrl_removeDataReadyHandler(BufferedPwMeterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedPwMeterCtrl_addOverrunHandler(BufferedPwMeterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedPwMeterCtrl_removeOverrunHandler(BufferedPwMeterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedPwMeterCtrl_addCacheOverflowHandler(BufferedPwMeterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedPwMeterCtrl_removeCacheOverflowHandler(BufferedPwMeterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedPwMeterCtrl_addStoppedHandler(BufferedPwMeterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCntrStopped, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedPwMeterCtrl_removeStoppedHandler(BufferedPwMeterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCntrStopped, (DaqEventProc)proc, userParam);}
/* ----------------------------------------------------------*/
/*PoChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 PoChannel_getChannel(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 98, int32)(obj); }
BDAQINL int8 PoChannel_getNoiseFiltered(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 99, int8)(obj); }
BDAQINL ErrorCode PoChannel_setNoiseFiltered(PoChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 100, int8)(obj, value); }
BDAQINL void PoChannel_getPulseWidth(PoChannel *obj, PulseWidth *x) { DAQFN_VT(DNLAPI_CNTR, 101, PulseWidth *)(obj, x); }
BDAQINL ErrorCode PoChannel_setPulseWidth(PoChannel *obj, PulseWidth const *x) { return DAQFN_ET(DNLAPI_CNTR, 102, PulseWidth const*)(obj, x); }
BDAQINL int8 PoChannel_getGated(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 103, int8)(obj); }
BDAQINL ErrorCode PoChannel_setGated(PoChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 104, int8)(obj, value); }
BDAQINL SignalPolarity PoChannel_getGatePolarity(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 105, SignalPolarity)(obj); }
BDAQINL ErrorCode PoChannel_setGatePolarity(PoChannel *obj, SignalPolarity value) { return DAQFN_ET(DNLAPI_CNTR, 106, SignalPolarity)(obj, value); }
BDAQINL OutSignalType PoChannel_getOutSignal(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 107, OutSignalType)(obj); }
BDAQINL ErrorCode PoChannel_setOutSignal(PoChannel *obj, OutSignalType value) { return DAQFN_ET(DNLAPI_CNTR, 108, OutSignalType)(obj, value); }
BDAQINL int32 PoChannel_getOutCount(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 109, int32)(obj); }
BDAQINL ErrorCode PoChannel_setOutCount(PoChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 110, int32)(obj, value); }
BDAQINL SignalDrop PoChannel_getTriggerSource(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 216, SignalDrop)(obj); }
BDAQINL ErrorCode PoChannel_setTriggerSource(PoChannel *obj, SignalDrop value) { return DAQFN_ET(DNLAPI_CNTR, 217, SignalDrop)(obj, value); }
BDAQINL ActiveSignal PoChannel_getTriggerEdge(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 218, ActiveSignal)(obj); }
BDAQINL ErrorCode PoChannel_setTriggerEdge(PoChannel *obj, ActiveSignal value) { return DAQFN_ET(DNLAPI_CNTR, 219, ActiveSignal)(obj, value); }
BDAQINL TriggerAction PoChannel_getTriggerAction(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 220, TriggerAction)(obj); }
BDAQINL ErrorCode PoChannel_setTriggerAction(PoChannel *obj, TriggerAction value) { return DAQFN_ET(DNLAPI_CNTR, 221, TriggerAction)(obj, value); }
BDAQINL double PoChannel_getTriggerDelayCount(PoChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 222, double)(obj); }
BDAQINL ErrorCode PoChannel_setTriggerDelayCount(PoChannel *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 223, double)(obj, value); }
/* ----------------------------------------------------------*/
/*PwModulatorCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode PwModulatorCtrl_LoadProfile(PwModulatorCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void PwModulatorCtrl_Cleanup(PwModulatorCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void PwModulatorCtrl_Dispose(PwModulatorCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void PwModulatorCtrl_getSelectedDevice(PwModulatorCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode PwModulatorCtrl_setSelectedDevice(PwModulatorCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState PwModulatorCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * PwModulatorCtrl_getDevice(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * PwModulatorCtrl_getSupportedDevices(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * PwModulatorCtrl_getSupportedModes(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * PwModulatorCtrl_getFeatures(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 PwModulatorCtrl_getChannelStart(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode PwModulatorCtrl_setChannelStart(PwModulatorCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 PwModulatorCtrl_getChannelCount(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode PwModulatorCtrl_setChannelCount(PwModulatorCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 PwModulatorCtrl_getEnabled(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode PwModulatorCtrl_setEnabled(PwModulatorCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 PwModulatorCtrl_getRunning(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double PwModulatorCtrl_getNoiseFilterBlockTime(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode PwModulatorCtrl_setNoiseFilterBlockTime(PwModulatorCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * PwModulatorCtrl_getNoiseFilter(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
/* Pulse width modulator methods */
BDAQINL IArray * PwModulatorCtrl_getChannels(PwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 111, IArray *)(obj); }
/*creator*/
BDAQINL PwModulatorCtrl* PwModulatorCtrl_Create(void) { return (PwModulatorCtrl *)DaqCtrlBase_Create(ScePwModulator); }
/* ----------------------------------------------------------*/
/*BufferedPwModulatorCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode BufferedPwModulatorCtrl_LoadProfile(BufferedPwModulatorCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void BufferedPwModulatorCtrl_Cleanup(BufferedPwModulatorCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void BufferedPwModulatorCtrl_Dispose(BufferedPwModulatorCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void BufferedPwModulatorCtrl_getSelectedDevice(BufferedPwModulatorCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setSelectedDevice(BufferedPwModulatorCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState BufferedPwModulatorCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * BufferedPwModulatorCtrl_getDevice(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * BufferedPwModulatorCtrl_getSupportedDevices(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * BufferedPwModulatorCtrl_getSupportedModes(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * BufferedPwModulatorCtrl_getFeatures(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 BufferedPwModulatorCtrl_getChannelStart(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setChannelStart(BufferedPwModulatorCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 BufferedPwModulatorCtrl_getChannelCount(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setChannelCount(BufferedPwModulatorCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 BufferedPwModulatorCtrl_getEnabled(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setEnabled(BufferedPwModulatorCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 BufferedPwModulatorCtrl_getRunning(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double BufferedPwModulatorCtrl_getNoiseFilterBlockTime(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setNoiseFilterBlockTime(BufferedPwModulatorCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * BufferedPwModulatorCtrl_getNoiseFilter(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
/* Buffered Pulse width modulator methods */
BDAQINL int32 BufferedPwModulatorCtrl_getBufferCapacity(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 186, int32)(obj); }
BDAQINL int8 BufferedPwModulatorCtrl_getBufferStatus(BufferedPwModulatorCtrl *obj, int32 ch, int32 *count, int32 *offset) { return DAQFN_TTTT(DNLAPI_CNTR, 191, int8, int32, int32 *, int32 *)(obj, ch, count, offset); }
BDAQINL Trigger* BufferedPwModulatorCtrl_getTrigger(BufferedPwModulatorCtrl *obj) { return DAQFN_TT(DNLAPI_CNTR, 171, Trigger *, int32)(obj, 0); }
BDAQINL int32 BufferedPwModulatorCtrl_getSamples(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 172, int32)(obj); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setSamples(BufferedPwModulatorCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 173, int32)(obj, value); }
BDAQINL int32 BufferedPwModulatorCtrl_getIntervalCount(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 174, int32)(obj); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setIntervalCount(BufferedPwModulatorCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 175, int32)(obj, value); }
BDAQINL int8 BufferedPwModulatorCtrl_getStreaming(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 187, int8)(obj); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setStreaming(BufferedPwModulatorCtrl *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 176, int8)(obj, value); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setSampleClkSrc(BufferedPwModulatorCtrl *obj, SignalDrop drop) { return DAQFN_ET(DNLAPI_CNTR, 177, SignalDrop)(obj, drop); }
BDAQINL SignalDrop BufferedPwModulatorCtrl_getSampleClkSrc(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 178, SignalDrop)(obj); }
BDAQINL void BufferedPwModulatorCtrl_getChannelMap(BufferedPwModulatorCtrl *obj, int32 count, int8 *chMap) { DAQFN_VTT(DNLAPI_CNTR, 169, int32, int8 *)(obj, count, chMap); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_setChannelMap(BufferedPwModulatorCtrl *obj, int32 count, int8 *chMap) { return DAQFN_ETT(DNLAPI_CNTR, 170, int32, int8 *)(obj, count, chMap); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_Prepare(BufferedPwModulatorCtrl *obj) { return DAQFN_EV(DNLAPI_CNTR, 180)(obj); }
BDAQINL void BufferedPwModulatorCtrl_Release(BufferedPwModulatorCtrl *obj) { DAQFN_VV(DNLAPI_CNTR, 181)(obj); }
BDAQINL IArray * BufferedPwModulatorCtrl_getChannels(BufferedPwModulatorCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 179, IArray *)(obj); }
BDAQINL ErrorCode BufferedPwModulatorCtrl_SetData(BufferedPwModulatorCtrl *obj, int32 cntr, int32 count, PulseWidth *buffer)
{
typedef ErrorCode (BDAQCALL *FNSETDATA)(void *, int32, int32, void*);
return ((FNSETDATA)DNLAPI_CNTR[182])(obj, cntr, count, buffer);
}
/*creator*/
BDAQINL BufferedPwModulatorCtrl* BufferedPwModulatorCtrl_Create(void) { return (BufferedPwModulatorCtrl *)DaqCtrlBase_Create(SceBufferedPwModulator); }
/*Helpers*/
/*event*/
BDAQINL void BufferedPwModulatorCtrl_addDataTransmittedHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCoDataTransmitted, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedPwModulatorCtrl_removeDataTransmittedHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCoDataTransmitted, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedPwModulatorCtrl_addUnderrunHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCoUnderrun, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedPwModulatorCtrl_removeUnderrunHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCoUnderrun, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedPwModulatorCtrl_addCacheEmptiedHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCoCacheEmptied, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedPwModulatorCtrl_removeCacheEmptiedHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCoCacheEmptied, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedPwModulatorCtrl_addTransitStoppedHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCoTransStopped, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedPwModulatorCtrl_removeTransitStoppedHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCoTransStopped, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedPwModulatorCtrl_addStoppedHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCntrStopped, (DaqEventProc)proc, userParam); }
BDAQINL void BufferedPwModulatorCtrl_removeStoppedHandler(BufferedPwModulatorCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCntrStopped, (DaqEventProc)proc, userParam); }
/* ----------------------------------------------------------*/
/*UdChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 UdChannel_getChannel(UdChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 112, int32)(obj); }
BDAQINL int8 UdChannel_getNoiseFiltered(UdChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 113, int8)(obj); }
BDAQINL ErrorCode UdChannel_setNoiseFiltered(UdChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 114, int8)(obj, value); }
BDAQINL CountingType UdChannel_getCountingType(UdChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 115, CountingType)(obj); }
BDAQINL ErrorCode UdChannel_setCountingType(UdChannel *obj, CountingType value) { return DAQFN_ET(DNLAPI_CNTR, 116, CountingType)(obj, value);}
BDAQINL int32 UdChannel_getInitialValue(UdChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 117, int32)(obj); }
BDAQINL ErrorCode UdChannel_setInitialValue(UdChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 118, int32)(obj, value); }
BDAQINL int32 UdChannel_getResetTimesByIndex(UdChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 119, int32)(obj); }
BDAQINL ErrorCode UdChannel_setResetTimesByIndex(UdChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 120, int32)(obj, value); }
// new properties for Counter continue comparing: outputting pulse settings
BDAQINL void UdChannel_getPulseWidth(UdChannel *obj, PulseWidth *x) { DAQFN_VT(DNLAPI_CNTR, 202, PulseWidth *)(obj, x); }
BDAQINL ErrorCode UdChannel_setPulseWidth(UdChannel *obj, PulseWidth const *x) { return DAQFN_ET(DNLAPI_CNTR, 203, PulseWidth const*)(obj, x); }
BDAQINL int8 UdChannel_getGated(UdChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 204, int8)(obj); }
BDAQINL ErrorCode UdChannel_setGated(UdChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 205, int8)(obj, value); }
BDAQINL SignalPolarity UdChannel_getGatePolarity(UdChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 206, SignalPolarity)(obj); }
BDAQINL ErrorCode UdChannel_setGatePolarity(UdChannel *obj, SignalPolarity value) { return DAQFN_ET(DNLAPI_CNTR, 207, SignalPolarity)(obj, value); }
BDAQINL OutSignalType UdChannel_getOutSignal(UdChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 208, OutSignalType)(obj); }
BDAQINL ErrorCode UdChannel_setOutSignal(UdChannel *obj, OutSignalType value) { return DAQFN_ET(DNLAPI_CNTR, 209, OutSignalType)(obj, value); }
BDAQINL int32 UdChannel_getOutCount(UdChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 210, int32)(obj); }
BDAQINL ErrorCode UdChannel_setOutCount(UdChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 211, int32)(obj, value); }
/* ----------------------------------------------------------*/
/*UdCounterCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode UdCounterCtrl_LoadProfile(UdCounterCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void UdCounterCtrl_Cleanup(UdCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void UdCounterCtrl_Dispose(UdCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void UdCounterCtrl_getSelectedDevice(UdCounterCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode UdCounterCtrl_setSelectedDevice(UdCounterCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState UdCounterCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * UdCounterCtrl_getDevice(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * UdCounterCtrl_getSupportedDevices(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * UdCounterCtrl_getSupportedModes(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * UdCounterCtrl_getFeatures(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 UdCounterCtrl_getChannelStart(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode UdCounterCtrl_setChannelStart(UdCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 UdCounterCtrl_getChannelCount(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode UdCounterCtrl_setChannelCount(UdCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 UdCounterCtrl_getEnabled(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode UdCounterCtrl_setEnabled(UdCounterCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 UdCounterCtrl_getRunning(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double UdCounterCtrl_getNoiseFilterBlockTime(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode UdCounterCtrl_setNoiseFilterBlockTime(UdCounterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * UdCounterCtrl_getNoiseFilter(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
/* UdCounterCtrl methods */
BDAQINL ErrorCode UdCounterCtrl_SnapStart(UdCounterCtrl *obj, EventId srcId) { return DAQFN_ET(DNLAPI_CNTR, 121, EventId)(obj, srcId); }
BDAQINL ErrorCode UdCounterCtrl_SnapStop(UdCounterCtrl *obj, EventId srcId) { return DAQFN_ET(DNLAPI_CNTR, 122, EventId)(obj, srcId); }
BDAQINL ErrorCode UdCounterCtrl_CompareAppendTable(UdCounterCtrl *obj, int32 channel, int32 count, int32 *table) { return DAQFN_ETTT(DNLAPI_CNTR, 224, int32, int32, int32 *)(obj, channel, count, table); }
BDAQINL ErrorCode UdCounterCtrl_CompareSetTable(UdCounterCtrl *obj, int32 channel, int32 count, int32 *table) { return DAQFN_ETTT(DNLAPI_CNTR, 123, int32, int32, int32 *)(obj, channel, count, table); }
BDAQINL ErrorCode UdCounterCtrl_CompareAppendInterval(UdCounterCtrl *obj, int32 channel, int32 start, int32 increment,int32 count) { return DAQFN_ETTTT(DNLAPI_CNTR, 225, int32, int32, int32, int32)(obj, channel, start, increment, count); }
BDAQINL ErrorCode UdCounterCtrl_CompareSetInterval(UdCounterCtrl *obj, int32 channel, int32 start, int32 increment,int32 count) { return DAQFN_ETTTT(DNLAPI_CNTR, 124, int32, int32, int32, int32)(obj, channel, start, increment, count); }
BDAQINL ErrorCode UdCounterCtrl_CompareClear(UdCounterCtrl *obj, int32 channel) { return DAQFN_ET(DNLAPI_CNTR, 125, int32)(obj, channel); }
BDAQINL ErrorCode UdCounterCtrl_ValueReset(UdCounterCtrl *obj) { return DAQFN_EV(DNLAPI_CNTR, 126)(obj); }
BDAQINL ErrorCode UdCounterCtrl_Read(UdCounterCtrl *obj, int32 count, int32 *buffer) { return DAQFN_ETT(DNLAPI_CNTR, 127, int32, int32 *)(obj, count, buffer); }
BDAQINL IArray * UdCounterCtrl_getChannels(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 128, IArray *)(obj); }
BDAQINL int8 UdCounterCtrl_getCcpDatCtrlCodeEnabled(UdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 263, int8)(obj); }
BDAQINL ErrorCode UdCounterCtrl_setCcpDatCtrlCodeEnabled(UdCounterCtrl *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 264, int8)(obj, value); }
/*creator*/
BDAQINL UdCounterCtrl* UdCounterCtrl_Create(void) { return (UdCounterCtrl *)DaqCtrlBase_Create(SceUdCounter); }
/*Helpers*/
BDAQINL void UdCounterCtrl_addUdCntrEventHandler(UdCounterCtrl *obj, UdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtUdIndex0, (DaqEventProc)proc, userParam);}
BDAQINL void UdCounterCtrl_removeUdCntrEventHandler(UdCounterCtrl *obj, UdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtUdIndex0, (DaqEventProc)proc, userParam);}
/* ----------------------------------------------------------*/
/*BufferedUdCounterCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode BufferedUdCounterCtrl_LoadProfile(BufferedUdCounterCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void BufferedUdCounterCtrl_Cleanup(BufferedUdCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void BufferedUdCounterCtrl_Dispose(BufferedUdCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void BufferedUdCounterCtrl_getSelectedDevice(BufferedUdCounterCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode BufferedUdCounterCtrl_setSelectedDevice(BufferedUdCounterCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState BufferedUdCounterCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * BufferedUdCounterCtrl_getDevice(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * BufferedUdCounterCtrl_getSupportedDevices(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * BufferedUdCounterCtrl_getSupportedModes(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * BufferedUdCounterCtrl_getFeatures(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 BufferedUdCounterCtrl_getChannelStart(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode BufferedUdCounterCtrl_setChannelStart(BufferedUdCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 BufferedUdCounterCtrl_getChannelCount(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode BufferedUdCounterCtrl_setChannelCount(BufferedUdCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 BufferedUdCounterCtrl_getEnabled(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode BufferedUdCounterCtrl_setEnabled(BufferedUdCounterCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 BufferedUdCounterCtrl_getRunning(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double BufferedUdCounterCtrl_getNoiseFilterBlockTime(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode BufferedUdCounterCtrl_setNoiseFilterBlockTime(BufferedUdCounterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * BufferedUdCounterCtrl_getNoiseFilter(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
/* Buffered UdCounterCtrl methods */
BDAQINL int32 BufferedUdCounterCtrl_getBufferCapacity(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 185, int32)(obj); }
BDAQINL int8 BufferedUdCounterCtrl_getBufferStatus(BufferedUdCounterCtrl *obj, int32 ch, int32 *count, int32 *offset) { return DAQFN_TTTT(DNLAPI_CNTR, 190, int8, int32, int32 *, int32 *)(obj, ch, count, offset); }
BDAQINL Trigger* BufferedUdCounterCtrl_getTrigger(BufferedUdCounterCtrl *obj) { return DAQFN_TT(DNLAPI_CNTR, 161, Trigger *, int32)(obj, 0); }
BDAQINL Record* BufferedUdCounterCtrl_getRecord(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 162, Record *)(obj); }
BDAQINL ErrorCode BufferedUdCounterCtrl_setSampleClkSrc(BufferedUdCounterCtrl *obj, SignalDrop drop) { return DAQFN_ET(DNLAPI_CNTR, 163, SignalDrop)(obj, drop); }
BDAQINL SignalDrop BufferedUdCounterCtrl_getSampleClkSrc(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 164, SignalDrop)(obj); }
BDAQINL void BufferedUdCounterCtrl_getChannelMap(BufferedUdCounterCtrl *obj, int32 count, int8 *chMap) { DAQFN_VTT(DNLAPI_CNTR, 159, int32, int8 *)(obj, count, chMap); }
BDAQINL ErrorCode BufferedUdCounterCtrl_setChannelMap(BufferedUdCounterCtrl *obj, int32 count, int8 *chMap) { return DAQFN_ETT(DNLAPI_CNTR, 160, int32, int8 *)(obj, count, chMap); }
BDAQINL ErrorCode BufferedUdCounterCtrl_Prepare(BufferedUdCounterCtrl *obj) { return DAQFN_EV(DNLAPI_CNTR, 166)(obj); }
BDAQINL void BufferedUdCounterCtrl_Release(BufferedUdCounterCtrl *obj) { DAQFN_VV(DNLAPI_CNTR, 167)(obj); }
BDAQINL IArray * BufferedUdCounterCtrl_getChannels(BufferedUdCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 165, IArray *)(obj); }
BDAQINL ErrorCode BufferedUdCounterCtrl_GetDataI32(BufferedUdCounterCtrl *obj, int32 cntr, int32 count, int32 dataBuf[], int32 timeout, int32 *returned, double *startTime)
{
typedef ErrorCode (BDAQCALL *FNGETDATA)(void *, int32, int32, void*, int32, int32*, double*);
return ((FNGETDATA)DNLAPI_CNTR[168])(obj, cntr, count, dataBuf, timeout, returned, startTime);
}
/*creator*/
BDAQINL BufferedUdCounterCtrl* BufferedUdCounterCtrl_Create(void) { return (BufferedUdCounterCtrl *)DaqCtrlBase_Create(SceBufferedUdCounter); }
/*Helpers*/
BDAQINL void BufferedUdCounterCtrl_addDataReadyHandler(BufferedUdCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedUdCounterCtrl_removeDataReadyHandler(BufferedUdCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCiDataReady, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedUdCounterCtrl_addOverrunHandler(BufferedUdCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedUdCounterCtrl_removeOverrunHandler(BufferedUdCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCiOverrun, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedUdCounterCtrl_addCacheOverflowHandler(BufferedUdCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedUdCounterCtrl_removeCacheOverflowHandler(BufferedUdCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedUdCounterCtrl_addStoppedHandler(BufferedUdCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, EvtCntrStopped, (DaqEventProc)proc, userParam);}
BDAQINL void BufferedUdCounterCtrl_removeStoppedHandler(BufferedUdCounterCtrl *obj, BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, EvtCntrStopped, (DaqEventProc)proc, userParam);}
/* ----------------------------------------------------------*/
/*AbsChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 AbsChannel_getChannel(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 233, int32)(obj); }
BDAQINL int8 AbsChannel_getNoiseFiltered(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 234, int8)(obj); }
BDAQINL ErrorCode AbsChannel_setNoiseFiltered(AbsChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 235, int8)(obj, value); }
BDAQINL CodingType AbsChannel_getCodingType(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 236, CodingType)(obj); }
BDAQINL ErrorCode AbsChannel_setCodingType(AbsChannel *obj, CodingType value) { return DAQFN_ET(DNLAPI_CNTR, 237, CodingType)(obj, value); }
BDAQINL Baudrate AbsChannel_getBaudrate(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 238, Baudrate)(obj); }
BDAQINL ErrorCode AbsChannel_setBaudrate(AbsChannel *obj, Baudrate value) { return DAQFN_ET(DNLAPI_CNTR, 239, Baudrate)(obj, value); }
BDAQINL ErrorRetType AbsChannel_getErrorRetType(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 240, ErrorRetType)(obj); }
BDAQINL ErrorCode AbsChannel_setErrorRetType(AbsChannel *obj, ErrorRetType value) { return DAQFN_ET(DNLAPI_CNTR, 241, ErrorRetType)(obj, value);}
BDAQINL int32 AbsChannel_getErrorRetValue(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 242, int32)(obj); }
BDAQINL ErrorCode AbsChannel_setErrorRetValue(AbsChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 243, int32)(obj, value); }
BDAQINL ActiveSignal AbsChannel_getLatchSigEdge(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 244, ActiveSignal)(obj); }
BDAQINL ErrorCode AbsChannel_setLatchSigEdge(AbsChannel *obj, ActiveSignal value) { return DAQFN_ET(DNLAPI_CNTR, 245, ActiveSignal)(obj, value);}
BDAQINL OutSignalType AbsChannel_getOutSignal(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 246, OutSignalType)(obj); }
BDAQINL ErrorCode AbsChannel_setOutSignal(AbsChannel *obj, OutSignalType value) { return DAQFN_ET(DNLAPI_CNTR, 247, OutSignalType)(obj, value);}
BDAQINL int32 AbsChannel_getCompareValue0(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 248, int32)(obj); }
BDAQINL ErrorCode AbsChannel_setCompareValue0(AbsChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 249, int32)(obj, value); }
BDAQINL int8 AbsChannel_getCompare0Enabled(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 250, int8)(obj); }
BDAQINL ErrorCode AbsChannel_setCompare0Enabled(AbsChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 251, int8)(obj, value); }
BDAQINL int32 AbsChannel_getCompareValue1(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 252, int32)(obj); }
BDAQINL ErrorCode AbsChannel_setCompareValue1(AbsChannel *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 253, int32)(obj, value); }
BDAQINL int8 AbsChannel_getCompare1Enabled(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 254, int8)(obj); }
BDAQINL ErrorCode AbsChannel_setCompare1Enabled(AbsChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 255, int8)(obj, value); }
BDAQINL int32 AbsChannel_getLatchedValue(AbsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 256, int32)(obj); }
/* ----------------------------------------------------------*/
/*AbsCounterCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode AbsCounterCtrl_LoadProfile(AbsCounterCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void AbsCounterCtrl_Cleanup(AbsCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void AbsCounterCtrl_Dispose(AbsCounterCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void AbsCounterCtrl_getSelectedDevice(AbsCounterCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode AbsCounterCtrl_setSelectedDevice(AbsCounterCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState AbsCounterCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * AbsCounterCtrl_getDevice(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * AbsCounterCtrl_getSupportedDevices(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * AbsCounterCtrl_getSupportedModes(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * AbsCounterCtrl_getFeatures(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 AbsCounterCtrl_getChannelStart(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode AbsCounterCtrl_setChannelStart(AbsCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 AbsCounterCtrl_getChannelCount(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode AbsCounterCtrl_setChannelCount(AbsCounterCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 AbsCounterCtrl_getEnabled(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode AbsCounterCtrl_setEnabled(AbsCounterCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 AbsCounterCtrl_getRunning(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double AbsCounterCtrl_getNoiseFilterBlockTime(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode AbsCounterCtrl_setNoiseFilterBlockTime(AbsCounterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * AbsCounterCtrl_getNoiseFilter(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
BDAQINL double AbsCounterCtrl_getMeasurementTimeout(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 130, double)(obj); }
BDAQINL ErrorCode AbsCounterCtrl_setMeasurementTimeout(AbsCounterCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 131, double)(obj, value); }
/* Event counter methods */
BDAQINL IArray * AbsCounterCtrl_getChannels(AbsCounterCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 257, IArray *)(obj); }
BDAQINL ErrorCode AbsCounterCtrl_Read(AbsCounterCtrl *obj, int32 count, int32 *buffer) { return DAQFN_ETT(DNLAPI_CNTR, 258, int32, int32 *)(obj, count, buffer); }
BDAQINL ErrorCode AbsCounterCtrl_StatusRead(AbsCounterCtrl *obj, int32 count, int32 *buffer) { return DAQFN_ETT(DNLAPI_CNTR, 259, int32, int32 *)(obj, count, buffer); }
/*creator*/
BDAQINL AbsCounterCtrl* AbsCounterCtrl_Create(void) { return (AbsCounterCtrl *)DaqCtrlBase_Create(SceAbsCounter); }
/* ----------------------------------------------------------*/
/*EsChannel */
/* ----------------------------------------------------------*/
BDAQINL int32 EsChannel_getChannel(EsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 192, int32)(obj); }
BDAQINL int8 EsChannel_getNoiseFiltered(EsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 193, int8)(obj); }
BDAQINL ErrorCode EsChannel_setNoiseFiltered(EsChannel *obj, int8 value) { return DAQFN_ET(DNLAPI_CNTR, 194, int8)(obj, value); }
BDAQINL ActiveSignal EsChannel_getStartCountingEdge(EsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 195, ActiveSignal)(obj); }
BDAQINL ErrorCode EsChannel_setStartCountingEdge(EsChannel *obj, ActiveSignal value) { return DAQFN_ET(DNLAPI_CNTR, 196, ActiveSignal)(obj, value);}
BDAQINL ActiveSignal EsChannel_getStopCountingEdge(EsChannel *obj) { return DAQFN_TV(DNLAPI_CNTR, 197, ActiveSignal)(obj); }
BDAQINL ErrorCode EsChannel_setStopCountingEdge(EsChannel *obj, ActiveSignal value) { return DAQFN_ET(DNLAPI_CNTR, 198, ActiveSignal)(obj, value);}
/* ----------------------------------------------------------*/
/*EdgeSeparationCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode EdgeSeparationCtrl_LoadProfile(EdgeSeparationCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void EdgeSeparationCtrl_Cleanup(EdgeSeparationCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void EdgeSeparationCtrl_Dispose(EdgeSeparationCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void EdgeSeparationCtrl_getSelectedDevice(EdgeSeparationCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode EdgeSeparationCtrl_setSelectedDevice(EdgeSeparationCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState EdgeSeparationCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * EdgeSeparationCtrl_getDevice(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * EdgeSeparationCtrl_getSupportedDevices(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * EdgeSeparationCtrl_getSupportedModes(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/*base2*/
BDAQINL CntrFeatures * EdgeSeparationCtrl_getFeatures(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(obj); }
BDAQINL int32 EdgeSeparationCtrl_getChannelStart(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj); }
BDAQINL ErrorCode EdgeSeparationCtrl_setChannelStart(EdgeSeparationCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, value); }
BDAQINL int32 EdgeSeparationCtrl_getChannelCount(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(obj); }
BDAQINL ErrorCode EdgeSeparationCtrl_setChannelCount(EdgeSeparationCtrl *obj, int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, value); }
BDAQINL int8 EdgeSeparationCtrl_getEnabled(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 39, int8)(obj); }
BDAQINL ErrorCode EdgeSeparationCtrl_setEnabled(EdgeSeparationCtrl *obj, int8 enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, int8)(obj, enabled); }
BDAQINL int8 EdgeSeparationCtrl_getRunning(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 41, int8)(obj); }
BDAQINL double EdgeSeparationCtrl_getNoiseFilterBlockTime(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 42, double)(obj); }
BDAQINL ErrorCode EdgeSeparationCtrl_setNoiseFilterBlockTime(EdgeSeparationCtrl *obj, double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(obj, value); }
BDAQINL NosFltChannel * EdgeSeparationCtrl_getNoiseFilter_getNoiseFilter(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(obj);}
/* Edge Separation methods */
BDAQINL ErrorCode EdgeSeparationCtrl_Read(EdgeSeparationCtrl *obj, int32 count, double *buffer) { return DAQFN_ETT(DNLAPI_CNTR, 199, int32, double *)(obj, count, buffer); }
BDAQINL IArray * EdgeSeparationCtrl_getChannels(EdgeSeparationCtrl *obj) { return DAQFN_TV(DNLAPI_CNTR, 200, IArray *)(obj); }
/*creator*/
BDAQINL EdgeSeparationCtrl* EdgeSeparationCtrl_Create(void) { return (EdgeSeparationCtrl *)DaqCtrlBase_Create(SceEdgeSeparation); }
/*************************************************************/
/* ctrl class : Calibration related */
/* ----------------------------------------------------------*/
/* CaliSubject */
/* ----------------------------------------------------------*/
BDAQINL wchar_t const * CaliSubject_getDescription(CaliSubject *obj) { return DAQFN_TV(DNLAPI_BASE, 105, wchar_t const *)(obj);}
BDAQINL wchar_t const * CaliSubject_getInstruction(CaliSubject *obj) { return DAQFN_TV(DNLAPI_BASE, 106, wchar_t const *)(obj);}
BDAQINL wchar_t const * CaliSubject_getTargetRange(CaliSubject *obj) { return DAQFN_TV(DNLAPI_BASE, 107, wchar_t const *)(obj);}
BDAQINL CaliState CaliSubject_AdjCodeGetCurrentState(CaliSubject *obj,double *value, int32 *count, int32 code[]) { return DAQFN_TTTT(DNLAPI_BASE, 108, CaliState, double *, int32 *, int32 *)(obj, value, count, code);}
BDAQINL void CaliSubject_AdjCodeGetRange(CaliSubject *obj, int32 lower[], int32 upper[]) { DAQFN_VTT(DNLAPI_BASE, 109, int32 *, int32 *)(obj, lower, upper);}
BDAQINL ErrorCode CaliSubject_ManualAdjStart(CaliSubject *obj) { return DAQFN_EV(DNLAPI_BASE, 110)(obj); }
BDAQINL ErrorCode CaliSubject_ManualAdjStop(CaliSubject *obj) { return DAQFN_EV(DNLAPI_BASE, 111)(obj); }
BDAQINL ErrorCode CaliSubject_ManualAdjSetCode(CaliSubject *obj, int32 count, int32 code[]) { return DAQFN_ETT(DNLAPI_BASE, 112, int32, int32 *)(obj, count, code); }
/* ----------------------------------------------------------*/
/* CaliSection */
/* ----------------------------------------------------------*/
BDAQINL wchar_t const * CaliSection_getTypeName(CaliSection *obj) { return DAQFN_TV(DNLAPI_BASE, 113, wchar_t const *)(obj);}
BDAQINL wchar_t const * CaliSection_getDescription(CaliSection *obj) { return DAQFN_TV(DNLAPI_BASE, 114, wchar_t const *)(obj);}
BDAQINL wchar_t const * CaliSection_getInstruction(CaliSection *obj) { return DAQFN_TV(DNLAPI_BASE, 115, wchar_t const *)(obj);}
BDAQINL IArray * CaliSection_getSubjects(CaliSection *obj) { return DAQFN_TV(DNLAPI_BASE, 116, IArray *)(obj); }
BDAQINL ErrorCode CaliSection_Prepare(CaliSection *obj) { return DAQFN_EV(DNLAPI_BASE, 146)(obj); }
BDAQINL ErrorCode CaliSection_BatchStart(CaliSection *obj) { return DAQFN_EV(DNLAPI_BASE, 117)(obj); }
BDAQINL void CaliSection_BatchTerminate(CaliSection *obj) { DAQFN_VV(DNLAPI_BASE, 118)(obj); }
/* ----------------------------------------------------------*/
/* CaliSolution */
/* ----------------------------------------------------------*/
BDAQINL wchar_t const * CaliSolution_getTypeName(CaliSolution *obj) { return DAQFN_TV(DNLAPI_BASE, 119, wchar_t const *)(obj);}
BDAQINL wchar_t const * CaliSolution_getDescription(CaliSolution *obj) { return DAQFN_TV(DNLAPI_BASE, 120, wchar_t const *)(obj);}
BDAQINL wchar_t const * CaliSolution_getInstruction(CaliSolution *obj) { return DAQFN_TV(DNLAPI_BASE, 121, wchar_t const *)(obj);}
BDAQINL int8 const * CaliSolution_getAuxiliaryImage(CaliSolution *obj, int32 *size) { return DAQFN_TT(DNLAPI_BASE, 122, int8 const*, int32 *)(obj, size); }
BDAQINL IArray * CaliSolution_getSections(CaliSolution *obj) { return DAQFN_TV(DNLAPI_BASE, 123, IArray *)(obj); }
BDAQINL ErrorCode CaliSolution_AdjCodesSave(CaliSolution *obj) { return DAQFN_EV(DNLAPI_BASE, 124)(obj); }
BDAQINL ErrorCode CaliSolution_AdjCodesLoad(CaliSolution *obj) { return DAQFN_EV(DNLAPI_BASE, 125)(obj); }
BDAQINL ErrorCode CaliSolution_AdjCodesSaveToGoldBackup(CaliSolution *obj) { return DAQFN_EV(DNLAPI_BASE, 126)(obj); }
BDAQINL ErrorCode CaliSolution_AdjCodesLoadFromGoldBackup(CaliSolution *obj, int32 action) { return DAQFN_ET(DNLAPI_BASE, 127, int32)(obj, action); }
/* ----------------------------------------------------------*/
/*CalibrationCtrl */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode CalibrationCtrl_LoadProfile(CalibrationCtrl *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void CalibrationCtrl_Cleanup(CalibrationCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void CalibrationCtrl_Dispose(CalibrationCtrl *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void CalibrationCtrl_getSelectedDevice(CalibrationCtrl *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode CalibrationCtrl_setSelectedDevice(CalibrationCtrl *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState CalibrationCtrl_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * CalibrationCtrl_getDevice(CalibrationCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * CalibrationCtrl_getSupportedDevices(CalibrationCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * CalibrationCtrl_getSupportedModes(CalibrationCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/* CalibrationCtrl methods */
BDAQINL IArray * CalibrationCtrl_getSolutions(CalibrationCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 128, IArray *)(obj); }
BDAQINL ErrorCode CalibrationCtrl_setLanguageType(CalibrationCtrl *obj, int32 type) { return DAQFN_ET(DNLAPI_BASE, 149, int32)(obj, type); }
/*creator*/
BDAQINL CalibrationCtrl * CalibrationCtrl_Create(void) { return (CalibrationCtrl *)DaqCtrlBase_Create(SceCalibration); }
/*************************************************************/
/* ctrl class : Firmware download related */
/* ----------------------------------------------------------*/
/* FirmwareCtrl */
/* ----------------------------------------------------------*/
BDAQINL wchar_t const * FirmwareCtrl_getDescription(FirmwareCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 129, wchar_t const *)(obj);}
BDAQINL wchar_t const * FirmwareCtrl_getNotice(FirmwareCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 130, wchar_t const *)(obj);}
BDAQINL wchar_t const * FirmwareCtrl_getActivationTitle(FirmwareCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 131, wchar_t const *)(obj);}
BDAQINL wchar_t const * FirmwareCtrl_getVersionOnDevice(FirmwareCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 132, wchar_t const *)(obj);}
BDAQINL wchar_t const * FirmwareCtrl_getVersionOnFile(FirmwareCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 133, wchar_t const *)(obj);}
BDAQINL int32 FirmwareCtrl_getOverwriteProgressing(FirmwareCtrl *obj) { return DAQFN_TV(DNLAPI_BASE, 134, int32)(obj); }
BDAQINL ErrorCode FirmwareCtrl_LoadFwFile(FirmwareCtrl *obj, wchar_t const *filePath) { return DAQFN_ET(DNLAPI_BASE, 135, wchar_t const *)(obj, filePath); }
BDAQINL ErrorCode FirmwareCtrl_Overwrite(FirmwareCtrl *obj, FwAction action, wchar_t const *activationCode) { return DAQFN_ETT(DNLAPI_BASE,136, FwAction, wchar_t const *)(obj, action, activationCode); }
/* ----------------------------------------------------------*/
/*FirmwareCtrls */
/* ----------------------------------------------------------*/
/*base1*/
BDAQINL ErrorCode FirmwareCtrls_LoadProfile(FirmwareCtrls *obj, wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(obj, fileName); }
BDAQINL void FirmwareCtrls_Cleanup(FirmwareCtrls *obj) { DAQFN_VV(DNLAPI_BASE, 83)(obj); }
BDAQINL void FirmwareCtrls_Dispose(FirmwareCtrls *obj) { DAQFN_VV(DNLAPI_BASE, 84)(obj); }
BDAQINL void FirmwareCtrls_getSelectedDevice(FirmwareCtrls *obj, DeviceInformation *x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(obj, x); }
BDAQINL ErrorCode FirmwareCtrls_setSelectedDevice(FirmwareCtrls *obj, DeviceInformation const *x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(obj, x); }
BDAQINL ControlState FirmwareCtrls_getState(void *obj) { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(obj); }
BDAQINL DeviceCtrl * FirmwareCtrls_getDevice(FirmwareCtrls *obj) { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj); }
BDAQINL IArray * FirmwareCtrls_getSupportedDevices(FirmwareCtrls *obj) { return DAQFN_TV(DNLAPI_BASE, 89, IArray *)(obj); }
BDAQINL IArray * FirmwareCtrls_getSupportedModes(FirmwareCtrls *obj) { return DAQFN_TV(DNLAPI_BASE, 90, IArray *)(obj); }
/* FirmwareCtrls methods */
BDAQINL IArray * FirmwareCtrls_getFirmwares(FirmwareCtrls *obj) { return DAQFN_TV(DNLAPI_BASE, 137, IArray *)(obj); }
BDAQINL ErrorCode FirmwareCtrls_setLanguageType(FirmwareCtrls *obj, int32 type) { return DAQFN_ET(DNLAPI_BASE, 148, int32)(obj, type); }
/*creator*/
BDAQINL FirmwareCtrls * FirmwareCtrls_Create(void) { return (FirmwareCtrls *)DaqCtrlBase_Create(SceFirmware); }
/**********************************************************/
/* For compatible */
/**********************************************************/
#if !defined(__cplusplus) || defined(_BDAQ_C_INTERFACE)
typedef IArray ICollection;
typedef ICounterIndexer CounterCapabilityIndexer;
typedef AiChannel AnalogInputChannel;
typedef AoChannel AnalogChannel;
typedef NosFltChannel NoiseFilterChannel;
typedef DioFeatures DiFeatures;
typedef DioFeatures DoFeatures;
typedef CntrFeatures EventCounterFeatures;
typedef CntrFeatures FreqMeterFeatures;
typedef CntrFeatures OneShotFeatures;
typedef CntrFeatures TimerPulseFeatures;
typedef CntrFeatures PwMeterFeatures;
typedef CntrFeatures PwModulatorFeatures;
typedef CntrFeatures UdCounterFeatures;
typedef struct DeviceEventHandler {
void (BDAQCALL *DeviceEvent)(void *obj, void *sender, DeviceEventArgs *args);
} DeviceEventHandler;
typedef struct DeviceEventListener {
DeviceEventHandler const *vtbl;
}DeviceEventListener;
typedef struct BfdAiEventHandler {
void (BDAQCALL *BfdAiEvent)(void *obj, void *sender, BfdAiEventArgs *args);
} BfdAiEventHandler;
typedef struct BfdAiEventListener {
BfdAiEventHandler const *vtbl;
} BfdAiEventListener;
typedef struct BfdAoEventHandler {
void (BDAQCALL *BfdAoEvent)(void *obj, void *sender, BfdAoEventArgs *args);
} BfdAoEventHandler;
typedef struct BfdAoEventListener {
BfdAoEventHandler const *vtbl;
} BfdAoEventListener;
typedef struct DiSnapEventHandler {
void (BDAQCALL *DiSnapEvent)(void *obj, void *sender, DiSnapEventArgs *args);
} DiSnapEventHandler;
typedef struct DiSnapEventListener {
DiSnapEventHandler const *vtbl;
} DiSnapEventListener;
typedef struct CntrEventHandler {
void (BDAQCALL *CntrEvent)(void *obj, void *sender, CntrEventArgs *args);
} CntrEventHandler;
typedef struct CntrEventListener {
CntrEventHandler const *vtbl;
} CntrEventListener;
typedef struct UdCntrEventHandler {
void (BDAQCALL *UdCntrEvent)(void *obj, void *sender, UdCntrEventArgs *args);
} UdCntrEventHandler;
typedef struct UdCntrEventListener {
UdCntrEventHandler const *vtbl;
} UdCntrEventListener;
BDAQINL void BDAQCALL xxxCtrl_OnDeviceEvent(void *sender, DeviceEventArgs *args, void *userParam)
{
((DeviceEventListener *)userParam)->vtbl->DeviceEvent(userParam, sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnBfdAiEvent(void *sender, BfdAiEventArgs *args, void *userParam)
{
((BfdAiEventListener *)userParam)->vtbl->BfdAiEvent(userParam, sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnBfdAoEvent(void *sender, BfdAoEventArgs *args, void *userParam)
{
((BfdAoEventListener *)userParam)->vtbl->BfdAoEvent(userParam, sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnDiSnapEvent(void *sender, DiSnapEventArgs *args, void *userParam)
{
((DiSnapEventListener *)userParam)->vtbl->DiSnapEvent(userParam, sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnCntrEvent(void *sender, CntrEventArgs *args, void *userParam)
{
((CntrEventListener *)userParam)->vtbl->CntrEvent(userParam, sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnUdCntrEvent(void *sender, UdCntrEventArgs *args, void *userParam)
{
((UdCntrEventListener *)userParam)->vtbl->UdCntrEvent(userParam, sender, args);
}
#else
class DeviceEventListener
{
public:
virtual void BDAQCALL DeviceEvent(void * sender, DeviceEventArgs * args) = 0;
};
class BfdAiEventListener
{
public:
virtual void BDAQCALL BfdAiEvent(void * sender, BfdAiEventArgs * args) = 0;
};
class BfdAoEventListener
{
public:
virtual void BDAQCALL BfdAoEvent(void * sender, BfdAoEventArgs * args) = 0;
};
class DiSnapEventListener
{
public:
virtual void BDAQCALL DiSnapEvent(void * sender, DiSnapEventArgs * args) = 0;
};
class CntrEventListener
{
public:
virtual void BDAQCALL CntrEvent(void * sender, CntrEventArgs * args) = 0;
};
class UdCntrEventListener
{
public:
virtual void BDAQCALL UdCntrEvent(void * sender, UdCntrEventArgs * args) = 0;
};
BDAQINL void BDAQCALL xxxCtrl_OnDeviceEvent(void *sender, DeviceEventArgs *args, void *userParam)
{
((DeviceEventListener *)userParam)->DeviceEvent(sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnBfdAiEvent(void *sender, BfdAiEventArgs *args, void *userParam)
{
((BfdAiEventListener *)userParam)->BfdAiEvent(sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnBfdAoEvent(void *sender, BfdAoEventArgs *args, void *userParam)
{
((BfdAoEventListener *)userParam)->BfdAoEvent(sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnDiSnapEvent(void *sender, DiSnapEventArgs *args, void *userParam)
{
((DiSnapEventListener *)userParam)->DiSnapEvent(sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnCntrEvent(void *sender, CntrEventArgs *args, void *userParam)
{
((CntrEventListener *)userParam)->CntrEvent(sender, args);
}
BDAQINL void BDAQCALL xxxCtrl_OnUdCntrEvent(void *sender, UdCntrEventArgs *args, void *userParam)
{
((UdCntrEventListener *)userParam)->UdCntrEvent(sender, args);
}
#endif
/*
For compatible : helper method
*/
BDAQINL void xxxCtrl_addDeviceEventListener (void *obj, EventId id, DeviceEventListener *listener) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnDeviceEvent, listener); }
BDAQINL void xxxCtrl_removeDeviceEventListener(void *obj, EventId id, DeviceEventListener *listener) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnDeviceEvent, listener); }
BDAQINL void xxxCtrl_addBfdAiEventListener (void *obj, EventId id, BfdAiEventListener *listener) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnBfdAiEvent, listener); }
BDAQINL void xxxCtrl_removeBfdAiEventListener (void *obj, EventId id, BfdAiEventListener *listener) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnBfdAiEvent, listener); }
BDAQINL void xxxCtrl_addBfdAoEventListener (void *obj, EventId id, BfdAoEventListener *listener) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnBfdAoEvent, listener); }
BDAQINL void xxxCtrl_removeBfdAoEventListener (void *obj, EventId id, BfdAoEventListener *listener) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnBfdAoEvent, listener); }
BDAQINL void xxxCtrl_addDiSnapEventListener (void *obj, EventId id, DiSnapEventListener *listener) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnDiSnapEvent, listener); }
BDAQINL void xxxCtrl_removeDiSnapEventListener(void *obj, EventId id, DiSnapEventListener *listener) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnDiSnapEvent, listener); }
BDAQINL void xxxCtrl_addCntrEventListener (void *obj, EventId id, CntrEventListener *listener) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnCntrEvent, listener); }
BDAQINL void xxxCtrl_removeCntrEventListener (void *obj, EventId id, CntrEventListener *listener) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnCntrEvent, listener); }
BDAQINL void xxxCtrl_addUdCntrEventListener (void *obj, EventId id, UdCntrEventListener *listener) { DaqCtrlBase_addEventHandler ((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnUdCntrEvent, listener); }
BDAQINL void xxxCtrl_removeUdCntrEventListener(void *obj, EventId id, UdCntrEventListener *listener) { DaqCtrlBase_removeEventHandler((DaqCtrlBase*)obj, id, (DaqEventProc)xxxCtrl_OnUdCntrEvent, listener); }
BDAQINL ErrorCode xxxCtrl_UpdateProperties(void *obj)
{
DeviceCtrl *dev = DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(obj);
return dev ? DeviceCtrl_Refresh(dev) : ErrorFuncNotInited;
}
BDAQINL int32 xxxCntrCtrl_getChannel(void *obj)
{
return DAQFN_TV(DNLAPI_CNTR, 35, int32)(obj);
}
BDAQINL int32 xxxCntrCtrl_setChannel(void *obj, int32 ch)
{
DAQFN_ET(DNLAPI_CNTR, 38, int32)(obj, 1); // set channel count to 1
return DAQFN_ET(DNLAPI_CNTR, 36, int32)(obj, ch); // set channel start to ch
}
BDAQINL int32 EventCounterCtrl_getValue(EventCounterCtrl *obj)
{
int32 value = 0;
EventCounterCtrl_Read(obj, 1, &value);
return value;
}
BDAQINL FmChannel * FreqMeterCtrl_getCHPtr(FreqMeterCtrl *obj)
{
IArray *chs = FreqMeterCtrl_getChannels(obj);
return chs ? (FmChannel *)Array_getItem(chs, xxxCntrCtrl_getChannel(obj)) : NULL;
}
BDAQINL FreqMeasureMethod FreqMeterCtrl_getMethod(FreqMeterCtrl *obj)
{
FmChannel *ch = FreqMeterCtrl_getCHPtr(obj);
return ch ? FmChannel_getFmMethod(ch) : AutoAdaptive;
}
BDAQINL ErrorCode FreqMeterCtrl_setMethod(FreqMeterCtrl *obj, FreqMeasureMethod value)
{
FmChannel *ch = FreqMeterCtrl_getCHPtr(obj);
return ch ? FmChannel_setFmMethod(ch, value) : ErrorFuncNotInited;
}
BDAQINL double FreqMeterCtrl_getCollectionPeriod(FreqMeterCtrl *obj)
{
FmChannel *ch = FreqMeterCtrl_getCHPtr(obj);
return ch ? FmChannel_getCollectionPeriod(ch) : 0;
}
BDAQINL ErrorCode FreqMeterCtrl_setCollectionPeriod(FreqMeterCtrl *obj, double value)
{
FmChannel *ch = FreqMeterCtrl_getCHPtr(obj);
return ch ? FmChannel_setCollectionPeriod(ch, value) : ErrorFuncNotInited;
}
BDAQINL double FreqMeterCtrl_getValue(FreqMeterCtrl *obj)
{
double value = 0.0;
FreqMeterCtrl_Read(obj, 1, &value);
return value;
}
BDAQINL OsChannel * OneShotCtrl_getCHPtr(OneShotCtrl *obj)
{
IArray *chs = OneShotCtrl_getChannels(obj);
return chs ? (OsChannel *)Array_getItem(chs, xxxCntrCtrl_getChannel(obj)) : NULL;
}
BDAQINL int32 OneShotCtrl_getDelayCount(OneShotCtrl *obj)
{
OsChannel *ch = OneShotCtrl_getCHPtr(obj);
return ch ? OsChannel_getDelayCount(ch) : 0;
}
BDAQINL ErrorCode OneShotCtrl_setDelayCount(OneShotCtrl *obj, int32 value)
{
OsChannel *ch = OneShotCtrl_getCHPtr(obj);
return ch ? OsChannel_setDelayCount(ch, value) : ErrorFuncNotInited;
}
BDAQINL TmrChannel * TimerPulseCtrl_getCHPtr(TimerPulseCtrl *obj)
{
IArray *chs = TimerPulseCtrl_getChannels(obj);
return chs ? (TmrChannel *)Array_getItem(chs, xxxCntrCtrl_getChannel(obj)) : NULL;
}
BDAQINL double TimerPulseCtrl_getFrequency(TimerPulseCtrl *obj)
{
TmrChannel *ch = TimerPulseCtrl_getCHPtr(obj);
return ch ? TmrChannel_getFrequency(ch) : 0;
}
BDAQINL ErrorCode TimerPulseCtrl_setFrequency(TimerPulseCtrl *obj, double value)
{
TmrChannel *ch = TimerPulseCtrl_getCHPtr(obj);
return ch ? TmrChannel_setFrequency(ch, value) : ErrorFuncNotInited;
}
BDAQINL void PwMeterCtrl_getValue(PwMeterCtrl *obj, PulseWidth *width)
{
PwMeterCtrl_Read(obj, 1, width);
}
BDAQINL PoChannel * PwModulatorCtrl_getCHPtr(PwModulatorCtrl *obj)
{
IArray *chs = PwModulatorCtrl_getChannels(obj);
return chs ? (PoChannel *)Array_getItem(chs, xxxCntrCtrl_getChannel(obj)) : NULL;
}
BDAQINL void PwModulatorCtrl_getPulseWidth(PwModulatorCtrl *obj, PulseWidth *width)
{
PoChannel *ch = PwModulatorCtrl_getCHPtr(obj);
if (ch) { PoChannel_getPulseWidth(ch, width); }
else { width->HiPeriod = width->LoPeriod = 0.0; }
}
BDAQINL ErrorCode PwModulatorCtrl_setPulseWidth(PwModulatorCtrl *obj, PulseWidth const *width)
{
PoChannel *ch = PwModulatorCtrl_getCHPtr(obj);
return ch ? PoChannel_setPulseWidth(ch, width) : ErrorFuncNotInited;
}
BDAQINL UdChannel * UdCounterCtrl_getCHPtr(UdCounterCtrl *obj)
{
int32 ch = xxxCntrCtrl_getChannel(obj);
IArray *chs = UdCounterCtrl_getChannels(obj);
if (ch < 0) { return NULL; }
return chs ? (UdChannel *)Array_getItem(chs, ch) : NULL;
}
BDAQINL SignalCountingType UdCounterCtrl_getCountingType(UdCounterCtrl *obj)
{
UdChannel *ch = UdCounterCtrl_getCHPtr(obj);
return ch ? UdChannel_getCountingType(ch) : CountingNone;
}
BDAQINL ErrorCode UdCounterCtrl_setCountingType(UdCounterCtrl *obj, SignalCountingType value)
{
UdChannel *ch = UdCounterCtrl_getCHPtr(obj);
return ch ? UdChannel_setCountingType(ch, value) : ErrorFuncNotInited;
}
BDAQINL int32 UdCounterCtrl_getInitialValue(UdCounterCtrl *obj)
{
UdChannel *ch = UdCounterCtrl_getCHPtr(obj);
return ch ? UdChannel_getInitialValue(ch) : 0;
}
BDAQINL ErrorCode UdCounterCtrl_setInitialValue(UdCounterCtrl *obj, int32 value)
{
UdChannel *ch = UdCounterCtrl_getCHPtr(obj);
return ch ? UdChannel_setInitialValue(ch, value) : ErrorFuncNotInited;
}
BDAQINL int32 UdCounterCtrl_getResetTimesByIndex(UdCounterCtrl *obj)
{
UdChannel *ch = UdCounterCtrl_getCHPtr(obj);
return ch ? UdChannel_getResetTimesByIndex(ch) : 0;
}
BDAQINL ErrorCode UdCounterCtrl_setResetTimesByIndex(UdCounterCtrl *obj, int32 value)
{
UdChannel *ch = UdCounterCtrl_getCHPtr(obj);
return ch ? UdChannel_setResetTimesByIndex(ch, value) : ErrorFuncNotInited;
}
BDAQINL int32 UdCounterCtrl_getValue(UdCounterCtrl *obj)
{
int32 value = 0;
UdCounterCtrl_Read(obj, 1, &value);
return value;
}
/*
For compatible : Global
*/
#define AdxInstantAiCtrlCreate InstantAiCtrl_Create
#define AdxBufferedAiCtrlCreate BufferedAiCtrl_Create
#define AdxInstantAoCtrlCreate InstantAoCtrl_Create
#define AdxBufferedAoCtrlCreate BufferedAoCtrl_Create
#define AdxInstantDiCtrlCreate InstantDiCtrl_Create
#define AdxInstantDoCtrlCreate InstantDoCtrl_Create
#define AdxEventCounterCtrlCreate EventCounterCtrl_Create
#define AdxFreqMeterCtrlCreate FreqMeterCtrl_Create
#define AdxOneShotCtrlCreate OneShotCtrl_Create
#define AdxPwMeterCtrlCreate PwMeterCtrl_Create
#define AdxPwModulatorCtrlCreate PwModulatorCtrl_Create
#define AdxTimerPulseCtrlCreate TimerPulseCtrl_Create
#define AdxUdCounterCtrlCreate UdCounterCtrl_Create
/*
For compatible : ICollection
*/
#define ICollection_Dispose Array_Dispose
#define ICollection_getCount Array_getLength
#define ICollection_getItem Array_getItem
/*
For compatible : NoiseFilterChannel
*/
#define NoiseFilterChannel_getChannel NosFltChannel_getChannel
#define NoiseFilterChannel_getEnabled NosFltChannel_getEnabled
#define NoiseFilterChannel_setEnabled NosFltChannel_setEnabled
/*
For compatible : AnalogInputChannel
*/
#define AnalogInputChannel_getChannel AiChannel_getChannel
#define AnalogInputChannel_getValueRange AiChannel_getValueRange
#define AnalogInputChannel_setValueRange AiChannel_setValueRange
#define AnalogInputChannel_getSignalType AiChannel_getSignalType
#define AnalogInputChannel_setSignalType AiChannel_setSignalType
#define AnalogInputChannel_getBurnoutRetType AiChannel_getBurnoutRetType
#define AnalogInputChannel_setBurnoutRetType AiChannel_setBurnoutRetType
#define AnalogInputChannel_getBurnoutRetValue AiChannel_getBurnoutRetValue
#define AnalogInputChannel_setBurnoutRetValue AiChannel_setBurnoutRetValue
/*
For compatible : AiFeatures
*/
#define AiFeatures_getTriggerSupported(x) (AiFeatures_getTriggerCount(x) > 0)
#define AiFeatures_getTrigger1Supported(x) (AiFeatures_getTriggerCount(x) > 1)
/*
For compatible : AnalogChannel
*/
#define AnalogChannel_getChannel AoChannel_getChannel
#define AnalogChannel_getValueRange AoChannel_getValueRange
#define AnalogChannel_setValueRange AoChannel_setValueRange
/*
For compatible : PortDirection
*/
#define PortDirection_getPort DioPort_getPort
#define PortDirection_getDirection DioPort_getDirection
#define PortDirection_setDirection DioPort_setDirection
/*
For compatible : Counter Capability Indexer
*/
#define CounterCapabilityIndexer_Dispose CounterIndexer_Dispose
#define CounterCapabilityIndexer_getCount CounterIndexer_getLength
#define CounterCapabilityIndexer_getItem CounterIndexer_getItem
/*
For compatible :
*/
#define InstantAiCtrl_getInitialized(obj) (InstantAiCtrl_getState(obj) != Uninited)
#define InstantAiCtrl_getCanEditProperty(obj) InstantAiCtrl_getInitialized(obj)
#define InstantAiCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define InstantAiCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define InstantAiCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define InstantAiCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define InstantAiCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define InstantAiCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define InstantAiCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define BufferedAiCtrl_getInitialized(obj) (BufferedAiCtrl_getState(obj) != Uninited)
#define BufferedAiCtrl_getCanEditProperty(obj) BufferedAiCtrl_getInitialized(obj)
#define BufferedAiCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define BufferedAiCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define BufferedAiCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define BufferedAiCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define BufferedAiCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define BufferedAiCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define BufferedAiCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define BufferedAiCtrl_addDataReadyListener(obj, listener) xxxCtrl_addBfdAiEventListener (obj, EvtBufferedAiDataReady, listener)
#define BufferedAiCtrl_removeDataReadyListener(obj, listener) xxxCtrl_removeBfdAiEventListener (obj, EvtBufferedAiDataReady, listener)
#define BufferedAiCtrl_addOverrunListener(obj, listener) xxxCtrl_addBfdAiEventListener (obj, EvtBufferedAiOverrun, listener)
#define BufferedAiCtrl_removeOverrunListener(obj, listener) xxxCtrl_removeBfdAiEventListener (obj, EvtBufferedAiOverrun, listener)
#define BufferedAiCtrl_addCacheOverflowListener(obj, listener) xxxCtrl_addBfdAiEventListener (obj, EvtBufferedAiCacheOverflow, listener)
#define BufferedAiCtrl_removeCacheOverflowListener(obj, listener) xxxCtrl_removeBfdAiEventListener (obj, EvtBufferedAiCacheOverflow, listener)
#define BufferedAiCtrl_addStoppedListener(obj, listener) xxxCtrl_addBfdAiEventListener (obj, EvtBufferedAiStopped, listener)
#define BufferedAiCtrl_removeStoppedListener(obj, listener) xxxCtrl_removeBfdAiEventListener (obj, EvtBufferedAiStopped, listener)
#define WaveformAiCtrl_getInitialized(obj) (WaveformAiCtrl_getState(obj) != Uninited)
#define WaveformAiCtrl_getCanEditProperty(obj) WaveformAiCtrl_getInitialized(obj)
#define WaveformAiCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define InstantAoCtrl_getInitialized(obj) (InstantAoCtrl_getState(obj) != Uninited)
#define InstantAoCtrl_getCanEditProperty(obj) InstantAoCtrl_getInitialized(obj)
#define InstantAoCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define InstantAoCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define InstantAoCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define InstantAoCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define InstantAoCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define InstantAoCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define InstantAoCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define BufferedAoCtrl_getInitialized(obj) (BufferedAoCtrl_getState(obj) != Uninited)
#define BufferedAoCtrl_getCanEditProperty(obj) BufferedAoCtrl_getInitialized(obj)
#define BufferedAoCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define BufferedAoCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define BufferedAoCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define BufferedAoCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define BufferedAoCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define BufferedAoCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define BufferedAoCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define BufferedAoCtrl_addDataTransmittedListener(obj, listener) xxxCtrl_addBfdAoEventListener (obj, EvtBufferedAoDataTransmitted, listener)
#define BufferedAoCtrl_removeDataTransmittedListener(obj, listener) xxxCtrl_removeBfdAoEventListener (obj, EvtBufferedAoDataTransmitted, listener)
#define BufferedAoCtrl_addUnderrunListener(obj, listener) xxxCtrl_addBfdAoEventListener (obj, EvtBufferedAoUnderrun, listener)
#define BufferedAoCtrl_removeUnderrunListener(obj, listener) xxxCtrl_removeBfdAoEventListener (obj, EvtBufferedAoUnderrun, listener)
#define BufferedAoCtrl_addCacheEmptiedListener(obj, listener) xxxCtrl_addBfdAoEventListener (obj, EvtBufferedAoCacheEmptied, listener)
#define BufferedAoCtrl_removeCacheEmptiedListener(obj, listener) xxxCtrl_removeBfdAoEventListener (obj, EvtBufferedAoCacheEmptied, listener)
#define BufferedAoCtrl_addTransitStoppedListener(obj, listener) xxxCtrl_addBfdAoEventListener (obj, EvtBufferedAoTransStopped, listener)
#define BufferedAoCtrl_removeTransitStoppedListener(obj, listener) xxxCtrl_removeBfdAoEventListener (obj, EvtBufferedAoTransStopped, listener)
#define BufferedAoCtrl_addStoppedListener(obj, listener) xxxCtrl_addBfdAoEventListener (obj, EvtBufferedAoStopped, listener)
#define BufferedAoCtrl_removeStoppedListener(obj, listener) xxxCtrl_removeBfdAoEventListener (obj, EvtBufferedAoStopped, listener)
#define InstantDiCtrl_getInitialized(obj) (InstantDiCtrl_getState(obj) != Uninited)
#define InstantDiCtrl_getCanEditProperty(obj) InstantDiCtrl_getInitialized(obj)
#define InstantDiCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define InstantDiCtrl_getPortDirection(obj) InstantDiCtrl_getPorts(obj)
#define InstantDiCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define InstantDiCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define InstantDiCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define InstantDiCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define InstantDiCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define InstantDiCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define InstantDiCtrl_addInterruptListener(obj, listener) xxxCtrl_addDiSnapEventListener (obj, EvtDiInterrupt, listener)
#define InstantDiCtrl_removeInterruptListener(obj, listener) xxxCtrl_removeDiSnapEventListener(obj, EvtDiInterrupt, listener)
#define InstantDiCtrl_addChangeOfStateListener(obj, listener) xxxCtrl_addDiSnapEventListener (obj, EvtDiStatusChange, listener)
#define InstantDiCtrl_removeChangeOfStateListener(obj, listener) xxxCtrl_removeDiSnapEventListener(obj, EvtDiStatusChange, listener)
#define InstantDiCtrl_addPatternMatchListener(obj, listener) xxxCtrl_addDiSnapEventListener (obj, EvtDiPatternMatch, listener)
#define InstantDiCtrl_removePatternMatchListener(obj, listener) xxxCtrl_removeDiSnapEventListener(obj, EvtDiPatternMatch, listener)
#define InstantDoCtrl_getInitialized(obj) (InstantDoCtrl_getState(obj) != Uninited)
#define InstantDoCtrl_getCanEditProperty(obj) InstantDoCtrl_getInitialized(obj)
#define InstantDoCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define InstantDoCtrl_getPortDirection(obj) InstantDoCtrl_getPorts(obj)
#define InstantDoCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define InstantDoCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define InstantDoCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define InstantDoCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define InstantDoCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define InstantDoCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define EventCounterCtrl_getInitialized(obj) (EventCounterCtrl_getState(obj) != Uninited)
#define EventCounterCtrl_getCanEditProperty(obj) EventCounterCtrl_getInitialized(obj)
#define EventCounterCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define EventCounterCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define EventCounterCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define EventCounterCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define EventCounterCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define EventCounterCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define EventCounterCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define EventCounterCtrl_getChannel(obj) xxxCntrCtrl_getChannel(obj)
#define EventCounterCtrl_setChannel(obj, ch) xxxCntrCtrl_setChannel(obj, ch)
#define FreqMeterCtrl_getInitialized(obj) (FreqMeterCtrl_getState(obj) != Uninited)
#define FreqMeterCtrl_getCanEditProperty(obj) FreqMeterCtrl_getInitialized(obj)
#define FreqMeterCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define FreqMeterCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define FreqMeterCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define FreqMeterCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define FreqMeterCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define FreqMeterCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define FreqMeterCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define FreqMeterCtrl_getChannel(obj) xxxCntrCtrl_getChannel(obj)
#define FreqMeterCtrl_setChannel(obj, ch) xxxCntrCtrl_setChannel(obj, ch)
#define OneShotCtrl_getInitialized(obj) (OneShotCtrl_getState(obj) != Uninited)
#define OneShotCtrl_getCanEditProperty(obj) OneShotCtrl_getInitialized(obj)
#define OneShotCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define OneShotCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define OneShotCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define OneShotCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define OneShotCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define OneShotCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define OneShotCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define OneShotCtrl_addOneShotListener(obj, listener) xxxCtrl_addCntrEventListener (obj, EvtCntOneShot0, listener)
#define OneShotCtrl_removeOneShotListener(obj, listener) xxxCtrl_removeCntrEventListener (obj, EvtCntOneShot0, listener)
#define OneShotCtrl_getChannel(obj) xxxCntrCtrl_getChannel(obj)
#define OneShotCtrl_setChannel(obj, ch) xxxCntrCtrl_setChannel(obj, ch)
#define TimerPulseCtrl_getInitialized(obj) (TimerPulseCtrl_getState(obj) != Uninited)
#define TimerPulseCtrl_getCanEditProperty(obj) TimerPulseCtrl_getInitialized(obj)
#define TimerPulseCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define TimerPulseCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define TimerPulseCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define TimerPulseCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define TimerPulseCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define TimerPulseCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define TimerPulseCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define TimerPulseCtrl_addTimerTickListener(obj, listener) xxxCtrl_addCntrEventListener (obj, EvtCntTimer0, listener)
#define TimerPulseCtrl_removeTimerTickListener(obj, listener) xxxCtrl_removeCntrEventListener (obj, EvtCntTimer0, listener)
#define TimerPulseCtrl_getChannel(obj) xxxCntrCtrl_getChannel(obj)
#define TimerPulseCtrl_setChannel(obj, ch) xxxCntrCtrl_setChannel(obj, ch)
#define PwMeterCtrl_getInitialized(obj) (PwMeterCtrl_getState(obj) != Uninited)
#define PwMeterCtrl_getCanEditProperty(obj) PwMeterCtrl_getInitialized(obj)
#define PwMeterCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define PwMeterCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define PwMeterCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define PwMeterCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define PwMeterCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define PwMeterCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define PwMeterCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define PwMeterCtrl_addOverflowListener(obj, listener) xxxCtrl_addCntrEventListener (obj, EvtCntPwmInOverflow0, listener)
#define PwMeterCtrl_removeOverflowListener(obj, listener) xxxCtrl_removeCntrEventListener (obj, EvtCntPwmInOverflow0, listener)
#define PwMeterCtrl_getChannel(obj) xxxCntrCtrl_getChannel(obj)
#define PwMeterCtrl_setChannel(obj, ch) xxxCntrCtrl_setChannel(obj, ch)
#define PwModulatorCtrl_getInitialized(obj) (PwModulatorCtrl_getState(obj) != Uninited)
#define PwModulatorCtrl_getCanEditProperty(obj) PwModulatorCtrl_getInitialized(obj)
#define PwModulatorCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define PwModulatorCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define PwModulatorCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define PwModulatorCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define PwModulatorCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define PwModulatorCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define PwModulatorCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define PwModulatorCtrl_getChannel(obj) xxxCntrCtrl_getChannel(obj)
#define PwModulatorCtrl_setChannel(obj, ch) xxxCntrCtrl_setChannel(obj, ch)
#define UdCounterCtrl_getInitialized(obj) (UdCounterCtrl_getState(obj) != Uninited)
#define UdCounterCtrl_getCanEditProperty(obj) UdCounterCtrl_getInitialized(obj)
#define UdCounterCtrl_UpdateProperties(obj) xxxCtrl_UpdateProperties(obj)
#define UdCounterCtrl_addRemovedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceRemoved, listener)
#define UdCounterCtrl_removeRemovedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceRemoved, listener)
#define UdCounterCtrl_addReconnectedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtDeviceReconnected, listener)
#define UdCounterCtrl_removeReconnectedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtDeviceReconnected, listener)
#define UdCounterCtrl_addPropertyChangedListener(obj, listener) xxxCtrl_addDeviceEventListener (obj, EvtPropertyChanged, listener)
#define UdCounterCtrl_removePropertyChangedListener(obj, listener) xxxCtrl_removeDeviceEventListener(obj, EvtPropertyChanged, listener)
#define UdCounterCtrl_addUdCntrEventListener(obj, listener) xxxCtrl_addUdCntrEventListener (obj, EvtUdIndex0, listener)
#define UdCounterCtrl_removeUdCntrEventListener(obj, listener) xxxCtrl_removeUdCntrEventListener(obj, EvtUdIndex0, listener)
#define UdCounterCtrl_getChannel(obj) xxxCntrCtrl_getChannel(obj)
#define UdCounterCtrl_setChannel(obj, ch) xxxCntrCtrl_setChannel(obj, ch)
/*
For compatible : DI features / DO Features
*/
#define DiFeatures_getPortProgrammable DioFeatures_getPortProgrammable
#define DiFeatures_getPortCount DioFeatures_getPortCount
#define DiFeatures_getPortsType DioFeatures_getPortsType
#define DiFeatures_getDiSupported DioFeatures_getDiSupported
#define DiFeatures_getDoSupported DioFeatures_getDoSupported
#define DiFeatures_getChannelCountMax DioFeatures_getChannelCountMax
#define DiFeatures_getDataMask DioFeatures_getDiDataMask
#define DiFeatures_getNoiseFilterSupported DioFeatures_getDiNoiseFilterSupported
#define DiFeatures_getNoiseFilterOfChannels DioFeatures_getDiNoiseFilterOfChannels
#define DiFeatures_getNoiseFilterBlockTimeRange DioFeatures_getDiNoiseFilterBlockTimeRange
#define DiFeatures_getDiintSupported DioFeatures_getDiintSupported
#define DiFeatures_getDiintGateSupported DioFeatures_getDiintGateSupported
#define DiFeatures_getDiCosintSupported DioFeatures_getDiCosintSupported
#define DiFeatures_getDiPmintSupported DioFeatures_getDiPmintSupported
#define DiFeatures_getDiintTriggerEdges DioFeatures_getDiintTriggerEdges
#define DiFeatures_getDiintOfChannels DioFeatures_getDiintOfChannels
#define DiFeatures_getDiintGateOfChannels DioFeatures_getDiintGateOfChannels
#define DiFeatures_getDiCosintOfPorts DioFeatures_getDiCosintOfPorts
#define DiFeatures_getDiPmintOfPorts DioFeatures_getDiPmintOfPorts
#define DiFeatures_getSnapEventSources DioFeatures_getDiSnapEventSources
#define DoFeatures_getPortProgrammable DioFeatures_getPortProgrammable
#define DoFeatures_getPortCount DioFeatures_getPortCount
#define DoFeatures_getPortsType DioFeatures_getPortsType
#define DoFeatures_getDiSupported DioFeatures_getDiSupported
#define DoFeatures_getDoSupported DioFeatures_getDoSupported
#define DoFeatures_getChannelCountMax DioFeatures_getChannelCountMax
#define DoFeatures_getDataMask DioFeatures_getDoDataMask
#define DoFeatures_getDoFreezeSignalSources DioFeatures_getDoFreezeSignalSources
#define DoFeatures_getDoReflectWdtFeedIntervalRange DioFeatures_getDoReflectWdtFeedIntervalRange
/*
For compatible : Counter Features
*/
#define EventCounterFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define EventCounterFeatures_getResolution CntrFeatures_getResolution
#define EventCounterFeatures_getDataSize CntrFeatures_getDataSize
#define EventCounterFeatures_getCapabilities CntrFeatures_getCapabilities
#define EventCounterFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define EventCounterFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define EventCounterFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define FreqMeterFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define FreqMeterFeatures_getResolution CntrFeatures_getResolution
#define FreqMeterFeatures_getDataSize CntrFeatures_getDataSize
#define FreqMeterFeatures_getCapabilities CntrFeatures_getCapabilities
#define FreqMeterFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define FreqMeterFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define FreqMeterFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define FreqMeterFeatures_getFmMethods CntrFeatures_getFmMethods
#define OneShotFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define OneShotFeatures_getResolution CntrFeatures_getResolution
#define OneShotFeatures_getDataSize CntrFeatures_getDataSize
#define OneShotFeatures_getCapabilities CntrFeatures_getCapabilities
#define OneShotFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define OneShotFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define OneShotFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define OneShotFeatures_getDelayCountRange CntrFeatures_getOsDelayCountRange
#define TimerPulseFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define TimerPulseFeatures_getResolution CntrFeatures_getResolution
#define TimerPulseFeatures_getDataSize CntrFeatures_getDataSize
#define TimerPulseFeatures_getCapabilities CntrFeatures_getCapabilities
#define TimerPulseFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define TimerPulseFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define TimerPulseFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define TimerPulseFeatures_getTimerFrequencyRange CntrFeatures_getTmrFrequencyRange
#define TimerPulseFeatures_getTimerEventSupported(_thiz_) 0
#define PwMeterFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define PwMeterFeatures_getResolution CntrFeatures_getResolution
#define PwMeterFeatures_getDataSize CntrFeatures_getDataSize
#define PwMeterFeatures_getCapabilities CntrFeatures_getCapabilities
#define PwMeterFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define PwMeterFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define PwMeterFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define PwMeterFeatures_getPwmCascadeGroup CntrFeatures_getPiCascadeGroup
#define PwMeterFeatures_getOverflowEventSupported(_thiz_) 0
#define PwModulatorFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define PwModulatorFeatures_getResolution CntrFeatures_getResolution
#define PwModulatorFeatures_getDataSize CntrFeatures_getDataSize
#define PwModulatorFeatures_getCapabilities CntrFeatures_getCapabilities
#define PwModulatorFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define PwModulatorFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define PwModulatorFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define PwModulatorFeatures_getHiPeriodRange CntrFeatures_getPoHiPeriodRange
#define PwModulatorFeatures_getLoPeriodRange CntrFeatures_getPoLoPeriodRange
#define UdCounterFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define UdCounterFeatures_getResolution CntrFeatures_getResolution
#define UdCounterFeatures_getDataSize CntrFeatures_getDataSize
#define UdCounterFeatures_getCapabilities CntrFeatures_getCapabilities
#define UdCounterFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define UdCounterFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define UdCounterFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define UdCounterFeatures_getCountingTypes CntrFeatures_getUdCountingTypes
#define UdCounterFeatures_getInitialValues CntrFeatures_getUdInitialValues
#define UdCounterFeatures_getSnapEventSources CntrFeatures_getUdSnapEventSources
#define BufferedEventCounterFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define BufferedEventCounterFeatures_getResolution CntrFeatures_getResolution
#define BufferedEventCounterFeatures_getDataSize CntrFeatures_getDataSize
#define BufferedEventCounterFeatures_getCapabilities CntrFeatures_getCapabilities
#define BufferedEventCounterFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define BufferedEventCounterFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define BufferedEventCounterFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define BufferedEventCounterFeatures_getTriggerSources CntrFeatures_getTriggerSources
#define BufferedEventCounterFeatures_getTriggerActions CntrFeatures_getTriggerActions
#define BufferedEventCounterFeatures_getSamplingClockSources CntrFeatures_getSamplingClockSources
#define BufferedFreqMeterFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define BufferedFreqMeterFeatures_getResolution CntrFeatures_getResolution
#define BufferedFreqMeterFeatures_getDataSize CntrFeatures_getDataSize
#define BufferedFreqMeterFeatures_getCapabilities CntrFeatures_getCapabilities
#define BufferedFreqMeterFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define BufferedFreqMeterFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define BufferedFreqMeterFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define BufferedFreqMeterFeatures_getFmMethods CntrFeatures_getFmMethods
#define BufferedFreqMeterFeatures_getTriggerSources CntrFeatures_getTriggerSources
#define BufferedFreqMeterFeatures_getTriggerActions CntrFeatures_getTriggerActions
#define BufferedFreqMeterFeatures_getSamplingClockSources CntrFeatures_getSamplingClockSources
#define BufferedUdCounterFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define BufferedUdCounterFeatures_getResolution CntrFeatures_getResolution
#define BufferedUdCounterFeatures_getDataSize CntrFeatures_getDataSize
#define BufferedUdCounterFeatures_getCapabilities CntrFeatures_getCapabilities
#define BufferedUdCounterFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define BufferedUdCounterFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define BufferedUdCounterFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define BufferedUdCounterFeatures_getCountingTypes CntrFeatures_getUdCountingTypes
#define BufferedUdCounterFeatures_getTriggerSources CntrFeatures_getTriggerSources
#define BufferedUdCounterFeatures_getTriggerActions CntrFeatures_getTriggerActions
#define BufferedUdCounterFeatures_getSamplingClockSources CntrFeatures_getSamplingClockSources
#define BufferedPwModulatorFeatures_getChannelCountMax CntrFeatures_getChannelCountMax
#define BufferedPwModulatorFeatures_getResolution CntrFeatures_getResolution
#define BufferedPwModulatorFeatures_getDataSize CntrFeatures_getDataSize
#define BufferedPwModulatorFeatures_getCapabilities CntrFeatures_getCapabilities
#define BufferedPwModulatorFeatures_getNoiseFilterSupported CntrFeatures_getNoiseFilterSupported
#define BufferedPwModulatorFeatures_getNoiseFilterOfChannels CntrFeatures_getNoiseFilterOfChannels
#define BufferedPwModulatorFeatures_getNoiseFilterBlockTimeRange CntrFeatures_getNoiseFilterBlockTimeRange
#define BufferedPwModulatorFeatures_getHiPeriodRange CntrFeatures_getPoHiPeriodRange
#define BufferedPwModulatorFeatures_getLoPeriodRange CntrFeatures_getPoLoPeriodRange
#define BufferedPwModulatorFeatures_getTriggerSources CntrFeatures_getTriggerSources
#define BufferedPwModulatorFeatures_getTriggerActions CntrFeatures_getTriggerActions
#define BufferedPwModulatorFeatures_getSamplingClockSources CntrFeatures_getSamplingClockSources
/**********************************************************/
/* */
/* DAQNAVI CSCL Classes */
/* */
/**********************************************************/
#if defined(__cplusplus) && !defined(_BDAQ_C_INTERFACE)
#define DAQCLS_DISABLE_CONSTRUCT(Class)\
Class(const Class &);\
Class &operator=(const Class &);\
~Class();\
/* ----------------------------------------------------------*/
/*common classes */
/* ----------------------------------------------------------*/
/* Interface Array */
template
class Array
{
public:
void Dispose() { Array_Dispose((IArray *)this); } /*destroy the instance*/
int32 getLength() { return Array_getLength((IArray *)this); }
T & getItem(int32 index) { return *(T *) Array_getItem((IArray *)this, index);}
public: /*for compatible*/
int32 getCount() { return getLength(); }
private:
DAQCLS_DISABLE_CONSTRUCT(Array)
};
/*for compatible*/
#define ICollection Array
/* Interface ScanChannel */
class ScanChannel
{
public:
int32 getChannelStart() { return ScanChannel_getChannelStart(this); }
ErrorCode setChannelStart(int32 value) { return ScanChannel_setChannelStart(this, value); }
int32 getChannelCount() { return ScanChannel_getChannelCount(this); }
ErrorCode setChannelCount(int32 value) { return ScanChannel_setChannelCount(this, value); }
int32 getSamples() { return ScanChannel_getSamples(this); }
ErrorCode setSamples(int32 value) { return ScanChannel_setSamples(this, value); }
int32 getIntervalCount() { return ScanChannel_getIntervalCount(this); }
ErrorCode setIntervalCount(int32 value) { return ScanChannel_setIntervalCount(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(ScanChannel)
};
/* Interface ConvertClock */
class ConvertClock
{
public:
SignalDrop getSource() { return ConvertClock_getSource(this); }
ErrorCode setSource(SignalDrop value) { return ConvertClock_setSource(this, value); }
double getRate() { return ConvertClock_getRate(this); }
ErrorCode setRate(double value) { return ConvertClock_setRate(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(ConvertClock)
};
/* Interface ScanClock */
class ScanClock
{
public:
SignalDrop getSource() { return ScanClock_getSource(this); }
ErrorCode setSource(SignalDrop value) { return ScanClock_setSource(this, value); }
double getRate() { return ScanClock_getRate(this); }
ErrorCode setRate(double value) { return ScanClock_setRate(this, value); }
int32 getScanCount() { return ScanClock_getScanCount(this); }
ErrorCode setScanCount(int32 value) { return ScanClock_setScanCount(this, value);}
private:
DAQCLS_DISABLE_CONSTRUCT(ScanClock)
};
/* Interface Trigger */
class Trigger
{
public:
SignalDrop getSource() { return Trigger_getSource(this); }
ErrorCode setSource(SignalDrop value) { return Trigger_setSource(this, value); }
ActiveSignal getEdge() { return Trigger_getEdge(this); }
ErrorCode setEdge(ActiveSignal value) { return Trigger_setEdge(this, value); }
double getLevel() { return Trigger_getLevel(this); }
ErrorCode setLevel(double value) { return Trigger_setLevel(this, value); }
TriggerAction getAction() { return Trigger_getAction(this); }
ErrorCode setAction(TriggerAction value) { return Trigger_setAction(this, value); }
int32 getDelayCount() { return Trigger_getDelayCount(this); }
ErrorCode setDelayCount(int32 value) { return Trigger_setDelayCount(this, value); }
double getHysteresisIndex() { return Trigger_getHysteresisIndex(this); }
ErrorCode setHysteresisIndex(double value) { return Trigger_setHysteresisIndex(this, value); }
FilterType getFilterType() { return Trigger_getFilterType(this); }
ErrorCode setFilterType(FilterType value) { return Trigger_setFilterType(this, value); }
double getFilterCutoffFreq() { return Trigger_getFilterCutoffFreq(this); }
ErrorCode setFilterCutoffFreq(double value) { return Trigger_setFilterCutoffFreq(this, value);}
private:
DAQCLS_DISABLE_CONSTRUCT(Trigger)
};
/*Interface Conversion*/
class Conversion
{
public:
SignalDrop getClockSource() { return Conversion_getClockSource(this); }
ErrorCode setClockSource(SignalDrop value) { return Conversion_setClockSource(this, value); }
double getClockRate() { return Conversion_getClockRate(this); }
ErrorCode setClockRate(double value) { return Conversion_setClockRate(this, value); }
int32 getChannelStart() { return Conversion_getChannelStart(this); }
ErrorCode setChannelStart(int32 value) { return Conversion_setChannelStart(this, value);}
int32 getChannelCount() { return Conversion_getChannelCount(this); }
ErrorCode setChannelCount(int32 value) { return Conversion_setChannelCount(this, value);}
void getChannelMap(int32 count, int8 *chMap) { Conversion_getChannelMap(this, count, chMap);}
ErrorCode setChannelMap(int32 count, int8 *chMap) { return Conversion_setChannelMap(this, count, chMap);}
private:
DAQCLS_DISABLE_CONSTRUCT(Conversion)
};
/*Interface Record*/
class Record
{
public:
int32 getSectionLength() { return Record_getSectionLength(this); }
ErrorCode setSectionLength(int32 value) { return Record_setSectionLength(this, value);}
int32 getSectionCount() { return Record_getSectionCount(this); }
ErrorCode setSectionCount(int32 value) { return Record_setSectionCount(this, value); }
int32 getCycles() { return Record_getCycles(this); }
ErrorCode setCycles(int32 value) { return Record_setCycles(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(Record)
};
/* Interface NosFltChannel */
class NosFltChannel
{
public:
int32 getChannel() { return NosFltChannel_getChannel(this); }
bool getEnabled() { return !!NosFltChannel_getEnabled(this); }
ErrorCode setEnabled(bool value) { return NosFltChannel_setEnabled(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(NosFltChannel)
};
typedef NosFltChannel NoiseFilterChannel; /*for compatible*/
/* Interface ScanPort */
class ScanPort
{
public:
int32 getPortStart() { return ScanPort_getPortStart(this); }
ErrorCode setPortStart(int32 value) { return ScanPort_setPortStart(this, value); }
int32 getPortCount() { return ScanPort_getPortCount(this); }
ErrorCode setPortCount(int32 value) { return ScanPort_setPortCount(this, value); }
void getPortMap(int32 count, int8 *portMap) { ScanPort_getPortMap(this, count, portMap);}
ErrorCode setPortMap(int32 count, int8 *portMap) { return ScanPort_setPortMap(this, count, portMap);}
int32 getSectionLength() { return ScanPort_getSectionLength(this); }
ErrorCode setSectionLength(int32 value) { return ScanPort_setSectionLength(this, value); }
int32 getSectionCount() { return ScanPort_getSectionCount(this); }
ErrorCode setSectionCount(int32 value) { return ScanPort_setSectionCount(this, value); }
int32 getCycles() { return ScanPort_getCycles(this); }
ErrorCode setCycles(int32 value) { return ScanPort_setCycles(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(ScanPort)
};
/* ----------------------------------------------------------*/
/*device ctrl class */
/* ----------------------------------------------------------*/
/* Interface DeviceCtrl */
class DeviceCtrl
{
/*event*/
void addEventHandler(EventId id, DeviceEventProc proc, void *userParam) { DeviceCtrl_addEventHandler(this, id, proc, userParam); }
void removeEventHandler(EventId id, DeviceEventProc proc, void *userParam) { DeviceCtrl_removeEventHandler(this, id, proc, userParam);}
public:
/*method*/
ErrorCode Refresh() { return DeviceCtrl_Refresh(this); }
ErrorCode ReadRegister(int32 space, int32 offset, int32 length, void *data) { return DeviceCtrl_ReadRegister(this, space, offset, length, data); }
ErrorCode WriteRegister(int32 space, int32 offset, int32 length, void *data){ return DeviceCtrl_WriteRegister(this, space, offset, length, data); }
ErrorCode ReadPrivateRegion(int32 signature, int32 length, uint8 *data) { return DeviceCtrl_ReadPrivateRegion(this, signature, length, data); }
ErrorCode WritePrivateRegion(int32 signature, int32 length, uint8 *data) { return DeviceCtrl_WritePrivateRegion(this, signature, length, data); }
ErrorCode SynchronizeTimebase() { return DeviceCtrl_SynchronizeTimebase(this); }
double CalculateAbsoluteTime(double const &relativeTime) { return DeviceCtrl_CalculateAbsoluteTime(this, relativeTime); }
/*property*/
int32 getDeviceNumber() { return DeviceCtrl_getDeviceNumber(this); }
ErrorCode getDescription(int32 length, wchar_t *desc) { return DeviceCtrl_getDescription(this, length, desc); }
ErrorCode setDescription(int32 length, wchar_t *desc) { return DeviceCtrl_setDescription(this, length, desc); }
AccessMode getAccessMode() { return DeviceCtrl_getAccessMode(this); }
ProductId getProductId() { return DeviceCtrl_getProductId(this); }
int32 getBoardId() { return DeviceCtrl_getBoardId(this); }
ErrorCode setBoardId(int32 value) { return DeviceCtrl_setBoardId(this, value); }
ErrorCode getBoardVersion(int32 length, wchar_t *ver) { return DeviceCtrl_getBoardVersion(this, length, ver); }
ErrorCode getDriverVersion(int32 length, wchar_t *ver) { return DeviceCtrl_getDriverVersion(this, length, ver); }
ErrorCode getDllVersion(int32 length, wchar_t *ver) { return DeviceCtrl_getDllVersion(this, length, ver); }
ErrorCode getLocation(int32 length, wchar_t *loc) { return DeviceCtrl_getLocation(this, length, loc); }
int32 getPrivateRegionLength() { return DeviceCtrl_getPrivateRegionLength(this); }
int32 getHotResetPreventable() { return DeviceCtrl_getHotResetPreventable(this); }
int32 getBusSlot() { return DeviceCtrl_getBusSlot(this); }
Array* getBaseAddresses() { return (Array*)DeviceCtrl_getBaseAddresses(this); }
Array* getInterrupts() { return (Array*)DeviceCtrl_getInterrupts(this); }
Array* getSupportedTerminalBoard() { return (Array*)DeviceCtrl_getSupportedTerminalBoard(this); }
Array* getSupportedEvents() { return (Array*)DeviceCtrl_getSupportedEvents(this); }
int32 getSupportedScenarios() { return DeviceCtrl_getSupportedScenarios(this); }
HANDLE getDevice() { return DeviceCtrl_getDevice(this); }
TerminalBoard getTerminalBoard() { return DeviceCtrl_getTerminalBoard(this); }
ErrorCode setTerminalBoard(TerminalBoard board) { return DeviceCtrl_setTerminalBoard(this, board); }
ErrorCode setLocateEnabled(bool value) { return DeviceCtrl_setLocateEnabled(this, value); }
static Array* getInstalledDevices() { return (Array*)DeviceCtrl_getInstalledDevices(); }
/*HW specific properties*/
// Byte[]
ErrorCode getHwSpecific(wchar_t *name, int32 &size, uint8 buffer[]) { return DeviceCtrl_getHwSpecific(this, name, &size, buffer); }
ErrorCode setHwSpecific(wchar_t *name, int32 size, uint8 buffer[]) { return DeviceCtrl_setHwSpecific(this, name, size, buffer); }
// I32
ErrorCode getHwSpecific(wchar_t *name, int32 &value)
{
int32 size = sizeof(int32);
return getHwSpecific(name, size, (uint8*)&value);
}
ErrorCode setHwSpecific(wchar_t *name, int32 value)
{
return setHwSpecific(name, sizeof(int32), (uint8*)&value);
}
// F64
ErrorCode getHwSpecific(wchar_t *name, double &value)
{
int32 size = sizeof(double);
return getHwSpecific(name, size, (uint8*)&value);
}
ErrorCode setHwSpecific(wchar_t *name, double value)
{
return setHwSpecific(name, sizeof(double), (uint8*)&value);
}
// new: fusion device properties ----------------------------------------------
Array* getSupportedFusionTypes() { return (Array*)DeviceCtrl_getSupportedFusionTypes(this); }
// new: programmable pin properties--------------------------------------------
Array* getProgrammableSignals() { return (Array*)DeviceCtrl_getProgrammableSignals(this); }
ErrorCode getProgrammableSignalsDirection(int32 length, SignalDirection dir[]) { return DeviceCtrl_getProgrammableSignalsDirection(this, length, dir); }
ErrorCode setProgrammableSignalsDirection(int32 length, SignalDirection dir[]) { return DeviceCtrl_setProgrammableSignalsDirection(this, length, dir); }
double getSignalNoiseFilterBlockTime() { return DeviceCtrl_getSignalNoiseFilterBlockTime(this); }
ErrorCode setSignalNoiseFilterBlockTime(double blkTime) { return DeviceCtrl_setSignalNoiseFilterBlockTime(this, blkTime); }
// new: features & properties for signal routing--------------------------------
Array* getRtSignalEndpoints() { return (Array*)DeviceCtrl_getRtSignalEndpoints(this); }
Array* getRtEndpointXSupportedSources(SignalDrop rep) { return (Array*)DeviceCtrl_getRtEndpointXSupportedSources(this, rep); }
SignalDrop getRtEndpointXSource(SignalDrop rep) { return DeviceCtrl_getRtEndpointXSource(this, rep); }
ErrorCode setRtEndpointXSource(SignalDrop rep, SignalDrop source) { return DeviceCtrl_setRtEndpointXSource(this, rep, source); }
public:
/*Create an independent device ctrl if necessary. Note: Use 'dispose' to free the object*/
static DeviceCtrl * Create(int32 devNumber, wchar_t const *desc, AccessMode mode) { return DeviceCtrl_Create(devNumber, desc, mode); }
void Dispose(void) { DeviceCtrl_Dispose(this); }
public: /*helpers*/
void addRemovedHandler(DeviceEventProc proc, void *userParam) { DeviceCtrl_addEventHandler (this, EvtDeviceRemoved, proc, userParam); }
void removeRemovedHandler(DeviceEventProc proc, void *userParam) { DeviceCtrl_removeEventHandler(this, EvtDeviceRemoved, proc, userParam); }
void addReconnectedHandler(DeviceEventProc proc, void *userParam) { DeviceCtrl_addEventHandler (this, EvtDeviceReconnected, proc, userParam);}
void removeReconnectedHandler(DeviceEventProc proc, void *userParam) { DeviceCtrl_removeEventHandler(this, EvtDeviceReconnected, proc, userParam);}
void addPropertyChangedHandler(DeviceEventProc proc, void *userParam) { DeviceCtrl_addEventHandler (this, EvtPropertyChanged, proc, userParam); }
void removePropertyChangedHandler(DeviceEventProc proc, void *userParam) { DeviceCtrl_removeEventHandler(this, EvtPropertyChanged, proc, userParam); }
private:
DAQCLS_DISABLE_CONSTRUCT(DeviceCtrl)
};
/* ----------------------------------------------------------*/
/*daq ctrl base class */
/* ----------------------------------------------------------*/
/* Interface DaqCtrlBase */
class DaqCtrlBase
{
public:
/*DAQ Control Common Method*/
ErrorCode LoadProfile(wchar_t const *fileName) { return DAQFN_ET(DNLAPI_BASE, 98, wchar_t const *)(this, fileName); }
void Cleanup() { DAQFN_VV(DNLAPI_BASE, 83)(this); } /*release the resources allocated.*/
void Dispose() { DAQFN_VV(DNLAPI_BASE, 84)(this); } /*destroy the instance*/
/*DAQ Control Common Property*/
void getSelectedDevice(DeviceInformation &x) { DAQFN_VT(DNLAPI_BASE, 85, DeviceInformation*)(this, &x); }
ErrorCode setSelectedDevice(DeviceInformation const &x) { return DAQFN_ET(DNLAPI_BASE, 86, DeviceInformation const*)(this, &x); }
ControlState getState() { return DAQFN_TV(DNLAPI_BASE, 87, ControlState)(this); }
DeviceCtrl* getDevice() { return DAQFN_TV(DNLAPI_BASE, 88, DeviceCtrl *)(this); }
HANDLE getModule() { return DAQFN_TV(DNLAPI_BASE, 93, HANDLE)(this); }
Array* getSupportedDevices() { return DAQFN_TV(DNLAPI_BASE, 89, Array*)(this); }
Array* getSupportedModes() { return DAQFN_TV(DNLAPI_BASE, 90, Array*) (this); }
public: /*For compatible ONLY!*/
void addRemovedListener(DeviceEventListener & listener) { xxxCtrl_addDeviceEventListener (this, EvtDeviceRemoved, &listener); }
void removeRemovedListener(DeviceEventListener & listener) { xxxCtrl_removeDeviceEventListener(this, EvtDeviceRemoved, &listener); }
void addReconnectedListener(DeviceEventListener & listener) { xxxCtrl_addDeviceEventListener (this, EvtDeviceReconnected, &listener); }
void removeReconnectedListener(DeviceEventListener & listener) { xxxCtrl_removeDeviceEventListener(this, EvtDeviceReconnected, &listener); }
void addPropertyChangedListener(DeviceEventListener & listener) { xxxCtrl_addDeviceEventListener (this, EvtPropertyChanged, &listener); }
void removePropertyChangedListener(DeviceEventListener & listener) { xxxCtrl_removeDeviceEventListener(this, EvtPropertyChanged, &listener); }
bool getInitialized() { return getState() != Uninited; }
bool getCanEditProperty() { return getState() != Uninited; }
ErrorCode UpdateProperties() { return getDevice()->Refresh(); }
private:
DAQCLS_DISABLE_CONSTRUCT(DaqCtrlBase)
};
/* ----------------------------------------------------------*/
/*AI related classes */
/* ----------------------------------------------------------*/
/* Interface CjcSetting */
class CjcSetting
{
public:
int32 getChannel() { return CjcSetting_getChannel(this); }
ErrorCode setChannel(int32 ch) { return CjcSetting_setChannel(this, ch); }
double getValue() { return CjcSetting_getValue(this); }
ErrorCode setValue(double value) { return CjcSetting_setValue(this, value); }
double getUpdateFreq() { return CjcSetting_getUpdateFreq(this); }
ErrorCode setUpdateFreq(double value) { return CjcSetting_setUpdateFreq(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(CjcSetting)
};
/* Interface AiChannel */
class AiChannel
{
public:
int32 getChannel() { return AiChannel_getChannel(this); }
ValueRange getValueRange() { return AiChannel_getValueRange(this); }
ErrorCode setValueRange(ValueRange value) { return AiChannel_setValueRange(this, value); }
AiSignalType getSignalType() { return AiChannel_getSignalType(this); }
ErrorCode setSignalType(AiSignalType value) { return AiChannel_setSignalType(this, value); }
BurnoutRetType getBurnoutRetType() { return AiChannel_getBurnoutRetType(this); }
ErrorCode setBurnoutRetType(BurnoutRetType value) { return AiChannel_setBurnoutRetType(this, value); }
double getBurnoutRetValue() { return AiChannel_getBurnoutRetValue(this); }
ErrorCode setBurnoutRetValue(double value) { return AiChannel_setBurnoutRetValue(this, value); }
double getBurnShortRetValue() { return AiChannel_getBurnShortRetValue(this); }
ErrorCode setBurnShortRetValue(double value) { return AiChannel_setBurnShortRetValue(this, value); }
/**/
FilterType getFilterType() { return AiChannel_getFilterType(this); }
ErrorCode setFilterType(FilterType value) { return AiChannel_setFilterType(this, value); }
double getFilterCutoffFreq() { return AiChannel_getFilterCutoffFreq(this); }
ErrorCode setFilterCutoffFreq(double value) { return AiChannel_setFilterCutoffFreq(this, value); }
double getFilterCutoffFreq1() { return AiChannel_getFilterCutoffFreq1(this); }
ErrorCode setFilterCutoffFreq1(double value) { return AiChannel_setFilterCutoffFreq1(this, value); }
int32 getLogicalNumber() { return AiChannel_getLogicalNumber(this); }
CouplingType getCouplingType() { return AiChannel_getCouplingType(this); }
ErrorCode setCouplingType(CouplingType value) { return AiChannel_setCouplingType(this, value); }
IepeType getIepeType() { return AiChannel_getIepeType(this); }
ErrorCode setIepeType(IepeType value) { return AiChannel_setIepeType(this, value); }
ImpedanceType getImpedanceType() { return AiChannel_getImpedanceType(this); }
ErrorCode setImpedanceType(ImpedanceType value) { return AiChannel_setImpedanceType(this, value); }
ErrorCode getSensorDescription(int32 &size, wchar_t desc[]) { return AiChannel_getSensorDescription(this, &size, desc);}
ErrorCode setSensorDescription(int32 size, wchar_t desc[]) { return AiChannel_setSensorDescription(this, size, desc);}
ErrorCode getScaleTable(int32 &size, MapFuncPiece table[]) { return AiChannel_getScaleTable(this, &size, table); }
ErrorCode setScaleTable(int32 size, MapFuncPiece table[]) { return AiChannel_setScaleTable(this, size, table); }
private:
DAQCLS_DISABLE_CONSTRUCT(AiChannel)
};
typedef Array AiChannelCollection; /*for compatible*/
typedef AiChannel AnalogInputChannel; /*for compatible*/
/* Interface AiFeatures */
class AiFeatures
{
public:
/*ADC features*/
int32 getResolution() { return AiFeatures_getResolution(this); }
int32 getDataSize() { return AiFeatures_getDataSize(this); }
int32 getDataMask() { return AiFeatures_getDataMask(this); }
double getTimestampResolution() { return AiFeatures_getTimestampResolution(this); }
/*channel features*/
int32 getChannelCountMax() { return AiFeatures_getChannelCountMax(this); }
bool getOverallValueRange() { return !!AiFeatures_getOverallValueRange(this); }
Array* getValueRanges() { return (Array* )AiFeatures_getValueRanges(this); }
Array* getBurnoutReturnTypes() { return (Array*)AiFeatures_getBurnoutReturnTypes(this);}
Array* getConnectionTypes() { return (Array*)AiFeatures_getConnectionTypes(this); }
bool getOverallConnection() { return !!AiFeatures_getOverallConnection(this); }
Array* getCouplingTypes() { return (Array*)AiFeatures_getCouplingTypes(this); }
Array* getIepeTypes() { return (Array*)AiFeatures_getIepeTypes(this); }
Array* getImpedanceTypes() { return (Array*)AiFeatures_getImpedanceTypes(this); }
/*filter*/
Array* getFilterTypes() { return (Array*)AiFeatures_getFilterTypes(this); }
void getFilterCutoffFreqRange(MathInterval &x) { AiFeatures_getFilterCutoffFreqRange(this, &x); }
void getFilterCutoffFreq1Range(MathInterval &x) { AiFeatures_getFilterCutoffFreq1Range(this, &x);}
/*CJC features*/
bool getThermoSupported() { return !!AiFeatures_getThermoSupported(this); }
Array* getCjcChannels() { return (Array*)AiFeatures_getCjcChannels(this);}
/*buffered ai->basic features*/
bool getBufferedAiSupported() { return !!AiFeatures_getBufferedAiSupported(this); }
SamplingMethod getSamplingMethod() { return AiFeatures_getSamplingMethod(this); }
int32 getChannelStartBase() { return AiFeatures_getChannelStartBase(this); }
int32 getChannelCountBase() { return AiFeatures_getChannelCountBase(this); }
/*buffered ai->conversion clock features*/
Array* getConvertClockSources() { return (Array*)AiFeatures_getConvertClockSources(this);}
void getConvertClockRange(MathInterval &x) { AiFeatures_getConvertClockRange(this, &x); }
/*buffered ai->burst scan*/
bool getBurstScanSupported() { return !!AiFeatures_getBurstScanSupported(this); }
Array* getScanClockSources() { return (Array*)AiFeatures_getScanClockSources(this); }
void getScanClockRange(MathInterval &x) { AiFeatures_getScanClockRange(this, &x); }
int32 getScanCountMax() { return AiFeatures_getScanCountMax(this); }
/*buffered ai->trigger features*/
bool getRetriggerable() { return !!AiFeatures_getRetriggerable(this); }
int32 getTriggerCount() { return AiFeatures_getTriggerCount(this); }
Array* getTriggerFilterTypes() { return (Array*)AiFeatures_getTriggerFilterTypes(this);}
void getTriggerFilterCutoffFreq(MathInterval &x){ AiFeatures_getTriggerFilterCutoffFreq(this, &x); }
/*trigger 0*/
Array* getTriggerActions() { return (Array*)AiFeatures_getTriggerActions(this); }
void getTriggerDelayRange(MathInterval &x) { AiFeatures_getTriggerDelayRange(this, &x); }
Array* getTriggerSources() { return (Array*)AiFeatures_getTriggerSources(this); }
ValueRange getTriggerSourceVrg() { return AiFeatures_getTriggerSourceVrg(this); }
double getTriggerHysteresisIndexMax() { return AiFeatures_getTriggerHysteresisIndexMax(this); }
int32 getTriggerHysteresisIndexStep() { return AiFeatures_getTriggerHysteresisIndexStep(this); }
/*trigger 1*/
Array* getTrigger1Actions() { return (Array*)AiFeatures_getTrigger1Actions(this); }
void getTrigger1DelayRange(MathInterval &x) { AiFeatures_getTrigger1DelayRange(this, &x); }
Array* getTrigger1Sources() { return (Array*)AiFeatures_getTrigger1Sources(this); }
ValueRange getTrigger1SourceVrg() { return AiFeatures_getTrigger1SourceVrg(this); }
double getTrigger1HysteresisIndexMax() { return AiFeatures_getTrigger1HysteresisIndexMax(this); }
int32 getTrigger1HysteresisIndexStep() { return AiFeatures_getTrigger1HysteresisIndexStep(this); }
/*trigger 2*/
Array* getTrigger2Actions() { return (Array*)AiFeatures_getTrigger2Actions(this); }
void getTrigger2DelayRange(MathInterval &x) { AiFeatures_getTrigger2DelayRange(this, &x); }
Array* getTrigger2Sources() { return (Array*)AiFeatures_getTrigger2Sources(this); }
ValueRange getTrigger2SourceVrg() { return AiFeatures_getTrigger2SourceVrg(this); }
double getTrigger2HysteresisIndexMax() { return AiFeatures_getTrigger2HysteresisIndexMax(this); }
int32 getTrigger2HysteresisIndexStep() { return AiFeatures_getTrigger2HysteresisIndexStep(this); }
/*trigger 3*/
Array* getTrigger3Actions() { return (Array*)AiFeatures_getTrigger3Actions(this); }
void getTrigger3DelayRange(MathInterval &x) { AiFeatures_getTrigger3DelayRange(this, &x); }
Array* getTrigger3Sources() { return (Array*)AiFeatures_getTrigger3Sources(this); }
ValueRange getTrigger3SourceVrg() { return AiFeatures_getTrigger3SourceVrg(this); }
double getTrigger3HysteresisIndexMax() { return AiFeatures_getTrigger3HysteresisIndexMax(this); }
int32 getTrigger3HysteresisIndexStep() { return AiFeatures_getTrigger3HysteresisIndexStep(this); }
/*sensor features*/
Array* getMeasureTypes() { return (Array*)AiFeatures_getMeasureTypes(this); }
Array* getBridgeResistances() { return (Array*)AiFeatures_getBridgeResistances(this); }
void getExcitingVoltageRange(MathInterval &x) { AiFeatures_getExcitingVoltageRange(this, &x); }
public: /*for compatible*/
MathInterval getConvertClockRange()
{
MathInterval x;
getConvertClockRange(x);
return x;
}
MathInterval getScanClockRange()
{
MathInterval x;
getScanClockRange(x);
return x;
}
MathInterval getTriggerDelayRange()
{
MathInterval x;
getTriggerDelayRange(x);
return x;
}
MathInterval getTrigger1DelayRange()
{
MathInterval x;
getTrigger1DelayRange(x);
return x;
}
bool getTriggerSupported()
{
return getTriggerCount() > 0;
}
bool getTrigger1Supported()
{
return getTriggerCount() > 1;
}
AiChannelType getChannelType()
{
return AiFeatures_getChannelType(this);
}
private:
DAQCLS_DISABLE_CONSTRUCT(AiFeatures)
};
/* Interface AiCtrlBase */
class AiCtrlBase : public DaqCtrlBase
{
public:
/*AI Control Common Method*/
/*AI Control Common Property*/
AiFeatures* getFeatures() { return DAQFN_TV(DNLAPI_AI, 58, AiFeatures *)(this); }
Array* getChannels() { return DAQFN_TV(DNLAPI_AI, 59, Array*)(this); }
int32 getChannelCount() { return DAQFN_TV(DNLAPI_AI, 60, int32 )(this); }
ErrorCode runSensorCalibration(int32 ch, CalibrationData const *data) { return DAQFN_ETT(DNLAPI_AI, 111, int32, CalibrationData const*)(this, ch, data); }
private:
DAQCLS_DISABLE_CONSTRUCT(AiCtrlBase)
};
/* Interface InstantAiCtrl */
class InstantAiCtrl : public AiCtrlBase
{
public:
/*Instant AI Method & Property*/
CjcSetting* getCjc() { return InstantAiCtrl_getCjc(this); }
ErrorCode ReadAny(int32 chStart, int32 chCount, void *dataRaw, double *dataScaled) { return InstantAiCtrl_ReadAny(this, chStart, chCount, dataRaw, dataScaled); }
double getAutoConvertClockRate() { return InstantAiCtrl_getAutoConvertClockRate(this); }
ErrorCode setAutoConvertClockRate(double value) { return InstantAiCtrl_setAutoConvertClockRate(this, value); }
int32 getAutoConvertChannelStart() { return InstantAiCtrl_getAutoConvertChannelStart(this); }
ErrorCode setAutoConvertChannelStart(int32 value) { return InstantAiCtrl_setAutoConvertChannelStart(this, value); }
int32 getAutoConvertChannelCount() { return InstantAiCtrl_getAutoConvertChannelCount(this); }
ErrorCode setAutoConvertChannelCount(int32 value) { return InstantAiCtrl_setAutoConvertChannelCount(this, value); }
public:
/*Create an InstantAictrl. Note: Use 'dispose' to free the object*/
static InstantAiCtrl * Create(void) { return InstantAiCtrl_Create(); }
public: /*helpers*/
ErrorCode Read(int32 ch, double &dataScaled) { return ReadAny(ch, 1, NULL, &dataScaled); }
ErrorCode Read(int32 ch, int16 &dataRaw) { return ReadAny(ch, 1, &dataRaw, NULL); }
ErrorCode Read(int32 ch, int32 &dataRaw) { return ReadAny(ch, 1, &dataRaw, NULL); }
ErrorCode Read(int32 chStart, int32 chCount, double dataScaled[]) { return ReadAny(chStart, chCount, NULL, dataScaled); }
ErrorCode Read(int32 chStart, int32 chCount, int16 dataRaw[], double dataScaled[]) { return ReadAny(chStart, chCount, dataRaw, dataScaled);}
ErrorCode Read(int32 chStart, int32 chCount, int32 dataRaw[], double dataScaled[]) { return ReadAny(chStart, chCount, dataRaw, dataScaled);}
private:
DAQCLS_DISABLE_CONSTRUCT(InstantAiCtrl)
};
/* Interface BufferedAiCtrl */
class BufferedAiCtrl : public AiCtrlBase
{
public:
/*Buffered AI Method*/
ErrorCode Prepare() { return BufferedAiCtrl_Prepare(this); }
ErrorCode RunOnce() { return BufferedAiCtrl_RunOnce(this); }
ErrorCode Start() { return BufferedAiCtrl_Start(this); }
ErrorCode Stop() { return BufferedAiCtrl_Stop(this); }
void Release() { BufferedAiCtrl_Release(this); }
bool GetBufferStatus(int32 *count, int32 *offset) { return !!BufferedAiCtrl_GetBufferStatus(this, count, offset);}
ErrorCode GetData(int32 count, int16 rawData[]) { return BufferedAiCtrl_GetDataI16(this, count, rawData); }
ErrorCode GetData(int32 count, int32 rawData[]) { return BufferedAiCtrl_GetDataI32(this, count, rawData); }
ErrorCode GetData(int32 count, double scaledData[]) { return BufferedAiCtrl_GetDataF64(this, count, scaledData); }
/*Buffered AI Property*/
void* getBuffer() { return BufferedAiCtrl_getBuffer(this); }
int32 getBufferCapacity() { return BufferedAiCtrl_getBufferCapacity(this); }
ScanChannel* getScanChannel() { return BufferedAiCtrl_getScanChannel(this); }
ConvertClock* getConvertClock() { return BufferedAiCtrl_getConvertClock(this); }
ScanClock* getScanClock() { return BufferedAiCtrl_getScanClock(this); }
Trigger* getTrigger() { return BufferedAiCtrl_getTrigger(this); }
Trigger* getTrigger1() { return BufferedAiCtrl_getTrigger1(this); }
Trigger* getTrigger2() { return BufferedAiCtrl_getTrigger2(this); }
Trigger* getTrigger3() { return BufferedAiCtrl_getTrigger3(this); }
bool getStreaming() { return !!BufferedAiCtrl_getStreaming(this); }
ErrorCode setStreaming(bool value) { return BufferedAiCtrl_setStreaming(this, value);}
public:
/*Create an BufferedAiCtrl. Note: Use 'dispose' to free the object*/
static BufferedAiCtrl * Create(void) { return BufferedAiCtrl_Create(); }
public: /*helpers*/
/*event*/
void addDataReadyHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiDataReady, (DaqEventProc)proc, userParam);}
void removeDataReadyHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiDataReady, (DaqEventProc)proc, userParam);}
void addOverrunHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiOverrun, (DaqEventProc)proc, userParam);}
void removeOverrunHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiOverrun, (DaqEventProc)proc, userParam);}
void addCacheOverflowHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiCacheOverflow, (DaqEventProc)proc, userParam);}
void removeCacheOverflowHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiCacheOverflow, (DaqEventProc)proc, userParam);}
void addStoppedHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiStopped, (DaqEventProc)proc, userParam);}
void removeStoppedHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiStopped, (DaqEventProc)proc, userParam);}
void addBurnOutHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiBurnOut, (DaqEventProc)proc, userParam);}
void removeBurnOutHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiBurnOut, (DaqEventProc)proc, userParam);}
public: /*For compatible ONLY!*/
void addDataReadyListener(BfdAiEventListener & listener) { BufferedAiCtrl_addDataReadyListener(this, &listener); }
void removeDataReadyListener(BfdAiEventListener & listener) { BufferedAiCtrl_removeDataReadyListener(this, &listener); }
void addOverrunListener(BfdAiEventListener & listener) { BufferedAiCtrl_addOverrunListener(this, &listener); }
void removeOverrunListener(BfdAiEventListener & listener) { BufferedAiCtrl_removeOverrunListener(this, &listener); }
void addCacheOverflowListener(BfdAiEventListener & listener) { BufferedAiCtrl_addCacheOverflowListener(this, &listener); }
void removeCacheOverflowListener(BfdAiEventListener & listener) { BufferedAiCtrl_removeCacheOverflowListener(this, &listener); }
void addStoppedListener(BfdAiEventListener & listener) { BufferedAiCtrl_addStoppedListener(this, &listener); }
void removeStoppedListener(BfdAiEventListener & listener) { BufferedAiCtrl_removeStoppedListener(this, &listener); }
private:
DAQCLS_DISABLE_CONSTRUCT(BufferedAiCtrl)
};
/* Interface WaveformAiCtrl */
class WaveformAiCtrl : public AiCtrlBase
{
public:
/*Waveform AI Method*/
ErrorCode Prepare() { return WaveformAiCtrl_Prepare(this); }
ErrorCode Start() { return WaveformAiCtrl_Start(this); }
ErrorCode Stop() { return WaveformAiCtrl_Stop(this); }
void Release() { WaveformAiCtrl_Release(this); }
bool GetBufferStatus(int32 *count, int32 *offset) { return !!WaveformAiCtrl_GetBufferStatus(this, count, offset);}
ErrorCode GetData(int32 count, int16 rawData[],
int32 timeout = 0, int32 *returned = NULL, double *startTime = NULL, int32 *markCount = NULL, DataMark *markBuf = NULL)
{
return WaveformAiCtrl_GetDataI16(this, count, rawData, timeout, returned, startTime, markCount, markBuf);
}
ErrorCode GetData(int32 count, int32 rawData[],
int32 timeout = 0, int32 *returned = NULL, double *startTime = NULL, int32 *markCount = NULL, DataMark *markBuf = NULL)
{
return WaveformAiCtrl_GetDataI32(this, count, rawData, timeout, returned, startTime, markCount, markBuf);
}
ErrorCode GetData(int32 count, double scaledData[],
int32 timeout = 0, int32 *returned = NULL, double *startTime = NULL, int32 *markCount = NULL, DataMark *markBuf = NULL)
{
return WaveformAiCtrl_GetDataF64(this, count, scaledData, timeout, returned, startTime, markCount, markBuf);
}
/*Waveform AI Property*/
void* getBuffer() { return WaveformAiCtrl_getBuffer(this); }
int32 getBufferCapacity() { return WaveformAiCtrl_getBufferCapacity(this); }
Conversion* getConversion() { return WaveformAiCtrl_getConversion(this); }
Record* getRecord() { return WaveformAiCtrl_getRecord(this); }
Trigger* getTrigger() { return WaveformAiCtrl_getTrigger(this); }
Trigger* getTrigger1() { return WaveformAiCtrl_getTrigger1(this); }
Trigger* getTrigger2() { return WaveformAiCtrl_getTrigger2(this); }
Trigger* getTrigger3() { return WaveformAiCtrl_getTrigger3(this); }
public:
/*Create an WaveformAiCtrl. Note: Use 'dispose' to free the object*/
static WaveformAiCtrl * Create(void) { return WaveformAiCtrl_Create(); }
public: /*helpers*/
/*event*/
void addDataReadyHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiDataReady, (DaqEventProc)proc, userParam);}
void removeDataReadyHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiDataReady, (DaqEventProc)proc, userParam);}
void addOverrunHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiOverrun, (DaqEventProc)proc, userParam);}
void removeOverrunHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiOverrun, (DaqEventProc)proc, userParam);}
void addCacheOverflowHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiCacheOverflow, (DaqEventProc)proc, userParam);}
void removeCacheOverflowHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiCacheOverflow, (DaqEventProc)proc, userParam);}
void addStoppedHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiStopped, (DaqEventProc)proc, userParam);}
void removeStoppedHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiStopped, (DaqEventProc)proc, userParam);}
void addBurnOutHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiBurnOut, (DaqEventProc)proc, userParam);}
void removeBurnOutHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiBurnOut, (DaqEventProc)proc, userParam);}
void addTimeStampOverrunHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiTimeStampOverrun, (DaqEventProc)proc, userParam);}
void removeTimeStampOverrunHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiTimeStampOverrun, (DaqEventProc)proc, userParam);}
void addTimeStampCacheOverflowHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiTimeStampCacheOverflow, (DaqEventProc)proc, userParam);}
void removeTimeStampCacheOverflowHandler(BfdAiEventProc proc, void *userParam){ DaqCtrlBase_removeEventHandler(this, EvtBufferedAiTimeStampCacheOverflow, (DaqEventProc)proc, userParam);}
void addMarkOverrunHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAiMarkOverrun, (DaqEventProc)proc, userParam);}
void removeMarkOverrunHandler(BfdAiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAiMarkOverrun, (DaqEventProc)proc, userParam);}
private:
DAQCLS_DISABLE_CONSTRUCT(WaveformAiCtrl)
};
/* ----------------------------------------------------------*/
/*AO related classes */
/* ----------------------------------------------------------*/
/* Interface AoChannel */
class AoChannel
{
public:
int32 getChannel() { return AoChannel_getChannel(this); }
ValueRange getValueRange() { return AoChannel_getValueRange(this); }
ErrorCode setValueRange(ValueRange value) { return AoChannel_setValueRange(this, value); }
double getExtRefBipolar() { return AoChannel_getExtRefBipolar(this); }
ErrorCode setExtRefBipolar(double value) { return AoChannel_setExtRefBipolar(this, value); }
double getExtRefUnipolar() { return AoChannel_getExtRefUnipolar(this); }
ErrorCode setExtRefUnipolar(double value) { return AoChannel_setExtRefUnipolar(this, value);}
ErrorCode getScaleTable(int32 &size, MapFuncPiece table[]) { return AoChannel_getScaleTable(this, &size, table); }
ErrorCode setScaleTable(int32 size, MapFuncPiece table[]) { return AoChannel_setScaleTable(this, size, table); }
private:
DAQCLS_DISABLE_CONSTRUCT(AoChannel)
};
typedef Array AoChannelCollection; /*for compatible*/
typedef AoChannel AnalogChannel; /*for compatible*/
/* Interface AoFeatures */
class AoFeatures
{
public:
/*DAC features*/
int32 getResolution() { return AoFeatures_getResolution(this); }
int32 getDataSize() { return AoFeatures_getDataSize(this); }
int32 getDataMask() { return AoFeatures_getDataMask(this); }
/*channel features*/
int32 getChannelCountMax() { return AoFeatures_getChannelCountMax(this); }
Array* getValueRanges() { return (Array*)AoFeatures_getValueRanges(this); }
bool getExternalRefAntiPolar() { return !!AoFeatures_getExternalRefAntiPolar(this); }
void getExternalRefRange(MathInterval &x) { AoFeatures_getExternalRefRange(this, &x); }
/*buffered ao->basic features*/
bool getBufferedAoSupported() { return !!AoFeatures_getBufferedAoSupported(this); }
SamplingMethod getSamplingMethod() { return AoFeatures_getSamplingMethod(this); }
int32 getChannelStartBase() { return AoFeatures_getChannelStartBase(this); }
int32 getChannelCountBase() { return AoFeatures_getChannelCountBase(this); }
/*buffered ao->conversion clock features*/
Array* getConvertClockSources() { return (Array*)AoFeatures_getConvertClockSources(this);}
void getConvertClockRange(MathInterval &x) { AoFeatures_getConvertClockRange(this, &x); }
/*buffered ao->trigger features*/
int32 getTriggerCount() { return AoFeatures_getTriggerCount(this); }
bool getRetriggerable() { return !!AoFeatures_getRetriggerable(this); }
/*trigger 0*/
Array* getTriggerSources() { return (Array*)AoFeatures_getTriggerSources(this); }
Array* getTriggerActions() { return (Array*)AoFeatures_getTriggerActions(this);}
void getTriggerDelayRange(MathInterval &x) { AoFeatures_getTriggerDelayRange(this, &x); }
/*trigger 1*/
Array* getTrigger1Sources() { return (Array*)AoFeatures_getTrigger1Sources(this); }
Array* getTrigger1Actions() { return (Array*)AoFeatures_getTrigger1Actions(this);}
void getTrigger1DelayRange(MathInterval &x) { AoFeatures_getTrigger1DelayRange(this, &x); }
public: /*for compatible*/
MathInterval getExternalRefRange()
{
MathInterval x;
getExternalRefRange(x);
return x;
}
MathInterval getConvertClockRange()
{
MathInterval x;
getConvertClockRange(x);
return x;
}
MathInterval getTriggerDelayRange()
{
MathInterval x;
getTriggerDelayRange(x);
return x;
}
MathInterval getTrigger1DelayRange()
{
MathInterval x;
getTrigger1DelayRange(x);
return x;
}
bool getTriggerSupported()
{
return getTriggerCount() > 0;
}
bool getTrigger1Supported()
{
return getTriggerCount() > 1;
}
private:
DAQCLS_DISABLE_CONSTRUCT(AoFeatures)
};
/* Interface AoCtrlBase */
class AoCtrlBase : public DaqCtrlBase
{
public:
/*AI Control Common Method*/
/*AO Control Common Property*/
AoFeatures* getFeatures() { return DAQFN_TV(DNLAPI_AO, 25, AoFeatures *)(this); }
Array* getChannels() { return DAQFN_TV(DNLAPI_AO, 26, Array*)(this);}
int32 getChannelCount() { return DAQFN_TV(DNLAPI_AO, 27, int32 )(this); }
public: /*For compatible ONLY!*/
/*Please use AoChannel's properties instead. */
double getExtRefValueForUnipolar() { return DAQFN_TV(DNLAPI_AO, 28, double)(this); }
ErrorCode setExtRefValueForUnipolar(double value) { return DAQFN_ET(DNLAPI_AO, 29, double)(this, value); }
double getExtRefValueForBipolar() { return DAQFN_TV(DNLAPI_AO, 30, double)(this); }
ErrorCode setExtRefValueForBipolar(double value) { return DAQFN_ET(DNLAPI_AO, 31, double)(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(AoCtrlBase)
};
/* Interface InstantAoCtrl */
class InstantAoCtrl : public AoCtrlBase
{
public:
/*Instant AO Method*/
ErrorCode WriteAny(int32 chStart, int32 chCount, void *dataRaw, double *dataScaled) { return InstantAoCtrl_WriteAny(this, chStart, chCount, dataRaw, dataScaled); }
public:
/*Create an InstantAoctrl. Note: Use 'dispose' to free the object*/
static InstantAoCtrl * Create(void) { return InstantAoCtrl_Create(); }
public: /*helpers*/
ErrorCode Write(int32 ch, double dataScaled) { return WriteAny(ch, 1, NULL, &dataScaled); }
ErrorCode Write(int32 ch, int16 dataRaw) { return WriteAny(ch, 1, &dataRaw, NULL); }
ErrorCode Write(int32 ch, int32 dataRaw) { return WriteAny(ch, 1, &dataRaw, NULL); }
ErrorCode Write(int32 chStart, int32 chCount, double dataScaled[]) { return WriteAny(chStart, chCount, NULL, dataScaled);}
ErrorCode Write(int32 chStart, int32 chCount, int16 dataRaw[]) { return WriteAny(chStart, chCount, dataRaw, NULL); }
ErrorCode Write(int32 chStart, int32 chCount, int32 dataRaw[]) { return WriteAny(chStart, chCount, dataRaw, NULL); }
private:
DAQCLS_DISABLE_CONSTRUCT(InstantAoCtrl)
};
/* Interface BufferedAoCtrl */
class BufferedAoCtrl : public AoCtrlBase
{
public:
/*Buffered AO Method*/
ErrorCode Prepare() { return BufferedAoCtrl_Prepare(this); }
ErrorCode RunOnce() { return BufferedAoCtrl_RunOnce(this); }
ErrorCode Start() { return BufferedAoCtrl_Start(this); }
ErrorCode Stop(int32 action) { return BufferedAoCtrl_Stop(this, action);}
void Release() { BufferedAoCtrl_Release(this); }
bool GetBufferStatus(int32 *count, int32 *offset) { return !!BufferedAoCtrl_GetBufferStatus(this, count, offset);}
ErrorCode SetData(int32 count, int16 rawData[]) { return BufferedAoCtrl_SetDataI16(this, count, rawData); }
ErrorCode SetData(int32 count, int32 rawData[]) { return BufferedAoCtrl_SetDataI32(this, count, rawData); }
ErrorCode SetData(int32 count, double scaledData[]) { return BufferedAoCtrl_SetDataF64(this, count, scaledData);}
/*Buffered AO Property*/
void* getBuffer() { return BufferedAoCtrl_getBuffer(this); }
int32 getBufferCapacity() { return BufferedAoCtrl_getBufferCapacity(this); }
ScanChannel* getScanChannel() { return BufferedAoCtrl_getScanChannel(this); }
ConvertClock* getConvertClock() { return BufferedAoCtrl_getConvertClock(this); }
Trigger* getTrigger() { return BufferedAoCtrl_getTrigger(this); }
Trigger* getTrigger1() { return BufferedAoCtrl_getTrigger1(this); }
bool getStreaming() { return !!BufferedAoCtrl_getStreaming(this); }
ErrorCode setStreaming(bool value) { return BufferedAoCtrl_setStreaming(this, value); }
public:
/*Create an BufferedAoCtrl. Note: Use 'dispose' to free the object*/
static BufferedAoCtrl * Create(void) { return BufferedAoCtrl_Create(); }
public: /*helpers*/
/*event*/
void addDataTransmittedHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAoDataTransmitted, (DaqEventProc)proc, userParam); }
void removeDataTransmittedHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAoDataTransmitted, (DaqEventProc)proc, userParam); }
void addUnderrunHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAoUnderrun, (DaqEventProc)proc, userParam); }
void removeUnderrunHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAoUnderrun, (DaqEventProc)proc, userParam); }
void addCacheEmptiedHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAoCacheEmptied, (DaqEventProc)proc, userParam); }
void removeCacheEmptiedHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAoCacheEmptied, (DaqEventProc)proc, userParam); }
void addTransitStoppedHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAoTransStopped, (DaqEventProc)proc, userParam); }
void removeTransitStoppedHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAoTransStopped, (DaqEventProc)proc, userParam); }
void addStoppedHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedAoStopped, (DaqEventProc)proc, userParam); }
void removeStoppedHandler(BfdAoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedAoStopped, (DaqEventProc)proc, userParam); }
public: /*For compatible ONLY!*/
void addDataTransmittedListener(BfdAoEventListener & listener) { BufferedAoCtrl_addDataTransmittedListener(this, &listener); }
void removeDataTransmittedListener(BfdAoEventListener & listener) { BufferedAoCtrl_removeDataTransmittedListener(this, &listener); }
void addUnderrunListener(BfdAoEventListener & listener) { BufferedAoCtrl_addUnderrunListener(this, &listener); }
void removeUnderrunListener(BfdAoEventListener & listener) { BufferedAoCtrl_removeUnderrunListener(this, &listener); }
void addCacheEmptiedListener(BfdAoEventListener & listener) { BufferedAoCtrl_addCacheEmptiedListener(this, &listener); }
void removeCacheEmptiedListener(BfdAoEventListener & listener) { BufferedAoCtrl_removeCacheEmptiedListener(this, &listener); }
void addTransitStoppedListener(BfdAoEventListener & listener) { BufferedAoCtrl_addTransitStoppedListener(this, &listener); }
void removeTransitStoppedListener(BfdAoEventListener & listener) { BufferedAoCtrl_removeTransitStoppedListener(this, &listener); }
void addStoppedListener(BfdAoEventListener & listener) { BufferedAoCtrl_addStoppedListener(this, &listener); }
void removeStoppedListener(BfdAoEventListener & listener) { BufferedAoCtrl_removeStoppedListener(this, &listener); }
private:
DAQCLS_DISABLE_CONSTRUCT(BufferedAoCtrl)
};
/* ----------------------------------------------------------*/
/*DIO related classes */
/* ----------------------------------------------------------*/
/* Interface DioPort */
class DioPort
{
public:
int32 getPort() { return DioPort_getPort(this); }
uint8 getDirectionMask() { return DioPort_getDirectionMask(this); }
ErrorCode setDirectionMask(uint8 value) { return DioPort_setDirectionMask(this, value); }
/*DI port property*/
uint8 getDiInversePort() { return DioPort_getDiInversePort(this); }
ErrorCode setDiInversePort(uint8 value) { return DioPort_setDiInversePort(this, value); }
uint8 getDiOpenState() { return DioPort_getDiOpenState(this); }
ErrorCode setDiOpenState(uint8 value) { return DioPort_setDiOpenState(this, value); }
/*DO port property*/
uint8 getPresetValue() { return DioPort_getDoPresetValue(this); }
ErrorCode setPresetValue(uint8 value) { return DioPort_setDoPresetValue(this, value); }
DoCircuitType getDoCircuitType() { return DioPort_getDoCircuitType(this); }
ErrorCode setDoCircuitType(DoCircuitType value) { return DioPort_setDoCircuitType(this, value); }
public: /*For compatible ONLY!*/
DioPortDir getDirection() { return (DioPortDir)getDirectionMask(); }
ErrorCode setDirection(DioPortDir value) { return setDirectionMask((uint8)value); }
private:
DAQCLS_DISABLE_CONSTRUCT(DioPort)
};
typedef DioPort PortDirection; /*for compatible*/
/* Interface DiintChannel */
class DiintChannel
{
public:
int32 getChannel() { return DiintChannel_getChannel(this); }
bool getEnabled() { return !!DiintChannel_getEnabled(this); }
ErrorCode setEnabled(bool value) { return DiintChannel_setEnabled(this, value); }
bool getGated() { return !!DiintChannel_getGated(this); }
ErrorCode setGated(bool value) { return DiintChannel_setGated(this, value); }
ActiveSignal getTrigEdge() { return DiintChannel_getTrigEdge(this); }
ErrorCode setTrigEdge(ActiveSignal value) { return DiintChannel_setTrigEdge(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(DiintChannel)
};
/* Interface DiCosintPort */
class DiCosintPort
{
public:
int32 getPort() { return DiCosintPort_getPort(this); }
uint8 getMask() { return DiCosintPort_getMask(this); }
ErrorCode setMask(uint8 value) { return DiCosintPort_setMask(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(DiCosintPort)
};
/* Interface DiPmintPort */
class DiPmintPort
{
public:
int32 getPort() { return DiPmintPort_getPort(this); }
uint8 getMask() { return DiPmintPort_getMask(this); }
ErrorCode setMask(uint8 value) { return DiPmintPort_setMask(this, value); }
uint8 getPattern() { return DiPmintPort_getPattern(this); }
ErrorCode setPattern(uint8 value) { return DiPmintPort_setPattern(this, value);}
private:
DAQCLS_DISABLE_CONSTRUCT(DiPmintPort)
};
/* Interface DioFeatures */
class DioFeatures
{
public:
/*DIO common*/
bool getPortProgrammable() { return !!DioFeatures_getPortProgrammable(this); }
int32 getChannelCountMax() { return DioFeatures_getChannelCountMax(this); }
int32 getPortCount() { return DioFeatures_getPortCount(this); }
Array* getPortsType() { return (Array*)DioFeatures_getPortsType(this); }
bool getDiSupported() { return !!DioFeatures_getDiSupported(this); }
bool getDoSupported() { return !!DioFeatures_getDoSupported(this); }
/*DI features*/
Array* getDiDataMask() { return (Array*)DioFeatures_getDiDataMask(this); }
/*DI noise filter features*/
bool getDiNoiseFilterSupported() { return !!DioFeatures_getDiNoiseFilterSupported(this); }
Array* getDiNoiseFilterOfChannels() { return (Array*)DioFeatures_getDiNoiseFilterOfChannels(this);}
void getDiNoiseFilterBlockTimeRange(MathInterval &x) { DioFeatures_getDiNoiseFilterBlockTimeRange(this, &x); }
/*DI interrupt features*/
bool getDiintSupported() { return !!DioFeatures_getDiintSupported(this); }
bool getDiintGateSupported() { return !!DioFeatures_getDiintGateSupported(this); }
bool getDiCosintSupported() { return !!DioFeatures_getDiCosintSupported(this); }
bool getDiPmintSupported() { return !!DioFeatures_getDiPmintSupported(this); }
Array* getDiintTriggerEdges() { return (Array*)DioFeatures_getDiintTriggerEdges(this);}
Array* getDiintOfChannels() { return (Array*)DioFeatures_getDiintOfChannels(this); }
Array* getDiintGateOfChannels() { return (Array*)DioFeatures_getDiintGateOfChannels(this); }
Array* getDiCosintOfPorts() { return (Array*)DioFeatures_getDiCosintOfPorts(this); }
Array* getDiPmintOfPorts() { return (Array*)DioFeatures_getDiPmintOfPorts(this); }
Array* getDiSnapEventSources() { return (Array*)DioFeatures_getDiSnapEventSources(this); }
/*DO features*/
Array* getDoDataMask() { return (Array*)DioFeatures_getDoDataMask(this); }
Array* getDoFreezeSignalSources() { return (Array*)DioFeatures_getDoFreezeSignalSources(this); }
void getDoReflectWdtFeedIntervalRange(MathInterval &x) { DioFeatures_getDoReflectWdtFeedIntervalRange(this, &x); }
Depository getDoPresetValueDepository() { return DioFeatures_getDoPresetValueDepository(this); }
Array* getDoCircuitSelectableTypes() { return (Array*)DioFeatures_getDoCircuitSelectableTypes(this); }
/* buffered dio common */
int32 getResolution() { return DioFeatures_getResolution(this); }
int32 getDataSize() { return DioFeatures_getDataSize(this); }
/*buffered di->basic features*/
bool getBufferedDiSupported() { return !!DioFeatures_getBufferedDiSupported(this); }
SamplingMethod getDiSamplingMethod() { return DioFeatures_getDiSamplingMethod(this); }
/*buffered di->conversion clock features*/
Array* getDiConvertClockSources() { return (Array*)DioFeatures_getDiConvertClockSources(this);}
void getDiConvertClockRange(MathInterval &x) { DioFeatures_getDiConvertClockRange(this, &x); }
/*buffered di->trigger features*/
bool getDiRetriggerable() { return !!DioFeatures_getDiRetriggerable(this); }
int32 getDiTriggerCount() { return DioFeatures_getDiTriggerCount(this); }
/*trigger 0*/
Array* getDiTriggerActions() { return (Array*)DioFeatures_getDiTriggerActions(this); }
void getDiTriggerDelayRange(MathInterval &x) { DioFeatures_getDiTriggerDelayRange(this, &x); }
Array* getDiTriggerSources() { return (Array*)DioFeatures_getDiTriggerSources(this); }
ValueRange getDiTriggerSourceVrg() { return DioFeatures_getDiTriggerSourceVrg(this); }
double getDiTriggerHysteresisIndexMax() { return DioFeatures_getDiTriggerHysteresisIndexMax(this); }
int32 getDiTriggerHysteresisIndexStep() { return DioFeatures_getDiTriggerHysteresisIndexStep(this); }
/*trigger 1*/
Array* getDiTrigger1Actions() { return (Array*)DioFeatures_getDiTrigger1Actions(this); }
void getDiTrigger1DelayRange(MathInterval &x) { DioFeatures_getDiTrigger1DelayRange(this, &x); }
Array* getDiTrigger1Sources() { return (Array*)DioFeatures_getDiTrigger1Sources(this); }
ValueRange getDiTrigger1SourceVrg() { return DioFeatures_getDiTrigger1SourceVrg(this); }
double getDiTrigger1HysteresisIndexMax() { return DioFeatures_getDiTrigger1HysteresisIndexMax(this); }
int32 getDiTrigger1HysteresisIndexStep() { return DioFeatures_getDiTrigger1HysteresisIndexStep(this); }
/*buffered do->basic features*/
bool getBufferedDoSupported() { return !!DioFeatures_getBufferedDoSupported(this); }
SamplingMethod getDoSamplingMethod() { return DioFeatures_getDoSamplingMethod(this); }
/*buffered do->conversion clock features*/
Array* getDoConvertClockSources() { return (Array*)DioFeatures_getDoConvertClockSources(this);}
void getDoConvertClockRange(MathInterval &x) { DioFeatures_getDoConvertClockRange(this, &x); }
/*buffered do->trigger features*/
bool getDoRetriggerable() { return !!DioFeatures_getDoRetriggerable(this); }
int32 getDoTriggerCount() { return DioFeatures_getDoTriggerCount(this); }
/*trigger 0*/
Array* getDoTriggerActions() { return (Array*)DioFeatures_getDoTriggerActions(this); }
void getDoTriggerDelayRange(MathInterval &x) { DioFeatures_getDoTriggerDelayRange(this, &x); }
Array* getDoTriggerSources() { return (Array*)DioFeatures_getDoTriggerSources(this); }
ValueRange getDoTriggerSourceVrg() { return DioFeatures_getDoTriggerSourceVrg(this); }
double getDoTriggerHysteresisIndexMax() { return DioFeatures_getDoTriggerHysteresisIndexMax(this); }
int32 getDoTriggerHysteresisIndexStep() { return DioFeatures_getDoTriggerHysteresisIndexStep(this); }
/*trigger 1*/
Array* getDoTrigger1Actions() { return (Array*)DioFeatures_getDoTrigger1Actions(this); }
void getDoTrigger1DelayRange(MathInterval &x) { DioFeatures_getDoTrigger1DelayRange(this, &x); }
Array* getDoTrigger1Sources() { return (Array*)DioFeatures_getDoTrigger1Sources(this); }
ValueRange getDoTrigger1SourceVrg() { return DioFeatures_getDoTrigger1SourceVrg(this); }
double getDoTrigger1HysteresisIndexMax() { return DioFeatures_getDoTrigger1HysteresisIndexMax(this); }
int32 getDoTrigger1HysteresisIndexStep() { return DioFeatures_getDoTrigger1HysteresisIndexStep(this); }
public: /*for compatible*/
MathInterval getDiNoiseFilterBlockTimeRange()
{
MathInterval x;
getDiNoiseFilterBlockTimeRange(x);
return x;
}
MathInterval getDoReflectWdtFeedIntervalRange()
{
MathInterval x;
getDoReflectWdtFeedIntervalRange(x);
return x;
}
MathInterval getDiConvertClockRange()
{
MathInterval x;
getDiConvertClockRange(x);
return x;
}
MathInterval getDiTriggerDelayRange()
{
MathInterval x;
getDiTriggerDelayRange(x);
return x;
}
MathInterval getDiTrigger1DelayRange()
{
MathInterval x;
getDiTrigger1DelayRange(x);
return x;
}
MathInterval getDoConvertClockRange()
{
MathInterval x;
getDoConvertClockRange(x);
return x;
}
MathInterval getDoTriggerDelayRange()
{
MathInterval x;
getDoTriggerDelayRange(x);
return x;
}
MathInterval getDoTrigger1DelayRange()
{
MathInterval x;
getDoTrigger1DelayRange(x);
return x;
}
bool getDiTriggerSupported() { return getDiTriggerCount() > 0; }
bool getDiTrigger1Supported() { return getDiTriggerCount() > 1; }
bool getDoTriggerSupported() { return getDoTriggerCount() > 0; }
bool getDoTrigger1Supported() { return getDoTriggerCount() > 1; }
Array* getDataMask() { return (Array*)DioFeatures_getDataMask(this); }
bool getNoiseFilterSupported() { return getDiNoiseFilterSupported(); }
Array* getNoiseFilterOfChannels() { return getDiNoiseFilterOfChannels(); }
MathInterval getNoiseFilterBlockTimeRange() { return getDiNoiseFilterBlockTimeRange(); }
Array* getSnapEventSources() { return (Array*)getDiSnapEventSources(); }
private:
DAQCLS_DISABLE_CONSTRUCT(DioFeatures)
};
typedef DioFeatures DiFeatures; /*for compatible*/
typedef DioFeatures DoFeatures; /*for compatible*/
/* Interface DioCtrlBase */
class DioCtrlBase : public DaqCtrlBase
{
public:
/*DIO Control Common Property*/
DioFeatures* getFeatures() { return DAQFN_TV(DNLAPI_DIO, 45, DioFeatures *)(this); }
int32 getPortCount() { return DAQFN_TV(DNLAPI_DIO, 46, int32)(this); }
Array* getPorts() { return DAQFN_TV(DNLAPI_DIO, 47, Array*)(this);}
public: /*for compatible*/
Array* getPortDirection() { return getPorts(); }
private:
DAQCLS_DISABLE_CONSTRUCT(DioCtrlBase)
};
/* Interface InstantDiCtrl */
class InstantDiCtrl : public DioCtrlBase
{
public:
/*Instant DI Method*/
ErrorCode ReadAny(int32 portStart, int32 portCount, uint8 data[]) { return InstantDiCtrl_ReadAny(this, portStart, portCount, data); }
ErrorCode ReadBit(int32 port, int32 bit, uint8* data) { return InstantDiCtrl_ReadBit(this, port, bit, data); }
ErrorCode SnapStart() { return InstantDiCtrl_SnapStart(this); }
ErrorCode SnapStop() { return InstantDiCtrl_SnapStop(this); }
/*Instant DI Property*/
double getNoiseFilterBlockTime() { return InstantDiCtrl_getNoiseFilterBlockTime(this); }
ErrorCode setNoiseFilterBlockTime(double value) { return InstantDiCtrl_setNoiseFilterBlockTime(this, value); }
Array* getNoiseFilter() { return (Array*)InstantDiCtrl_getNoiseFilter(this); }
Array* getDiintChannels() { return (Array*)InstantDiCtrl_getDiintChannels(this);}
Array* getDiCosintPorts() { return (Array*)InstantDiCtrl_getDiCosintPorts(this);}
Array* getDiPmintPorts() { return (Array*)InstantDiCtrl_getDiPmintPorts(this); }
public:
/*Create an InstantDiCtrl. Note: Use 'dispose' to free the object*/
static InstantDiCtrl * Create(void) { return InstantDiCtrl_Create(); }
public: /*helpers*/
ErrorCode Read(int32 port, uint8 & data) { return ReadAny(port, 1, &data); }
ErrorCode Read(int32 portStart, int32 portCount, uint8 data[]) { return ReadAny(portStart, portCount, data); }
/*event*/
void addInterruptHandler(DiSnapEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtDiInterrupt, (DaqEventProc)proc, userParam);}
void removeInterruptHandler(DiSnapEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtDiInterrupt, (DaqEventProc)proc, userParam);}
void addChangeOfStateHandler(DiSnapEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtDiStatusChange, (DaqEventProc)proc, userParam);}
void removeChangeOfStateHandler(DiSnapEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtDiStatusChange, (DaqEventProc)proc, userParam);}
void addPatternMatchHandler(DiSnapEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtDiPatternMatch, (DaqEventProc)proc, userParam);}
void removePatternMatchHandler(DiSnapEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtDiPatternMatch, (DaqEventProc)proc, userParam);}
public: /*For compatible ONLY!*/
void addInterruptListener(DiSnapEventListener & listener) { InstantDiCtrl_addInterruptListener(this, &listener); }
void removeInterruptListener(DiSnapEventListener & listener) { InstantDiCtrl_removeInterruptListener(this, &listener); }
void addChangeOfStateListener(DiSnapEventListener & listener) { InstantDiCtrl_addChangeOfStateListener(this, &listener); }
void removeChangeOfStateListener(DiSnapEventListener & listener) { InstantDiCtrl_removeChangeOfStateListener(this, &listener); }
void addPatternMatchListener(DiSnapEventListener & listener) { InstantDiCtrl_addPatternMatchListener(this, &listener); }
void removePatternMatchListener(DiSnapEventListener & listener) { InstantDiCtrl_removePatternMatchListener(this, &listener); }
private:
DAQCLS_DISABLE_CONSTRUCT(InstantDiCtrl)
};
/* Interface BufferedDiCtrl */
class BufferedDiCtrl : public DioCtrlBase
{
public:
/*Buffered DI Method*/
ErrorCode Prepare() { return BufferedDiCtrl_Prepare(this); }
ErrorCode Start() { return BufferedDiCtrl_Start(this); }
ErrorCode Stop() { return BufferedDiCtrl_Stop(this); }
void Release() { BufferedDiCtrl_Release(this); }
bool GetBufferStatus(int32 *count, int32 *offset) { return !!BufferedDiCtrl_GetBufferStatus(this, count, offset);}
ErrorCode GetData(int32 count, int8 rawData[],
int32 timeout = 0, int32 *returned = NULL, double *startTime = NULL, int32 *markCount = NULL, DataMark *markBuf = NULL)
{
return BufferedDiCtrl_GetData(this, count, rawData, timeout, returned, startTime, markCount, markBuf);
}
/*Buffered DI Property*/
void* getBuffer() { return BufferedDiCtrl_getBuffer(this); }
int32 getBufferCapacity() { return BufferedDiCtrl_getBufferCapacity(this); }
ScanPort* getScanPort() { return BufferedDiCtrl_getScanPort(this); }
ConvertClock* getConvertClock() { return BufferedDiCtrl_getConvertClock(this); }
Trigger* getTrigger() { return BufferedDiCtrl_getTrigger(this); }
Trigger* getTrigger1() { return BufferedDiCtrl_getTrigger1(this); }
public:
/*Create an BufferedDiCtrl. Note: Use 'dispose' to free the object*/
static BufferedDiCtrl * Create(void) { return BufferedDiCtrl_Create(); }
public: /*helpers*/
/*event*/
void addDataReadyHandler(BfdDiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedDiDataReady, (DaqEventProc)proc, userParam);}
void removeDataReadyHandler(BfdDiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedDiDataReady, (DaqEventProc)proc, userParam);}
void addOverrunHandler(BfdDiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedDiOverrun, (DaqEventProc)proc, userParam);}
void removeOverrunHandler(BfdDiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedDiOverrun, (DaqEventProc)proc, userParam);}
void addCacheOverflowHandler(BfdDiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedDiCacheOverflow, (DaqEventProc)proc, userParam);}
void removeCacheOverflowHandler(BfdDiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedDiCacheOverflow, (DaqEventProc)proc, userParam);}
void addStoppedHandler(BfdDiEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedDiStopped, (DaqEventProc)proc, userParam);}
void removeStoppedHandler(BfdDiEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedDiStopped, (DaqEventProc)proc, userParam);}
private:
DAQCLS_DISABLE_CONSTRUCT(BufferedDiCtrl)
};
/* Interface InstantDoCtrl */
class InstantDoCtrl : public DioCtrlBase
{
public:
/*Instant DO Method*/
ErrorCode WriteAny(int32 portStart, int32 portCount, uint8 data[]) { return InstantDoCtrl_WriteAny(this, portStart, portCount, data); }
ErrorCode ReadAny(int32 portStart, int32 portCount, uint8 data[]) { return InstantDoCtrl_ReadAny(this, portStart, portCount, data); }
ErrorCode WriteBit(int32 port, int32 bit, uint8 data) { return InstantDoCtrl_WriteBit(this, port, bit, data); }
ErrorCode ReadBit(int32 port, int32 bit, uint8* data) { return InstantDoCtrl_ReadBit(this, port, bit, data); }
public:
/*Create an InstantDoCtrl. Note: Use 'dispose' to free the object*/
static InstantDoCtrl * Create(void) { return InstantDoCtrl_Create(); }
public: /*helpers*/
ErrorCode Write(int32 port, uint8 data) { return WriteAny(port, 1, &data); }
ErrorCode Write(int32 portStart, int32 portCount, uint8 data[]) { return WriteAny(portStart, portCount, data); }
ErrorCode Read(int32 port, uint8 &data) { return ReadAny(port, 1, &data); }
ErrorCode Read(int32 portStart, int32 portCount, uint8 data[]) { return ReadAny(portStart, portCount, data); }
private:
DAQCLS_DISABLE_CONSTRUCT(InstantDoCtrl)
};
/* Interface BufferedDoCtrl */
class BufferedDoCtrl : public DioCtrlBase
{
public:
/*Buffered DO Method*/
ErrorCode Prepare() { return BufferedDoCtrl_Prepare(this); }
ErrorCode RunOnce() { return BufferedDoCtrl_RunOnce(this); }
ErrorCode Start() { return BufferedDoCtrl_Start(this); }
ErrorCode Stop(int32 action) { return BufferedDoCtrl_Stop(this, action);}
void Release() { BufferedDoCtrl_Release(this); }
bool GetBufferStatus(int32 *count, int32 *offset) { return !!BufferedDoCtrl_GetBufferStatus(this, count, offset);}
ErrorCode SetData(int32 count, int8 rawData[]) { return BufferedDoCtrl_SetData(this, count, rawData); }
/*Buffered DO Property*/
void* getBuffer() { return BufferedDoCtrl_getBuffer(this); }
int32 getBufferCapacity() { return BufferedDoCtrl_getBufferCapacity(this); }
ScanPort* getScanPort() { return BufferedDoCtrl_getScanPort(this); }
ConvertClock* getConvertClock() { return BufferedDoCtrl_getConvertClock(this); }
Trigger* getTrigger() { return BufferedDoCtrl_getTrigger(this); }
Trigger* getTrigger1() { return BufferedDoCtrl_getTrigger1(this); }
public:
/*Create an BufferedDoCtrl. Note: Use 'dispose' to free the object*/
static BufferedDoCtrl * Create(void) { return BufferedDoCtrl_Create(); }
public: /*helpers*/
/*event*/
void addDataTransmittedHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedDoDataTransmitted, (DaqEventProc)proc, userParam); }
void removeDataTransmittedHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedDoDataTransmitted, (DaqEventProc)proc, userParam); }
void addUnderrunHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedDoUnderrun, (DaqEventProc)proc, userParam); }
void removeUnderrunHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedDoUnderrun, (DaqEventProc)proc, userParam); }
void addCacheEmptiedHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedDoCacheEmptied, (DaqEventProc)proc, userParam); }
void removeCacheEmptiedHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedDoCacheEmptied, (DaqEventProc)proc, userParam); }
void addTransitStoppedHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedDoTransStopped, (DaqEventProc)proc, userParam); }
void removeTransitStoppedHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedDoTransStopped, (DaqEventProc)proc, userParam); }
void addStoppedHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtBufferedDoStopped, (DaqEventProc)proc, userParam); }
void removeStoppedHandler(BfdDoEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtBufferedDoStopped, (DaqEventProc)proc, userParam); }
private:
DAQCLS_DISABLE_CONSTRUCT(BufferedDoCtrl)
};
/* ----------------------------------------------------------*/
/*Counter related classes */
/* ----------------------------------------------------------*/
template
class CounterIndexer
{
public:
void Dispose() { CounterIndexer_Dispose((ICounterIndexer*)this); } /*destroy the instance*/
int32 getLength() { return CounterIndexer_getLength((ICounterIndexer*)this); }
Array* getItem(int32 channel) { return (Array*)CounterIndexer_getItem((ICounterIndexer*)this, channel); }
public: /*for compatible*/
int32 getCount() { return getLength(); }
private:
DAQCLS_DISABLE_CONSTRUCT(CounterIndexer)
};
typedef CounterIndexer CounterCapabilityIndexer;
typedef CounterIndexer CounterClockSourceIndexer;
typedef CounterIndexer CounterGateSourceIndexer;
typedef CounterIndexer CounterTriggerSourceIndexer;
class CntrFeatures
{
public:
/*channel features*/
int32 getChannelCountMax() { return CntrFeatures_getChannelCountMax(this); }
int32 getResolution() { return CntrFeatures_getResolution(this); }
int32 getDataSize() { return CntrFeatures_getDataSize(this); }
CounterCapabilityIndexer* getCapabilities() { return (CounterCapabilityIndexer*)CntrFeatures_getCapabilities(this);}
/*noise filter features*/
bool getNoiseFilterSupported() { return !!CntrFeatures_getNoiseFilterSupported(this); }
Array* getNoiseFilterOfChannels() { return (Array*)CntrFeatures_getNoiseFilterOfChannels(this);}
void getNoiseFilterBlockTimeRange(MathInterval &x) { CntrFeatures_getNoiseFilterBlockTimeRange(this, &x); }
/*new*/
void getMeasurementTimeoutRange(MathInterval &x) { CntrFeatures_getMeasurementTimeoutRange(this, &x); }
/*event counting features*/
CounterClockSourceIndexer* getEcClockSources() { return (CounterClockSourceIndexer*)CntrFeatures_getEcClockSources(this);}
Array* getEcClockPolarities() { return (Array*)CntrFeatures_getEcClockPolarities(this); }
Array* getEcGatePolarities() { return (Array*)CntrFeatures_getEcGatePolarities(this); }
Array* getEcGateControlOfChannels() { return (Array*)CntrFeatures_getEcGateControlOfChannels(this); }
/*frequency measurement features*/
Array* getFmMethods() { return (Array*)CntrFeatures_getFmMethods(this); }
/*one-shot features*/
CounterClockSourceIndexer* getOsClockSources() { return (CounterClockSourceIndexer*)CntrFeatures_getOsClockSources(this);}
Array* getOsClockPolarities() { return (Array*)CntrFeatures_getOsClockPolarities(this); }
CounterGateSourceIndexer* getOsGateSources() { return (CounterGateSourceIndexer*)CntrFeatures_getOsGateSources(this); }
Array* getOsGatePolarities() { return (Array*)CntrFeatures_getOsGatePolarities(this); }
Array* getOsOutSignals() { return (Array*)CntrFeatures_getOsOutSignals(this); }
void getOsDelayCountRange(MathInterval &x) { CntrFeatures_getOsDelayCountRange(this, &x); }
/*timer/pulse features*/
Array* getTmrGateControlOfChannels() { return (Array*)CntrFeatures_getTmrGateControlOfChannels(this); }
Array* getTmrGatePolarities() { return (Array*)CntrFeatures_getTmrGatePolarities(this);}
Array* getTmrOutSignals() { return (Array*)CntrFeatures_getTmrOutSignals(this); }
void getTmrFrequencyRange(MathInterval &x) { CntrFeatures_getTmrFrequencyRange(this, &x); }
/*pulse width measurement features*/
Array* getPiCascadeGroup() { return (Array*)CntrFeatures_getPiCascadeGroup(this);}
/*pulse width modulation features*/
Array* getPoGateControlOfChannels() { return (Array*)CntrFeatures_getPoGateControlOfChannels(this); }
Array* getPoGatePolarities() { return (Array*)CntrFeatures_getPoGatePolarities(this);}
Array* getPoOutSignals() { return (Array*)CntrFeatures_getPoOutSignals(this); }
void getPoHiPeriodRange(MathInterval &x) { CntrFeatures_getPoHiPeriodRange(this, &x); }
void getPoLoPeriodRange(MathInterval &x) { CntrFeatures_getPoLoPeriodRange(this, &x); }
void getPoOutCountRange(MathInterval &x) { CntrFeatures_getPoOutCountRange(this, &x); }
/* new trigger features for pulse width modulation*/
int32 getPoTriggerCount() { return CntrFeatures_getPoTriggerCount(this); }
CounterTriggerSourceIndexer* getPoTriggerSources() { return (CounterTriggerSourceIndexer*)CntrFeatures_getPoTriggerSources(this); }
Array* getPoTriggerActions() { return (Array*)CntrFeatures_getPoTriggerActions(this); }
void getPoTriggerDelayRange(MathInterval &x) { CntrFeatures_getPoTriggerDelayRange(this, &x); }
/*up-down counter features*/
Array* getUdCountingTypes() { return (Array*)CntrFeatures_getUdCountingTypes(this); }
Array* getUdInitialValues() { return (Array*)CntrFeatures_getUdInitialValues(this); }
Array* getUdSnapEventSources() { return (Array*)CntrFeatures_getUdSnapEventSources(this); }
void getUdValueResetTimes(MathInterval &x) { CntrFeatures_getUdValueResetTimes(this, &x); }
// new features for Counter continue comparing: outputting pulse settings
Array* getCcpGateControlOfChannels() { return (Array*)CntrFeatures_getCcpGateControlOfChannels(this); }
Array* getCcpGatePolarities() { return (Array*)CntrFeatures_getCcpGatePolarities(this);}
Array* getCcpOutSignals() { return (Array*)CntrFeatures_getCcpOutSignals(this); }
void getCcpHiPeriodRange(MathInterval &x) { CntrFeatures_getCcpHiPeriodRange(this, &x); }
void getCcpLoPeriodRange(MathInterval &x) { CntrFeatures_getCcpLoPeriodRange(this, &x); }
void getCcpOutCountRange(MathInterval &x) { CntrFeatures_getCcpOutCountRange(this, &x); }
bool getCcpDataCtrlCodeSupported() { return !!CntrFeatures_getCcpDataCtrlCodeSupported(this); }
/*new buffered counter*/
int32 getTriggerCount() { return CntrFeatures_getTriggerCount(this); }
Array* getTriggerSources() { return (Array*)CntrFeatures_getTriggerSources(this); }
Array* getTriggerActions() { return (Array*)CntrFeatures_getTriggerActions(this); }
CounterClockSourceIndexer* getEcSampleClockSources() { return (CounterClockSourceIndexer*)CntrFeatures_getEcSampleClockSources(this); }
CounterClockSourceIndexer* getPiSampleClockSources() { return (CounterClockSourceIndexer*)CntrFeatures_getPiSampleClockSources(this); }
CounterClockSourceIndexer* getPoSampleClockSources() { return (CounterClockSourceIndexer*)CntrFeatures_getPoSampleClockSources(this); }
CounterClockSourceIndexer* getUdSampleClockSources() { return (CounterClockSourceIndexer*)CntrFeatures_getUdSampleClockSources(this); }
/*absolute counter features*/
Array* getAbsCodingTypes() { return (Array*)CntrFeatures_getAbsCodingTypes(this); }
Array* getAbsBaudrates() { return (Array*)CntrFeatures_getAbsBaudrates(this); }
Array* getAbsErrorRetTypes() { return (Array*)CntrFeatures_getAbsErrorRetTypes(this); }
Array* getAbsOutSignals() { return (Array*)CntrFeatures_getAbsOutSignals(this); }
Array* getAbsLatchSignalEdges() { return (Array*)CntrFeatures_getAbsLatchSignalEdges(this); }
public: /*for compatible*/
MathInterval getNoiseFilterBlockTimeRange()
{
MathInterval x;
getNoiseFilterBlockTimeRange(x);
return x;
}
MathInterval getDelayCountRange()
{
MathInterval x;
getOsDelayCountRange(x);
return x;
}
MathInterval getTimerFrequencyRange()
{
MathInterval x;
getTmrFrequencyRange(x);
return x;
}
Array* getPwmCascadeGroup()
{
return getPiCascadeGroup();
}
MathInterval getHiPeriodRange()
{
MathInterval x;
getPoHiPeriodRange(x);
return x;
}
MathInterval getLoPeriodRange()
{
MathInterval x;
getPoLoPeriodRange(x);
return x;
}
Array* getCountingTypes()
{
return getUdCountingTypes();
}
Array* getInitialValues()
{
return getUdInitialValues();
}
Array* getSnapEventSources()
{
return (Array*)getUdSnapEventSources();
}
bool getOneShotEventSupported()
{
return false;
}
bool getTimerEventSupported()
{
return false;
}
bool getOverflowEventSupported()
{
return false;
}
private:
DAQCLS_DISABLE_CONSTRUCT(CntrFeatures)
};
/*for compatible*/
typedef CntrFeatures EventCounterFeatures ;
typedef CntrFeatures FreqMeterFeatures;
typedef CntrFeatures OneShotFeatures;
typedef CntrFeatures TimerPulseFeatures;
typedef CntrFeatures PwMeterFeatures;
typedef CntrFeatures PwModulatorFeatures;
typedef CntrFeatures UdCounterFeatures;
/* Interface CntrCtrlBase */
class CntrCtrlBase : public DaqCtrlBase
{
public:
/*Counter Control Common Property*/
CntrFeatures* getFeatures() { return DAQFN_TV(DNLAPI_CNTR, 34, CntrFeatures *)(this); }
int32 getChannelStart() { return DAQFN_TV(DNLAPI_CNTR, 35, int32)(this); }
ErrorCode setChannelStart(int32 value) { return DAQFN_ET(DNLAPI_CNTR, 36, int32)(this, value); }
int32 getChannelCount() { return DAQFN_TV(DNLAPI_CNTR, 37, int32)(this); }
ErrorCode setChannelCount(int32 value) { return DAQFN_ET(DNLAPI_CNTR, 38, int32)(this, value); }
bool getEnabled() { return DAQFN_TV(DNLAPI_CNTR, 39, bool)(this); }
ErrorCode setEnabled(bool enabled) { return DAQFN_ET(DNLAPI_CNTR, 40, bool)(this, enabled); }
bool getRunning() { return DAQFN_TV(DNLAPI_CNTR, 41, bool)(this); }
//
double getNoiseFilterBlockTime() { return DAQFN_TV(DNLAPI_CNTR, 42, double)(this); }
ErrorCode setNoiseFilterBlockTime(double value) { return DAQFN_ET(DNLAPI_CNTR, 43, double)(this, value); }
//
double getMeasurementTimeout() { return DAQFN_TV(DNLAPI_CNTR, 130, double)(this); }
ErrorCode setMeasurementTimeout(double value) { return DAQFN_ET(DNLAPI_CNTR, 131, double)(this, value); }
public: /*for compatible*/
int32 getChannel() { return getChannelStart(); }
ErrorCode setChannel(int32 ch) { setChannelCount(1); return setChannelStart(ch); }
NosFltChannel* getNoiseFilter() { return DAQFN_TV(DNLAPI_CNTR, 44, NosFltChannel *)(this); }
private:
DAQCLS_DISABLE_CONSTRUCT(CntrCtrlBase)
};
/* Interface EcChannel */
class EcChannel
{
public:
/*Common Property*/
int32 getChannel() { return EcChannel_getChannel(this); }
bool getNoiseFiltered() { return !!EcChannel_getNoiseFiltered(this); }
ErrorCode setNoiseFiltered(bool value) { return EcChannel_setNoiseFiltered(this, value); }
/*Event counting Property*/
SignalDrop getClockSource() { return EcChannel_getClockSource(this); }
ErrorCode setClockSource(SignalDrop value) { return EcChannel_setClockSource(this, value); }
SignalPolarity getClockPolarity() { return EcChannel_getClockPolarity(this); }
ErrorCode setClockPolarity(SignalPolarity value) { return EcChannel_setClockPolarity(this, value); }
SignalPolarity getGatePolarity() { return EcChannel_getGatePolarity(this); }
ErrorCode setGatePolarity(SignalPolarity value) { return EcChannel_setGatePolarity(this, value); }
bool getGated() { return !!EcChannel_getGated(this); }
ErrorCode setGated(bool value) { return EcChannel_setGated(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(EcChannel)
};
/* Interface EventCounterCtrl */
class EventCounterCtrl : public CntrCtrlBase
{
public:
/*Event Counter Method*/
ErrorCode Read(int32 &data) { return EventCounterCtrl_Read(this, 1, &data); }
ErrorCode Read(int32 count, int32 *data) { return EventCounterCtrl_Read(this, count, data); }
/*Event Counter Property*/
Array* getChannels() { return (Array*)EventCounterCtrl_getChannels(this); }
/*Create an EventCounterCtrl. Note: Use 'dispose' to free the object*/
static EventCounterCtrl * Create(void) { return EventCounterCtrl_Create(); }
public: /*for compatible*/
int32 getValue() { return EventCounterCtrl_getValue(this); }
private:
DAQCLS_DISABLE_CONSTRUCT(EventCounterCtrl)
};
/* Interface BufferedEventCounterCtrl */
class BufferedEventCounterCtrl : public CntrCtrlBase
{
public:
/*Buffered Event Counter Method*/
ErrorCode GetData(int32 cntr, int32 count, int32 data[], int32 timeout = 0, int32 *returned = NULL, double *startTime = NULL)
{
return BufferedEventCounterCtrl_GetDataI32(this, cntr, count, data, timeout, returned, startTime);
}
int32 getBufferCapacity() { return BufferedEventCounterCtrl_getBufferCapacity(this); }
Trigger* getTrigger() { return BufferedEventCounterCtrl_getTrigger(this); }
Record* getRecord() { return BufferedEventCounterCtrl_getRecord(this); }
ErrorCode setSampleClkSrc(SignalDrop drop) { return BufferedEventCounterCtrl_setSampleClkSrc(this, drop); }
SignalDrop getSampleClkSrc() { return BufferedEventCounterCtrl_getSampleClkSrc(this); }
void getChannelMap(int32 count, int8 *chMap) { BufferedEventCounterCtrl_getChannelMap(this, count, chMap);}
ErrorCode setChannelMap(int32 count, int8 *chMap) { return BufferedEventCounterCtrl_setChannelMap(this, count, chMap);}
ErrorCode Prepare() { return BufferedEventCounterCtrl_Prepare(this); }
void Release() { BufferedEventCounterCtrl_Release(this); }
bool GetBufferStatus(int32 ch, int32 *count, int32 *offset) { return !!BufferedEventCounterCtrl_getBufferStatus(this, ch, count, offset);}
/*Event Counter Property*/
Array* getChannels() { return (Array*)BufferedEventCounterCtrl_getChannels(this); }
/*Create an BufferedEventCounterCtrl. Note: Use 'dispose' to free the object*/
static BufferedEventCounterCtrl * Create(void) { return BufferedEventCounterCtrl_Create(); }
public: /*helpers*/
/*event*/
void addDataReadyHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCiDataReady, (DaqEventProc)proc, userParam);}
void removeDataReadyHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCiDataReady, (DaqEventProc)proc, userParam);}
void addOverrunHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCiOverrun, (DaqEventProc)proc, userParam);}
void removeOverrunHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCiOverrun, (DaqEventProc)proc, userParam);}
void addCacheOverflowHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
void removeCacheOverflowHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
void addStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCntrStopped, (DaqEventProc)proc, userParam);}
void removeStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCntrStopped, (DaqEventProc)proc, userParam);}
private:
DAQCLS_DISABLE_CONSTRUCT(BufferedEventCounterCtrl)
};
/* Interface FmChannel */
class FmChannel
{
public:
/*Common Property*/
int32 getChannel() { return FmChannel_getChannel(this); }
bool getNoiseFiltered() { return !!FmChannel_getNoiseFiltered(this); }
ErrorCode setNoiseFiltered(bool value) { return FmChannel_setNoiseFiltered(this, value); }
/*Frequency measurement Property*/
FreqMeasureMethod getFmMethod() { return FmChannel_getFmMethod(this); }
ErrorCode setFmMethod(FreqMeasureMethod value) { return FmChannel_setFmMethod(this, value); }
double getCollectionPeriod() { return FmChannel_getCollectionPeriod(this); }
ErrorCode setCollectionPeriod(double value) { return FmChannel_setCollectionPeriod(this, value); }
double getTimeup() { return FmChannel_getTimeup(this); }
ErrorCode setTimeup(double value) { return FmChannel_setTimeup(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(FmChannel)
};
/* Interface FreqMeterCtrl */
class FreqMeterCtrl : public CntrCtrlBase
{
public:
/*Frequency Meter Method*/
ErrorCode Read(double &data) { return FreqMeterCtrl_Read(this, 1, &data); }
ErrorCode Read(int32 count, double *data) { return FreqMeterCtrl_Read(this, count, data); }
/*Frequency Meter Property*/
Array* getChannels() { return (Array*)FreqMeterCtrl_getChannels(this); }
/*Create an FreqMeterCtrl. Note: Use 'dispose' to free the object*/
static FreqMeterCtrl * Create(void) { return FreqMeterCtrl_Create(); }
public: /*for compatible*/
double getValue() { return FreqMeterCtrl_getValue(this); }
FreqMeasureMethod getMethod() { return FreqMeterCtrl_getMethod(this); }
ErrorCode setMethod(FreqMeasureMethod value) { return FreqMeterCtrl_setMethod(this, value); }
double getCollectionPeriod() { return FreqMeterCtrl_getCollectionPeriod(this); }
ErrorCode setCollectionPeriod(double value) { return FreqMeterCtrl_setCollectionPeriod(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(FreqMeterCtrl)
};
/* Interface OsChannel */
class OsChannel
{
public:
/*Common*/
int32 getChannel() { return OsChannel_getChannel(this); }
bool getNoiseFiltered() { return !!OsChannel_getNoiseFiltered(this); }
ErrorCode setNoiseFiltered(bool value) { return OsChannel_setNoiseFiltered(this, value); }
/*One-shot Property*/
int32 getDelayCount() { return OsChannel_getDelayCount(this); }
ErrorCode setDelayCount(int32 value) { return OsChannel_setDelayCount(this, value); }
SignalDrop getClockSource() { return OsChannel_getClockSource(this); }
ErrorCode setClockSource(SignalDrop value) { return OsChannel_setClockSource(this, value); }
SignalPolarity getClockPolarity() { return OsChannel_getClockPolarity(this); }
ErrorCode setClockPolarity(SignalPolarity value) { return OsChannel_setClockPolarity(this, value); }
SignalDrop getGateSource() { return OsChannel_getGateSource(this); }
ErrorCode setGateSource(SignalDrop value) { return OsChannel_setGateSource(this, value); }
SignalPolarity getGatePolarity() { return OsChannel_getGatePolarity(this); }
ErrorCode setGatePolarity(SignalPolarity value) { return OsChannel_setGatePolarity(this, value); }
OutSignalType getOutSignal() { return OsChannel_getOutSignal(this); }
ErrorCode setOutSignal(OutSignalType value) { return OsChannel_setOutSignal(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(OsChannel)
};
/* Interface OneShotCtrl */
class OneShotCtrl : public CntrCtrlBase
{
public:
/*One-shot Property*/
Array* getChannels() { return (Array*)OneShotCtrl_getChannels(this); }
/*Create an OneShotCtrl. Note: Use 'dispose' to free the object*/
static OneShotCtrl * Create(void) { return OneShotCtrl_Create(); }
public: /*helpers*/
/*event*/
void addOneShotHandler(CntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCntOneShot0, (DaqEventProc)proc, userParam);}
void removeOneShotHandler(CntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCntOneShot0, (DaqEventProc)proc, userParam);}
/*for compatible*/
int32 getDelayCount() { return OneShotCtrl_getDelayCount(this); }
ErrorCode setDelayCount(int32 value) { return OneShotCtrl_setDelayCount(this, value); }
public: /*For compatible ONLY!*/
void addOneShotListener(CntrEventListener & listener) { OneShotCtrl_addOneShotListener(this, &listener); }
void removeOneShotListener(CntrEventListener & listener) { OneShotCtrl_removeOneShotListener(this, &listener); }
private:
DAQCLS_DISABLE_CONSTRUCT(OneShotCtrl)
};
/* Interface TmrChannel */
class TmrChannel
{
public:
/*Common*/
int32 getChannel() { return TmrChannel_getChannel(this); }
bool getNoiseFiltered() { return !!TmrChannel_getNoiseFiltered(this); }
ErrorCode setNoiseFiltered(bool value) { return TmrChannel_setNoiseFiltered(this, value); }
/*Timer/Pulse Property*/
double getFrequency() { return TmrChannel_getFrequency(this); }
ErrorCode setFrequency(double value) { return TmrChannel_setFrequency(this, value); }
bool getGated() { return !!TmrChannel_getGated(this); }
ErrorCode setGated(bool value) { return TmrChannel_setGated(this, value); }
SignalPolarity getGatePolarity() { return TmrChannel_getGatePolarity(this); }
ErrorCode setGatePolarity(SignalPolarity value) { return TmrChannel_setGatePolarity(this, value); }
OutSignalType getOutSignal() { return TmrChannel_getOutSignal(this); }
ErrorCode setOutSignal(OutSignalType value) { return TmrChannel_setOutSignal(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(TmrChannel)
};
/* Interface TimerPulseCtrl */
class TimerPulseCtrl : public CntrCtrlBase
{
public:
/*Timer/Pulse Property*/
Array* getChannels() { return (Array*)TimerPulseCtrl_getChannels(this); }
/*Create an TimerPulseCtrl. Note: Use 'dispose' to free the object*/
static TimerPulseCtrl * Create(void) { return TimerPulseCtrl_Create(); }
public: /*helpers*/
/*event*/
void addTimerTickHandler(CntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCntTimer0, (DaqEventProc)proc, userParam); }
void removeTimerTickHandler(CntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCntTimer0, (DaqEventProc)proc, userParam); }
/*for compatible*/
double getFrequency() { return TimerPulseCtrl_getFrequency(this); }
ErrorCode setFrequency(double value) { return TimerPulseCtrl_setFrequency(this, value); }
public: /*For compatible ONLY!*/
void addTimerTickListener(CntrEventListener & listener) { TimerPulseCtrl_addTimerTickListener(this, &listener); }
void removeTimerTickListener(CntrEventListener & listener) { TimerPulseCtrl_removeTimerTickListener(this, &listener); }
private:
DAQCLS_DISABLE_CONSTRUCT(TimerPulseCtrl)
};
/* Interface PiChannel */
class PiChannel
{
public:
/*Common*/
int32 getChannel() { return PiChannel_getChannel(this); }
bool getNoiseFiltered() { return !!PiChannel_getNoiseFiltered(this); }
ErrorCode setNoiseFiltered(bool value) { return PiChannel_setNoiseFiltered(this, value); }
double getTimeup() { return PiChannel_getTimeup(this); }
ErrorCode setTimeup(double value) { return PiChannel_setTimeup(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(PiChannel)
};
/* Interface PwMeterCtrl */
class PwMeterCtrl : public CntrCtrlBase
{
public:
/*Pulse Width Measurement Method*/
ErrorCode Read(PulseWidth &data) { return PwMeterCtrl_Read(this, 1, &data); }
ErrorCode Read(int32 count, PulseWidth *data) { return PwMeterCtrl_Read(this, count, data); }
/*Pulse Width Measurement Property*/
Array* getChannels() { return (Array*)PwMeterCtrl_getChannels(this); }
/*Create an PwMeterCtrl. Note: Use 'dispose' to free the object*/
static PwMeterCtrl * Create(void) { return PwMeterCtrl_Create(); }
public: /*helpers*/
/*event*/
void addOverflowHandler(CntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCntPwmInOverflow0, (DaqEventProc)proc, userParam);}
void removeOverflowHandler(CntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCntPwmInOverflow0, (DaqEventProc)proc, userParam);}
/*for compatible*/
void getValue(PulseWidth &width) { Read(1, &width); }
public: /*For compatible ONLY!*/
void addOverflowListener(CntrEventListener & listener) { PwMeterCtrl_addOverflowListener(this, &listener); }
void removeOverflowListener(CntrEventListener & listener) { PwMeterCtrl_removeOverflowListener(this, &listener); }
private:
DAQCLS_DISABLE_CONSTRUCT(PwMeterCtrl)
};
/* Interface BufferedPwMeterCtrl */
class BufferedPwMeterCtrl : public CntrCtrlBase
{
public:
/*Buffered Pulse Width Measurement Method*/
ErrorCode GetData(int32 cntr, int32 count, PulseWidth *data, int32 timeout = 0, int32 *returned = NULL, double *startTime = NULL)
{
return BufferedPwMeterCtrl_GetData(this, cntr, count, data, timeout, returned, startTime);
}
int32 getBufferCapacity() { return BufferedPwMeterCtrl_getBufferCapacity(this); }
Trigger* getTrigger() { return BufferedPwMeterCtrl_getTrigger(this); }
Record* getRecord() { return BufferedPwMeterCtrl_getRecord(this); }
ErrorCode setSampleClkSrc(SignalDrop drop) { return BufferedPwMeterCtrl_setSampleClkSrc(this, drop); }
SignalDrop getSampleClkSrc() { return BufferedPwMeterCtrl_getSampleClkSrc(this); }
void getChannelMap(int32 count, int8 *chMap) { BufferedPwMeterCtrl_getChannelMap(this, count, chMap);}
ErrorCode setChannelMap(int32 count, int8 *chMap) { return BufferedPwMeterCtrl_setChannelMap(this, count, chMap);}
ErrorCode Prepare() { return BufferedPwMeterCtrl_Prepare(this); }
void Release() { BufferedPwMeterCtrl_Release(this); }
bool GetBufferStatus(int32 ch, int32 *count, int32 *offset) { return !!BufferedPwMeterCtrl_getBufferStatus(this, ch, count, offset);}
/*Pulse Width Measurement Property*/
Array* getChannels() { return (Array*)BufferedPwMeterCtrl_getChannels(this); }
/*Create an BufferedPwMeterCtrl. Note: Use 'dispose' to free the object*/
static BufferedPwMeterCtrl * Create(void) { return BufferedPwMeterCtrl_Create(); }
public: /*helpers*/
/*event*/
void addDataReadyHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCiDataReady, (DaqEventProc)proc, userParam);}
void removeDataReadyHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCiDataReady, (DaqEventProc)proc, userParam);}
void addOverrunHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCiOverrun, (DaqEventProc)proc, userParam);}
void removeOverrunHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCiOverrun, (DaqEventProc)proc, userParam);}
void addCacheOverflowHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
void removeCacheOverflowHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
void addStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCntrStopped, (DaqEventProc)proc, userParam);}
void removeStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCntrStopped, (DaqEventProc)proc, userParam);}
private:
DAQCLS_DISABLE_CONSTRUCT(BufferedPwMeterCtrl)
};
/* Interface PoChannel */
class PoChannel
{
public:
/*Common*/
int32 getChannel() { return PoChannel_getChannel(this); }
bool getNoiseFiltered() { return !!PoChannel_getNoiseFiltered(this); }
ErrorCode setNoiseFiltered(bool value) { return PoChannel_setNoiseFiltered(this, value); }
/*Pulse Width Modulation Property*/
void getPulseWidth(PulseWidth &width) { PoChannel_getPulseWidth(this, &width); }
ErrorCode setPulseWidth(PulseWidth const &width) { return PoChannel_setPulseWidth(this, &width); }
bool getGated() { return !!PoChannel_getGated(this); }
ErrorCode setGated(bool value) { return PoChannel_setGated(this, value); }
SignalPolarity getGatePolarity() { return PoChannel_getGatePolarity(this); }
ErrorCode setGatePolarity(SignalPolarity value) { return PoChannel_setGatePolarity(this, value); }
OutSignalType getOutSignal() { return PoChannel_getOutSignal(this); }
ErrorCode setOutSignal(OutSignalType value) { return PoChannel_setOutSignal(this, value); }
int32 getOutCount() { return PoChannel_getOutCount(this); }
ErrorCode setOutCount(int32 count) { return PoChannel_setOutCount(this, count); }
/*new: trigger settings*/
SignalDrop getTriggerSource() { return PoChannel_getTriggerSource(this); }
ErrorCode setTriggerSource(SignalDrop value) { return PoChannel_setTriggerSource(this, value);}
ActiveSignal getTriggerEdge() { return PoChannel_getTriggerEdge(this); }
ErrorCode setTriggerEdge(ActiveSignal value) { return PoChannel_setTriggerEdge(this, value); }
TriggerAction getTriggerAction() { return PoChannel_getTriggerAction(this); }
ErrorCode setTriggerAction(TriggerAction value) { return PoChannel_setTriggerAction(this, value);}
double getTriggerDelayCount() { return PoChannel_getTriggerDelayCount(this); }
ErrorCode setTriggerDelayCount(double value) { return PoChannel_setTriggerDelayCount(this, value);}
private:
DAQCLS_DISABLE_CONSTRUCT(PoChannel)
};
/* Interface PwModulatorCtrl */
class PwModulatorCtrl : public CntrCtrlBase
{
public:
/*Pulse Width Modulation Property*/
Array* getChannels() { return (Array*)PwModulatorCtrl_getChannels(this); }
/*Create an PwModulatorCtrl. Note: Use 'dispose' to free the object*/
static PwModulatorCtrl * Create(void) { return PwModulatorCtrl_Create(); }
public:
/*for compatible*/
void getPulseWidth(PulseWidth &width) { PwModulatorCtrl_getPulseWidth(this, &width); }
ErrorCode setPulseWidth(PulseWidth const &width) { return PwModulatorCtrl_setPulseWidth(this, &width); }
private:
DAQCLS_DISABLE_CONSTRUCT(PwModulatorCtrl)
};
/* Interface BufferedPwModulatorCtrl */
class BufferedPwModulatorCtrl : public CntrCtrlBase
{
public:
/*Buffered Event Counter Method*/
ErrorCode SetData(int32 cntr, int32 count, PulseWidth *data)
{
return BufferedPwModulatorCtrl_SetData(this, cntr, count, data);
}
int32 getBufferCapacity() { return BufferedPwModulatorCtrl_getBufferCapacity(this); }
Trigger* getTrigger() { return BufferedPwModulatorCtrl_getTrigger(this); }
int32 getSamples() { return BufferedPwModulatorCtrl_getSamples(this); }
ErrorCode setSamples(int32 value) { return BufferedPwModulatorCtrl_setSamples(this, value); }
int32 getIntervalCount() { return BufferedPwModulatorCtrl_getIntervalCount(this); }
ErrorCode setIntervalCount(int32 value) { return BufferedPwModulatorCtrl_setIntervalCount(this, value); }
bool getStreaming() { return !!BufferedPwModulatorCtrl_getStreaming(this); }
ErrorCode setStreaming(bool value) { return BufferedPwModulatorCtrl_setStreaming(this, value); }
ErrorCode setSampleClkSrc(SignalDrop drop) { return BufferedPwModulatorCtrl_setSampleClkSrc(this, drop); }
SignalDrop getSampleClkSrc() { return BufferedPwModulatorCtrl_getSampleClkSrc(this); }
void getChannelMap(int32 count, int8 *chMap) { BufferedPwModulatorCtrl_getChannelMap(this, count, chMap);}
ErrorCode setChannelMap(int32 count, int8 *chMap) { return BufferedPwModulatorCtrl_setChannelMap(this, count, chMap);}
ErrorCode Prepare() { return BufferedPwModulatorCtrl_Prepare(this); }
void Release() { BufferedPwModulatorCtrl_Release(this); }
bool GetBufferStatus(int32 ch, int32 *count, int32 *offset) { return !!BufferedPwModulatorCtrl_getBufferStatus(this, ch, count, offset);}
/*Pulse Width Modulation Property*/
Array* getChannels() { return (Array*)BufferedPwModulatorCtrl_getChannels(this); }
/*Create an BufferedPwModulatorCtrl. Note: Use 'dispose' to free the object*/
static BufferedPwModulatorCtrl * Create(void) { return BufferedPwModulatorCtrl_Create(); }
public: /*helpers*/
/*event*/
void addDataTransmittedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCoDataTransmitted, (DaqEventProc)proc, userParam); }
void removeDataTransmittedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCoDataTransmitted, (DaqEventProc)proc, userParam); }
void addUnderrunHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCoUnderrun, (DaqEventProc)proc, userParam); }
void removeUnderrunHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCoUnderrun, (DaqEventProc)proc, userParam); }
void addCacheEmptiedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCoCacheEmptied, (DaqEventProc)proc, userParam); }
void removeCacheEmptiedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCoCacheEmptied, (DaqEventProc)proc, userParam); }
void addTransitStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCoTransStopped, (DaqEventProc)proc, userParam); }
void removeTransitStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCoTransStopped, (DaqEventProc)proc, userParam); }
void addStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCntrStopped, (DaqEventProc)proc, userParam); }
void removeStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCntrStopped, (DaqEventProc)proc, userParam); }
private:
DAQCLS_DISABLE_CONSTRUCT(BufferedPwModulatorCtrl)
};
/* Interface UdChannel */
class UdChannel
{
public:
/*Common*/
int32 getChannel() { return UdChannel_getChannel(this); }
bool getNoiseFiltered() { return !!UdChannel_getNoiseFiltered(this); }
ErrorCode setNoiseFiltered(bool value) { return UdChannel_setNoiseFiltered(this, value); }
/*Up-down Counter Property*/
CountingType getCountingType() { return UdChannel_getCountingType(this); }
ErrorCode setCountingType(CountingType value) { return UdChannel_setCountingType(this, value); }
int32 getInitialValue() { return UdChannel_getInitialValue(this); }
ErrorCode setInitialValue(int32 value) { return UdChannel_setInitialValue(this, value); }
int32 getResetTimesByIndex() { return UdChannel_getResetTimesByIndex(this); }
ErrorCode setResetTimesByIndex(int32 value) { return UdChannel_setResetTimesByIndex(this, value); }
// new properties for Counter continue comparing: outputting pulse settings
void getPulseWidth(PulseWidth &width) { UdChannel_getPulseWidth(this, &width); }
ErrorCode setPulseWidth(PulseWidth const &width) { return UdChannel_setPulseWidth(this, &width); }
bool getGated() { return !!UdChannel_getGated(this); }
ErrorCode setGated(bool value) { return UdChannel_setGated(this, value); }
SignalPolarity getGatePolarity() { return UdChannel_getGatePolarity(this); }
ErrorCode setGatePolarity(SignalPolarity value) { return UdChannel_setGatePolarity(this, value); }
OutSignalType getOutSignal() { return UdChannel_getOutSignal(this); }
ErrorCode setOutSignal(OutSignalType value) { return UdChannel_setOutSignal(this, value); }
int32 getOutCount() { return UdChannel_getOutCount(this); }
ErrorCode setOutCount(int32 count) { return UdChannel_setOutCount(this, count); }
private:
DAQCLS_DISABLE_CONSTRUCT(UdChannel)
};
/* Interface UdCounterCtrl */
class UdCounterCtrl : public CntrCtrlBase
{
public:
/*Up-down Counter Method*/
ErrorCode SnapStart(EventId srcId) { return UdCounterCtrl_SnapStart(this, srcId); }
ErrorCode SnapStop(EventId srcId) { return UdCounterCtrl_SnapStop(this, srcId); }
ErrorCode CompareAppendTable(int32 channel, int32 count, int32 *table) { return UdCounterCtrl_CompareAppendTable(this, channel, count, table); }
ErrorCode CompareSetTable(int32 channel, int32 count, int32 *table) { return UdCounterCtrl_CompareSetTable(this, channel, count, table); }
ErrorCode CompareAppendInterval(int32 channel, int32 start, int32 increment,int32 count) { return UdCounterCtrl_CompareAppendInterval(this, channel, start, increment, count); }
ErrorCode CompareSetInterval(int32 channel, int32 start, int32 increment,int32 count) { return UdCounterCtrl_CompareSetInterval(this, channel, start, increment, count); }
ErrorCode CompareClear(int32 channel) { return UdCounterCtrl_CompareClear(this, channel); }
ErrorCode ValueReset() { return UdCounterCtrl_ValueReset(this); }
ErrorCode Read(int32 &data) { return UdCounterCtrl_Read(this, 1, &data); }
ErrorCode Read(int32 count, int32 *data) { return UdCounterCtrl_Read(this, count, data); }
/*Up-down Counter Property*/
Array* getChannels() { return (Array*)UdCounterCtrl_getChannels(this); }
bool getCcpDatCtrlCodeEnabled() { return !!UdCounterCtrl_getCcpDatCtrlCodeEnabled(this); }
ErrorCode setCcpDatCtrlCodeEnabled(bool value) { return UdCounterCtrl_setCcpDatCtrlCodeEnabled(this, value); }
/*Create an UdCounterCtrl. Note: Use 'dispose' to free the object*/
static UdCounterCtrl * Create(void) { return UdCounterCtrl_Create(); }
public: /*helpers*/
/*event*/
void addUdCntrEventHandler(UdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtUdIndex0, (DaqEventProc)proc, userParam);}
void removeUdCntrEventHandler(UdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtUdIndex0, (DaqEventProc)proc, userParam);}
/*for compatible*/
int32 getValue() { return UdCounterCtrl_getValue(this); }
CountingType getCountingType() { return UdCounterCtrl_getCountingType(this); }
ErrorCode setCountingType(CountingType value) { return UdCounterCtrl_setCountingType(this, value); }
int32 getInitialValue() { return UdCounterCtrl_getInitialValue(this); }
ErrorCode setInitialValue(int32 value) { return UdCounterCtrl_setInitialValue(this, value); }
int32 getResetTimesByIndex() { return UdCounterCtrl_getResetTimesByIndex(this); }
ErrorCode setResetTimesByIndex(int32 value) { return UdCounterCtrl_setResetTimesByIndex(this, value);}
ErrorCode CompareAppendTable(int32 count, int32 *table) { return CompareAppendTable(getChannel(), count, table); }
ErrorCode CompareSetTable(int32 count, int32 *table) { return CompareSetTable(getChannel(), count, table); }
ErrorCode CompareAppendInterval(int32 start, int32 increment,int32 count) { return CompareAppendInterval(getChannel(), start, increment, count); }
ErrorCode CompareSetInterval(int32 start, int32 increment,int32 count) { return CompareSetInterval(getChannel(), start, increment, count); }
ErrorCode CompareClear() { return CompareClear(getChannel()); }
public: /*For compatible ONLY!*/
void addUdCntrEventListener(UdCntrEventListener &listener) { UdCounterCtrl_addUdCntrEventListener(this, &listener); }
void removeUdCntrEventListener(UdCntrEventListener &listener) { UdCounterCtrl_removeUdCntrEventListener(this, &listener); }
ErrorCode SnapStart(int32 srcId) { return UdCounterCtrl_SnapStart(this, (EventId)srcId); }
ErrorCode SnapStop(int32 srcId) { return UdCounterCtrl_SnapStop(this, (EventId)srcId); }
private:
DAQCLS_DISABLE_CONSTRUCT(UdCounterCtrl)
};
/* Interface BufferedUdCounterCtrl */
class BufferedUdCounterCtrl : public CntrCtrlBase
{
public:
/*Buffered Up-down Counter Method*/
ErrorCode GetData(int32 cntr, int32 count, int32 data[], int32 timeout = 0, int32 *returned = NULL, double *startTime = NULL)
{
return BufferedUdCounterCtrl_GetDataI32(this, cntr, count, data, timeout, returned, startTime);
}
int32 getBufferCapacity() { return BufferedUdCounterCtrl_getBufferCapacity(this); }
Trigger* getTrigger() { return BufferedUdCounterCtrl_getTrigger(this); }
Record* getRecord() { return BufferedUdCounterCtrl_getRecord(this); }
ErrorCode setSampleClkSrc(SignalDrop drop) { return BufferedUdCounterCtrl_setSampleClkSrc(this, drop); }
SignalDrop getSampleClkSrc() { return BufferedUdCounterCtrl_getSampleClkSrc(this); }
void getChannelMap(int32 count, int8 *chMap) { BufferedUdCounterCtrl_getChannelMap(this, count, chMap);}
ErrorCode setChannelMap(int32 count, int8 *chMap) { return BufferedUdCounterCtrl_setChannelMap(this, count, chMap);}
ErrorCode Prepare() { return BufferedUdCounterCtrl_Prepare(this); }
void Release() { BufferedUdCounterCtrl_Release(this); }
bool GetBufferStatus(int32 ch, int32 *count, int32 *offset) { return !!BufferedUdCounterCtrl_getBufferStatus(this, ch, count, offset);}
/*Up-down Counter Property*/
Array* getChannels() { return (Array*)BufferedUdCounterCtrl_getChannels(this); }
/*Create an UdCounterCtrl. Note: Use 'dispose' to free the object*/
static BufferedUdCounterCtrl * Create(void) { return BufferedUdCounterCtrl_Create(); }
public: /*helpers*/
/*event*/
void addDataReadyHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCiDataReady, (DaqEventProc)proc, userParam);}
void removeDataReadyHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCiDataReady, (DaqEventProc)proc, userParam);}
void addOverrunHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCiOverrun, (DaqEventProc)proc, userParam);}
void removeOverrunHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCiOverrun, (DaqEventProc)proc, userParam);}
void addCacheOverflowHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
void removeCacheOverflowHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCiCacheOverflow, (DaqEventProc)proc, userParam);}
void addStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_addEventHandler (this, EvtCntrStopped, (DaqEventProc)proc, userParam);}
void removeStoppedHandler(BfdCntrEventProc proc, void *userParam) { DaqCtrlBase_removeEventHandler(this, EvtCntrStopped, (DaqEventProc)proc, userParam);}
private:
DAQCLS_DISABLE_CONSTRUCT(BufferedUdCounterCtrl)
};
/* Interface AbsChannel */
class AbsChannel
{
public:
/*Common Property*/
int32 getChannel() { return AbsChannel_getChannel(this); }
bool getNoiseFiltered() { return !!AbsChannel_getNoiseFiltered(this); }
ErrorCode setNoiseFiltered(bool value) { return AbsChannel_setNoiseFiltered(this, value); }
/*absolute counting Property*/
CodingType getCodingType() { return AbsChannel_getCodingType(this); }
ErrorCode setCodingType(CodingType value) { return AbsChannel_setCodingType(this, value); }
Baudrate getBaudrate() { return AbsChannel_getBaudrate(this); }
ErrorCode setBaudrate(Baudrate value) { return AbsChannel_setBaudrate(this, value); }
ErrorRetType getErrorRetType() { return AbsChannel_getErrorRetType(this); }
ErrorCode setErrorRetType(ErrorRetType value) { return AbsChannel_setErrorRetType(this, value); }
int32 getErrorRetValue() { return AbsChannel_getErrorRetValue(this); }
ErrorCode setErrorRetValue(int32 value) { return AbsChannel_setErrorRetValue(this, value); }
ActiveSignal getLatchSigEdge() { return AbsChannel_getLatchSigEdge(this); }
ErrorCode setLatchSigEdge(ActiveSignal value) { return AbsChannel_setLatchSigEdge(this, value); }
OutSignalType getOutSignal() { return AbsChannel_getOutSignal(this); }
ErrorCode setOutSignal(OutSignalType value) { return AbsChannel_setOutSignal(this, value); }
int32 getCompareValue0() { return AbsChannel_getCompareValue0(this); }
ErrorCode setCompareValue0(int32 value) { return AbsChannel_setCompareValue0(this, value); }
bool getCompare0Enabled() { return !!AbsChannel_getCompare0Enabled(this); }
ErrorCode setCompare0Enabled(bool value) { return AbsChannel_setCompare0Enabled(this, value); }
int32 getCompareValue1() { return AbsChannel_getCompareValue1(this); }
ErrorCode setCompareValue1(int32 value) { return AbsChannel_setCompareValue1(this, value); }
bool getCompare1Enabled() { return !!AbsChannel_getCompare1Enabled(this); }
ErrorCode setCompare1Enabled(bool value) { return AbsChannel_setCompare1Enabled(this, value); }
int32 getLatchedValue() { return AbsChannel_getLatchedValue(this); }
private:
DAQCLS_DISABLE_CONSTRUCT(AbsChannel)
};
/* Interface AbsCounterCtrl */
class AbsCounterCtrl : public CntrCtrlBase
{
public:
/*Event Counter Method*/
ErrorCode Read(int32 &data) { return AbsCounterCtrl_Read(this, 1, &data); }
ErrorCode Read(int32 count, int32 *data) { return AbsCounterCtrl_Read(this, count, data); }
ErrorCode StatusRead(int32 &data) { return AbsCounterCtrl_StatusRead(this, 1, &data); }
ErrorCode StatusRead(int32 count, int32 *data) { return AbsCounterCtrl_StatusRead(this, count, data); }
/*Event Counter Property*/
Array* getChannels() { return (Array*)AbsCounterCtrl_getChannels(this); }
/*Create an EventCounterCtrl. Note: Use 'dispose' to free the object*/
static AbsCounterCtrl * Create(void) { return AbsCounterCtrl_Create(); }
private:
DAQCLS_DISABLE_CONSTRUCT(AbsCounterCtrl)
};
/* Interface EsChannel */
class EsChannel
{
public:
/*Common Property*/
int32 getChannel() { return EsChannel_getChannel(this); }
bool getNoiseFiltered() { return !!EsChannel_getNoiseFiltered(this); }
ErrorCode setNoiseFiltered(bool value) { return EsChannel_setNoiseFiltered(this, value); }
/*Edge Separation Measurement Property*/
ActiveSignal getStartCountingEdge() { return EsChannel_getStartCountingEdge(this); }
ErrorCode setStartCountingEdge(ActiveSignal value) { return EsChannel_setStartCountingEdge(this, value); }
ActiveSignal getStopCountingEdge() { return EsChannel_getStopCountingEdge(this); }
ErrorCode setStopCountingEdge(ActiveSignal value) { return EsChannel_setStopCountingEdge(this, value); }
private:
DAQCLS_DISABLE_CONSTRUCT(EsChannel)
};
/* Interface EdgeSeparationCtrl */
class EdgeSeparationCtrl : public CntrCtrlBase
{
public:
/*Edge Separation Method*/
ErrorCode Read(double &data) { return EdgeSeparationCtrl_Read(this, 1, &data); }
ErrorCode Read(int32 count, double *data) { return EdgeSeparationCtrl_Read(this, count, data); }
/*Edge Separation Property*/
Array* getChannels() { return (Array*)EdgeSeparationCtrl_getChannels(this); }
/*Create an EdgeSeparationCtrl. Note: Use 'dispose' to free the object*/
static EdgeSeparationCtrl * Create(void) { return EdgeSeparationCtrl_Create(); }
private:
DAQCLS_DISABLE_CONSTRUCT(EdgeSeparationCtrl)
};
/*************************************************************/
/* ctrl class : Calibration related */
/* ----------------------------------------------------------*/
/* Interface CaliSubject */
class CaliSubject
{
public:
wchar_t const * getDescription(void) { return CaliSubject_getDescription(this); }
wchar_t const * getInstruction(void) { return CaliSubject_getInstruction(this); }
wchar_t const * getTargetRange(void) { return CaliSubject_getTargetRange(this); }
CaliState AdjCodeGetCurrentState(double *value, int32 *count, int32 code[]) { return CaliSubject_AdjCodeGetCurrentState(this, value, count, code); }
void AdjCodeGetRange(int32 lower[], int32 upper[]) { CaliSubject_AdjCodeGetRange(this, lower, upper); }
ErrorCode ManualAdjStart(void) { return CaliSubject_ManualAdjStart(this); }
ErrorCode ManualAdjStop(void) { return CaliSubject_ManualAdjStop(this); }
ErrorCode ManualAdjSetCode(int32 count, int32 code[]) { return CaliSubject_ManualAdjSetCode(this, count, code); }
private:
DAQCLS_DISABLE_CONSTRUCT(CaliSubject)
};
/* Interface CaliSection */
class CaliSection
{
public:
wchar_t const * getTypeName(void) { return CaliSection_getTypeName(this); }
wchar_t const * getDescription(void) { return CaliSection_getDescription(this); }
wchar_t const * getInstruction(void) { return CaliSection_getInstruction(this); }
Array* getSubjects(void) { return (Array*)CaliSection_getSubjects(this);}
ErrorCode Prepare(void) { return CaliSection_Prepare(this); }
ErrorCode BatchStart(void) { return CaliSection_BatchStart(this); }
void BatchTerminate(void) { CaliSection_BatchTerminate(this); }
private:
DAQCLS_DISABLE_CONSTRUCT(CaliSection)
};
/* Interface CaliSolution */
class CaliSolution
{
public:
wchar_t const * getTypeName(void) { return CaliSolution_getTypeName(this); }
wchar_t const * getDescription(void) { return CaliSolution_getDescription(this); }
wchar_t const * getInstruction(void) { return CaliSolution_getInstruction(this); }
int8 const * getAuxiliaryImage(int32 *size) { return CaliSolution_getAuxiliaryImage(this, size); }
Array* getSections(void) { return (Array*)CaliSolution_getSections(this);}
ErrorCode AdjCodesSave(void) { return CaliSolution_AdjCodesSave(this); }
ErrorCode AdjCodesLoad(void) { return CaliSolution_AdjCodesLoad(this); }
ErrorCode AdjCodesSaveToGoldBackup(void) { return CaliSolution_AdjCodesSaveToGoldBackup(this); }
ErrorCode AdjCodesLoadFromGoldBackup(int32 action) { return CaliSolution_AdjCodesLoadFromGoldBackup(this, action); }
private:
DAQCLS_DISABLE_CONSTRUCT(CaliSolution)
};
/* Interface CalibrationCtrl */
class CalibrationCtrl : public DaqCtrlBase
{
public:
Array* getSolutions(void) { return (Array*)CalibrationCtrl_getSolutions(this);}
ErrorCode setLanguageType(int32 type) { return CalibrationCtrl_setLanguageType(this, type); }
/*Create an CalibrationCtrl. Note: Use 'dispose' to free the object*/
static CalibrationCtrl * Create(void) { return CalibrationCtrl_Create(); }
private:
DAQCLS_DISABLE_CONSTRUCT(CalibrationCtrl)
};
/*************************************************************/
/* ctrl class : Firmware download related */
/* ----------------------------------------------------------*/
/* Interface FirmwareCtrl */
class FirmwareCtrl
{
public:
wchar_t const * getDescription(void) { return FirmwareCtrl_getDescription(this); }
wchar_t const * getNotice(void) { return FirmwareCtrl_getNotice(this); }
wchar_t const * getActivationTitle(void) { return FirmwareCtrl_getActivationTitle(this); }
wchar_t const * getVersionOnDevice(void) { return FirmwareCtrl_getVersionOnDevice(this); }
wchar_t const * getVersionOnFile(void) { return FirmwareCtrl_getVersionOnFile(this); }
int32 getOverwriteProgressing(void) { return FirmwareCtrl_getOverwriteProgressing(this); }
ErrorCode LoadFwFile(wchar_t const * filePath) { return FirmwareCtrl_LoadFwFile(this, filePath); }
ErrorCode Overwrite(FwAction action, wchar_t const *activationCode) { return FirmwareCtrl_Overwrite(this, action, activationCode); }
private:
DAQCLS_DISABLE_CONSTRUCT(FirmwareCtrl)
};
/* Interface FirmwareCtrls */
class FirmwareCtrls : public DaqCtrlBase
{
public:
Array* getFirmwares(void) { return (Array*)FirmwareCtrls_getFirmwares(this);}
ErrorCode setLanguageType(int32 type) { return FirmwareCtrls_setLanguageType(this, type); }
/*Create an CalibrationCtrl. Note: Use 'dispose' to free the object*/
static FirmwareCtrls * Create(void) { return FirmwareCtrls_Create(); }
private:
DAQCLS_DISABLE_CONSTRUCT(FirmwareCtrls)
};
#endif //defined(__cplusplus) && !defined(_BDAQ_C_INTERFACE)
#endif // DAQNAVI_CORE
END_NAMEAPCE_AUTOMATION_BDAQ
#endif /*_BDAQ_COM_LIKE_CLASS_LIB*/