Core

DAQmx is a python wrapper to the National Instruments DAQmx driver. You can use core to access the driver in c-style.

National Instruments does not allow to copy any documentation so you have to search C-api reference for the method name.

You need the io feature in your license to unlock the DAQmx features.

htf.daqmx.core.DAQmxAOSeriesCalAdjust(*arg)

int32 __CFUNC DAQmxAOSeriesCalAdjust (CalHandle calHandle, float64 referenceVoltage);

htf.daqmx.core.DAQmxAddCDAQSyncConnection(*arg)

int32 __CFUNC DAQmxAddCDAQSyncConnection(const char portList[]);

htf.daqmx.core.DAQmxAddGlobalChansToTask(*arg)

int32 __CFUNC DAQmxAddGlobalChansToTask (TaskHandle taskHandle, const char channelNames[]);

htf.daqmx.core.DAQmxAddNetworkDevice(*arg)

int32 __CFUNC DAQmxAddNetworkDevice (const char IPAddress[],const char deviceName[], bool32 attemptReservation, float64 timeout, char deviceNameOut[], uInt32 deviceNameOutBufferSize);

htf.daqmx.core.DAQmxAdjust1102Cal(*arg)

int32 __CFUNC DAQmxAdjust1102Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1104Cal(*arg)

int32 __CFUNC DAQmxAdjust1104Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1112Cal(*arg)

int32 __CFUNC DAQmxAdjust1112Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1122Cal(*arg)

int32 __CFUNC DAQmxAdjust1122Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1124Cal(*arg)

int32 __CFUNC DAQmxAdjust1124Cal (CalHandle calHandle, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1125Cal(*arg)

int32 __CFUNC DAQmxAdjust1125Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1126Cal(*arg)

int32 __CFUNC DAQmxAdjust1126Cal (CalHandle calHandle, float64 refFreq, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1141Cal(*arg)

int32 __CFUNC DAQmxAdjust1141Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1142Cal(*arg)

int32 __CFUNC DAQmxAdjust1142Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1143Cal(*arg)

int32 __CFUNC DAQmxAdjust1143Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1502Cal(*arg)

int32 __CFUNC DAQmxAdjust1502Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1503Cal(*arg)

int32 __CFUNC DAQmxAdjust1503Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1503CurrentCal(*arg)

int32 __CFUNC DAQmxAdjust1503CurrentCal (CalHandle calHandle, const char channelName[], float64 measCurrent);

htf.daqmx.core.DAQmxAdjust1520Cal(*arg)

int32 __CFUNC DAQmxAdjust1520Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1521Cal(*arg)

int32 __CFUNC DAQmxAdjust1521Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust153xCal(*arg)

int32 __CFUNC DAQmxAdjust153xCal (CalHandle calHandle, float64 refVoltage, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1540Cal(*arg)

int32 __CFUNC DAQmxAdjust1540Cal (CalHandle calHandle, float64 refVoltage, float64 measOutput, int32 inputCalSource);

htf.daqmx.core.DAQmxAdjust4204Cal(*arg)

int32 __CFUNC DAQmxAdjust4204Cal (CalHandle calHandle, const char channelNames[], float64 lowPassFreq, bool32 trackHoldEnabled, float64 inputVal);

htf.daqmx.core.DAQmxAdjust4220Cal(*arg)

int32 __CFUNC DAQmxAdjust4220Cal (CalHandle calHandle, const char channelNames[], float64 gain, float64 inputVal);

htf.daqmx.core.DAQmxAdjust4224Cal(*arg)

int32 __CFUNC DAQmxAdjust4224Cal (CalHandle calHandle, const char channelNames[], float64 gain, float64 inputVal);

htf.daqmx.core.DAQmxAdjust4225Cal(*arg)

int32 __CFUNC DAQmxAdjust4225Cal (CalHandle calHandle, const char channelNames[], float64 gain, float64 inputVal);

htf.daqmx.core.DAQmxAdjust4300Cal(*arg)

int32 __CFUNC DAQmxAdjust4300Cal (CalHandle calHandle, float64 refVoltage);

htf.daqmx.core.DAQmxAdjust4322Cal(*arg)

int32 __CFUNC DAQmxAdjust4322Cal (CalHandle calHandle, const char channelNames[], float64 refVal);

htf.daqmx.core.DAQmxAdjust433xCal(*arg)

int32 __CFUNC DAQmxAdjust433xCal (CalHandle calHandle, float64 refVoltage, float64 refExcitation, int32 shuntLocation);

htf.daqmx.core.DAQmxAdjust4353Cal(*arg)

int32 __CFUNC DAQmxAdjust4353Cal (CalHandle calHandle, const char channelNames[], float64 refVal);

htf.daqmx.core.DAQmxAdjust4357Cal(*arg)

int32 __CFUNC DAQmxAdjust4357Cal (CalHandle calHandle, const char channelNames[], const float64 refVals[], int32 numRefVals);

htf.daqmx.core.DAQmxAdjust4610Cal(*arg)

int32 __CFUNC DAQmxAdjust4610Cal (CalHandle calHandle, const char channelName[], float64 gain, float64 offset);

htf.daqmx.core.DAQmxAdjust9201Cal(*arg)

int32 __CFUNC DAQmxAdjust9201Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9203GainCal(*arg)

int32 __CFUNC DAQmxAdjust9203GainCal (CalHandle calHandle, const char channelNames[], float64 rangeMin, float64 rangeMax, float64 value);

htf.daqmx.core.DAQmxAdjust9203OffsetCal(*arg)

int32 __CFUNC DAQmxAdjust9203OffsetCal (CalHandle calHandle, const char channelNames[], float64 rangeMin, float64 rangeMax);

htf.daqmx.core.DAQmxAdjust9205Cal(*arg)

int32 __CFUNC DAQmxAdjust9205Cal(CalHandle calHandle, float64 value);

htf.daqmx.core.DAQmxAdjust9206Cal(*arg)

int32 __CFUNC DAQmxAdjust9206Cal(CalHandle calHandle, float64 value);

htf.daqmx.core.DAQmxAdjust9207GainCal(*arg)

int32 __CFUNC DAQmxAdjust9207GainCal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9207OffsetCal(*arg)

int32 __CFUNC DAQmxAdjust9207OffsetCal(CalHandle calHandle, const char channelNames[]);

htf.daqmx.core.DAQmxAdjust9208GainCal(*arg)

int32 __CFUNC DAQmxAdjust9208GainCal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9208OffsetCal(*arg)

int32 __CFUNC DAQmxAdjust9208OffsetCal(CalHandle calHandle, const char channelNames[]);

htf.daqmx.core.DAQmxAdjust9211Cal(*arg)

int32 __CFUNC DAQmxAdjust9211Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9213Cal(*arg)

int32 __CFUNC DAQmxAdjust9213Cal (CalHandle calHandle, const char channelNames[], float64 rangeMin, float64 rangeMax, float64 value);

htf.daqmx.core.DAQmxAdjust9214Cal(*arg)

int32 __CFUNC DAQmxAdjust9214Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9215Cal(*arg)

int32 __CFUNC DAQmxAdjust9215Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9217Cal(*arg)

int32 __CFUNC DAQmxAdjust9217Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9219Cal(*arg)

int32 __CFUNC DAQmxAdjust9219Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9220Cal(*arg)

int32 __CFUNC DAQmxAdjust9220Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9221Cal(*arg)

int32 __CFUNC DAQmxAdjust9221Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9222Cal(*arg)

int32 __CFUNC DAQmxAdjust9222Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9223Cal(*arg)

int32 __CFUNC DAQmxAdjust9223Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9225Cal(*arg)

int32 __CFUNC DAQmxAdjust9225Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9227Cal(*arg)

int32 __CFUNC DAQmxAdjust9227Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9229Cal(*arg)

int32 __CFUNC DAQmxAdjust9229Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9232Cal(*arg)

int32 __CFUNC DAQmxAdjust9232Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9234GainCal(*arg)

int32 __CFUNC DAQmxAdjust9234GainCal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9234OffsetCal(*arg)

int32 __CFUNC DAQmxAdjust9234OffsetCal(CalHandle calHandle, const char channelNames[]);

htf.daqmx.core.DAQmxAdjust9239Cal(*arg)

int32 __CFUNC DAQmxAdjust9239Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9242Cal(*arg)

int32 __CFUNC DAQmxAdjust9242Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9244Cal(*arg)

int32 __CFUNC DAQmxAdjust9244Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9263Cal(*arg)

int32 __CFUNC DAQmxAdjust9263Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9264Cal(*arg)

int32 __CFUNC DAQmxAdjust9264Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9265Cal(*arg)

int32 __CFUNC DAQmxAdjust9265Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjust9269Cal(*arg)

int32 __CFUNC DAQmxAdjust9269Cal(CalHandle calHandle, const char channelNames[], float64 value);

htf.daqmx.core.DAQmxAdjustDSAAICal(*arg)

int32 __CFUNC DAQmxAdjustDSAAICal (CalHandle calHandle, float64 referenceVoltage);

htf.daqmx.core.DAQmxAdjustDSAAICalEx(*arg)

int32 __CFUNC DAQmxAdjustDSAAICalEx (CalHandle calHandle, float64 referenceVoltage, bool32 inputsShorted);

htf.daqmx.core.DAQmxAdjustDSAAICalWithGainAndCoupling(*arg)

int32 __CFUNC DAQmxAdjustDSAAICalWithGainAndCoupling (CalHandle calHandle, int32 coupling, float64 gain, float64 referenceVoltage);

htf.daqmx.core.DAQmxAdjustDSAAOCal(*arg)

int32 __CFUNC DAQmxAdjustDSAAOCal (CalHandle calHandle, uInt32 channel, float64 requestedLowVoltage, float64 actualLowVoltage, float64 requestedHighVoltage, float64 actualHighVoltage, float64 gainSetting);

htf.daqmx.core.DAQmxAdjustDSAAOTimebaseCal(*arg)

int32 __CFUNC DAQmxAdjustDSAAOTimebaseCal (CalHandle calHandle, float64 measuredFrequency, bool32* calComplete);

htf.daqmx.core.DAQmxAdjustDSATimebaseCal(*arg)

int32 __CFUNC DAQmxAdjustDSATimebaseCal (CalHandle calHandle, float64 referenceFrequency);

htf.daqmx.core.DAQmxAdjustTIOTimebaseCal(*arg)

int32 __CFUNC DAQmxAdjustTIOTimebaseCal (CalHandle calHandle, float64 referenceFrequency);

htf.daqmx.core.DAQmxAreConfiguredCDAQSyncPortsDisconnected(*arg)

int32 __CFUNC DAQmxAreConfiguredCDAQSyncPortsDisconnected (const char chassisDevicesPorts[], float64 timeout, bool32* disconnectedPortsExist);

htf.daqmx.core.DAQmxAutoConfigureCDAQSyncConnections(*arg)

int32 __CFUNC DAQmxAutoConfigureCDAQSyncConnections(const char chassisDevicesPorts[], float64 timeout);

htf.daqmx.core.DAQmxCSeriesSetCalTemp(*arg)

int32 __CFUNC DAQmxCSeriesSetCalTemp(CalHandle calHandle, float64 temperature);

htf.daqmx.core.DAQmxCalculateReversePolyCoeff(*arg)

int32 __CFUNC DAQmxCalculateReversePolyCoeff (const float64 forwardCoeffs[], uInt32 numForwardCoeffsIn, float64 minValX, float64 maxValX, int32 numPointsToCompute, int32 reversePolyOrder, float64 reverseCoeffs[]);

htf.daqmx.core.DAQmxCfgAnlgEdgeRefTrig(*arg)

int32 __CFUNC DAQmxCfgAnlgEdgeRefTrig (TaskHandle taskHandle, const char triggerSource[], int32 triggerSlope, float64 triggerLevel, uInt32 pretriggerSamples);

htf.daqmx.core.DAQmxCfgAnlgEdgeStartTrig(*arg)

int32 __CFUNC DAQmxCfgAnlgEdgeStartTrig (TaskHandle taskHandle, const char triggerSource[], int32 triggerSlope, float64 triggerLevel);

htf.daqmx.core.DAQmxCfgAnlgWindowRefTrig(*arg)

int32 __CFUNC DAQmxCfgAnlgWindowRefTrig (TaskHandle taskHandle, const char triggerSource[], int32 triggerWhen, float64 windowTop, float64 windowBottom, uInt32 pretriggerSamples);

htf.daqmx.core.DAQmxCfgAnlgWindowStartTrig(*arg)

int32 __CFUNC DAQmxCfgAnlgWindowStartTrig (TaskHandle taskHandle, const char triggerSource[], int32 triggerWhen, float64 windowTop, float64 windowBottom);

htf.daqmx.core.DAQmxCfgBurstHandshakingTimingExportClock(*arg)

int32 __CFUNC DAQmxCfgBurstHandshakingTimingExportClock (TaskHandle taskHandle, int32 sampleMode, uInt64 sampsPerChan, float64 sampleClkRate, const char sampleClkOutpTerm[], int32 sampleClkPulsePolarity, int32 pauseWhen, int32 readyEventActiveLevel);

htf.daqmx.core.DAQmxCfgBurstHandshakingTimingImportClock(*arg)

int32 __CFUNC DAQmxCfgBurstHandshakingTimingImportClock (TaskHandle taskHandle, int32 sampleMode, uInt64 sampsPerChan, float64 sampleClkRate, const char sampleClkSrc[], int32 sampleClkActiveEdge, int32 pauseWhen, int32 readyEventActiveLevel);

htf.daqmx.core.DAQmxCfgChangeDetectionTiming(*arg)

int32 __CFUNC DAQmxCfgChangeDetectionTiming (TaskHandle taskHandle, const char risingEdgeChan[], const char fallingEdgeChan[], int32 sampleMode, uInt64 sampsPerChan);

htf.daqmx.core.DAQmxCfgDigEdgeAdvTrig(*arg)

int32 __CFUNC DAQmxCfgDigEdgeAdvTrig (TaskHandle taskHandle, const char triggerSource[], int32 triggerEdge);

htf.daqmx.core.DAQmxCfgDigEdgeRefTrig(*arg)

int32 __CFUNC DAQmxCfgDigEdgeRefTrig (TaskHandle taskHandle, const char triggerSource[], int32 triggerEdge, uInt32 pretriggerSamples);

htf.daqmx.core.DAQmxCfgDigEdgeStartTrig(*arg)

int32 __CFUNC DAQmxCfgDigEdgeStartTrig (TaskHandle taskHandle, const char triggerSource[], int32 triggerEdge);

htf.daqmx.core.DAQmxCfgDigPatternRefTrig(*arg)

int32 __CFUNC DAQmxCfgDigPatternRefTrig (TaskHandle taskHandle, const char triggerSource[], const char triggerPattern[], int32 triggerWhen, uInt32 pretriggerSamples);

htf.daqmx.core.DAQmxCfgDigPatternStartTrig(*arg)

int32 __CFUNC DAQmxCfgDigPatternStartTrig (TaskHandle taskHandle, const char triggerSource[], const char triggerPattern[], int32 triggerWhen);

htf.daqmx.core.DAQmxCfgHandshakingTiming(*arg)

int32 __CFUNC DAQmxCfgHandshakingTiming (TaskHandle taskHandle, int32 sampleMode, uInt64 sampsPerChan);

htf.daqmx.core.DAQmxCfgImplicitTiming(*arg)

int32 __CFUNC DAQmxCfgImplicitTiming (TaskHandle taskHandle, int32 sampleMode, uInt64 sampsPerChan);

htf.daqmx.core.DAQmxCfgInputBuffer(*arg)

int32 __CFUNC DAQmxCfgInputBuffer (TaskHandle taskHandle, uInt32 numSampsPerChan);

htf.daqmx.core.DAQmxCfgOutputBuffer(*arg)

int32 __CFUNC DAQmxCfgOutputBuffer (TaskHandle taskHandle, uInt32 numSampsPerChan);

htf.daqmx.core.DAQmxCfgPipelinedSampClkTiming(*arg)

int32 __CFUNC DAQmxCfgPipelinedSampClkTiming (TaskHandle taskHandle, const char source[], float64 rate, int32 activeEdge, int32 sampleMode, uInt64 sampsPerChan);

htf.daqmx.core.DAQmxCfgSampClkTiming(*arg)

int32 __CFUNC DAQmxCfgSampClkTiming (TaskHandle taskHandle, const char source[], float64 rate, int32 activeEdge, int32 sampleMode, uInt64 sampsPerChan);

htf.daqmx.core.DAQmxCfgWatchdogAOExpirStates(*arg)

int32 __CFUNC DAQmxCfgWatchdogAOExpirStates (TaskHandle taskHandle, const char channelNames[], const float64 expirStateArray[], const int32 outputTypeArray[], uInt32 arraySize);

htf.daqmx.core.DAQmxCfgWatchdogCOExpirStates(*arg)

int32 __CFUNC DAQmxCfgWatchdogCOExpirStates (TaskHandle taskHandle, const char channelNames[], const int32 expirStateArray[], uInt32 arraySize);

htf.daqmx.core.DAQmxCfgWatchdogDOExpirStates(*arg)

int32 __CFUNC DAQmxCfgWatchdogDOExpirStates (TaskHandle taskHandle, const char channelNames[], const int32 expirStateArray[], uInt32 arraySize);

htf.daqmx.core.DAQmxChangeExtCalPassword(*arg)

int32 __CFUNC DAQmxChangeExtCalPassword (const char deviceName[], const char password[], const char newPassword[]);

htf.daqmx.core.DAQmxClearTEDS(*arg)

int32 __CFUNC DAQmxClearTEDS (const char physicalChannel[]);

htf.daqmx.core.DAQmxClearTask(*arg)

int32 __CFUNC DAQmxClearTask (TaskHandle taskHandle);

htf.daqmx.core.DAQmxCloseExtCal(*arg)

int32 __CFUNC DAQmxCloseExtCal (CalHandle calHandle, int32 action);

htf.daqmx.core.DAQmxConfigureLogging(*arg)

int32 __CFUNC DAQmxConfigureLogging (TaskHandle taskHandle, const char filePath[], int32 loggingMode, const char groupName[], int32 operation);

htf.daqmx.core.DAQmxConfigureTEDS(*arg)

int32 __CFUNC DAQmxConfigureTEDS (const char physicalChannel[], const char filePath[]);

htf.daqmx.core.DAQmxConnectSCExpressCalAccChans(*arg)

int32 __CFUNC DAQmxConnectSCExpressCalAccChans (CalHandle calHandle, const char channelNames[], const char connection[]);

htf.daqmx.core.DAQmxConnectTerms(*arg)

int32 __CFUNC DAQmxConnectTerms (const char sourceTerminal[], const char destinationTerminal[], int32 signalModifiers);

htf.daqmx.core.DAQmxControlWatchdogTask(*arg)

int32 __CFUNC DAQmxControlWatchdogTask (TaskHandle taskHandle, int32 action);

htf.daqmx.core.DAQmxCreateAIAccelChan(*arg)

int32 __CFUNC DAQmxCreateAIAccelChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIBridgeChan(*arg)

int32 __CFUNC DAQmxCreateAIBridgeChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAICurrentChan(*arg)

int32 __CFUNC DAQmxCreateAICurrentChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 shuntResistorLoc, float64 extShuntResistorVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAICurrentRMSChan(*arg)

int32 __CFUNC DAQmxCreateAICurrentRMSChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 shuntResistorLoc, float64 extShuntResistorVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIDeviceTempChan(*arg)

int32 __CFUNC DAQmxCreateAIDeviceTempChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 units);

htf.daqmx.core.DAQmxCreateAIForceBridgePolynomialChan(*arg)

int32 __CFUNC DAQmxCreateAIForceBridgePolynomialChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,const float64 forwardCoeffs[],uInt32 numForwardCoeffs,const float64 reverseCoeffs[], uInt32 numReverseCoeffs,int32 electricalUnits,int32 physicalUnits,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIForceBridgeTableChan(*arg)

int32 __CFUNC DAQmxCreateAIForceBridgeTableChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,const float64 electricalVals[],uInt32 numElectricalVals,int32 electricalUnits, const float64 physicalVals[],uInt32 numPhysicalVals,int32 physicalUnits,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIForceBridgeTwoPointLinChan(*arg)

int32 __CFUNC DAQmxCreateAIForceBridgeTwoPointLinChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,float64 firstElectricalVal,float64 secondElectricalVal, int32 electricalUnits,float64 firstPhysicalVal,float64 secondPhysicalVal,int32 physicalUnits, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIForceIEPEChan(*arg)

int32 __CFUNC DAQmxCreateAIForceIEPEChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIFreqVoltageChan(*arg)

int32 __CFUNC DAQmxCreateAIFreqVoltageChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, float64 thresholdLevel, float64 hysteresis, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIMicrophoneChan(*arg)

int32 __CFUNC DAQmxCreateAIMicrophoneChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, int32 units, float64 micSensitivity, float64 maxSndPressLevel, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIPosEddyCurrProxProbeChan(*arg)

int32 __CFUNC DAQmxCreateAIPosEddyCurrProxProbeChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIPosLVDTChan(*arg)

int32 __CFUNC DAQmxCreateAIPosLVDTChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, int32 voltageExcitSource, float64 voltageExcitVal, float64 voltageExcitFreq, int32 ACExcitWireMode, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIPosRVDTChan(*arg)

int32 __CFUNC DAQmxCreateAIPosRVDTChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, int32 voltageExcitSource, float64 voltageExcitVal, float64 voltageExcitFreq, int32 ACExcitWireMode, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIPressureBridgePolynomialChan(*arg)

int32 __CFUNC DAQmxCreateAIPressureBridgePolynomialChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,const float64 forwardCoeffs[],uInt32 numForwardCoeffs,const float64 reverseCoeffs[], uInt32 numReverseCoeffs,int32 electricalUnits,int32 physicalUnits,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIPressureBridgeTableChan(*arg)

int32 __CFUNC DAQmxCreateAIPressureBridgeTableChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,const float64 electricalVals[],uInt32 numElectricalVals,int32 electricalUnits, const float64 physicalVals[],uInt32 numPhysicalVals,int32 physicalUnits,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIPressureBridgeTwoPointLinChan(*arg)

int32 __CFUNC DAQmxCreateAIPressureBridgeTwoPointLinChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,float64 firstElectricalVal,float64 secondElectricalVal,int32 electricalUnits, float64 firstPhysicalVal,float64 secondPhysicalVal,int32 physicalUnits,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIRTDChan(*arg)

int32 __CFUNC DAQmxCreateAIRTDChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 rtdType, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal, float64 r0);

htf.daqmx.core.DAQmxCreateAIResistanceChan(*arg)

int32 __CFUNC DAQmxCreateAIResistanceChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIRosetteStrainGageChan(*arg)

int32 __CFUNC DAQmxCreateAIRosetteStrainGageChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 rosetteType, float64 gageOrientation, const int32 rosetteMeasTypes[], uInt32 numRosetteMeasTypes, int32 strainConfig, int32 voltageExcitSource, float64 voltageExcitVal, float64 gageFactor, float64 nominalGageResistance,float64 poissonRatio,float64 leadWireResistance);

htf.daqmx.core.DAQmxCreateAIStrainGageChan(*arg)

int32 __CFUNC DAQmxCreateAIStrainGageChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 strainConfig, int32 voltageExcitSource, float64 voltageExcitVal, float64 gageFactor, float64 initialBridgeVoltage, float64 nominalGageResistance, float64 poissonRatio, float64 leadWireResistance, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAITempBuiltInSensorChan(*arg)

int32 __CFUNC DAQmxCreateAITempBuiltInSensorChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 units);

htf.daqmx.core.DAQmxCreateAIThrmcplChan(*arg)

int32 __CFUNC DAQmxCreateAIThrmcplChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 thermocoupleType, int32 cjcSource, float64 cjcVal, const char cjcChannel[]);

htf.daqmx.core.DAQmxCreateAIThrmstrChanIex(*arg)

int32 __CFUNC DAQmxCreateAIThrmstrChanIex (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal, float64 a, float64 b, float64 c);

htf.daqmx.core.DAQmxCreateAIThrmstrChanVex(*arg)

int32 __CFUNC DAQmxCreateAIThrmstrChanVex (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 voltageExcitSource, float64 voltageExcitVal, float64 a, float64 b, float64 c, float64 r1);

htf.daqmx.core.DAQmxCreateAITorqueBridgePolynomialChan(*arg)

int32 __CFUNC DAQmxCreateAITorqueBridgePolynomialChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,const float64 forwardCoeffs[],uInt32 numForwardCoeffs, const float64 reverseCoeffs[],uInt32 numReverseCoeffs,int32 electricalUnits,int32 physicalUnits ,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAITorqueBridgeTableChan(*arg)

int32 __CFUNC DAQmxCreateAITorqueBridgeTableChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,const float64 electricalVals[],uInt32 numElectricalVals, int32 electricalUnits,const float64 physicalVals[],uInt32 numPhysicalVals,int32 physicalUnits, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAITorqueBridgeTwoPointLinChan(*arg)

int32 __CFUNC DAQmxCreateAITorqueBridgeTwoPointLinChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 bridgeConfig,int32 voltageExcitSource,float64 voltageExcitVal, float64 nominalBridgeResistance,float64 firstElectricalVal,float64 secondElectricalVal,int32 electricalUnits, float64 firstPhysicalVal,float64 secondPhysicalVal,int32 physicalUnits,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIVelocityIEPEChan(*arg)

int32 __CFUNC DAQmxCreateAIVelocityIEPEChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIVoltageChan(*arg)

int32 __CFUNC DAQmxCreateAIVoltageChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIVoltageChanWithExcit(*arg)

int32 __CFUNC DAQmxCreateAIVoltageChanWithExcit (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 bridgeConfig, int32 voltageExcitSource, float64 voltageExcitVal, bool32 useExcitForScaling, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAIVoltageRMSChan(*arg)

int32 __CFUNC DAQmxCreateAIVoltageRMSChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAOCurrentChan(*arg)

int32 __CFUNC DAQmxCreateAOCurrentChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateAOFuncGenChan(*arg)

int32 __CFUNC DAQmxCreateAOFuncGenChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 type, float64 freq, float64 amplitude, float64 offset);

htf.daqmx.core.DAQmxCreateAOVoltageChan(*arg)

int32 __CFUNC DAQmxCreateAOVoltageChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateCIAngEncoderChan(*arg)

int32 __CFUNC DAQmxCreateCIAngEncoderChan (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 decodingType, bool32 ZidxEnable, float64 ZidxVal, int32 ZidxPhase, int32 units, uInt32 pulsesPerRev, float64 initialAngle, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateCICountEdgesChan(*arg)

int32 __CFUNC DAQmxCreateCICountEdgesChan (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 edge, uInt32 initialCount, int32 countDirection);

htf.daqmx.core.DAQmxCreateCIFreqChan(*arg)

int32 __CFUNC DAQmxCreateCIFreqChan (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 edge, int32 measMethod, float64 measTime, uInt32 divisor, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateCIGPSTimestampChan(*arg)

int32 __CFUNC DAQmxCreateCIGPSTimestampChan (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 units, int32 syncMethod, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateCILinEncoderChan(*arg)

int32 __CFUNC DAQmxCreateCILinEncoderChan (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 decodingType, bool32 ZidxEnable, float64 ZidxVal, int32 ZidxPhase, int32 units, float64 distPerPulse, float64 initialPos, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateCIPeriodChan(*arg)

int32 __CFUNC DAQmxCreateCIPeriodChan (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 edge, int32 measMethod, float64 measTime, uInt32 divisor, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateCIPulseChanFreq(*arg)

int32 __CFUNC DAQmxCreateCIPulseChanFreq (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units);

htf.daqmx.core.DAQmxCreateCIPulseChanTicks(*arg)

int32 __CFUNC DAQmxCreateCIPulseChanTicks (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], const char sourceTerminal[], float64 minVal, float64 maxVal);

htf.daqmx.core.DAQmxCreateCIPulseChanTime(*arg)

int32 __CFUNC DAQmxCreateCIPulseChanTime (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units);

htf.daqmx.core.DAQmxCreateCIPulseWidthChan(*arg)

int32 __CFUNC DAQmxCreateCIPulseWidthChan (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 startingEdge, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateCISemiPeriodChan(*arg)

int32 __CFUNC DAQmxCreateCISemiPeriodChan (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateCITwoEdgeSepChan(*arg)

int32 __CFUNC DAQmxCreateCITwoEdgeSepChan (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 firstEdge, int32 secondEdge, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateCOPulseChanFreq(*arg)

int32 __CFUNC DAQmxCreateCOPulseChanFreq (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 units, int32 idleState, float64 initialDelay, float64 freq, float64 dutyCycle);

htf.daqmx.core.DAQmxCreateCOPulseChanTicks(*arg)

int32 __CFUNC DAQmxCreateCOPulseChanTicks (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], const char sourceTerminal[], int32 idleState, int32 initialDelay, int32 lowTicks, int32 highTicks);

htf.daqmx.core.DAQmxCreateCOPulseChanTime(*arg)

int32 __CFUNC DAQmxCreateCOPulseChanTime (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 units, int32 idleState, float64 initialDelay, float64 lowTime, float64 highTime);

htf.daqmx.core.DAQmxCreateDIChan(*arg)

int32 __CFUNC DAQmxCreateDIChan (TaskHandle taskHandle, const char lines[], const char nameToAssignToLines[], int32 lineGrouping);

htf.daqmx.core.DAQmxCreateDOChan(*arg)

int32 __CFUNC DAQmxCreateDOChan (TaskHandle taskHandle, const char lines[], const char nameToAssignToLines[], int32 lineGrouping);

htf.daqmx.core.DAQmxCreateLinScale(*arg)

int32 __CFUNC DAQmxCreateLinScale (const char name[], float64 slope, float64 yIntercept, int32 preScaledUnits, const char scaledUnits[]);

htf.daqmx.core.DAQmxCreateMapScale(*arg)

int32 __CFUNC DAQmxCreateMapScale (const char name[], float64 prescaledMin, float64 prescaledMax, float64 scaledMin, float64 scaledMax, int32 preScaledUnits, const char scaledUnits[]);

htf.daqmx.core.DAQmxCreatePolynomialScale(*arg)

int32 __CFUNC DAQmxCreatePolynomialScale (const char name[], const float64 forwardCoeffs[], uInt32 numForwardCoeffsIn, const float64 reverseCoeffs[], uInt32 numReverseCoeffsIn, int32 preScaledUnits, const char scaledUnits[]);

htf.daqmx.core.DAQmxCreateTEDSAIAccelChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIAccelChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIBridgeChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIBridgeChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 voltageExcitSource,float64 voltageExcitVal,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAICurrentChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAICurrentChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 shuntResistorLoc, float64 extShuntResistorVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIForceBridgeChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIForceBridgeChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 voltageExcitSource,float64 voltageExcitVal,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIForceIEPEChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIForceIEPEChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIMicrophoneChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIMicrophoneChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, int32 units, float64 maxSndPressLevel, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIPosLVDTChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIPosLVDTChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 voltageExcitSource, float64 voltageExcitVal, float64 voltageExcitFreq, int32 ACExcitWireMode, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIPosRVDTChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIPosRVDTChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 voltageExcitSource, float64 voltageExcitVal, float64 voltageExcitFreq, int32 ACExcitWireMode, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIPressureBridgeChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIPressureBridgeChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 voltageExcitSource,float64 voltageExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIRTDChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIRTDChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal);

htf.daqmx.core.DAQmxCreateTEDSAIResistanceChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIResistanceChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIStrainGageChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIStrainGageChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 voltageExcitSource, float64 voltageExcitVal, float64 initialBridgeVoltage, float64 leadWireResistance, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIThrmcplChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIThrmcplChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 cjcSource, float64 cjcVal, const char cjcChannel[]);

htf.daqmx.core.DAQmxCreateTEDSAIThrmstrChanIex(*arg)

int32 __CFUNC DAQmxCreateTEDSAIThrmstrChanIex (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal);

htf.daqmx.core.DAQmxCreateTEDSAIThrmstrChanVex(*arg)

int32 __CFUNC DAQmxCreateTEDSAIThrmstrChanVex (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 voltageExcitSource, float64 voltageExcitVal, float64 r1);

htf.daqmx.core.DAQmxCreateTEDSAITorqueBridgeChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAITorqueBridgeChan (TaskHandle taskHandle,const char physicalChannel[],const char nameToAssignToChannel[],float64 minVal, float64 maxVal,int32 units,int32 voltageExcitSource,float64 voltageExcitVal,const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIVoltageChan(*arg)

int32 __CFUNC DAQmxCreateTEDSAIVoltageChan (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTEDSAIVoltageChanWithExcit(*arg)

int32 __CFUNC DAQmxCreateTEDSAIVoltageChanWithExcit (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 voltageExcitSource, float64 voltageExcitVal, const char customScaleName[]);

htf.daqmx.core.DAQmxCreateTableScale(*arg)

int32 __CFUNC DAQmxCreateTableScale (const char name[], const float64 prescaledVals[], uInt32 numPrescaledValsIn, const float64 scaledVals[], uInt32 numScaledValsIn, int32 preScaledUnits, const char scaledUnits[]);

htf.daqmx.core.DAQmxCreateTask(*arg)

int32 __CFUNC DAQmxCreateTask (const char taskName[], TaskHandle *taskHandle);

htf.daqmx.core.DAQmxCreateWatchdogTimerTask(*arg)

int32 __CFUNC_C DAQmxCreateWatchdogTimerTask (const char deviceName[], const char taskName[], TaskHandle *taskHandle, float64 timeout, const char lines[], int32 expState, …);

htf.daqmx.core.DAQmxCreateWatchdogTimerTaskEx(*arg)

int32 __CFUNC DAQmxCreateWatchdogTimerTaskEx (const char deviceName[], const char taskName[], TaskHandle *taskHandle, float64 timeout);

htf.daqmx.core.DAQmxDSASetCalTemp(*arg)

int32 __CFUNC DAQmxDSASetCalTemp (CalHandle calHandle, float64 temperature);

htf.daqmx.core.DAQmxDeleteNetworkDevice(*arg)

int32 __CFUNC DAQmxDeleteNetworkDevice(const char deviceName[]);

htf.daqmx.core.DAQmxDeleteSavedGlobalChan(*arg)

int32 __CFUNC DAQmxDeleteSavedGlobalChan (const char channelName[]);

htf.daqmx.core.DAQmxDeleteSavedScale(*arg)

int32 __CFUNC DAQmxDeleteSavedScale (const char scaleName[]);

htf.daqmx.core.DAQmxDeleteSavedTask(*arg)

int32 __CFUNC DAQmxDeleteSavedTask (const char taskName[]);

htf.daqmx.core.DAQmxDeviceSupportsCal(*arg)

int32 __CFUNC DAQmxDeviceSupportsCal (const char deviceName[], bool32 *calSupported);

htf.daqmx.core.DAQmxDisableAdvTrig(*arg)

int32 __CFUNC DAQmxDisableAdvTrig (TaskHandle taskHandle);

htf.daqmx.core.DAQmxDisableRefTrig(*arg)

int32 __CFUNC DAQmxDisableRefTrig (TaskHandle taskHandle);

htf.daqmx.core.DAQmxDisableStartTrig(*arg)

int32 __CFUNC DAQmxDisableStartTrig (TaskHandle taskHandle);

htf.daqmx.core.DAQmxDisconnectSCExpressCalAccChans(*arg)

int32 __CFUNC DAQmxDisconnectSCExpressCalAccChans (CalHandle calHandle);

htf.daqmx.core.DAQmxDisconnectTerms(*arg)

int32 __CFUNC DAQmxDisconnectTerms (const char sourceTerminal[], const char destinationTerminal[]);

htf.daqmx.core.DAQmxESeriesCalAdjust(*arg)

int32 __CFUNC DAQmxESeriesCalAdjust (CalHandle calHandle, float64 referenceVoltage);

htf.daqmx.core.DAQmxExportSignal(*arg)

int32 __CFUNC DAQmxExportSignal (TaskHandle taskHandle, int32 signalID, const char outputTerminal[]);

htf.daqmx.core.DAQmxGet4322CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet4322CalAdjustPoints (CalHandle calHandle, int32 outputType, float64* adjustmentPoints, uInt32 bufferSize );

htf.daqmx.core.DAQmxGet9201CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9201CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9203CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9203CalAdjustPoints (CalHandle calHandle, float64 rangeMin, float64 rangeMax, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9207CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9207CalAdjustPoints (CalHandle calHandle, const char channelNames[], float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9208CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9208CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9213CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9213CalAdjustPoints (CalHandle calHandle, float64 rangeMin, float64 rangeMax, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9214CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9214CalAdjustPoints (CalHandle calHandle, const char channelNames[], float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9215CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9215CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9217CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9217CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9219CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9219CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9220CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9220CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9221CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9221CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9222CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9222CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9223CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9223CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9225CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9225CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9227CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9227CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9229CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9229CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9232CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9232CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9234CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9234CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9239CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9239CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9242CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9242CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9244CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9244CalAdjustPoints (CalHandle calHandle, float64* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9263CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9263CalAdjustPoints (CalHandle calHandle, int32* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9264CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9264CalAdjustPoints (CalHandle calHandle, int32* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9265CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9265CalAdjustPoints (CalHandle calHandle, int32* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGet9269CalAdjustPoints(*arg)

int32 __CFUNC DAQmxGet9269CalAdjustPoints (CalHandle calHandle, int32* adjustmentPoints, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIACExcitFreq(*arg)

int32 __CFUNC DAQmxGetAIACExcitFreq(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIACExcitSyncEnable(*arg)

int32 __CFUNC DAQmxGetAIACExcitSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIACExcitWireMode(*arg)

int32 __CFUNC DAQmxGetAIACExcitWireMode(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIADCCustomTimingMode(*arg)

int32 __CFUNC DAQmxGetAIADCCustomTimingMode(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAIADCTimingMode(*arg)

int32 __CFUNC DAQmxGetAIADCTimingMode(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIAccelSensitivity(*arg)

int32 __CFUNC DAQmxGetAIAccelSensitivity(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIAccelSensitivityUnits(*arg)

int32 __CFUNC DAQmxGetAIAccelSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIAccelUnits(*arg)

int32 __CFUNC DAQmxGetAIAccelUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIAcceldBRef(*arg)

int32 __CFUNC DAQmxGetAIAcceldBRef(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIAtten(*arg)

int32 __CFUNC DAQmxGetAIAtten(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIAutoZeroMode(*arg)

int32 __CFUNC DAQmxGetAIAutoZeroMode(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIAveragingWinSize(*arg)

int32 __CFUNC DAQmxGetAIAveragingWinSize(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAIBridgeBalanceCoarsePot(*arg)

int32 __CFUNC DAQmxGetAIBridgeBalanceCoarsePot(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIBridgeBalanceFinePot(*arg)

int32 __CFUNC DAQmxGetAIBridgeBalanceFinePot(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIBridgeCfg(*arg)

int32 __CFUNC DAQmxGetAIBridgeCfg(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIBridgeElectricalUnits(*arg)

int32 __CFUNC DAQmxGetAIBridgeElectricalUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIBridgeInitialRatio(*arg)

int32 __CFUNC DAQmxGetAIBridgeInitialRatio(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgeInitialVoltage(*arg)

int32 __CFUNC DAQmxGetAIBridgeInitialVoltage(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgeNomResistance(*arg)

int32 __CFUNC DAQmxGetAIBridgeNomResistance(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgePhysicalUnits(*arg)

int32 __CFUNC DAQmxGetAIBridgePhysicalUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIBridgePolyForwardCoeff(*arg)

int32 __CFUNC DAQmxGetAIBridgePolyForwardCoeff (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIBridgePolyReverseCoeff(*arg)

int32 __CFUNC DAQmxGetAIBridgePolyReverseCoeff (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIBridgeScaleType(*arg)

int32 __CFUNC DAQmxGetAIBridgeScaleType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIBridgeShuntCalEnable(*arg)

int32 __CFUNC DAQmxGetAIBridgeShuntCalEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIBridgeShuntCalGainAdjust(*arg)

int32 __CFUNC DAQmxGetAIBridgeShuntCalGainAdjust(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgeShuntCalSelect(*arg)

int32 __CFUNC DAQmxGetAIBridgeShuntCalSelect(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIBridgeShuntCalShuntCalAActualResistance(*arg)

int32 __CFUNC DAQmxGetAIBridgeShuntCalShuntCalAActualResistance (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgeShuntCalShuntCalAResistance(*arg)

int32 __CFUNC DAQmxGetAIBridgeShuntCalShuntCalAResistance (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgeTableElectricalVals(*arg)

int32 __CFUNC DAQmxGetAIBridgeTableElectricalVals (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIBridgeTablePhysicalVals(*arg)

int32 __CFUNC DAQmxGetAIBridgeTablePhysicalVals (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIBridgeTwoPointLinFirstElectricalVal(*arg)

int32 __CFUNC DAQmxGetAIBridgeTwoPointLinFirstElectricalVal (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgeTwoPointLinFirstPhysicalVal(*arg)

int32 __CFUNC DAQmxGetAIBridgeTwoPointLinFirstPhysicalVal (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgeTwoPointLinSecondElectricalVal(*arg)

int32 __CFUNC DAQmxGetAIBridgeTwoPointLinSecondElectricalVal (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgeTwoPointLinSecondPhysicalVal(*arg)

int32 __CFUNC DAQmxGetAIBridgeTwoPointLinSecondPhysicalVal (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIBridgeUnits(*arg)

int32 __CFUNC DAQmxGetAIBridgeUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIChanCalApplyCalIfExp(*arg)

int32 __CFUNC DAQmxGetAIChanCalApplyCalIfExp(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIChanCalCalDate(*arg)

int32 __CFUNC DAQmxGetAIChanCalCalDate (TaskHandle taskHandle, const char channelName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);

htf.daqmx.core.DAQmxGetAIChanCalDesc(*arg)

int32 __CFUNC DAQmxGetAIChanCalDesc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIChanCalEnableCal(*arg)

int32 __CFUNC DAQmxGetAIChanCalEnableCal(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIChanCalExpDate(*arg)

int32 __CFUNC DAQmxGetAIChanCalExpDate (TaskHandle taskHandle, const char channelName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);

htf.daqmx.core.DAQmxGetAIChanCalHasValidCalInfo(*arg)

int32 __CFUNC DAQmxGetAIChanCalHasValidCalInfo(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIChanCalOperatorName(*arg)

int32 __CFUNC DAQmxGetAIChanCalOperatorName (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIChanCalPolyForwardCoeff(*arg)

int32 __CFUNC DAQmxGetAIChanCalPolyForwardCoeff (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIChanCalPolyReverseCoeff(*arg)

int32 __CFUNC DAQmxGetAIChanCalPolyReverseCoeff (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIChanCalScaleType(*arg)

int32 __CFUNC DAQmxGetAIChanCalScaleType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIChanCalTablePreScaledVals(*arg)

int32 __CFUNC DAQmxGetAIChanCalTablePreScaledVals (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIChanCalTableScaledVals(*arg)

int32 __CFUNC DAQmxGetAIChanCalTableScaledVals (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIChanCalVerifAcqVals(*arg)

int32 __CFUNC DAQmxGetAIChanCalVerifAcqVals (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIChanCalVerifRefVals(*arg)

int32 __CFUNC DAQmxGetAIChanCalVerifRefVals (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIConvActiveEdge(*arg)

int32 __CFUNC DAQmxGetAIConvActiveEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAIConvActiveEdgeEx(*arg)

int32 __CFUNC DAQmxGetAIConvActiveEdgeEx(TaskHandle taskHandle, const char deviceNames[], int32 *data);

htf.daqmx.core.DAQmxGetAIConvDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetAIConvDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAIConvDigFltrEnableEx(*arg)

int32 __CFUNC DAQmxGetAIConvDigFltrEnableEx(TaskHandle taskHandle, const char deviceNames[], bool32 *data);

htf.daqmx.core.DAQmxGetAIConvDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetAIConvDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAIConvDigFltrMinPulseWidthEx(*arg)

int32 __CFUNC DAQmxGetAIConvDigFltrMinPulseWidthEx (TaskHandle taskHandle, const char deviceNames[], float64 *data);

htf.daqmx.core.DAQmxGetAIConvDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetAIConvDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAIConvDigFltrTimebaseRateEx(*arg)

int32 __CFUNC DAQmxGetAIConvDigFltrTimebaseRateEx (TaskHandle taskHandle, const char deviceNames[], float64 *data);

htf.daqmx.core.DAQmxGetAIConvDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetAIConvDigFltrTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIConvDigFltrTimebaseSrcEx(*arg)

int32 __CFUNC DAQmxGetAIConvDigFltrTimebaseSrcEx (TaskHandle taskHandle, const char deviceNames[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIConvDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetAIConvDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAIConvDigSyncEnableEx(*arg)

int32 __CFUNC DAQmxGetAIConvDigSyncEnableEx(TaskHandle taskHandle, const char deviceNames[], bool32 *data);

htf.daqmx.core.DAQmxGetAIConvMaxRate(*arg)

int32 __CFUNC DAQmxGetAIConvMaxRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAIConvMaxRateEx(*arg)

int32 __CFUNC DAQmxGetAIConvMaxRateEx(TaskHandle taskHandle, const char deviceNames[], float64 *data);

htf.daqmx.core.DAQmxGetAIConvRate(*arg)

int32 __CFUNC DAQmxGetAIConvRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAIConvRateEx(*arg)

int32 __CFUNC DAQmxGetAIConvRateEx(TaskHandle taskHandle, const char deviceNames[], float64 *data);

htf.daqmx.core.DAQmxGetAIConvSrc(*arg)

int32 __CFUNC DAQmxGetAIConvSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIConvSrcEx(*arg)

int32 __CFUNC DAQmxGetAIConvSrcEx (TaskHandle taskHandle, const char deviceNames[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIConvTimebaseDiv(*arg)

int32 __CFUNC DAQmxGetAIConvTimebaseDiv(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetAIConvTimebaseDivEx(*arg)

int32 __CFUNC DAQmxGetAIConvTimebaseDivEx(TaskHandle taskHandle, const char deviceNames[], uInt32 *data);

htf.daqmx.core.DAQmxGetAIConvTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetAIConvTimebaseSrc(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAIConvTimebaseSrcEx(*arg)

int32 __CFUNC DAQmxGetAIConvTimebaseSrcEx(TaskHandle taskHandle, const char deviceNames[], int32 *data);

htf.daqmx.core.DAQmxGetAICoupling(*arg)

int32 __CFUNC DAQmxGetAICoupling(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAICurrentACRMSUnits(*arg)

int32 __CFUNC DAQmxGetAICurrentACRMSUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAICurrentShuntLoc(*arg)

int32 __CFUNC DAQmxGetAICurrentShuntLoc(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAICurrentShuntResistance(*arg)

int32 __CFUNC DAQmxGetAICurrentShuntResistance(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAICurrentUnits(*arg)

int32 __CFUNC DAQmxGetAICurrentUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAICustomScaleName(*arg)

int32 __CFUNC DAQmxGetAICustomScaleName (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIDCOffset(*arg)

int32 __CFUNC DAQmxGetAIDCOffset(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIDataXferCustomThreshold(*arg)

int32 __CFUNC DAQmxGetAIDataXferCustomThreshold(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAIDataXferMech(*arg)

int32 __CFUNC DAQmxGetAIDataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIDataXferReqCond(*arg)

int32 __CFUNC DAQmxGetAIDataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIDevScalingCoeff(*arg)

int32 __CFUNC DAQmxGetAIDevScalingCoeff (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAIDitherEnable(*arg)

int32 __CFUNC DAQmxGetAIDitherEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIEddyCurrentProxProbeSensitivity(*arg)

int32 __CFUNC DAQmxGetAIEddyCurrentProxProbeSensitivity (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIEddyCurrentProxProbeSensitivityUnits(*arg)

int32 __CFUNC DAQmxGetAIEddyCurrentProxProbeSensitivityUnits (TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIEddyCurrentProxProbeUnits(*arg)

int32 __CFUNC DAQmxGetAIEddyCurrentProxProbeUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIEnhancedAliasRejectionEnable(*arg)

int32 __CFUNC DAQmxGetAIEnhancedAliasRejectionEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIExcitActualVal(*arg)

int32 __CFUNC DAQmxGetAIExcitActualVal(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIExcitDCorAC(*arg)

int32 __CFUNC DAQmxGetAIExcitDCorAC(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIExcitSrc(*arg)

int32 __CFUNC DAQmxGetAIExcitSrc(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIExcitUseForScaling(*arg)

int32 __CFUNC DAQmxGetAIExcitUseForScaling(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIExcitUseMultiplexed(*arg)

int32 __CFUNC DAQmxGetAIExcitUseMultiplexed(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIExcitVal(*arg)

int32 __CFUNC DAQmxGetAIExcitVal(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIExcitVoltageOrCurrent(*arg)

int32 __CFUNC DAQmxGetAIExcitVoltageOrCurrent(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIFilterDelay(*arg)

int32 __CFUNC DAQmxGetAIFilterDelay(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIFilterDelayAdjustment(*arg)

int32 __CFUNC DAQmxGetAIFilterDelayAdjustment(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIFilterDelayUnits(*arg)

int32 __CFUNC DAQmxGetAIFilterDelayUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIForceIEPESensorSensitivity(*arg)

int32 __CFUNC DAQmxGetAIForceIEPESensorSensitivity (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIForceIEPESensorSensitivityUnits(*arg)

int32 __CFUNC DAQmxGetAIForceIEPESensorSensitivityUnits (TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIForceReadFromChan(*arg)

int32 __CFUNC DAQmxGetAIForceReadFromChan(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIForceUnits(*arg)

int32 __CFUNC DAQmxGetAIForceUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIFreqHyst(*arg)

int32 __CFUNC DAQmxGetAIFreqHyst(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIFreqThreshVoltage(*arg)

int32 __CFUNC DAQmxGetAIFreqThreshVoltage(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIFreqUnits(*arg)

int32 __CFUNC DAQmxGetAIFreqUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIGain(*arg)

int32 __CFUNC DAQmxGetAIGain(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIImpedance(*arg)

int32 __CFUNC DAQmxGetAIImpedance(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIInputSrc(*arg)

int32 __CFUNC DAQmxGetAIInputSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIIsTEDS(*arg)

int32 __CFUNC DAQmxGetAIIsTEDS(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAILVDTSensitivity(*arg)

int32 __CFUNC DAQmxGetAILVDTSensitivity(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAILVDTSensitivityUnits(*arg)

int32 __CFUNC DAQmxGetAILVDTSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAILVDTUnits(*arg)

int32 __CFUNC DAQmxGetAILVDTUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAILeadWireResistance(*arg)

int32 __CFUNC DAQmxGetAILeadWireResistance(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAILossyLSBRemovalCompressedSampSize(*arg)

int32 __CFUNC DAQmxGetAILossyLSBRemovalCompressedSampSize (TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAILowpassCutoffFreq(*arg)

int32 __CFUNC DAQmxGetAILowpassCutoffFreq(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAILowpassEnable(*arg)

int32 __CFUNC DAQmxGetAILowpassEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAILowpassSwitchCapClkSrc(*arg)

int32 __CFUNC DAQmxGetAILowpassSwitchCapClkSrc(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAILowpassSwitchCapExtClkDiv(*arg)

int32 __CFUNC DAQmxGetAILowpassSwitchCapExtClkDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAILowpassSwitchCapExtClkFreq(*arg)

int32 __CFUNC DAQmxGetAILowpassSwitchCapExtClkFreq (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAILowpassSwitchCapOutClkDiv(*arg)

int32 __CFUNC DAQmxGetAILowpassSwitchCapOutClkDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAIMax(*arg)

int32 __CFUNC DAQmxGetAIMax(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIMeasType(*arg)

int32 __CFUNC DAQmxGetAIMeasType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIMemMapEnable(*arg)

int32 __CFUNC DAQmxGetAIMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIMicrophoneSensitivity(*arg)

int32 __CFUNC DAQmxGetAIMicrophoneSensitivity(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIMin(*arg)

int32 __CFUNC DAQmxGetAIMin(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIOpenThrmcplDetectEnable(*arg)

int32 __CFUNC DAQmxGetAIOpenThrmcplDetectEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIPressureUnits(*arg)

int32 __CFUNC DAQmxGetAIPressureUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIProbeAtten(*arg)

int32 __CFUNC DAQmxGetAIProbeAtten(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIRTDA(*arg)

int32 __CFUNC DAQmxGetAIRTDA(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIRTDB(*arg)

int32 __CFUNC DAQmxGetAIRTDB(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIRTDC(*arg)

int32 __CFUNC DAQmxGetAIRTDC(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIRTDR0(*arg)

int32 __CFUNC DAQmxGetAIRTDR0(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIRTDType(*arg)

int32 __CFUNC DAQmxGetAIRTDType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIRVDTSensitivity(*arg)

int32 __CFUNC DAQmxGetAIRVDTSensitivity(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIRVDTSensitivityUnits(*arg)

int32 __CFUNC DAQmxGetAIRVDTSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIRVDTUnits(*arg)

int32 __CFUNC DAQmxGetAIRVDTUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIRawDataCompressionType(*arg)

int32 __CFUNC DAQmxGetAIRawDataCompressionType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIRawSampJustification(*arg)

int32 __CFUNC DAQmxGetAIRawSampJustification(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIRawSampSize(*arg)

int32 __CFUNC DAQmxGetAIRawSampSize(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAIRemoveFilterDelay(*arg)

int32 __CFUNC DAQmxGetAIRemoveFilterDelay(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIResistanceCfg(*arg)

int32 __CFUNC DAQmxGetAIResistanceCfg(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIResistanceUnits(*arg)

int32 __CFUNC DAQmxGetAIResistanceUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIResolution(*arg)

int32 __CFUNC DAQmxGetAIResolution(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIResolutionUnits(*arg)

int32 __CFUNC DAQmxGetAIResolutionUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIRngHigh(*arg)

int32 __CFUNC DAQmxGetAIRngHigh(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIRngLow(*arg)

int32 __CFUNC DAQmxGetAIRngLow(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIRosetteStrainGageOrientation(*arg)

int32 __CFUNC DAQmxGetAIRosetteStrainGageOrientation (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIRosetteStrainGageRosetteMeasType(*arg)

int32 __CFUNC DAQmxGetAIRosetteStrainGageRosetteMeasType (TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIRosetteStrainGageRosetteType(*arg)

int32 __CFUNC DAQmxGetAIRosetteStrainGageRosetteType (TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIRosetteStrainGageStrainChans(*arg)

int32 __CFUNC DAQmxGetAIRosetteStrainGageStrainChans (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAISampAndHoldEnable(*arg)

int32 __CFUNC DAQmxGetAISampAndHoldEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAISoundPressureMaxSoundPressureLvl(*arg)

int32 __CFUNC DAQmxGetAISoundPressureMaxSoundPressureLvl (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAISoundPressureUnits(*arg)

int32 __CFUNC DAQmxGetAISoundPressureUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAISoundPressuredBRef(*arg)

int32 __CFUNC DAQmxGetAISoundPressuredBRef(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIStrainGageCfg(*arg)

int32 __CFUNC DAQmxGetAIStrainGageCfg(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIStrainGageForceReadFromChan(*arg)

int32 __CFUNC DAQmxGetAIStrainGageForceReadFromChan (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAIStrainGageGageFactor(*arg)

int32 __CFUNC DAQmxGetAIStrainGageGageFactor(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIStrainGagePoissonRatio(*arg)

int32 __CFUNC DAQmxGetAIStrainGagePoissonRatio(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIStrainUnits(*arg)

int32 __CFUNC DAQmxGetAIStrainUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAITEDSUnits(*arg)

int32 __CFUNC DAQmxGetAITEDSUnits (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAITempUnits(*arg)

int32 __CFUNC DAQmxGetAITempUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAITermCfg(*arg)

int32 __CFUNC DAQmxGetAITermCfg(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIThrmcplCJCChan(*arg)

int32 __CFUNC DAQmxGetAIThrmcplCJCChan (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAIThrmcplCJCSrc(*arg)

int32 __CFUNC DAQmxGetAIThrmcplCJCSrc(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIThrmcplCJCVal(*arg)

int32 __CFUNC DAQmxGetAIThrmcplCJCVal(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIThrmcplLeadOffsetVoltage(*arg)

int32 __CFUNC DAQmxGetAIThrmcplLeadOffsetVoltage(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIThrmcplScaleType(*arg)

int32 __CFUNC DAQmxGetAIThrmcplScaleType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIThrmcplType(*arg)

int32 __CFUNC DAQmxGetAIThrmcplType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIThrmstrA(*arg)

int32 __CFUNC DAQmxGetAIThrmstrA(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIThrmstrB(*arg)

int32 __CFUNC DAQmxGetAIThrmstrB(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIThrmstrC(*arg)

int32 __CFUNC DAQmxGetAIThrmstrC(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIThrmstrR1(*arg)

int32 __CFUNC DAQmxGetAIThrmstrR1(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAITorqueUnits(*arg)

int32 __CFUNC DAQmxGetAITorqueUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIUsbXferReqCount(*arg)

int32 __CFUNC DAQmxGetAIUsbXferReqCount(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAIUsbXferReqSize(*arg)

int32 __CFUNC DAQmxGetAIUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAIVelocityIEPESensorSensitivity(*arg)

int32 __CFUNC DAQmxGetAIVelocityIEPESensorSensitivity (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIVelocityIEPESensorSensitivityUnits(*arg)

int32 __CFUNC DAQmxGetAIVelocityIEPESensorSensitivityUnits (TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIVelocityIEPESensordBRef(*arg)

int32 __CFUNC DAQmxGetAIVelocityIEPESensordBRef(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAIVelocityUnits(*arg)

int32 __CFUNC DAQmxGetAIVelocityUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIVoltageACRMSUnits(*arg)

int32 __CFUNC DAQmxGetAIVoltageACRMSUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIVoltageUnits(*arg)

int32 __CFUNC DAQmxGetAIVoltageUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAIVoltagedBRef(*arg)

int32 __CFUNC DAQmxGetAIVoltagedBRef(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOCurrentUnits(*arg)

int32 __CFUNC DAQmxGetAOCurrentUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAOCustomScaleName(*arg)

int32 __CFUNC DAQmxGetAOCustomScaleName (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAODACOffsetExtSrc(*arg)

int32 __CFUNC DAQmxGetAODACOffsetExtSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAODACOffsetSrc(*arg)

int32 __CFUNC DAQmxGetAODACOffsetSrc(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAODACOffsetVal(*arg)

int32 __CFUNC DAQmxGetAODACOffsetVal(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAODACRefAllowConnToGnd(*arg)

int32 __CFUNC DAQmxGetAODACRefAllowConnToGnd(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAODACRefConnToGnd(*arg)

int32 __CFUNC DAQmxGetAODACRefConnToGnd(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAODACRefExtSrc(*arg)

int32 __CFUNC DAQmxGetAODACRefExtSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAODACRefSrc(*arg)

int32 __CFUNC DAQmxGetAODACRefSrc(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAODACRefVal(*arg)

int32 __CFUNC DAQmxGetAODACRefVal(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAODACRngHigh(*arg)

int32 __CFUNC DAQmxGetAODACRngHigh(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAODACRngLow(*arg)

int32 __CFUNC DAQmxGetAODACRngLow(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAODataXferMech(*arg)

int32 __CFUNC DAQmxGetAODataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAODataXferReqCond(*arg)

int32 __CFUNC DAQmxGetAODataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAODevScalingCoeff(*arg)

int32 __CFUNC DAQmxGetAODevScalingCoeff (TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAOEnhancedImageRejectionEnable(*arg)

int32 __CFUNC DAQmxGetAOEnhancedImageRejectionEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAOFilterDelay(*arg)

int32 __CFUNC DAQmxGetAOFilterDelay(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOFilterDelayAdjustment(*arg)

int32 __CFUNC DAQmxGetAOFilterDelayAdjustment(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOFilterDelayUnits(*arg)

int32 __CFUNC DAQmxGetAOFilterDelayUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAOFuncGenAmplitude(*arg)

int32 __CFUNC DAQmxGetAOFuncGenAmplitude(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOFuncGenFMDeviation(*arg)

int32 __CFUNC DAQmxGetAOFuncGenFMDeviation(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOFuncGenFreq(*arg)

int32 __CFUNC DAQmxGetAOFuncGenFreq(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOFuncGenModulationType(*arg)

int32 __CFUNC DAQmxGetAOFuncGenModulationType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAOFuncGenOffset(*arg)

int32 __CFUNC DAQmxGetAOFuncGenOffset(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOFuncGenSquareDutyCycle(*arg)

int32 __CFUNC DAQmxGetAOFuncGenSquareDutyCycle(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOFuncGenType(*arg)

int32 __CFUNC DAQmxGetAOFuncGenType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAOGain(*arg)

int32 __CFUNC DAQmxGetAOGain(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOIdleOutputBehavior(*arg)

int32 __CFUNC DAQmxGetAOIdleOutputBehavior(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAOLoadImpedance(*arg)

int32 __CFUNC DAQmxGetAOLoadImpedance(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOMax(*arg)

int32 __CFUNC DAQmxGetAOMax(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOMemMapEnable(*arg)

int32 __CFUNC DAQmxGetAOMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAOMin(*arg)

int32 __CFUNC DAQmxGetAOMin(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOOutputImpedance(*arg)

int32 __CFUNC DAQmxGetAOOutputImpedance(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOOutputType(*arg)

int32 __CFUNC DAQmxGetAOOutputType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAOPowerAmpChannelEnable(*arg)

int32 __CFUNC DAQmxGetAOPowerAmpChannelEnable(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetAOPowerAmpGain(*arg)

int32 __CFUNC DAQmxGetAOPowerAmpGain(const char physicalChannel[], float64 *data);

htf.daqmx.core.DAQmxGetAOPowerAmpOffset(*arg)

int32 __CFUNC DAQmxGetAOPowerAmpOffset(const char physicalChannel[], float64 *data);

htf.daqmx.core.DAQmxGetAOPowerAmpOvercurrent(*arg)

int32 __CFUNC DAQmxGetAOPowerAmpOvercurrent(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetAOPowerAmpScalingCoeff(*arg)

int32 __CFUNC DAQmxGetAOPowerAmpScalingCoeff (const char physicalChannel[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetAOReglitchEnable(*arg)

int32 __CFUNC DAQmxGetAOReglitchEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAOResolution(*arg)

int32 __CFUNC DAQmxGetAOResolution(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOResolutionUnits(*arg)

int32 __CFUNC DAQmxGetAOResolutionUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAOTermCfg(*arg)

int32 __CFUNC DAQmxGetAOTermCfg(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAOUsbXferReqCount(*arg)

int32 __CFUNC DAQmxGetAOUsbXferReqCount(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAOUsbXferReqSize(*arg)

int32 __CFUNC DAQmxGetAOUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetAOUseOnlyOnBrdMem(*arg)

int32 __CFUNC DAQmxGetAOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetAOVoltageCurrentLimit(*arg)

int32 __CFUNC DAQmxGetAOVoltageCurrentLimit(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetAOVoltageUnits(*arg)

int32 __CFUNC DAQmxGetAOVoltageUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetAdvTrigType(*arg)

int32 __CFUNC DAQmxGetAdvTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnalogPowerUpStates(*arg)

int32 __CFUNC_C DAQmxGetAnalogPowerUpStates (const char deviceName[], const char channelName[], float64* state, int32 channelType, …);

htf.daqmx.core.DAQmxGetAnalogPowerUpStatesWithOutputType(*arg)

int32 __CFUNC_C DAQmxGetAnalogPowerUpStatesWithOutputType (const char channelNames[], float64 stateArray[], int32 channelTypeArray[], uInt32 *arraySizePtr);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigCoupling(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigCoupling(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigDigFltrTimebaseSrc (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigHyst(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigHyst(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigLvl(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigLvl(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigSlope(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigSlope(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigSrc(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeRefTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigCoupling(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigCoupling(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigDigFltrTimebaseSrc (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigHyst(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigHyst(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigLvl(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigLvl(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigSlope(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigSlope(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigSrc(*arg)

int32 __CFUNC DAQmxGetAnlgEdgeStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigCoupling(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigCoupling(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigDigFltrTimebaseSrc (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigHyst(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigHyst(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigLvl(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigLvl(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigSrc(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigWhen(*arg)

int32 __CFUNC DAQmxGetAnlgLvlPauseTrigWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigBtm(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigBtm(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigCoupling(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigCoupling(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigDigFltrTimebaseSrc (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigSrc(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigTop(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigTop(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigWhen(*arg)

int32 __CFUNC DAQmxGetAnlgWinPauseTrigWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigBtm(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigBtm(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigCoupling(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigCoupling(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigDigFltrTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigSrc(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigTop(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigTop(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinRefTrigWhen(*arg)

int32 __CFUNC DAQmxGetAnlgWinRefTrigWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigBtm(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigBtm(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigCoupling(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigCoupling(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigDigFltrTimebaseSrc (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigSrc(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigTop(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigTop(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetAnlgWinStartTrigWhen(*arg)

int32 __CFUNC DAQmxGetAnlgWinStartTrigWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetArmStartTerm(*arg)

int32 __CFUNC DAQmxGetArmStartTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetArmStartTrigType(*arg)

int32 __CFUNC DAQmxGetArmStartTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetAutoConfiguredCDAQSyncConnections(*arg)

int32 __CFUNC DAQmxGetAutoConfiguredCDAQSyncConnections(char portList[], uInt32 portListSize);

htf.daqmx.core.DAQmxGetBufInputBufSize(*arg)

int32 __CFUNC DAQmxGetBufInputBufSize(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetBufInputOnbrdBufSize(*arg)

int32 __CFUNC DAQmxGetBufInputOnbrdBufSize(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetBufOutputBufSize(*arg)

int32 __CFUNC DAQmxGetBufOutputBufSize(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetBufOutputOnbrdBufSize(*arg)

int32 __CFUNC DAQmxGetBufOutputOnbrdBufSize(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetBufferAttribute(*arg)

int32 __CFUNC_C DAQmxGetBufferAttribute (TaskHandle taskHandle, int32 attribute, void *value);

htf.daqmx.core.DAQmxGetCIAngEncoderInitialAngle(*arg)

int32 __CFUNC DAQmxGetCIAngEncoderInitialAngle(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIAngEncoderPulsesPerRev(*arg)

int32 __CFUNC DAQmxGetCIAngEncoderPulsesPerRev(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCIAngEncoderUnits(*arg)

int32 __CFUNC DAQmxGetCIAngEncoderUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCICount(*arg)

int32 __CFUNC DAQmxGetCICount(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesActiveEdge(*arg)

int32 __CFUNC DAQmxGetCICountEdgesActiveEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountDirDigFltrEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountDirDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountDirDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountDirDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountDirDigSyncEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountResetActiveEdge(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountResetActiveEdge (TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountResetDigFltrEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountResetDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountResetDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountResetDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountResetDigSyncEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountResetEnable(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountResetEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountResetResetCount(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountResetResetCount (TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesCountResetTerm(*arg)

int32 __CFUNC DAQmxGetCICountEdgesCountResetTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCICountEdgesDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCICountEdgesDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCICountEdgesDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCICountEdgesDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCICountEdgesDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCICountEdgesDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCICountEdgesDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCICountEdgesDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCICountEdgesDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesDir(*arg)

int32 __CFUNC DAQmxGetCICountEdgesDir(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesDirTerm(*arg)

int32 __CFUNC DAQmxGetCICountEdgesDirTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCICountEdgesInitialCnt(*arg)

int32 __CFUNC DAQmxGetCICountEdgesInitialCnt(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCICountEdgesTerm(*arg)

int32 __CFUNC DAQmxGetCICountEdgesTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCICtrTimebaseActiveEdge(*arg)

int32 __CFUNC DAQmxGetCICtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCICtrTimebaseDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCICtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCICtrTimebaseDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCICtrTimebaseDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCICtrTimebaseDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCICtrTimebaseDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCICtrTimebaseDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCICtrTimebaseDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCICtrTimebaseDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCICtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCICtrTimebaseMasterTimebaseDiv(*arg)

int32 __CFUNC DAQmxGetCICtrTimebaseMasterTimebaseDiv (TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCICtrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCICtrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCICtrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCICtrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCICustomScaleName(*arg)

int32 __CFUNC DAQmxGetCICustomScaleName (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIDataXferMech(*arg)

int32 __CFUNC DAQmxGetCIDataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIDataXferReqCond(*arg)

int32 __CFUNC DAQmxGetCIDataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIDupCountPrevent(*arg)

int32 __CFUNC DAQmxGetCIDupCountPrevent(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIEncoderAInputDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCIEncoderAInputDigFltrEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIEncoderAInputDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCIEncoderAInputDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIEncoderAInputDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCIEncoderAInputDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIEncoderAInputDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCIEncoderAInputDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIEncoderAInputDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCIEncoderAInputDigSyncEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIEncoderAInputTerm(*arg)

int32 __CFUNC DAQmxGetCIEncoderAInputTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIEncoderBInputDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCIEncoderBInputDigFltrEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIEncoderBInputDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCIEncoderBInputDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIEncoderBInputDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCIEncoderBInputDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIEncoderBInputDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCIEncoderBInputDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIEncoderBInputDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCIEncoderBInputDigSyncEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIEncoderBInputTerm(*arg)

int32 __CFUNC DAQmxGetCIEncoderBInputTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIEncoderDecodingType(*arg)

int32 __CFUNC DAQmxGetCIEncoderDecodingType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIEncoderZIndexEnable(*arg)

int32 __CFUNC DAQmxGetCIEncoderZIndexEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIEncoderZIndexPhase(*arg)

int32 __CFUNC DAQmxGetCIEncoderZIndexPhase(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIEncoderZIndexVal(*arg)

int32 __CFUNC DAQmxGetCIEncoderZIndexVal(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIEncoderZInputDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCIEncoderZInputDigFltrEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIEncoderZInputDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCIEncoderZInputDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIEncoderZInputDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCIEncoderZInputDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIEncoderZInputDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCIEncoderZInputDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIEncoderZInputDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCIEncoderZInputDigSyncEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIEncoderZInputTerm(*arg)

int32 __CFUNC DAQmxGetCIEncoderZInputTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIFreqDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCIFreqDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIFreqDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCIFreqDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIFreqDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCIFreqDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIFreqDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCIFreqDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIFreqDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCIFreqDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIFreqDiv(*arg)

int32 __CFUNC DAQmxGetCIFreqDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCIFreqEnableAveraging(*arg)

int32 __CFUNC DAQmxGetCIFreqEnableAveraging(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIFreqMeasMeth(*arg)

int32 __CFUNC DAQmxGetCIFreqMeasMeth(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIFreqMeasTime(*arg)

int32 __CFUNC DAQmxGetCIFreqMeasTime(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIFreqStartingEdge(*arg)

int32 __CFUNC DAQmxGetCIFreqStartingEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIFreqTerm(*arg)

int32 __CFUNC DAQmxGetCIFreqTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIFreqUnits(*arg)

int32 __CFUNC DAQmxGetCIFreqUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIGPSSyncMethod(*arg)

int32 __CFUNC DAQmxGetCIGPSSyncMethod(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIGPSSyncSrc(*arg)

int32 __CFUNC DAQmxGetCIGPSSyncSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCILinEncoderDistPerPulse(*arg)

int32 __CFUNC DAQmxGetCILinEncoderDistPerPulse(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCILinEncoderInitialPos(*arg)

int32 __CFUNC DAQmxGetCILinEncoderInitialPos(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCILinEncoderUnits(*arg)

int32 __CFUNC DAQmxGetCILinEncoderUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIMax(*arg)

int32 __CFUNC DAQmxGetCIMax(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIMeasType(*arg)

int32 __CFUNC DAQmxGetCIMeasType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIMemMapEnable(*arg)

int32 __CFUNC DAQmxGetCIMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIMin(*arg)

int32 __CFUNC DAQmxGetCIMin(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCINumPossiblyInvalidSamps(*arg)

int32 __CFUNC DAQmxGetCINumPossiblyInvalidSamps(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCIOutputState(*arg)

int32 __CFUNC DAQmxGetCIOutputState(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPeriodDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCIPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPeriodDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCIPeriodDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPeriodDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCIPeriodDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPeriodDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCIPeriodDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPeriodDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCIPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPeriodDiv(*arg)

int32 __CFUNC DAQmxGetCIPeriodDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCIPeriodEnableAveraging(*arg)

int32 __CFUNC DAQmxGetCIPeriodEnableAveraging(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPeriodMeasMeth(*arg)

int32 __CFUNC DAQmxGetCIPeriodMeasMeth(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPeriodMeasTime(*arg)

int32 __CFUNC DAQmxGetCIPeriodMeasTime(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPeriodStartingEdge(*arg)

int32 __CFUNC DAQmxGetCIPeriodStartingEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPeriodTerm(*arg)

int32 __CFUNC DAQmxGetCIPeriodTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPeriodUnits(*arg)

int32 __CFUNC DAQmxGetCIPeriodUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPrescaler(*arg)

int32 __CFUNC DAQmxGetCIPrescaler(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCIPulseFreqDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCIPulseFreqDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPulseFreqDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCIPulseFreqDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPulseFreqDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCIPulseFreqDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPulseFreqDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCIPulseFreqDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPulseFreqDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCIPulseFreqDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPulseFreqStartEdge(*arg)

int32 __CFUNC DAQmxGetCIPulseFreqStartEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPulseFreqTerm(*arg)

int32 __CFUNC DAQmxGetCIPulseFreqTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPulseFreqUnits(*arg)

int32 __CFUNC DAQmxGetCIPulseFreqUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPulseTicksDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCIPulseTicksDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPulseTicksDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCIPulseTicksDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPulseTicksDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCIPulseTicksDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPulseTicksDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCIPulseTicksDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPulseTicksDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCIPulseTicksDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPulseTicksStartEdge(*arg)

int32 __CFUNC DAQmxGetCIPulseTicksStartEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPulseTicksTerm(*arg)

int32 __CFUNC DAQmxGetCIPulseTicksTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPulseTimeDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCIPulseTimeDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPulseTimeDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCIPulseTimeDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPulseTimeDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCIPulseTimeDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPulseTimeDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCIPulseTimeDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPulseTimeDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCIPulseTimeDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPulseTimeStartEdge(*arg)

int32 __CFUNC DAQmxGetCIPulseTimeStartEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPulseTimeTerm(*arg)

int32 __CFUNC DAQmxGetCIPulseTimeTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPulseTimeUnits(*arg)

int32 __CFUNC DAQmxGetCIPulseTimeUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPulseWidthDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCIPulseWidthDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPulseWidthDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCIPulseWidthDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPulseWidthDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCIPulseWidthDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCIPulseWidthDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCIPulseWidthDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPulseWidthDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCIPulseWidthDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCIPulseWidthStartingEdge(*arg)

int32 __CFUNC DAQmxGetCIPulseWidthStartingEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIPulseWidthTerm(*arg)

int32 __CFUNC DAQmxGetCIPulseWidthTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCIPulseWidthUnits(*arg)

int32 __CFUNC DAQmxGetCIPulseWidthUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCISemiPeriodDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCISemiPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCISemiPeriodDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCISemiPeriodDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCISemiPeriodDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCISemiPeriodDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCISemiPeriodDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCISemiPeriodDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCISemiPeriodDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCISemiPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCISemiPeriodStartingEdge(*arg)

int32 __CFUNC DAQmxGetCISemiPeriodStartingEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCISemiPeriodTerm(*arg)

int32 __CFUNC DAQmxGetCISemiPeriodTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCISemiPeriodUnits(*arg)

int32 __CFUNC DAQmxGetCISemiPeriodUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCITCReached(*arg)

int32 __CFUNC DAQmxGetCITCReached(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCITimestampInitialSeconds(*arg)

int32 __CFUNC DAQmxGetCITimestampInitialSeconds(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCITimestampUnits(*arg)

int32 __CFUNC DAQmxGetCITimestampUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigFltrEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigSyncEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstEdge(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepFirstEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstTerm(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepFirstTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigFltrEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigSyncEnable (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondEdge(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepSecondEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondTerm(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepSecondTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCITwoEdgeSepUnits(*arg)

int32 __CFUNC DAQmxGetCITwoEdgeSepUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCIUsbXferReqCount(*arg)

int32 __CFUNC DAQmxGetCIUsbXferReqCount(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCIUsbXferReqSize(*arg)

int32 __CFUNC DAQmxGetCIUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOAutoIncrCnt(*arg)

int32 __CFUNC DAQmxGetCOAutoIncrCnt(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOConstrainedGenMode(*arg)

int32 __CFUNC DAQmxGetCOConstrainedGenMode(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCOCount(*arg)

int32 __CFUNC DAQmxGetCOCount(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOCtrTimebaseActiveEdge(*arg)

int32 __CFUNC DAQmxGetCOCtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetCOCtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetCOCtrTimebaseDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCOCtrTimebaseDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCOCtrTimebaseDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetCOCtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCOCtrTimebaseMasterTimebaseDiv(*arg)

int32 __CFUNC DAQmxGetCOCtrTimebaseMasterTimebaseDiv (TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOCtrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetCOCtrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCOCtrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetCOCtrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCODataXferMech(*arg)

int32 __CFUNC DAQmxGetCODataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCODataXferReqCond(*arg)

int32 __CFUNC DAQmxGetCODataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCOEnableInitialDelayOnRetrigger(*arg)

int32 __CFUNC DAQmxGetCOEnableInitialDelayOnRetrigger (TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCOMemMapEnable(*arg)

int32 __CFUNC DAQmxGetCOMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCOOutputState(*arg)

int32 __CFUNC DAQmxGetCOOutputState(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCOOutputType(*arg)

int32 __CFUNC DAQmxGetCOOutputType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCOPrescaler(*arg)

int32 __CFUNC DAQmxGetCOPrescaler(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOPulseDone(*arg)

int32 __CFUNC DAQmxGetCOPulseDone(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCOPulseDutyCyc(*arg)

int32 __CFUNC DAQmxGetCOPulseDutyCyc(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCOPulseFreq(*arg)

int32 __CFUNC DAQmxGetCOPulseFreq(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCOPulseFreqInitialDelay(*arg)

int32 __CFUNC DAQmxGetCOPulseFreqInitialDelay(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCOPulseFreqUnits(*arg)

int32 __CFUNC DAQmxGetCOPulseFreqUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCOPulseHighTicks(*arg)

int32 __CFUNC DAQmxGetCOPulseHighTicks(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOPulseHighTime(*arg)

int32 __CFUNC DAQmxGetCOPulseHighTime(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCOPulseIdleState(*arg)

int32 __CFUNC DAQmxGetCOPulseIdleState(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCOPulseLowTicks(*arg)

int32 __CFUNC DAQmxGetCOPulseLowTicks(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOPulseLowTime(*arg)

int32 __CFUNC DAQmxGetCOPulseLowTime(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCOPulseTerm(*arg)

int32 __CFUNC DAQmxGetCOPulseTerm (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCOPulseTicksInitialDelay(*arg)

int32 __CFUNC DAQmxGetCOPulseTicksInitialDelay(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOPulseTimeInitialDelay(*arg)

int32 __CFUNC DAQmxGetCOPulseTimeInitialDelay(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetCOPulseTimeUnits(*arg)

int32 __CFUNC DAQmxGetCOPulseTimeUnits(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetCORdyForNewVal(*arg)

int32 __CFUNC DAQmxGetCORdyForNewVal(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCOUsbXferReqCount(*arg)

int32 __CFUNC DAQmxGetCOUsbXferReqCount(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOUsbXferReqSize(*arg)

int32 __CFUNC DAQmxGetCOUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetCOUseOnlyOnBrdMem(*arg)

int32 __CFUNC DAQmxGetCOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetCalAccConnectionCount(*arg)

int32 __CFUNC DAQmxGetCalAccConnectionCount(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetCalDevTemp(*arg)

int32 __CFUNC DAQmxGetCalDevTemp(const char deviceName[], float64 *data);

htf.daqmx.core.DAQmxGetCalInfoAttribute(*arg)

int32 __CFUNC_C DAQmxGetCalInfoAttribute (const char deviceName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetCalRecommendedAccConnectionCountLimit(*arg)

int32 __CFUNC DAQmxGetCalRecommendedAccConnectionCountLimit(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetCalUserDefinedInfo(*arg)

int32 __CFUNC DAQmxGetCalUserDefinedInfo(const char deviceName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetCalUserDefinedInfoMaxSize(*arg)

int32 __CFUNC DAQmxGetCalUserDefinedInfoMaxSize(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetCarrierSerialNum(*arg)

int32 __CFUNC DAQmxGetCarrierSerialNum(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetChanAttribute(*arg)

int32 __CFUNC_C DAQmxGetChanAttribute (TaskHandle taskHandle, const char channel[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetChanDescr(*arg)

int32 __CFUNC DAQmxGetChanDescr(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetChanIsGlobal(*arg)

int32 __CFUNC DAQmxGetChanIsGlobal(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetChanType(*arg)

int32 __CFUNC DAQmxGetChanType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetChangeDetectDIFallingEdgePhysicalChans(*arg)

int32 __CFUNC DAQmxGetChangeDetectDIFallingEdgePhysicalChans (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetChangeDetectDIRisingEdgePhysicalChans(*arg)

int32 __CFUNC DAQmxGetChangeDetectDIRisingEdgePhysicalChans (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetChangeDetectDITristate(*arg)

int32 __CFUNC DAQmxGetChangeDetectDITristate(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDIAcquireOn(*arg)

int32 __CFUNC DAQmxGetDIAcquireOn(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDIDataXferMech(*arg)

int32 __CFUNC DAQmxGetDIDataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDIDataXferReqCond(*arg)

int32 __CFUNC DAQmxGetDIDataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDIDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetDIDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDIDigFltrEnableBusMode(*arg)

int32 __CFUNC DAQmxGetDIDigFltrEnableBusMode(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDIDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetDIDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetDIDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetDIDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetDIDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetDIDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDIDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetDIDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDIInvertLines(*arg)

int32 __CFUNC DAQmxGetDIInvertLines(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDILogicFamily(*arg)

int32 __CFUNC DAQmxGetDILogicFamily(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDIMemMapEnable(*arg)

int32 __CFUNC DAQmxGetDIMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDINumLines(*arg)

int32 __CFUNC DAQmxGetDINumLines(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetDITristate(*arg)

int32 __CFUNC DAQmxGetDITristate(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDIUsbXferReqCount(*arg)

int32 __CFUNC DAQmxGetDIUsbXferReqCount(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetDIUsbXferReqSize(*arg)

int32 __CFUNC DAQmxGetDIUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetDODataXferMech(*arg)

int32 __CFUNC DAQmxGetDODataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDODataXferReqCond(*arg)

int32 __CFUNC DAQmxGetDODataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDOGenerateOn(*arg)

int32 __CFUNC DAQmxGetDOGenerateOn(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDOInvertLines(*arg)

int32 __CFUNC DAQmxGetDOInvertLines(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDOLineStatesDoneState(*arg)

int32 __CFUNC DAQmxGetDOLineStatesDoneState(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDOLineStatesPausedState(*arg)

int32 __CFUNC DAQmxGetDOLineStatesPausedState(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDOLineStatesStartState(*arg)

int32 __CFUNC DAQmxGetDOLineStatesStartState(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDOLogicFamily(*arg)

int32 __CFUNC DAQmxGetDOLogicFamily(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDOMemMapEnable(*arg)

int32 __CFUNC DAQmxGetDOMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDONumLines(*arg)

int32 __CFUNC DAQmxGetDONumLines(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetDOOutputDriveType(*arg)

int32 __CFUNC DAQmxGetDOOutputDriveType(TaskHandle taskHandle, const char channel[], int32 *data);

htf.daqmx.core.DAQmxGetDOOvercurrentAutoReenable(*arg)

int32 __CFUNC DAQmxGetDOOvercurrentAutoReenable(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDOOvercurrentLimit(*arg)

int32 __CFUNC DAQmxGetDOOvercurrentLimit(TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetDOOvercurrentReenablePeriod(*arg)

int32 __CFUNC DAQmxGetDOOvercurrentReenablePeriod (TaskHandle taskHandle, const char channel[], float64 *data);

htf.daqmx.core.DAQmxGetDOTristate(*arg)

int32 __CFUNC DAQmxGetDOTristate(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDOUsbXferReqCount(*arg)

int32 __CFUNC DAQmxGetDOUsbXferReqCount(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetDOUsbXferReqSize(*arg)

int32 __CFUNC DAQmxGetDOUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);

htf.daqmx.core.DAQmxGetDOUseOnlyOnBrdMem(*arg)

int32 __CFUNC DAQmxGetDOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetDelayFromSampClkDelay(*arg)

int32 __CFUNC DAQmxGetDelayFromSampClkDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetDelayFromSampClkDelayEx(*arg)

int32 __CFUNC DAQmxGetDelayFromSampClkDelayEx (TaskHandle taskHandle, const char deviceNames[], float64 *data);

htf.daqmx.core.DAQmxGetDelayFromSampClkDelayUnits(*arg)

int32 __CFUNC DAQmxGetDelayFromSampClkDelayUnits(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDelayFromSampClkDelayUnitsEx(*arg)

int32 __CFUNC DAQmxGetDelayFromSampClkDelayUnitsEx (TaskHandle taskHandle, const char deviceNames[], int32 *data);

htf.daqmx.core.DAQmxGetDevAIBridgeRngs(*arg)

int32 __CFUNC DAQmxGetDevAIBridgeRngs(const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAICouplings(*arg)

int32 __CFUNC DAQmxGetDevAICouplings(const char device[], int32 *data);

htf.daqmx.core.DAQmxGetDevAICurrentIntExcitDiscreteVals(*arg)

int32 __CFUNC DAQmxGetDevAICurrentIntExcitDiscreteVals (const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAICurrentRngs(*arg)

int32 __CFUNC DAQmxGetDevAICurrentRngs(const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAIFreqRngs(*arg)

int32 __CFUNC DAQmxGetDevAIFreqRngs(const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAIGains(*arg)

int32 __CFUNC DAQmxGetDevAIGains(const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAILowpassCutoffFreqDiscreteVals(*arg)

int32 __CFUNC DAQmxGetDevAILowpassCutoffFreqDiscreteVals (const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAILowpassCutoffFreqRangeVals(*arg)

int32 __CFUNC DAQmxGetDevAILowpassCutoffFreqRangeVals (const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAIMaxMultiChanRate(*arg)

int32 __CFUNC DAQmxGetDevAIMaxMultiChanRate(const char device[], float64 *data);

htf.daqmx.core.DAQmxGetDevAIMaxSingleChanRate(*arg)

int32 __CFUNC DAQmxGetDevAIMaxSingleChanRate(const char device[], float64 *data);

htf.daqmx.core.DAQmxGetDevAIMinRate(*arg)

int32 __CFUNC DAQmxGetDevAIMinRate(const char device[], float64 *data);

htf.daqmx.core.DAQmxGetDevAIPhysicalChans(*arg)

int32 __CFUNC DAQmxGetDevAIPhysicalChans(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevAIResistanceRngs(*arg)

int32 __CFUNC DAQmxGetDevAIResistanceRngs(const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAISampModes(*arg)

int32 __CFUNC DAQmxGetDevAISampModes(const char device[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAISimultaneousSamplingSupported(*arg)

int32 __CFUNC DAQmxGetDevAISimultaneousSamplingSupported(const char device[], bool32 *data);

htf.daqmx.core.DAQmxGetDevAISupportedMeasTypes(*arg)

int32 __CFUNC DAQmxGetDevAISupportedMeasTypes(const char device[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAITrigUsage(*arg)

int32 __CFUNC DAQmxGetDevAITrigUsage(const char device[], int32 *data);

htf.daqmx.core.DAQmxGetDevAIVoltageIntExcitDiscreteVals(*arg)

int32 __CFUNC DAQmxGetDevAIVoltageIntExcitDiscreteVals (const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAIVoltageIntExcitRangeVals(*arg)

int32 __CFUNC DAQmxGetDevAIVoltageIntExcitRangeVals (const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAIVoltageRngs(*arg)

int32 __CFUNC DAQmxGetDevAIVoltageRngs(const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAOCurrentRngs(*arg)

int32 __CFUNC DAQmxGetDevAOCurrentRngs(const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAOGains(*arg)

int32 __CFUNC DAQmxGetDevAOGains(const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAOMaxRate(*arg)

int32 __CFUNC DAQmxGetDevAOMaxRate(const char device[], float64 *data);

htf.daqmx.core.DAQmxGetDevAOMinRate(*arg)

int32 __CFUNC DAQmxGetDevAOMinRate(const char device[], float64 *data);

htf.daqmx.core.DAQmxGetDevAOPhysicalChans(*arg)

int32 __CFUNC DAQmxGetDevAOPhysicalChans(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevAOSampClkSupported(*arg)

int32 __CFUNC DAQmxGetDevAOSampClkSupported(const char device[], bool32 *data);

htf.daqmx.core.DAQmxGetDevAOSampModes(*arg)

int32 __CFUNC DAQmxGetDevAOSampModes(const char device[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAOSupportedOutputTypes(*arg)

int32 __CFUNC DAQmxGetDevAOSupportedOutputTypes (const char device[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAOTrigUsage(*arg)

int32 __CFUNC DAQmxGetDevAOTrigUsage(const char device[], int32 *data);

htf.daqmx.core.DAQmxGetDevAOVoltageRngs(*arg)

int32 __CFUNC DAQmxGetDevAOVoltageRngs(const char device[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAccessoryProductNums(*arg)

int32 __CFUNC DAQmxGetDevAccessoryProductNums(const char device[], uInt32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAccessoryProductTypes(*arg)

int32 __CFUNC DAQmxGetDevAccessoryProductTypes(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevAccessorySerialNums(*arg)

int32 __CFUNC DAQmxGetDevAccessorySerialNums(const char device[], uInt32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevAnlgTrigSupported(*arg)

int32 __CFUNC DAQmxGetDevAnlgTrigSupported(const char device[], bool32 *data);

htf.daqmx.core.DAQmxGetDevBusType(*arg)

int32 __CFUNC DAQmxGetDevBusType(const char device[], int32 *data);

htf.daqmx.core.DAQmxGetDevCIMaxSize(*arg)

int32 __CFUNC DAQmxGetDevCIMaxSize(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevCIMaxTimebase(*arg)

int32 __CFUNC DAQmxGetDevCIMaxTimebase(const char device[], float64 *data);

htf.daqmx.core.DAQmxGetDevCIPhysicalChans(*arg)

int32 __CFUNC DAQmxGetDevCIPhysicalChans(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevCISampClkSupported(*arg)

int32 __CFUNC DAQmxGetDevCISampClkSupported(const char device[], bool32 *data);

htf.daqmx.core.DAQmxGetDevCISampModes(*arg)

int32 __CFUNC DAQmxGetDevCISampModes(const char device[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevCISupportedMeasTypes(*arg)

int32 __CFUNC DAQmxGetDevCISupportedMeasTypes(const char device[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevCITrigUsage(*arg)

int32 __CFUNC DAQmxGetDevCITrigUsage(const char device[], int32 *data);

htf.daqmx.core.DAQmxGetDevCOMaxSize(*arg)

int32 __CFUNC DAQmxGetDevCOMaxSize(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevCOMaxTimebase(*arg)

int32 __CFUNC DAQmxGetDevCOMaxTimebase(const char device[], float64 *data);

htf.daqmx.core.DAQmxGetDevCOPhysicalChans(*arg)

int32 __CFUNC DAQmxGetDevCOPhysicalChans(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevCOSampClkSupported(*arg)

int32 __CFUNC DAQmxGetDevCOSampClkSupported(const char device[], bool32 *data);

htf.daqmx.core.DAQmxGetDevCOSampModes(*arg)

int32 __CFUNC DAQmxGetDevCOSampModes(const char device[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevCOSupportedOutputTypes(*arg)

int32 __CFUNC DAQmxGetDevCOSupportedOutputTypes (const char device[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetDevCOTrigUsage(*arg)

int32 __CFUNC DAQmxGetDevCOTrigUsage(const char device[], int32 *data);

htf.daqmx.core.DAQmxGetDevChassisModuleDevNames(*arg)

int32 __CFUNC DAQmxGetDevChassisModuleDevNames(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevCompactDAQChassisDevName(*arg)

int32 __CFUNC DAQmxGetDevCompactDAQChassisDevName(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevCompactDAQSlotNum(*arg)

int32 __CFUNC DAQmxGetDevCompactDAQSlotNum(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevDILines(*arg)

int32 __CFUNC DAQmxGetDevDILines(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevDIMaxRate(*arg)

int32 __CFUNC DAQmxGetDevDIMaxRate(const char device[], float64 *data);

htf.daqmx.core.DAQmxGetDevDIPorts(*arg)

int32 __CFUNC DAQmxGetDevDIPorts(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevDITrigUsage(*arg)

int32 __CFUNC DAQmxGetDevDITrigUsage(const char device[], int32 *data);

htf.daqmx.core.DAQmxGetDevDOLines(*arg)

int32 __CFUNC DAQmxGetDevDOLines(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevDOMaxRate(*arg)

int32 __CFUNC DAQmxGetDevDOMaxRate(const char device[], float64 *data);

htf.daqmx.core.DAQmxGetDevDOPorts(*arg)

int32 __CFUNC DAQmxGetDevDOPorts(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevDOTrigUsage(*arg)

int32 __CFUNC DAQmxGetDevDOTrigUsage(const char device[], int32 *data);

htf.daqmx.core.DAQmxGetDevDigTrigSupported(*arg)

int32 __CFUNC DAQmxGetDevDigTrigSupported(const char device[], bool32 *data);

htf.daqmx.core.DAQmxGetDevIsSimulated(*arg)

int32 __CFUNC DAQmxGetDevIsSimulated(const char device[], bool32 *data);

htf.daqmx.core.DAQmxGetDevNumDMAChans(*arg)

int32 __CFUNC DAQmxGetDevNumDMAChans(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevPCIBusNum(*arg)

int32 __CFUNC DAQmxGetDevPCIBusNum(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevPCIDevNum(*arg)

int32 __CFUNC DAQmxGetDevPCIDevNum(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevPXIChassisNum(*arg)

int32 __CFUNC DAQmxGetDevPXIChassisNum(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevPXISlotNum(*arg)

int32 __CFUNC DAQmxGetDevPXISlotNum(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevProductCategory(*arg)

int32 __CFUNC DAQmxGetDevProductCategory(const char device[], int32 *data);

htf.daqmx.core.DAQmxGetDevProductNum(*arg)

int32 __CFUNC DAQmxGetDevProductNum(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevProductType(*arg)

int32 __CFUNC DAQmxGetDevProductType(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevSerialNum(*arg)

int32 __CFUNC DAQmxGetDevSerialNum(const char device[], uInt32 *data);

htf.daqmx.core.DAQmxGetDevTCPIPEthernetIP(*arg)

int32 __CFUNC DAQmxGetDevTCPIPEthernetIP(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevTCPIPHostname(*arg)

int32 __CFUNC DAQmxGetDevTCPIPHostname(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevTCPIPWirelessIP(*arg)

int32 __CFUNC DAQmxGetDevTCPIPWirelessIP(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDevTEDSHWTEDSSupported(*arg)

int32 __CFUNC DAQmxGetDevTEDSHWTEDSSupported(const char device[], bool32 *data);

htf.daqmx.core.DAQmxGetDevTerminals(*arg)

int32 __CFUNC DAQmxGetDevTerminals(const char device[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDeviceAttribute(*arg)

int32 __CFUNC_C DAQmxGetDeviceAttribute (const char deviceName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetDigEdgeAdvTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetDigEdgeAdvTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDigEdgeAdvTrigEdge(*arg)

int32 __CFUNC DAQmxGetDigEdgeAdvTrigEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigEdgeAdvTrigSrc(*arg)

int32 __CFUNC DAQmxGetDigEdgeAdvTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseSrc (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigEdge(*arg)

int32 __CFUNC DAQmxGetDigEdgeArmStartTrigEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigSrc(*arg)

int32 __CFUNC DAQmxGetDigEdgeArmStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetDigEdgeRefTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetDigEdgeRefTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetDigEdgeRefTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetDigEdgeRefTrigDigFltrTimebaseSrc (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetDigEdgeRefTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDigEdgeRefTrigEdge(*arg)

int32 __CFUNC DAQmxGetDigEdgeRefTrigEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigEdgeRefTrigSrc(*arg)

int32 __CFUNC DAQmxGetDigEdgeRefTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetDigEdgeStartTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetDigEdgeStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetDigEdgeStartTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetDigEdgeStartTrigDigFltrTimebaseSrc (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetDigEdgeStartTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDigEdgeStartTrigEdge(*arg)

int32 __CFUNC DAQmxGetDigEdgeStartTrigEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigEdgeStartTrigSrc(*arg)

int32 __CFUNC DAQmxGetDigEdgeStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigEdgeWatchdogExpirTrigEdge(*arg)

int32 __CFUNC DAQmxGetDigEdgeWatchdogExpirTrigEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigEdgeWatchdogExpirTrigSrc(*arg)

int32 __CFUNC DAQmxGetDigEdgeWatchdogExpirTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetDigLvlPauseTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetDigLvlPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetDigLvlPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetDigLvlPauseTrigDigFltrTimebaseSrc (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetDigLvlPauseTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetDigLvlPauseTrigSrc(*arg)

int32 __CFUNC DAQmxGetDigLvlPauseTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigLvlPauseTrigWhen(*arg)

int32 __CFUNC DAQmxGetDigLvlPauseTrigWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigPatternPauseTrigPattern(*arg)

int32 __CFUNC DAQmxGetDigPatternPauseTrigPattern(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigPatternPauseTrigSrc(*arg)

int32 __CFUNC DAQmxGetDigPatternPauseTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigPatternPauseTrigWhen(*arg)

int32 __CFUNC DAQmxGetDigPatternPauseTrigWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigPatternRefTrigPattern(*arg)

int32 __CFUNC DAQmxGetDigPatternRefTrigPattern(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigPatternRefTrigSrc(*arg)

int32 __CFUNC DAQmxGetDigPatternRefTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigPatternRefTrigWhen(*arg)

int32 __CFUNC DAQmxGetDigPatternRefTrigWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigPatternStartTrigPattern(*arg)

int32 __CFUNC DAQmxGetDigPatternStartTrigPattern(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigPatternStartTrigSrc(*arg)

int32 __CFUNC DAQmxGetDigPatternStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetDigPatternStartTrigWhen(*arg)

int32 __CFUNC DAQmxGetDigPatternStartTrigWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigitalLogicFamilyPowerUpState(*arg)

int32 __CFUNC DAQmxGetDigitalLogicFamilyPowerUpState(const char deviceName[], int32* logicFamily);

htf.daqmx.core.DAQmxGetDigitalPowerUpStates(*arg)

int32 __CFUNC_C DAQmxGetDigitalPowerUpStates (const char deviceName[], const char channelName[], int32* state, …);

htf.daqmx.core.DAQmxGetDigitalPullUpPullDownStates(*arg)

int32 __CFUNC_C DAQmxGetDigitalPullUpPullDownStates (const char deviceName[], const char channelName[], int32* state, …);

htf.daqmx.core.DAQmxGetDisconnectedCDAQSyncPorts(*arg)

int32 __CFUNC DAQmxGetDisconnectedCDAQSyncPorts(char portList[], uInt32 portListSize);

htf.daqmx.core.DAQmxGetErrorString(errorCode, errorString, bufferSize)

int32 __CFUNC DAQmxGetErrorString (int32 errorCode, char errorString[], uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExported10MHzRefClkOutputTerm(*arg)

int32 __CFUNC DAQmxGetExported10MHzRefClkOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExported20MHzTimebaseOutputTerm(*arg)

int32 __CFUNC DAQmxGetExported20MHzTimebaseOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAIConvClkOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedAIConvClkOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAIConvClkPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedAIConvClkPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedAIHoldCmpltEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedAIHoldCmpltEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAIHoldCmpltEventPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedAIHoldCmpltEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedAdvCmpltEventDelay(*arg)

int32 __CFUNC DAQmxGetExportedAdvCmpltEventDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedAdvCmpltEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedAdvCmpltEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAdvCmpltEventPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedAdvCmpltEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedAdvCmpltEventPulseWidth(*arg)

int32 __CFUNC DAQmxGetExportedAdvCmpltEventPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedAdvTrigOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedAdvTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAdvTrigPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedAdvTrigPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedAdvTrigPulseWidth(*arg)

int32 __CFUNC DAQmxGetExportedAdvTrigPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedAdvTrigPulseWidthUnits(*arg)

int32 __CFUNC DAQmxGetExportedAdvTrigPulseWidthUnits(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedChangeDetectEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedChangeDetectEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedChangeDetectEventPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedChangeDetectEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedCtrOutEventOutputBehavior(*arg)

int32 __CFUNC DAQmxGetExportedCtrOutEventOutputBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedCtrOutEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedCtrOutEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedCtrOutEventPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedCtrOutEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedCtrOutEventToggleIdleState(*arg)

int32 __CFUNC DAQmxGetExportedCtrOutEventToggleIdleState(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedDataActiveEventLvlActiveLvl(*arg)

int32 __CFUNC DAQmxGetExportedDataActiveEventLvlActiveLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedDataActiveEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedDataActiveEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedDividedSampClkTimebaseOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedDividedSampClkTimebaseOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedHshkEventDelay(*arg)

int32 __CFUNC DAQmxGetExportedHshkEventDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventInterlockedAssertOnStart(*arg)

int32 __CFUNC DAQmxGetExportedHshkEventInterlockedAssertOnStart(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventInterlockedAssertedLvl(*arg)

int32 __CFUNC DAQmxGetExportedHshkEventInterlockedAssertedLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventInterlockedDeassertDelay(*arg)

int32 __CFUNC DAQmxGetExportedHshkEventInterlockedDeassertDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventOutputBehavior(*arg)

int32 __CFUNC DAQmxGetExportedHshkEventOutputBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedHshkEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedHshkEventPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedHshkEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventPulseWidth(*arg)

int32 __CFUNC DAQmxGetExportedHshkEventPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedPauseTrigLvlActiveLvl(*arg)

int32 __CFUNC DAQmxGetExportedPauseTrigLvlActiveLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedPauseTrigOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedPauseTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedRdyForStartEventLvlActiveLvl(*arg)

int32 __CFUNC DAQmxGetExportedRdyForStartEventLvlActiveLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedRdyForStartEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedRdyForStartEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedRdyForXferEventDeassertCond(*arg)

int32 __CFUNC DAQmxGetExportedRdyForXferEventDeassertCond(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedRdyForXferEventDeassertCondCustomThreshold(*arg)

int32 __CFUNC DAQmxGetExportedRdyForXferEventDeassertCondCustomThreshold (TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetExportedRdyForXferEventLvlActiveLvl(*arg)

int32 __CFUNC DAQmxGetExportedRdyForXferEventLvlActiveLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedRdyForXferEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedRdyForXferEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedRefTrigOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedRefTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedRefTrigPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedRefTrigPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedSampClkDelayOffset(*arg)

int32 __CFUNC DAQmxGetExportedSampClkDelayOffset(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedSampClkOutputBehavior(*arg)

int32 __CFUNC DAQmxGetExportedSampClkOutputBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedSampClkOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedSampClkOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedSampClkPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedSampClkPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedSampClkTimebaseOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedSampClkTimebaseOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedSignalAttribute(*arg)

int32 __CFUNC_C DAQmxGetExportedSignalAttribute(TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetExportedStartTrigOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedStartTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedStartTrigPulsePolarity(*arg)

int32 __CFUNC DAQmxGetExportedStartTrigPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedSyncPulseEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedSyncPulseEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedWatchdogExpiredEventOutputTerm(*arg)

int32 __CFUNC DAQmxGetExportedWatchdogExpiredEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExtCalLastDateAndTime(*arg)

int32 __CFUNC DAQmxGetExtCalLastDateAndTime (const char deviceName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);

htf.daqmx.core.DAQmxGetExtCalLastTemp(*arg)

int32 __CFUNC DAQmxGetExtCalLastTemp(const char deviceName[], float64 *data);

htf.daqmx.core.DAQmxGetExtCalRecommendedInterval(*arg)

int32 __CFUNC DAQmxGetExtCalRecommendedInterval(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetExtendedErrorInfo(errorString, bufferSize)

int32 __CFUNC DAQmxGetExtendedErrorInfo (char errorString[], uInt32 bufferSize);

htf.daqmx.core.DAQmxGetHshkDelayAfterXfer(*arg)

int32 __CFUNC DAQmxGetHshkDelayAfterXfer(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetHshkSampleInputDataWhen(*arg)

int32 __CFUNC DAQmxGetHshkSampleInputDataWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetHshkStartCond(*arg)

int32 __CFUNC DAQmxGetHshkStartCond(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetHshkTrigType(*arg)

int32 __CFUNC DAQmxGetHshkTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetImplicitUnderflowBehavior(*arg)

int32 __CFUNC DAQmxGetImplicitUnderflowBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetInterlockedHshkTrigAssertedLvl(*arg)

int32 __CFUNC DAQmxGetInterlockedHshkTrigAssertedLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetInterlockedHshkTrigSrc(*arg)

int32 __CFUNC DAQmxGetInterlockedHshkTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetLoggingFilePath(*arg)

int32 __CFUNC DAQmxGetLoggingFilePath(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetLoggingFilePreallocationSize(*arg)

int32 __CFUNC DAQmxGetLoggingFilePreallocationSize(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetLoggingFileWriteSize(*arg)

int32 __CFUNC DAQmxGetLoggingFileWriteSize(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetLoggingMode(*arg)

int32 __CFUNC DAQmxGetLoggingMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetLoggingPause(*arg)

int32 __CFUNC DAQmxGetLoggingPause(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetLoggingSampsPerFile(*arg)

int32 __CFUNC DAQmxGetLoggingSampsPerFile(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetLoggingTDMSGroupName(*arg)

int32 __CFUNC DAQmxGetLoggingTDMSGroupName(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetLoggingTDMSOperation(*arg)

int32 __CFUNC DAQmxGetLoggingTDMSOperation(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetMasterTimebaseRate(*arg)

int32 __CFUNC DAQmxGetMasterTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetMasterTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetMasterTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetNthTaskChannel(*arg)

int32 __CFUNC DAQmxGetNthTaskChannel (TaskHandle taskHandle, uInt32 index, char buffer[], int32 bufferSize);

htf.daqmx.core.DAQmxGetNthTaskDevice(*arg)

int32 __CFUNC DAQmxGetNthTaskDevice (TaskHandle taskHandle, uInt32 index, char buffer[], int32 bufferSize);

htf.daqmx.core.DAQmxGetNthTaskReadChannel(*arg)

int32 __CFUNC DAQmxGetNthTaskReadChannel (TaskHandle taskHandle, uInt32 index, char buffer[], int32 bufferSize);

htf.daqmx.core.DAQmxGetOnDemandSimultaneousAOEnable(*arg)

int32 __CFUNC DAQmxGetOnDemandSimultaneousAOEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetPauseTrigTerm(*arg)

int32 __CFUNC DAQmxGetPauseTrigTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPauseTrigType(*arg)

int32 __CFUNC DAQmxGetPauseTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetPersistedChanAllowInteractiveDeletion(*arg)

int32 __CFUNC DAQmxGetPersistedChanAllowInteractiveDeletion(const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedChanAllowInteractiveEditing(*arg)

int32 __CFUNC DAQmxGetPersistedChanAllowInteractiveEditing(const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedChanAttribute(*arg)

int32 __CFUNC_C DAQmxGetPersistedChanAttribute (const char channel[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetPersistedChanAuthor(*arg)

int32 __CFUNC DAQmxGetPersistedChanAuthor(const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPersistedScaleAllowInteractiveDeletion(*arg)

int32 __CFUNC DAQmxGetPersistedScaleAllowInteractiveDeletion(const char scaleName[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedScaleAllowInteractiveEditing(*arg)

int32 __CFUNC DAQmxGetPersistedScaleAllowInteractiveEditing(const char scaleName[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedScaleAttribute(*arg)

int32 __CFUNC_C DAQmxGetPersistedScaleAttribute(const char scaleName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetPersistedScaleAuthor(*arg)

int32 __CFUNC DAQmxGetPersistedScaleAuthor(const char scaleName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPersistedTaskAllowInteractiveDeletion(*arg)

int32 __CFUNC DAQmxGetPersistedTaskAllowInteractiveDeletion(const char taskName[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedTaskAllowInteractiveEditing(*arg)

int32 __CFUNC DAQmxGetPersistedTaskAllowInteractiveEditing(const char taskName[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedTaskAttribute(*arg)

int32 __CFUNC_C DAQmxGetPersistedTaskAttribute (const char taskName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetPersistedTaskAuthor(*arg)

int32 __CFUNC DAQmxGetPersistedTaskAuthor(const char taskName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPhysicalChanAIInputSrcs(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAIInputSrcs(const char physicalChannel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPhysicalChanAISupportedMeasTypes(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAISupportedMeasTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanAITermCfgs(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAITermCfgs(const char physicalChannel[], int32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOManualControlAmplitude(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAOManualControlAmplitude(const char physicalChannel[], float64 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOManualControlEnable(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAOManualControlEnable(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOManualControlFreq(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAOManualControlFreq(const char physicalChannel[], float64 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOManualControlShortDetected(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAOManualControlShortDetected(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOSupportedOutputTypes(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAOSupportedOutputTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanAOSupportedPowerUpOutputTypes(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAOSupportedPowerUpOutputTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanAOTermCfgs(*arg)

int32 __CFUNC DAQmxGetPhysicalChanAOTermCfgs(const char physicalChannel[], int32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAttribute(*arg)

int32 __CFUNC_C DAQmxGetPhysicalChanAttribute (const char physicalChannel[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetPhysicalChanCISupportedMeasTypes(*arg)

int32 __CFUNC DAQmxGetPhysicalChanCISupportedMeasTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanCOSupportedOutputTypes(*arg)

int32 __CFUNC DAQmxGetPhysicalChanCOSupportedOutputTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanDIChangeDetectSupported(*arg)

int32 __CFUNC DAQmxGetPhysicalChanDIChangeDetectSupported(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDIPortWidth(*arg)

int32 __CFUNC DAQmxGetPhysicalChanDIPortWidth(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDISampClkSupported(*arg)

int32 __CFUNC DAQmxGetPhysicalChanDISampClkSupported(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDISampModes(*arg)

int32 __CFUNC DAQmxGetPhysicalChanDISampModes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanDOPortWidth(*arg)

int32 __CFUNC DAQmxGetPhysicalChanDOPortWidth(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDOSampClkSupported(*arg)

int32 __CFUNC DAQmxGetPhysicalChanDOSampClkSupported(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDOSampModes(*arg)

int32 __CFUNC DAQmxGetPhysicalChanDOSampModes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanName(*arg)

int32 __CFUNC DAQmxGetPhysicalChanName (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSBitStream(*arg)

int32 __CFUNC DAQmxGetPhysicalChanTEDSBitStream (const char physicalChannel[], uInt8 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSMfgID(*arg)

int32 __CFUNC DAQmxGetPhysicalChanTEDSMfgID(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSModelNum(*arg)

int32 __CFUNC DAQmxGetPhysicalChanTEDSModelNum(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSSerialNum(*arg)

int32 __CFUNC DAQmxGetPhysicalChanTEDSSerialNum(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSTemplateIDs(*arg)

int32 __CFUNC DAQmxGetPhysicalChanTEDSTemplateIDs (const char physicalChannel[], uInt32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSVersionLetter(*arg)

int32 __CFUNC DAQmxGetPhysicalChanTEDSVersionLetter (const char physicalChannel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSVersionNum(*arg)

int32 __CFUNC DAQmxGetPhysicalChanTEDSVersionNum(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPossibleSCExpressCalAccConnections(*arg)

int32 __CFUNC DAQmxGetPossibleSCExpressCalAccConnections (const char deviceName[], const char channelNames[], char *connections, uInt32 connectionsBufferSize);

htf.daqmx.core.DAQmxGetReadAccessoryInsertionOrRemovalDetected(*arg)

int32 __CFUNC DAQmxGetReadAccessoryInsertionOrRemovalDetected(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadAttribute(*arg)

int32 __CFUNC_C DAQmxGetReadAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetReadAutoStart(*arg)

int32 __CFUNC DAQmxGetReadAutoStart(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadAvailSampPerChan(*arg)

int32 __CFUNC DAQmxGetReadAvailSampPerChan(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetReadChangeDetectHasOverflowed(*arg)

int32 __CFUNC DAQmxGetReadChangeDetectHasOverflowed(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadChannelsToRead(*arg)

int32 __CFUNC DAQmxGetReadChannelsToRead(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadCommonModeRangeErrorChans(*arg)

int32 __CFUNC DAQmxGetReadCommonModeRangeErrorChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadCommonModeRangeErrorChansExist(*arg)

int32 __CFUNC DAQmxGetReadCommonModeRangeErrorChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadCurrReadPos(*arg)

int32 __CFUNC DAQmxGetReadCurrReadPos(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetReadDevsWithInsertedOrRemovedAccessories(*arg)

int32 __CFUNC DAQmxGetReadDevsWithInsertedOrRemovedAccessories (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadDigitalLinesBytesPerChan(*arg)

int32 __CFUNC DAQmxGetReadDigitalLinesBytesPerChan(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetReadNumChans(*arg)

int32 __CFUNC DAQmxGetReadNumChans(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetReadOffset(*arg)

int32 __CFUNC DAQmxGetReadOffset(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetReadOpenCurrentLoopChans(*arg)

int32 __CFUNC DAQmxGetReadOpenCurrentLoopChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOpenCurrentLoopChansExist(*arg)

int32 __CFUNC DAQmxGetReadOpenCurrentLoopChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadOpenThrmcplChans(*arg)

int32 __CFUNC DAQmxGetReadOpenThrmcplChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOpenThrmcplChansExist(*arg)

int32 __CFUNC DAQmxGetReadOpenThrmcplChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadOverWrite(*arg)

int32 __CFUNC DAQmxGetReadOverWrite(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetReadOvercurrentChans(*arg)

int32 __CFUNC DAQmxGetReadOvercurrentChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOvercurrentChansExist(*arg)

int32 __CFUNC DAQmxGetReadOvercurrentChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadOverloadedChans(*arg)

int32 __CFUNC DAQmxGetReadOverloadedChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOverloadedChansExist(*arg)

int32 __CFUNC DAQmxGetReadOverloadedChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadOvertemperatureChans(*arg)

int32 __CFUNC DAQmxGetReadOvertemperatureChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOvertemperatureChansExist(*arg)

int32 __CFUNC DAQmxGetReadOvertemperatureChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadRawDataWidth(*arg)

int32 __CFUNC DAQmxGetReadRawDataWidth(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetReadReadAllAvailSamp(*arg)

int32 __CFUNC DAQmxGetReadReadAllAvailSamp(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadRelativeTo(*arg)

int32 __CFUNC DAQmxGetReadRelativeTo(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetReadSleepTime(*arg)

int32 __CFUNC DAQmxGetReadSleepTime(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetReadTotalSampPerChanAcquired(*arg)

int32 __CFUNC DAQmxGetReadTotalSampPerChanAcquired(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetReadWaitMode(*arg)

int32 __CFUNC DAQmxGetReadWaitMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetRealTimeAttribute(*arg)

int32 __CFUNC_C DAQmxGetRealTimeAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetRealTimeConvLateErrorsToWarnings(*arg)

int32 __CFUNC DAQmxGetRealTimeConvLateErrorsToWarnings(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetRealTimeNumOfWarmupIters(*arg)

int32 __CFUNC DAQmxGetRealTimeNumOfWarmupIters(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetRealTimeReportMissedSamp(*arg)

int32 __CFUNC DAQmxGetRealTimeReportMissedSamp(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetRealTimeWaitForNextSampClkWaitMode(*arg)

int32 __CFUNC DAQmxGetRealTimeWaitForNextSampClkWaitMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetRealTimeWriteRecoveryMode(*arg)

int32 __CFUNC DAQmxGetRealTimeWriteRecoveryMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetRefClkRate(*arg)

int32 __CFUNC DAQmxGetRefClkRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetRefClkSrc(*arg)

int32 __CFUNC DAQmxGetRefClkSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetRefTrigAutoTrigEnable(*arg)

int32 __CFUNC DAQmxGetRefTrigAutoTrigEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetRefTrigAutoTriggered(*arg)

int32 __CFUNC DAQmxGetRefTrigAutoTriggered(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetRefTrigDelay(*arg)

int32 __CFUNC DAQmxGetRefTrigDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetRefTrigPretrigSamples(*arg)

int32 __CFUNC DAQmxGetRefTrigPretrigSamples(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetRefTrigTerm(*arg)

int32 __CFUNC DAQmxGetRefTrigTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetRefTrigType(*arg)

int32 __CFUNC DAQmxGetRefTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkActiveEdge(*arg)

int32 __CFUNC DAQmxGetSampClkActiveEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkDigFltrEnable(*arg)

int32 __CFUNC DAQmxGetSampClkDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetSampClkDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxGetSampClkDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxGetSampClkDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetSampClkDigFltrTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkDigSyncEnable(*arg)

int32 __CFUNC DAQmxGetSampClkDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetSampClkMaxRate(*arg)

int32 __CFUNC DAQmxGetSampClkMaxRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkOverrunBehavior(*arg)

int32 __CFUNC DAQmxGetSampClkOverrunBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkRate(*arg)

int32 __CFUNC DAQmxGetSampClkRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkSrc(*arg)

int32 __CFUNC DAQmxGetSampClkSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkTerm(*arg)

int32 __CFUNC DAQmxGetSampClkTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkTimebaseActiveEdge(*arg)

int32 __CFUNC DAQmxGetSampClkTimebaseActiveEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkTimebaseDiv(*arg)

int32 __CFUNC DAQmxGetSampClkTimebaseDiv(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetSampClkTimebaseMasterTimebaseDiv(*arg)

int32 __CFUNC DAQmxGetSampClkTimebaseMasterTimebaseDiv(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetSampClkTimebaseRate(*arg)

int32 __CFUNC DAQmxGetSampClkTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkTimebaseSrc(*arg)

int32 __CFUNC DAQmxGetSampClkTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkTimebaseTerm(*arg)

int32 __CFUNC DAQmxGetSampClkTimebaseTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkTimingResponseMode(*arg)

int32 __CFUNC DAQmxGetSampClkTimingResponseMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkUnderflowBehavior(*arg)

int32 __CFUNC DAQmxGetSampClkUnderflowBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampQuantSampMode(*arg)

int32 __CFUNC DAQmxGetSampQuantSampMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampQuantSampPerChan(*arg)

int32 __CFUNC DAQmxGetSampQuantSampPerChan(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetSampTimingEngine(*arg)

int32 __CFUNC DAQmxGetSampTimingEngine(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetSampTimingType(*arg)

int32 __CFUNC DAQmxGetSampTimingType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetScaleAttribute(*arg)

int32 __CFUNC_C DAQmxGetScaleAttribute (const char scaleName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetScaleDescr(*arg)

int32 __CFUNC DAQmxGetScaleDescr(const char scaleName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetScaleLinSlope(*arg)

int32 __CFUNC DAQmxGetScaleLinSlope(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleLinYIntercept(*arg)

int32 __CFUNC DAQmxGetScaleLinYIntercept(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleMapPreScaledMax(*arg)

int32 __CFUNC DAQmxGetScaleMapPreScaledMax(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleMapPreScaledMin(*arg)

int32 __CFUNC DAQmxGetScaleMapPreScaledMin(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleMapScaledMax(*arg)

int32 __CFUNC DAQmxGetScaleMapScaledMax(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleMapScaledMin(*arg)

int32 __CFUNC DAQmxGetScaleMapScaledMin(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScalePolyForwardCoeff(*arg)

int32 __CFUNC DAQmxGetScalePolyForwardCoeff (const char scaleName[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetScalePolyReverseCoeff(*arg)

int32 __CFUNC DAQmxGetScalePolyReverseCoeff (const char scaleName[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetScalePreScaledUnits(*arg)

int32 __CFUNC DAQmxGetScalePreScaledUnits(const char scaleName[], int32 *data);

htf.daqmx.core.DAQmxGetScaleScaledUnits(*arg)

int32 __CFUNC DAQmxGetScaleScaledUnits(const char scaleName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetScaleTablePreScaledVals(*arg)

int32 __CFUNC DAQmxGetScaleTablePreScaledVals (const char scaleName[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetScaleTableScaledVals(*arg)

int32 __CFUNC DAQmxGetScaleTableScaledVals (const char scaleName[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetScaleType(*arg)

int32 __CFUNC DAQmxGetScaleType(const char scaleName[], int32 *data);

htf.daqmx.core.DAQmxGetSelfCalLastDateAndTime(*arg)

int32 __CFUNC DAQmxGetSelfCalLastDateAndTime (const char deviceName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);

htf.daqmx.core.DAQmxGetSelfCalLastTemp(*arg)

int32 __CFUNC DAQmxGetSelfCalLastTemp(const char deviceName[], float64 *data);

htf.daqmx.core.DAQmxGetSelfCalSupported(*arg)

int32 __CFUNC DAQmxGetSelfCalSupported(const char deviceName[], bool32 *data);

htf.daqmx.core.DAQmxGetStartTrigDelay(*arg)

int32 __CFUNC DAQmxGetStartTrigDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetStartTrigDelayUnits(*arg)

int32 __CFUNC DAQmxGetStartTrigDelayUnits(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetStartTrigRetriggerable(*arg)

int32 __CFUNC DAQmxGetStartTrigRetriggerable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetStartTrigTerm(*arg)

int32 __CFUNC DAQmxGetStartTrigTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetStartTrigType(*arg)

int32 __CFUNC DAQmxGetStartTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSwitchChanAnlgBusSharingEnable(*arg)

int32 __CFUNC DAQmxGetSwitchChanAnlgBusSharingEnable(const char switchChannelName[], bool32 *data);

htf.daqmx.core.DAQmxGetSwitchChanAttribute(*arg)

int32 __CFUNC_C DAQmxGetSwitchChanAttribute (const char switchChannelName[], int32 attribute, void *value);

htf.daqmx.core.DAQmxGetSwitchChanBandwidth(*arg)

int32 __CFUNC DAQmxGetSwitchChanBandwidth(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanImpedance(*arg)

int32 __CFUNC DAQmxGetSwitchChanImpedance(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACCarryCurrent(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxACCarryCurrent(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACCarryPwr(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxACCarryPwr(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACSwitchCurrent(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxACSwitchCurrent(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACSwitchPwr(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxACSwitchPwr(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACVoltage(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxACVoltage(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCCarryCurrent(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxDCCarryCurrent(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCCarryPwr(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxDCCarryPwr(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCSwitchCurrent(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxDCSwitchCurrent(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCSwitchPwr(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxDCSwitchPwr(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCVoltage(*arg)

int32 __CFUNC DAQmxGetSwitchChanMaxDCVoltage(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanUsage(*arg)

int32 __CFUNC DAQmxGetSwitchChanUsage(const char switchChannelName[], int32 *data);

htf.daqmx.core.DAQmxGetSwitchChanWireMode(*arg)

int32 __CFUNC DAQmxGetSwitchChanWireMode(const char switchChannelName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevAutoConnAnlgBus(*arg)

int32 __CFUNC DAQmxGetSwitchDevAutoConnAnlgBus(const char deviceName[], bool32 *data);

htf.daqmx.core.DAQmxGetSwitchDevNumColumns(*arg)

int32 __CFUNC DAQmxGetSwitchDevNumColumns(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevNumRelays(*arg)

int32 __CFUNC DAQmxGetSwitchDevNumRelays(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevNumRows(*arg)

int32 __CFUNC DAQmxGetSwitchDevNumRows(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevNumSwitchChans(*arg)

int32 __CFUNC DAQmxGetSwitchDevNumSwitchChans(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevPwrDownLatchRelaysAfterSettling(*arg)

int32 __CFUNC DAQmxGetSwitchDevPwrDownLatchRelaysAfterSettling(const char deviceName[], bool32 *data);

htf.daqmx.core.DAQmxGetSwitchDevRelayList(*arg)

int32 __CFUNC DAQmxGetSwitchDevRelayList(const char deviceName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSwitchDevSettled(*arg)

int32 __CFUNC DAQmxGetSwitchDevSettled(const char deviceName[], bool32 *data);

htf.daqmx.core.DAQmxGetSwitchDevSettlingTime(*arg)

int32 __CFUNC DAQmxGetSwitchDevSettlingTime(const char deviceName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchDevSwitchChanList(*arg)

int32 __CFUNC DAQmxGetSwitchDevSwitchChanList(const char deviceName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSwitchDevTemperature(*arg)

int32 __CFUNC DAQmxGetSwitchDevTemperature(const char deviceName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchDevTopology(*arg)

int32 __CFUNC DAQmxGetSwitchDevTopology(const char deviceName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSwitchDeviceAttribute(*arg)

int32 __CFUNC_C DAQmxGetSwitchDeviceAttribute (const char deviceName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetSwitchScanAttribute(*arg)

int32 __CFUNC_C DAQmxGetSwitchScanAttribute (TaskHandle taskHandle, int32 attribute, void *value);

htf.daqmx.core.DAQmxGetSwitchScanBreakMode(*arg)

int32 __CFUNC DAQmxGetSwitchScanBreakMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSwitchScanRepeatMode(*arg)

int32 __CFUNC DAQmxGetSwitchScanRepeatMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSwitchScanWaitingForAdv(*arg)

int32 __CFUNC DAQmxGetSwitchScanWaitingForAdv(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetSyncClkInterval(*arg)

int32 __CFUNC DAQmxGetSyncClkInterval(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetSyncPulseMinDelayToStart(*arg)

int32 __CFUNC DAQmxGetSyncPulseMinDelayToStart(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSyncPulseResetDelay(*arg)

int32 __CFUNC DAQmxGetSyncPulseResetDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSyncPulseResetTime(*arg)

int32 __CFUNC DAQmxGetSyncPulseResetTime(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSyncPulseSrc(*arg)

int32 __CFUNC DAQmxGetSyncPulseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSyncPulseSyncTime(*arg)

int32 __CFUNC DAQmxGetSyncPulseSyncTime(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSyncPulseTerm(*arg)

int32 __CFUNC DAQmxGetSyncPulseTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSysDevNames(*arg)

int32 __CFUNC DAQmxGetSysDevNames(char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSysGlobalChans(*arg)

int32 __CFUNC DAQmxGetSysGlobalChans(char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSysNIDAQMajorVersion(*arg)

int32 __CFUNC DAQmxGetSysNIDAQMajorVersion(uInt32 *data);

htf.daqmx.core.DAQmxGetSysNIDAQMinorVersion(*arg)

int32 __CFUNC DAQmxGetSysNIDAQMinorVersion(uInt32 *data);

htf.daqmx.core.DAQmxGetSysNIDAQUpdateVersion(*arg)

int32 __CFUNC DAQmxGetSysNIDAQUpdateVersion(uInt32 *data);

htf.daqmx.core.DAQmxGetSysScales(*arg)

int32 __CFUNC DAQmxGetSysScales(char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSysTasks(*arg)

int32 __CFUNC DAQmxGetSysTasks(char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSystemInfoAttribute(*arg)

int32 __CFUNC_C DAQmxGetSystemInfoAttribute (int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTaskAttribute(*arg)

int32 __CFUNC_C DAQmxGetTaskAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTaskChannels(*arg)

int32 __CFUNC DAQmxGetTaskChannels(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetTaskComplete(*arg)

int32 __CFUNC DAQmxGetTaskComplete(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetTaskDevices(*arg)

int32 __CFUNC DAQmxGetTaskDevices(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetTaskName(*arg)

int32 __CFUNC DAQmxGetTaskName(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetTaskNumChans(*arg)

int32 __CFUNC DAQmxGetTaskNumChans(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetTaskNumDevices(*arg)

int32 __CFUNC DAQmxGetTaskNumDevices(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetTimingAttribute(*arg)

int32 __CFUNC_C DAQmxGetTimingAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTimingAttributeEx(*arg)

int32 __CFUNC_C DAQmxGetTimingAttributeEx (TaskHandle taskHandle, const char deviceNames[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTrigAttribute(*arg)

int32 __CFUNC_C DAQmxGetTrigAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTriggerSyncType(*arg)

int32 __CFUNC DAQmxGetTriggerSyncType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWatchdogAOExpirState(*arg)

int32 __CFUNC DAQmxGetWatchdogAOExpirState(TaskHandle taskHandle, const char lines[], float64 *data);

htf.daqmx.core.DAQmxGetWatchdogAOOutputType(*arg)

int32 __CFUNC DAQmxGetWatchdogAOOutputType(TaskHandle taskHandle, const char lines[], int32 *data);

htf.daqmx.core.DAQmxGetWatchdogAttribute(*arg)

int32 __CFUNC_C DAQmxGetWatchdogAttribute (TaskHandle taskHandle, const char lines[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetWatchdogCOExpirState(*arg)

int32 __CFUNC DAQmxGetWatchdogCOExpirState(TaskHandle taskHandle, const char lines[], int32 *data);

htf.daqmx.core.DAQmxGetWatchdogDOExpirState(*arg)

int32 __CFUNC DAQmxGetWatchdogDOExpirState(TaskHandle taskHandle, const char lines[], int32 *data);

htf.daqmx.core.DAQmxGetWatchdogExpirTrigTrigOnNetworkConnLoss(*arg)

int32 __CFUNC DAQmxGetWatchdogExpirTrigTrigOnNetworkConnLoss(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWatchdogExpirTrigType(*arg)

int32 __CFUNC DAQmxGetWatchdogExpirTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWatchdogHasExpired(*arg)

int32 __CFUNC DAQmxGetWatchdogHasExpired(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWatchdogTimeout(*arg)

int32 __CFUNC DAQmxGetWatchdogTimeout(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetWriteAccessoryInsertionOrRemovalDetected(*arg)

int32 __CFUNC DAQmxGetWriteAccessoryInsertionOrRemovalDetected(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteAttribute(*arg)

int32 __CFUNC_C DAQmxGetWriteAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetWriteCurrWritePos(*arg)

int32 __CFUNC DAQmxGetWriteCurrWritePos(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetWriteDevsWithInsertedOrRemovedAccessories(*arg)

int32 __CFUNC DAQmxGetWriteDevsWithInsertedOrRemovedAccessories (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteDigitalLinesBytesPerChan(*arg)

int32 __CFUNC DAQmxGetWriteDigitalLinesBytesPerChan(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetWriteNextWriteIsLast(*arg)

int32 __CFUNC DAQmxGetWriteNextWriteIsLast(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteNumChans(*arg)

int32 __CFUNC DAQmxGetWriteNumChans(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetWriteOffset(*arg)

int32 __CFUNC DAQmxGetWriteOffset(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWriteOpenCurrentLoopChans(*arg)

int32 __CFUNC DAQmxGetWriteOpenCurrentLoopChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteOpenCurrentLoopChansExist(*arg)

int32 __CFUNC DAQmxGetWriteOpenCurrentLoopChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteOvercurrentChans(*arg)

int32 __CFUNC DAQmxGetWriteOvercurrentChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteOvercurrentChansExist(*arg)

int32 __CFUNC DAQmxGetWriteOvercurrentChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteOverloadedChans(*arg)

int32 __CFUNC DAQmxGetWriteOverloadedChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteOverloadedChansExist(*arg)

int32 __CFUNC DAQmxGetWriteOverloadedChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteOvertemperatureChans(*arg)

int32 __CFUNC DAQmxGetWriteOvertemperatureChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteOvertemperatureChansExist(*arg)

int32 __CFUNC DAQmxGetWriteOvertemperatureChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWritePowerSupplyFaultChans(*arg)

int32 __CFUNC DAQmxGetWritePowerSupplyFaultChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWritePowerSupplyFaultChansExist(*arg)

int32 __CFUNC DAQmxGetWritePowerSupplyFaultChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteRawDataWidth(*arg)

int32 __CFUNC DAQmxGetWriteRawDataWidth(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetWriteRegenMode(*arg)

int32 __CFUNC DAQmxGetWriteRegenMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWriteRelativeTo(*arg)

int32 __CFUNC DAQmxGetWriteRelativeTo(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWriteSleepTime(*arg)

int32 __CFUNC DAQmxGetWriteSleepTime(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetWriteSpaceAvail(*arg)

int32 __CFUNC DAQmxGetWriteSpaceAvail(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetWriteTotalSampPerChanGenerated(*arg)

int32 __CFUNC DAQmxGetWriteTotalSampPerChanGenerated(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetWriteWaitMode(*arg)

int32 __CFUNC DAQmxGetWriteWaitMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxInitExtCal(*arg)

int32 __CFUNC DAQmxInitExtCal (const char deviceName[], const char password[], CalHandle *calHandle);

htf.daqmx.core.DAQmxIsReadOrWriteLate(*arg)

bool32 __CFUNC DAQmxIsReadOrWriteLate (int32 errorCode);

htf.daqmx.core.DAQmxIsTaskDone(*arg)

int32 __CFUNC DAQmxIsTaskDone (TaskHandle taskHandle, bool32 *isTaskDone);

htf.daqmx.core.DAQmxLoadTask(*arg)

int32 __CFUNC DAQmxLoadTask (const char taskName[], TaskHandle *taskHandle);

htf.daqmx.core.DAQmxMSeriesCalAdjust(*arg)

int32 __CFUNC DAQmxMSeriesCalAdjust (CalHandle calHandle, float64 referenceVoltage);

htf.daqmx.core.DAQmxPerformBridgeOffsetNullingCal(*arg)

int32 __CFUNC DAQmxPerformBridgeOffsetNullingCal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxPerformBridgeOffsetNullingCalEx(*arg)

int32 __CFUNC DAQmxPerformBridgeOffsetNullingCalEx (TaskHandle taskHandle, const char channel[], bool32 skipUnsupportedChannels);

htf.daqmx.core.DAQmxPerformBridgeShuntCal(*arg)

int32 __CFUNC DAQmxPerformBridgeShuntCal (TaskHandle taskHandle, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, float64 bridgeResistance, bool32 skipUnsupportedChannels);

htf.daqmx.core.DAQmxPerformStrainShuntCal(*arg)

int32 __CFUNC DAQmxPerformStrainShuntCal (TaskHandle taskHandle, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, bool32 skipUnsupportedChannels);

htf.daqmx.core.DAQmxPerformThrmcplLeadOffsetNullingCal(*arg)

int32 __CFUNC DAQmxPerformThrmcplLeadOffsetNullingCal (TaskHandle taskHandle, const char channel[], bool32 skipUnsupportedChannels);

htf.daqmx.core.DAQmxReadAnalogF64(*arg)

int32 __CFUNC DAQmxReadAnalogF64 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, float64 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadAnalogScalarF64(*arg)

int32 __CFUNC DAQmxReadAnalogScalarF64 (TaskHandle taskHandle, float64 timeout, float64 *value, bool32 *reserved);

htf.daqmx.core.DAQmxReadBinaryI16(*arg)

int32 __CFUNC DAQmxReadBinaryI16 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, int16 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadBinaryI32(*arg)

int32 __CFUNC DAQmxReadBinaryI32 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, int32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadBinaryU16(*arg)

int32 __CFUNC DAQmxReadBinaryU16 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt16 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadBinaryU32(*arg)

int32 __CFUNC DAQmxReadBinaryU32 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadCounterF64(*arg)

int32 __CFUNC DAQmxReadCounterF64 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, float64 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadCounterScalarF64(*arg)

int32 __CFUNC DAQmxReadCounterScalarF64 (TaskHandle taskHandle, float64 timeout, float64 *value, bool32 *reserved);

htf.daqmx.core.DAQmxReadCounterScalarU32(*arg)

int32 __CFUNC DAQmxReadCounterScalarU32 (TaskHandle taskHandle, float64 timeout, uInt32 *value, bool32 *reserved);

htf.daqmx.core.DAQmxReadCounterU32(*arg)

int32 __CFUNC DAQmxReadCounterU32 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, uInt32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadCtrFreq(*arg)

int32 __CFUNC DAQmxReadCtrFreq (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 interleaved, float64 readArrayFrequency[], float64 readArrayDutyCycle[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadCtrFreqScalar(*arg)

int32 __CFUNC DAQmxReadCtrFreqScalar (TaskHandle taskHandle, float64 timeout, float64 *frequency, float64 *dutyCycle, bool32 *reserved);

htf.daqmx.core.DAQmxReadCtrTicks(*arg)

int32 __CFUNC DAQmxReadCtrTicks (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 interleaved, uInt32 readArrayHighTicks[], uInt32 readArrayLowTicks[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadCtrTicksScalar(*arg)

int32 __CFUNC DAQmxReadCtrTicksScalar (TaskHandle taskHandle, float64 timeout, uInt32 *highTicks, uInt32 *lowTicks, bool32 *reserved);

htf.daqmx.core.DAQmxReadCtrTime(*arg)

int32 __CFUNC DAQmxReadCtrTime (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 interleaved, float64 readArrayHighTime[], float64 readArrayLowTime[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadCtrTimeScalar(*arg)

int32 __CFUNC DAQmxReadCtrTimeScalar (TaskHandle taskHandle, float64 timeout, float64 *highTime, float64 *lowTime, bool32 *reserved);

htf.daqmx.core.DAQmxReadDigitalLines(*arg)

int32 __CFUNC DAQmxReadDigitalLines (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt8 readArray[], uInt32 arraySizeInBytes, int32 *sampsPerChanRead, int32 *numBytesPerSamp, bool32 *reserved);

htf.daqmx.core.DAQmxReadDigitalScalarU32(*arg)

int32 __CFUNC DAQmxReadDigitalScalarU32 (TaskHandle taskHandle, float64 timeout, uInt32 *value, bool32 *reserved);

htf.daqmx.core.DAQmxReadDigitalU16(*arg)

int32 __CFUNC DAQmxReadDigitalU16 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt16 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadDigitalU32(*arg)

int32 __CFUNC DAQmxReadDigitalU32 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadDigitalU8(*arg)

int32 __CFUNC DAQmxReadDigitalU8 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt8 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadRaw(*arg)

int32 __CFUNC DAQmxReadRaw (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, void *readArray, uInt32 arraySizeInBytes, int32 *sampsRead, int32 *numBytesPerSamp, bool32 *reserved);

htf.daqmx.core.DAQmxRegisterDoneEvent(*arg)

int32 __CFUNC DAQmxRegisterDoneEvent (TaskHandle task, uInt32 options, DAQmxDoneEventCallbackPtr callbackFunction, void *callbackData);

htf.daqmx.core.DAQmxRegisterEveryNSamplesEvent(*arg)

int32 __CFUNC DAQmxRegisterEveryNSamplesEvent (TaskHandle task, int32 everyNsamplesEventType, uInt32 nSamples, uInt32 options, DAQmxEveryNSamplesEventCallbackPtr callbackFunction, void *callbackData);

htf.daqmx.core.DAQmxRegisterSignalEvent(*arg)

int32 __CFUNC DAQmxRegisterSignalEvent (TaskHandle task, int32 signalID, uInt32 options, DAQmxSignalEventCallbackPtr callbackFunction, void *callbackData);

htf.daqmx.core.DAQmxRemoveCDAQSyncConnection(*arg)

int32 __CFUNC DAQmxRemoveCDAQSyncConnection(const char portList[]);

htf.daqmx.core.DAQmxReserveNetworkDevice(*arg)

int32 __CFUNC DAQmxReserveNetworkDevice(const char deviceName[], bool32 overrideReservation);

htf.daqmx.core.DAQmxResetAIACExcitFreq(*arg)

int32 __CFUNC DAQmxResetAIACExcitFreq(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIACExcitSyncEnable(*arg)

int32 __CFUNC DAQmxResetAIACExcitSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIACExcitWireMode(*arg)

int32 __CFUNC DAQmxResetAIACExcitWireMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIADCCustomTimingMode(*arg)

int32 __CFUNC DAQmxResetAIADCCustomTimingMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIADCTimingMode(*arg)

int32 __CFUNC DAQmxResetAIADCTimingMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAccelSensitivity(*arg)

int32 __CFUNC DAQmxResetAIAccelSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAccelSensitivityUnits(*arg)

int32 __CFUNC DAQmxResetAIAccelSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAccelUnits(*arg)

int32 __CFUNC DAQmxResetAIAccelUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAcceldBRef(*arg)

int32 __CFUNC DAQmxResetAIAcceldBRef(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAtten(*arg)

int32 __CFUNC DAQmxResetAIAtten(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAutoZeroMode(*arg)

int32 __CFUNC DAQmxResetAIAutoZeroMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAveragingWinSize(*arg)

int32 __CFUNC DAQmxResetAIAveragingWinSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeBalanceCoarsePot(*arg)

int32 __CFUNC DAQmxResetAIBridgeBalanceCoarsePot(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeBalanceFinePot(*arg)

int32 __CFUNC DAQmxResetAIBridgeBalanceFinePot(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeCfg(*arg)

int32 __CFUNC DAQmxResetAIBridgeCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeElectricalUnits(*arg)

int32 __CFUNC DAQmxResetAIBridgeElectricalUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeInitialRatio(*arg)

int32 __CFUNC DAQmxResetAIBridgeInitialRatio(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeInitialVoltage(*arg)

int32 __CFUNC DAQmxResetAIBridgeInitialVoltage(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeNomResistance(*arg)

int32 __CFUNC DAQmxResetAIBridgeNomResistance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgePhysicalUnits(*arg)

int32 __CFUNC DAQmxResetAIBridgePhysicalUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgePolyForwardCoeff(*arg)

int32 __CFUNC DAQmxResetAIBridgePolyForwardCoeff(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgePolyReverseCoeff(*arg)

int32 __CFUNC DAQmxResetAIBridgePolyReverseCoeff(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeScaleType(*arg)

int32 __CFUNC DAQmxResetAIBridgeScaleType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalEnable(*arg)

int32 __CFUNC DAQmxResetAIBridgeShuntCalEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalGainAdjust(*arg)

int32 __CFUNC DAQmxResetAIBridgeShuntCalGainAdjust(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalSelect(*arg)

int32 __CFUNC DAQmxResetAIBridgeShuntCalSelect(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalShuntCalAActualResistance(*arg)

int32 __CFUNC DAQmxResetAIBridgeShuntCalShuntCalAActualResistance (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalShuntCalAResistance(*arg)

int32 __CFUNC DAQmxResetAIBridgeShuntCalShuntCalAResistance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTableElectricalVals(*arg)

int32 __CFUNC DAQmxResetAIBridgeTableElectricalVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTablePhysicalVals(*arg)

int32 __CFUNC DAQmxResetAIBridgeTablePhysicalVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTwoPointLinFirstElectricalVal(*arg)

int32 __CFUNC DAQmxResetAIBridgeTwoPointLinFirstElectricalVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTwoPointLinFirstPhysicalVal(*arg)

int32 __CFUNC DAQmxResetAIBridgeTwoPointLinFirstPhysicalVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTwoPointLinSecondElectricalVal(*arg)

int32 __CFUNC DAQmxResetAIBridgeTwoPointLinSecondElectricalVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTwoPointLinSecondPhysicalVal(*arg)

int32 __CFUNC DAQmxResetAIBridgeTwoPointLinSecondPhysicalVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeUnits(*arg)

int32 __CFUNC DAQmxResetAIBridgeUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalApplyCalIfExp(*arg)

int32 __CFUNC DAQmxResetAIChanCalApplyCalIfExp(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalDesc(*arg)

int32 __CFUNC DAQmxResetAIChanCalDesc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalEnableCal(*arg)

int32 __CFUNC DAQmxResetAIChanCalEnableCal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalOperatorName(*arg)

int32 __CFUNC DAQmxResetAIChanCalOperatorName(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalPolyForwardCoeff(*arg)

int32 __CFUNC DAQmxResetAIChanCalPolyForwardCoeff(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalPolyReverseCoeff(*arg)

int32 __CFUNC DAQmxResetAIChanCalPolyReverseCoeff(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalScaleType(*arg)

int32 __CFUNC DAQmxResetAIChanCalScaleType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalTablePreScaledVals(*arg)

int32 __CFUNC DAQmxResetAIChanCalTablePreScaledVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalTableScaledVals(*arg)

int32 __CFUNC DAQmxResetAIChanCalTableScaledVals (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalVerifAcqVals(*arg)

int32 __CFUNC DAQmxResetAIChanCalVerifAcqVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalVerifRefVals(*arg)

int32 __CFUNC DAQmxResetAIChanCalVerifRefVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIConvActiveEdge(*arg)

int32 __CFUNC DAQmxResetAIConvActiveEdge(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvActiveEdgeEx(*arg)

int32 __CFUNC DAQmxResetAIConvActiveEdgeEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetAIConvDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigFltrEnableEx(*arg)

int32 __CFUNC DAQmxResetAIConvDigFltrEnableEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetAIConvDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigFltrMinPulseWidthEx(*arg)

int32 __CFUNC DAQmxResetAIConvDigFltrMinPulseWidthEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetAIConvDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigFltrTimebaseRateEx(*arg)

int32 __CFUNC DAQmxResetAIConvDigFltrTimebaseRateEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetAIConvDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigFltrTimebaseSrcEx(*arg)

int32 __CFUNC DAQmxResetAIConvDigFltrTimebaseSrcEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetAIConvDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigSyncEnableEx(*arg)

int32 __CFUNC DAQmxResetAIConvDigSyncEnableEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvRate(*arg)

int32 __CFUNC DAQmxResetAIConvRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvRateEx(*arg)

int32 __CFUNC DAQmxResetAIConvRateEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvSrc(*arg)

int32 __CFUNC DAQmxResetAIConvSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvSrcEx(*arg)

int32 __CFUNC DAQmxResetAIConvSrcEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvTimebaseDiv(*arg)

int32 __CFUNC DAQmxResetAIConvTimebaseDiv(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvTimebaseDivEx(*arg)

int32 __CFUNC DAQmxResetAIConvTimebaseDivEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetAIConvTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvTimebaseSrcEx(*arg)

int32 __CFUNC DAQmxResetAIConvTimebaseSrcEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAICoupling(*arg)

int32 __CFUNC DAQmxResetAICoupling(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICurrentACRMSUnits(*arg)

int32 __CFUNC DAQmxResetAICurrentACRMSUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICurrentShuntLoc(*arg)

int32 __CFUNC DAQmxResetAICurrentShuntLoc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICurrentShuntResistance(*arg)

int32 __CFUNC DAQmxResetAICurrentShuntResistance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICurrentUnits(*arg)

int32 __CFUNC DAQmxResetAICurrentUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICustomScaleName(*arg)

int32 __CFUNC DAQmxResetAICustomScaleName(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDCOffset(*arg)

int32 __CFUNC DAQmxResetAIDCOffset(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDataXferCustomThreshold(*arg)

int32 __CFUNC DAQmxResetAIDataXferCustomThreshold(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDataXferMech(*arg)

int32 __CFUNC DAQmxResetAIDataXferMech(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDataXferReqCond(*arg)

int32 __CFUNC DAQmxResetAIDataXferReqCond(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDitherEnable(*arg)

int32 __CFUNC DAQmxResetAIDitherEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIEddyCurrentProxProbeSensitivity(*arg)

int32 __CFUNC DAQmxResetAIEddyCurrentProxProbeSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIEddyCurrentProxProbeSensitivityUnits(*arg)

int32 __CFUNC DAQmxResetAIEddyCurrentProxProbeSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIEddyCurrentProxProbeUnits(*arg)

int32 __CFUNC DAQmxResetAIEddyCurrentProxProbeUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIEnhancedAliasRejectionEnable(*arg)

int32 __CFUNC DAQmxResetAIEnhancedAliasRejectionEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitActualVal(*arg)

int32 __CFUNC DAQmxResetAIExcitActualVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitDCorAC(*arg)

int32 __CFUNC DAQmxResetAIExcitDCorAC(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitSrc(*arg)

int32 __CFUNC DAQmxResetAIExcitSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitUseForScaling(*arg)

int32 __CFUNC DAQmxResetAIExcitUseForScaling(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitUseMultiplexed(*arg)

int32 __CFUNC DAQmxResetAIExcitUseMultiplexed(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitVal(*arg)

int32 __CFUNC DAQmxResetAIExcitVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitVoltageOrCurrent(*arg)

int32 __CFUNC DAQmxResetAIExcitVoltageOrCurrent(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFilterDelayAdjustment(*arg)

int32 __CFUNC DAQmxResetAIFilterDelayAdjustment(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFilterDelayUnits(*arg)

int32 __CFUNC DAQmxResetAIFilterDelayUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIForceIEPESensorSensitivity(*arg)

int32 __CFUNC DAQmxResetAIForceIEPESensorSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIForceIEPESensorSensitivityUnits(*arg)

int32 __CFUNC DAQmxResetAIForceIEPESensorSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIForceReadFromChan(*arg)

int32 __CFUNC DAQmxResetAIForceReadFromChan(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIForceUnits(*arg)

int32 __CFUNC DAQmxResetAIForceUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFreqHyst(*arg)

int32 __CFUNC DAQmxResetAIFreqHyst(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFreqThreshVoltage(*arg)

int32 __CFUNC DAQmxResetAIFreqThreshVoltage(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFreqUnits(*arg)

int32 __CFUNC DAQmxResetAIFreqUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIGain(*arg)

int32 __CFUNC DAQmxResetAIGain(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIImpedance(*arg)

int32 __CFUNC DAQmxResetAIImpedance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIInputSrc(*arg)

int32 __CFUNC DAQmxResetAIInputSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILVDTSensitivity(*arg)

int32 __CFUNC DAQmxResetAILVDTSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILVDTSensitivityUnits(*arg)

int32 __CFUNC DAQmxResetAILVDTSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILVDTUnits(*arg)

int32 __CFUNC DAQmxResetAILVDTUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILeadWireResistance(*arg)

int32 __CFUNC DAQmxResetAILeadWireResistance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILossyLSBRemovalCompressedSampSize(*arg)

int32 __CFUNC DAQmxResetAILossyLSBRemovalCompressedSampSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassCutoffFreq(*arg)

int32 __CFUNC DAQmxResetAILowpassCutoffFreq(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassEnable(*arg)

int32 __CFUNC DAQmxResetAILowpassEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassSwitchCapClkSrc(*arg)

int32 __CFUNC DAQmxResetAILowpassSwitchCapClkSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassSwitchCapExtClkDiv(*arg)

int32 __CFUNC DAQmxResetAILowpassSwitchCapExtClkDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassSwitchCapExtClkFreq(*arg)

int32 __CFUNC DAQmxResetAILowpassSwitchCapExtClkFreq(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassSwitchCapOutClkDiv(*arg)

int32 __CFUNC DAQmxResetAILowpassSwitchCapOutClkDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIMax(*arg)

int32 __CFUNC DAQmxResetAIMax(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIMemMapEnable(*arg)

int32 __CFUNC DAQmxResetAIMemMapEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIMicrophoneSensitivity(*arg)

int32 __CFUNC DAQmxResetAIMicrophoneSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIMin(*arg)

int32 __CFUNC DAQmxResetAIMin(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIOpenThrmcplDetectEnable(*arg)

int32 __CFUNC DAQmxResetAIOpenThrmcplDetectEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIPressureUnits(*arg)

int32 __CFUNC DAQmxResetAIPressureUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIProbeAtten(*arg)

int32 __CFUNC DAQmxResetAIProbeAtten(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDA(*arg)

int32 __CFUNC DAQmxResetAIRTDA(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDB(*arg)

int32 __CFUNC DAQmxResetAIRTDB(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDC(*arg)

int32 __CFUNC DAQmxResetAIRTDC(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDR0(*arg)

int32 __CFUNC DAQmxResetAIRTDR0(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDType(*arg)

int32 __CFUNC DAQmxResetAIRTDType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRVDTSensitivity(*arg)

int32 __CFUNC DAQmxResetAIRVDTSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRVDTSensitivityUnits(*arg)

int32 __CFUNC DAQmxResetAIRVDTSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRVDTUnits(*arg)

int32 __CFUNC DAQmxResetAIRVDTUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRawDataCompressionType(*arg)

int32 __CFUNC DAQmxResetAIRawDataCompressionType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRemoveFilterDelay(*arg)

int32 __CFUNC DAQmxResetAIRemoveFilterDelay(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIResistanceCfg(*arg)

int32 __CFUNC DAQmxResetAIResistanceCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIResistanceUnits(*arg)

int32 __CFUNC DAQmxResetAIResistanceUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRngHigh(*arg)

int32 __CFUNC DAQmxResetAIRngHigh(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRngLow(*arg)

int32 __CFUNC DAQmxResetAIRngLow(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRosetteStrainGageOrientation(*arg)

int32 __CFUNC DAQmxResetAIRosetteStrainGageOrientation(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRosetteStrainGageRosetteMeasType(*arg)

int32 __CFUNC DAQmxResetAIRosetteStrainGageRosetteMeasType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAISampAndHoldEnable(*arg)

int32 __CFUNC DAQmxResetAISampAndHoldEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAISoundPressureMaxSoundPressureLvl(*arg)

int32 __CFUNC DAQmxResetAISoundPressureMaxSoundPressureLvl(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAISoundPressureUnits(*arg)

int32 __CFUNC DAQmxResetAISoundPressureUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAISoundPressuredBRef(*arg)

int32 __CFUNC DAQmxResetAISoundPressuredBRef(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainGageCfg(*arg)

int32 __CFUNC DAQmxResetAIStrainGageCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainGageForceReadFromChan(*arg)

int32 __CFUNC DAQmxResetAIStrainGageForceReadFromChan(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainGageGageFactor(*arg)

int32 __CFUNC DAQmxResetAIStrainGageGageFactor(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainGagePoissonRatio(*arg)

int32 __CFUNC DAQmxResetAIStrainGagePoissonRatio(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainUnits(*arg)

int32 __CFUNC DAQmxResetAIStrainUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAITempUnits(*arg)

int32 __CFUNC DAQmxResetAITempUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAITermCfg(*arg)

int32 __CFUNC DAQmxResetAITermCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmcplCJCVal(*arg)

int32 __CFUNC DAQmxResetAIThrmcplCJCVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmcplLeadOffsetVoltage(*arg)

int32 __CFUNC DAQmxResetAIThrmcplLeadOffsetVoltage(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmcplScaleType(*arg)

int32 __CFUNC DAQmxResetAIThrmcplScaleType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmcplType(*arg)

int32 __CFUNC DAQmxResetAIThrmcplType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmstrA(*arg)

int32 __CFUNC DAQmxResetAIThrmstrA(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmstrB(*arg)

int32 __CFUNC DAQmxResetAIThrmstrB(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmstrC(*arg)

int32 __CFUNC DAQmxResetAIThrmstrC(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmstrR1(*arg)

int32 __CFUNC DAQmxResetAIThrmstrR1(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAITorqueUnits(*arg)

int32 __CFUNC DAQmxResetAITorqueUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIUsbXferReqCount(*arg)

int32 __CFUNC DAQmxResetAIUsbXferReqCount(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIUsbXferReqSize(*arg)

int32 __CFUNC DAQmxResetAIUsbXferReqSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVelocityIEPESensorSensitivity(*arg)

int32 __CFUNC DAQmxResetAIVelocityIEPESensorSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVelocityIEPESensorSensitivityUnits(*arg)

int32 __CFUNC DAQmxResetAIVelocityIEPESensorSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVelocityIEPESensordBRef(*arg)

int32 __CFUNC DAQmxResetAIVelocityIEPESensordBRef(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVelocityUnits(*arg)

int32 __CFUNC DAQmxResetAIVelocityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVoltageACRMSUnits(*arg)

int32 __CFUNC DAQmxResetAIVoltageACRMSUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVoltageUnits(*arg)

int32 __CFUNC DAQmxResetAIVoltageUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVoltagedBRef(*arg)

int32 __CFUNC DAQmxResetAIVoltagedBRef(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOCurrentUnits(*arg)

int32 __CFUNC DAQmxResetAOCurrentUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOCustomScaleName(*arg)

int32 __CFUNC DAQmxResetAOCustomScaleName(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACOffsetExtSrc(*arg)

int32 __CFUNC DAQmxResetAODACOffsetExtSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACOffsetSrc(*arg)

int32 __CFUNC DAQmxResetAODACOffsetSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACOffsetVal(*arg)

int32 __CFUNC DAQmxResetAODACOffsetVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefAllowConnToGnd(*arg)

int32 __CFUNC DAQmxResetAODACRefAllowConnToGnd(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefConnToGnd(*arg)

int32 __CFUNC DAQmxResetAODACRefConnToGnd(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefExtSrc(*arg)

int32 __CFUNC DAQmxResetAODACRefExtSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefSrc(*arg)

int32 __CFUNC DAQmxResetAODACRefSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefVal(*arg)

int32 __CFUNC DAQmxResetAODACRefVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRngHigh(*arg)

int32 __CFUNC DAQmxResetAODACRngHigh(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRngLow(*arg)

int32 __CFUNC DAQmxResetAODACRngLow(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODataXferMech(*arg)

int32 __CFUNC DAQmxResetAODataXferMech(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODataXferReqCond(*arg)

int32 __CFUNC DAQmxResetAODataXferReqCond(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOEnhancedImageRejectionEnable(*arg)

int32 __CFUNC DAQmxResetAOEnhancedImageRejectionEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFilterDelay(*arg)

int32 __CFUNC DAQmxResetAOFilterDelay(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFilterDelayAdjustment(*arg)

int32 __CFUNC DAQmxResetAOFilterDelayAdjustment(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFilterDelayUnits(*arg)

int32 __CFUNC DAQmxResetAOFilterDelayUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenAmplitude(*arg)

int32 __CFUNC DAQmxResetAOFuncGenAmplitude(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenFMDeviation(*arg)

int32 __CFUNC DAQmxResetAOFuncGenFMDeviation(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenFreq(*arg)

int32 __CFUNC DAQmxResetAOFuncGenFreq(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenModulationType(*arg)

int32 __CFUNC DAQmxResetAOFuncGenModulationType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenOffset(*arg)

int32 __CFUNC DAQmxResetAOFuncGenOffset(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenSquareDutyCycle(*arg)

int32 __CFUNC DAQmxResetAOFuncGenSquareDutyCycle(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenType(*arg)

int32 __CFUNC DAQmxResetAOFuncGenType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOGain(*arg)

int32 __CFUNC DAQmxResetAOGain(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOIdleOutputBehavior(*arg)

int32 __CFUNC DAQmxResetAOIdleOutputBehavior(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOLoadImpedance(*arg)

int32 __CFUNC DAQmxResetAOLoadImpedance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOMax(*arg)

int32 __CFUNC DAQmxResetAOMax(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOMemMapEnable(*arg)

int32 __CFUNC DAQmxResetAOMemMapEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOMin(*arg)

int32 __CFUNC DAQmxResetAOMin(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOOutputImpedance(*arg)

int32 __CFUNC DAQmxResetAOOutputImpedance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOPowerAmpChannelEnable(*arg)

int32 __CFUNC DAQmxResetAOPowerAmpChannelEnable(const char physicalChannel[]);

htf.daqmx.core.DAQmxResetAOReglitchEnable(*arg)

int32 __CFUNC DAQmxResetAOReglitchEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOResolutionUnits(*arg)

int32 __CFUNC DAQmxResetAOResolutionUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOTermCfg(*arg)

int32 __CFUNC DAQmxResetAOTermCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOUsbXferReqCount(*arg)

int32 __CFUNC DAQmxResetAOUsbXferReqCount(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOUsbXferReqSize(*arg)

int32 __CFUNC DAQmxResetAOUsbXferReqSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOUseOnlyOnBrdMem(*arg)

int32 __CFUNC DAQmxResetAOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOVoltageCurrentLimit(*arg)

int32 __CFUNC DAQmxResetAOVoltageCurrentLimit(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOVoltageUnits(*arg)

int32 __CFUNC DAQmxResetAOVoltageUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAdvTrigType(*arg)

int32 __CFUNC DAQmxResetAdvTrigType(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigCoupling(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigHyst(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigHyst(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigLvl(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigLvl(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigSlope(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigSlope(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigSrc(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigCoupling(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigHyst(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigHyst(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigLvl(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigLvl(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigSlope(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigSlope(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigSrc(*arg)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigCoupling(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigHyst(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigHyst(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigLvl(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigLvl(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigSrc(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigWhen(*arg)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigWhen(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigBtm(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigBtm(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigCoupling(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigSrc(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigTop(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigTop(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigWhen(*arg)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigWhen(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigBtm(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigBtm(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigCoupling(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigSrc(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigTop(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigTop(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigWhen(*arg)

int32 __CFUNC DAQmxResetAnlgWinRefTrigWhen(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigBtm(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigBtm(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigCoupling(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigSrc(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigTop(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigTop(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigWhen(*arg)

int32 __CFUNC DAQmxResetAnlgWinStartTrigWhen(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetArmStartTrigType(*arg)

int32 __CFUNC DAQmxResetArmStartTrigType(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetBufInputBufSize(*arg)

int32 __CFUNC DAQmxResetBufInputBufSize(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetBufOutputBufSize(*arg)

int32 __CFUNC DAQmxResetBufOutputBufSize(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetBufOutputOnbrdBufSize(*arg)

int32 __CFUNC DAQmxResetBufOutputOnbrdBufSize(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetBufferAttribute(*arg)

int32 __CFUNC DAQmxResetBufferAttribute (TaskHandle taskHandle, int32 attribute);

htf.daqmx.core.DAQmxResetCIAngEncoderInitialAngle(*arg)

int32 __CFUNC DAQmxResetCIAngEncoderInitialAngle(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIAngEncoderPulsesPerRev(*arg)

int32 __CFUNC DAQmxResetCIAngEncoderPulsesPerRev(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIAngEncoderUnits(*arg)

int32 __CFUNC DAQmxResetCIAngEncoderUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesActiveEdge(*arg)

int32 __CFUNC DAQmxResetCICountEdgesActiveEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetActiveEdge(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountResetActiveEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetEnable(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountResetEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetResetCount(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountResetResetCount(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetTerm(*arg)

int32 __CFUNC DAQmxResetCICountEdgesCountResetTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCICountEdgesDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCICountEdgesDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCICountEdgesDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCICountEdgesDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCICountEdgesDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDir(*arg)

int32 __CFUNC DAQmxResetCICountEdgesDir(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDirTerm(*arg)

int32 __CFUNC DAQmxResetCICountEdgesDirTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesInitialCnt(*arg)

int32 __CFUNC DAQmxResetCICountEdgesInitialCnt(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesTerm(*arg)

int32 __CFUNC DAQmxResetCICountEdgesTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseActiveEdge(*arg)

int32 __CFUNC DAQmxResetCICtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCICtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseMasterTimebaseDiv(*arg)

int32 __CFUNC DAQmxResetCICtrTimebaseMasterTimebaseDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCICtrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCICtrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICustomScaleName(*arg)

int32 __CFUNC DAQmxResetCICustomScaleName(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIDataXferMech(*arg)

int32 __CFUNC DAQmxResetCIDataXferMech(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIDataXferReqCond(*arg)

int32 __CFUNC DAQmxResetCIDataXferReqCond(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIDupCountPrevent(*arg)

int32 __CFUNC DAQmxResetCIDupCountPrevent(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCIEncoderAInputDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputTerm(*arg)

int32 __CFUNC DAQmxResetCIEncoderAInputTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCIEncoderBInputDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputTerm(*arg)

int32 __CFUNC DAQmxResetCIEncoderBInputTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderDecodingType(*arg)

int32 __CFUNC DAQmxResetCIEncoderDecodingType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZIndexEnable(*arg)

int32 __CFUNC DAQmxResetCIEncoderZIndexEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZIndexPhase(*arg)

int32 __CFUNC DAQmxResetCIEncoderZIndexPhase(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZIndexVal(*arg)

int32 __CFUNC DAQmxResetCIEncoderZIndexVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCIEncoderZInputDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputTerm(*arg)

int32 __CFUNC DAQmxResetCIEncoderZInputTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCIFreqDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCIFreqDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCIFreqDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCIFreqDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCIFreqDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDiv(*arg)

int32 __CFUNC DAQmxResetCIFreqDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqEnableAveraging(*arg)

int32 __CFUNC DAQmxResetCIFreqEnableAveraging(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqMeasMeth(*arg)

int32 __CFUNC DAQmxResetCIFreqMeasMeth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqMeasTime(*arg)

int32 __CFUNC DAQmxResetCIFreqMeasTime(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqStartingEdge(*arg)

int32 __CFUNC DAQmxResetCIFreqStartingEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqTerm(*arg)

int32 __CFUNC DAQmxResetCIFreqTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqUnits(*arg)

int32 __CFUNC DAQmxResetCIFreqUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIGPSSyncMethod(*arg)

int32 __CFUNC DAQmxResetCIGPSSyncMethod(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIGPSSyncSrc(*arg)

int32 __CFUNC DAQmxResetCIGPSSyncSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCILinEncoderDistPerPulse(*arg)

int32 __CFUNC DAQmxResetCILinEncoderDistPerPulse(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCILinEncoderInitialPos(*arg)

int32 __CFUNC DAQmxResetCILinEncoderInitialPos(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCILinEncoderUnits(*arg)

int32 __CFUNC DAQmxResetCILinEncoderUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIMax(*arg)

int32 __CFUNC DAQmxResetCIMax(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIMemMapEnable(*arg)

int32 __CFUNC DAQmxResetCIMemMapEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIMin(*arg)

int32 __CFUNC DAQmxResetCIMin(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCIPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCIPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCIPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCIPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCIPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDiv(*arg)

int32 __CFUNC DAQmxResetCIPeriodDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodEnableAveraging(*arg)

int32 __CFUNC DAQmxResetCIPeriodEnableAveraging(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodMeasMeth(*arg)

int32 __CFUNC DAQmxResetCIPeriodMeasMeth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodMeasTime(*arg)

int32 __CFUNC DAQmxResetCIPeriodMeasTime(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodStartingEdge(*arg)

int32 __CFUNC DAQmxResetCIPeriodStartingEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodTerm(*arg)

int32 __CFUNC DAQmxResetCIPeriodTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodUnits(*arg)

int32 __CFUNC DAQmxResetCIPeriodUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPrescaler(*arg)

int32 __CFUNC DAQmxResetCIPrescaler(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCIPulseFreqDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCIPulseFreqDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCIPulseFreqDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCIPulseFreqDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCIPulseFreqDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqStartEdge(*arg)

int32 __CFUNC DAQmxResetCIPulseFreqStartEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqTerm(*arg)

int32 __CFUNC DAQmxResetCIPulseFreqTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqUnits(*arg)

int32 __CFUNC DAQmxResetCIPulseFreqUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCIPulseTicksDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCIPulseTicksDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCIPulseTicksDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCIPulseTicksDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCIPulseTicksDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksStartEdge(*arg)

int32 __CFUNC DAQmxResetCIPulseTicksStartEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksTerm(*arg)

int32 __CFUNC DAQmxResetCIPulseTicksTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCIPulseTimeDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCIPulseTimeDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCIPulseTimeDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCIPulseTimeDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCIPulseTimeDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeStartEdge(*arg)

int32 __CFUNC DAQmxResetCIPulseTimeStartEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeTerm(*arg)

int32 __CFUNC DAQmxResetCIPulseTimeTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeUnits(*arg)

int32 __CFUNC DAQmxResetCIPulseTimeUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCIPulseWidthDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCIPulseWidthDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCIPulseWidthDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCIPulseWidthDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCIPulseWidthDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthStartingEdge(*arg)

int32 __CFUNC DAQmxResetCIPulseWidthStartingEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthTerm(*arg)

int32 __CFUNC DAQmxResetCIPulseWidthTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthUnits(*arg)

int32 __CFUNC DAQmxResetCIPulseWidthUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCISemiPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCISemiPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCISemiPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCISemiPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCISemiPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodStartingEdge(*arg)

int32 __CFUNC DAQmxResetCISemiPeriodStartingEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodTerm(*arg)

int32 __CFUNC DAQmxResetCISemiPeriodTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodUnits(*arg)

int32 __CFUNC DAQmxResetCISemiPeriodUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITimestampInitialSeconds(*arg)

int32 __CFUNC DAQmxResetCITimestampInitialSeconds(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITimestampUnits(*arg)

int32 __CFUNC DAQmxResetCITimestampUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstEdge(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstTerm(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondEdge(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondTerm(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepUnits(*arg)

int32 __CFUNC DAQmxResetCITwoEdgeSepUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIUsbXferReqCount(*arg)

int32 __CFUNC DAQmxResetCIUsbXferReqCount(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIUsbXferReqSize(*arg)

int32 __CFUNC DAQmxResetCIUsbXferReqSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOAutoIncrCnt(*arg)

int32 __CFUNC DAQmxResetCOAutoIncrCnt(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOConstrainedGenMode(*arg)

int32 __CFUNC DAQmxResetCOConstrainedGenMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOCtrTimebaseActiveEdge(*arg)

int32 __CFUNC DAQmxResetCOCtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOCtrTimebaseDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetCOCtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOCtrTimebaseDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetCOCtrTimebaseDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOCtrTimebaseDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCOCtrTimebaseDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOCtrTimebaseDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCOCtrTimebaseDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOCtrTimebaseDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetCOCtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOCtrTimebaseMasterTimebaseDiv(*arg)

int32 __CFUNC DAQmxResetCOCtrTimebaseMasterTimebaseDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOCtrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetCOCtrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOCtrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetCOCtrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCODataXferMech(*arg)

int32 __CFUNC DAQmxResetCODataXferMech(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCODataXferReqCond(*arg)

int32 __CFUNC DAQmxResetCODataXferReqCond(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOEnableInitialDelayOnRetrigger(*arg)

int32 __CFUNC DAQmxResetCOEnableInitialDelayOnRetrigger(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOMemMapEnable(*arg)

int32 __CFUNC DAQmxResetCOMemMapEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPrescaler(*arg)

int32 __CFUNC DAQmxResetCOPrescaler(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseDutyCyc(*arg)

int32 __CFUNC DAQmxResetCOPulseDutyCyc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseFreq(*arg)

int32 __CFUNC DAQmxResetCOPulseFreq(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseFreqInitialDelay(*arg)

int32 __CFUNC DAQmxResetCOPulseFreqInitialDelay(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseFreqUnits(*arg)

int32 __CFUNC DAQmxResetCOPulseFreqUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseHighTicks(*arg)

int32 __CFUNC DAQmxResetCOPulseHighTicks(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseHighTime(*arg)

int32 __CFUNC DAQmxResetCOPulseHighTime(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseIdleState(*arg)

int32 __CFUNC DAQmxResetCOPulseIdleState(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseLowTicks(*arg)

int32 __CFUNC DAQmxResetCOPulseLowTicks(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseLowTime(*arg)

int32 __CFUNC DAQmxResetCOPulseLowTime(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseTerm(*arg)

int32 __CFUNC DAQmxResetCOPulseTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseTicksInitialDelay(*arg)

int32 __CFUNC DAQmxResetCOPulseTicksInitialDelay(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseTimeInitialDelay(*arg)

int32 __CFUNC DAQmxResetCOPulseTimeInitialDelay(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOPulseTimeUnits(*arg)

int32 __CFUNC DAQmxResetCOPulseTimeUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOUsbXferReqCount(*arg)

int32 __CFUNC DAQmxResetCOUsbXferReqCount(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOUsbXferReqSize(*arg)

int32 __CFUNC DAQmxResetCOUsbXferReqSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCOUseOnlyOnBrdMem(*arg)

int32 __CFUNC DAQmxResetCOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetChanAttribute(*arg)

int32 __CFUNC DAQmxResetChanAttribute (TaskHandle taskHandle, const char channel[], int32 attribute);

htf.daqmx.core.DAQmxResetChanDescr(*arg)

int32 __CFUNC DAQmxResetChanDescr(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetChangeDetectDIFallingEdgePhysicalChans(*arg)

int32 __CFUNC DAQmxResetChangeDetectDIFallingEdgePhysicalChans(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetChangeDetectDIRisingEdgePhysicalChans(*arg)

int32 __CFUNC DAQmxResetChangeDetectDIRisingEdgePhysicalChans(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetChangeDetectDITristate(*arg)

int32 __CFUNC DAQmxResetChangeDetectDITristate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetDIAcquireOn(*arg)

int32 __CFUNC DAQmxResetDIAcquireOn(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIDataXferMech(*arg)

int32 __CFUNC DAQmxResetDIDataXferMech(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIDataXferReqCond(*arg)

int32 __CFUNC DAQmxResetDIDataXferReqCond(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIDigFltrEnable(*arg)

int32 __CFUNC DAQmxResetDIDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIDigFltrEnableBusMode(*arg)

int32 __CFUNC DAQmxResetDIDigFltrEnableBusMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIDigFltrMinPulseWidth(*arg)

int32 __CFUNC DAQmxResetDIDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIDigFltrTimebaseRate(*arg)

int32 __CFUNC DAQmxResetDIDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIDigFltrTimebaseSrc(*arg)

int32 __CFUNC DAQmxResetDIDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIDigSyncEnable(*arg)

int32 __CFUNC DAQmxResetDIDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIInvertLines(*arg)

int32 __CFUNC DAQmxResetDIInvertLines(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDILogicFamily(*arg)

int32 __CFUNC DAQmxResetDILogicFamily(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIMemMapEnable(*arg)

int32 __CFUNC DAQmxResetDIMemMapEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDITristate(*arg)

int32 __CFUNC DAQmxResetDITristate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIUsbXferReqCount(*arg)

int32 __CFUNC DAQmxResetDIUsbXferReqCount(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDIUsbXferReqSize(*arg)

int32 __CFUNC DAQmxResetDIUsbXferReqSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDODataXferMech(*arg)

int32 __CFUNC DAQmxResetDODataXferMech(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDODataXferReqCond(*arg)

int32 __CFUNC DAQmxResetDODataXferReqCond(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOGenerateOn(*arg)

int32 __CFUNC DAQmxResetDOGenerateOn(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOInvertLines(*arg)

int32 __CFUNC DAQmxResetDOInvertLines(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOLineStatesDoneState(*arg)

int32 __CFUNC DAQmxResetDOLineStatesDoneState(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOLineStatesPausedState(*arg)

int32 __CFUNC DAQmxResetDOLineStatesPausedState(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOLineStatesStartState(*arg)

int32 __CFUNC DAQmxResetDOLineStatesStartState(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOLogicFamily(*arg)

int32 __CFUNC DAQmxResetDOLogicFamily(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOMemMapEnable(*arg)

int32 __CFUNC DAQmxResetDOMemMapEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOOutputDriveType(*arg)

int32 __CFUNC DAQmxResetDOOutputDriveType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOOvercurrentAutoReenable(*arg)

int32 __CFUNC DAQmxResetDOOvercurrentAutoReenable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOOvercurrentLimit(*arg)

int32 __CFUNC DAQmxResetDOOvercurrentLimit(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetDOOvercurrentReenablePeriod(*arg)