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(referenceVoltage)

int32 __CFUNC DAQmxAOSeriesCalAdjust (CalHandle calHandle, float64 referenceVoltage);

htf.daqmx.core.DAQmxAddCDAQSyncConnection(portList)

int32 __CFUNC DAQmxAddCDAQSyncConnection(const char portList[]);

htf.daqmx.core.DAQmxAddGlobalChansToTask(taskHandle, channelNames)

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

htf.daqmx.core.DAQmxAddNetworkDevice(IPAddress, deviceName, attemptReservation, timeout, deviceNameOut, deviceNameOutBufferSize)

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

htf.daqmx.core.DAQmxAdjust1102Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1104Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1112Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1122Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1124Cal(measOutput)

int32 __CFUNC DAQmxAdjust1124Cal (CalHandle calHandle, float64 measOutput);

htf.daqmx.core.DAQmxAdjust1125Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1126Cal(refFreq, measOutput)

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

htf.daqmx.core.DAQmxAdjust1141Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1142Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1143Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1502Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1503Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1503CurrentCal(channelName, measCurrent)

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

htf.daqmx.core.DAQmxAdjust1520Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1521Cal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust153xCal(refVoltage, measOutput)

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

htf.daqmx.core.DAQmxAdjust1540Cal(refVoltage, measOutput, inputCalSource)

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

htf.daqmx.core.DAQmxAdjust4204Cal(channelNames, lowPassFreq, trackHoldEnabled, inputVal)

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

htf.daqmx.core.DAQmxAdjust4220Cal(channelNames, gain, inputVal)

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

htf.daqmx.core.DAQmxAdjust4224Cal(channelNames, gain, inputVal)

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

htf.daqmx.core.DAQmxAdjust4225Cal(channelNames, gain, inputVal)

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

htf.daqmx.core.DAQmxAdjust4300Cal(refVoltage)

int32 __CFUNC DAQmxAdjust4300Cal (CalHandle calHandle, float64 refVoltage);

htf.daqmx.core.DAQmxAdjust4322Cal(channelNames, refVal)

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

htf.daqmx.core.DAQmxAdjust433xCal(refVoltage, refExcitation, shuntLocation)

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

htf.daqmx.core.DAQmxAdjust4353Cal(channelNames, refVal)

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

htf.daqmx.core.DAQmxAdjust4357Cal(channelNames, refVals, numRefVals)

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

htf.daqmx.core.DAQmxAdjust4610Cal(channelName, gain, offset)

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

htf.daqmx.core.DAQmxAdjust9201Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9203GainCal(channelNames, rangeMin, rangeMax, value)

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

htf.daqmx.core.DAQmxAdjust9203OffsetCal(channelNames, rangeMin, rangeMax)

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

htf.daqmx.core.DAQmxAdjust9205Cal(value)

int32 __CFUNC DAQmxAdjust9205Cal(CalHandle calHandle, float64 value);

htf.daqmx.core.DAQmxAdjust9206Cal(value)

int32 __CFUNC DAQmxAdjust9206Cal(CalHandle calHandle, float64 value);

htf.daqmx.core.DAQmxAdjust9207GainCal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9207OffsetCal(channelNames)

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

htf.daqmx.core.DAQmxAdjust9208GainCal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9208OffsetCal(channelNames)

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

htf.daqmx.core.DAQmxAdjust9211Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9213Cal(channelNames, rangeMin, rangeMax, value)

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

htf.daqmx.core.DAQmxAdjust9214Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9215Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9217Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9219Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9220Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9221Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9222Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9223Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9225Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9227Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9229Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9232Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9234GainCal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9234OffsetCal(channelNames)

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

htf.daqmx.core.DAQmxAdjust9239Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9242Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9244Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9263Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9264Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9265Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjust9269Cal(channelNames, value)

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

htf.daqmx.core.DAQmxAdjustDSAAICal(referenceVoltage)

int32 __CFUNC DAQmxAdjustDSAAICal (CalHandle calHandle, float64 referenceVoltage);

htf.daqmx.core.DAQmxAdjustDSAAICalEx(referenceVoltage, inputsShorted)

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

htf.daqmx.core.DAQmxAdjustDSAAICalWithGainAndCoupling(coupling, gain, referenceVoltage)

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

htf.daqmx.core.DAQmxAdjustDSAAOCal(channel, requestedLowVoltage, actualLowVoltage, requestedHighVoltage, actualHighVoltage, gainSetting)

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

htf.daqmx.core.DAQmxAdjustDSAAOTimebaseCal(measuredFrequency, calComplete)

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

htf.daqmx.core.DAQmxAdjustDSATimebaseCal(referenceFrequency)

int32 __CFUNC DAQmxAdjustDSATimebaseCal (CalHandle calHandle, float64 referenceFrequency);

htf.daqmx.core.DAQmxAdjustTIOTimebaseCal(referenceFrequency)

int32 __CFUNC DAQmxAdjustTIOTimebaseCal (CalHandle calHandle, float64 referenceFrequency);

htf.daqmx.core.DAQmxAreConfiguredCDAQSyncPortsDisconnected(chassisDevicesPorts, timeout, disconnectedPortsExist)

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

htf.daqmx.core.DAQmxAutoConfigureCDAQSyncConnections(chassisDevicesPorts, timeout)

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

htf.daqmx.core.DAQmxCSeriesSetCalTemp(temperature)

int32 __CFUNC DAQmxCSeriesSetCalTemp(CalHandle calHandle, float64 temperature);

htf.daqmx.core.DAQmxCalculateReversePolyCoeff(forwardCoeffs, numForwardCoeffsIn, minValX, maxValX, numPointsToCompute, reversePolyOrder, reverseCoeffs)

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

htf.daqmx.core.DAQmxCfgAnlgEdgeRefTrig(taskHandle, triggerSource, triggerSlope, triggerLevel, pretriggerSamples)

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

htf.daqmx.core.DAQmxCfgAnlgEdgeStartTrig(taskHandle, triggerSource, triggerSlope, triggerLevel)

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

htf.daqmx.core.DAQmxCfgAnlgWindowRefTrig(taskHandle, triggerSource, triggerWhen, windowTop, windowBottom, pretriggerSamples)

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

htf.daqmx.core.DAQmxCfgAnlgWindowStartTrig(taskHandle, triggerSource, triggerWhen, windowTop, windowBottom)

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

htf.daqmx.core.DAQmxCfgBurstHandshakingTimingExportClock(taskHandle, sampleMode, sampsPerChan, sampleClkRate, sampleClkOutpTerm, sampleClkPulsePolarity, pauseWhen, readyEventActiveLevel)

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

htf.daqmx.core.DAQmxCfgBurstHandshakingTimingImportClock(taskHandle, sampleMode, sampsPerChan, sampleClkRate, sampleClkSrc, sampleClkActiveEdge, pauseWhen, readyEventActiveLevel)

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

htf.daqmx.core.DAQmxCfgChangeDetectionTiming(taskHandle, risingEdgeChan, fallingEdgeChan, sampleMode, sampsPerChan)

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

htf.daqmx.core.DAQmxCfgDigEdgeAdvTrig(taskHandle, triggerSource, triggerEdge)

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

htf.daqmx.core.DAQmxCfgDigEdgeRefTrig(taskHandle, triggerSource, triggerEdge, pretriggerSamples)

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

htf.daqmx.core.DAQmxCfgDigEdgeStartTrig(taskHandle, triggerSource, triggerEdge)

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

htf.daqmx.core.DAQmxCfgDigPatternRefTrig(taskHandle, triggerSource, triggerPattern, triggerWhen, pretriggerSamples)

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

htf.daqmx.core.DAQmxCfgDigPatternStartTrig(taskHandle, triggerSource, triggerPattern, triggerWhen)

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

htf.daqmx.core.DAQmxCfgHandshakingTiming(taskHandle, sampleMode, sampsPerChan)

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

htf.daqmx.core.DAQmxCfgImplicitTiming(taskHandle, sampleMode, sampsPerChan)

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

htf.daqmx.core.DAQmxCfgInputBuffer(taskHandle, numSampsPerChan)

int32 __CFUNC DAQmxCfgInputBuffer (TaskHandle taskHandle, uInt32 numSampsPerChan);

htf.daqmx.core.DAQmxCfgOutputBuffer(taskHandle, numSampsPerChan)

int32 __CFUNC DAQmxCfgOutputBuffer (TaskHandle taskHandle, uInt32 numSampsPerChan);

htf.daqmx.core.DAQmxCfgPipelinedSampClkTiming(taskHandle, source, rate, activeEdge, sampleMode, sampsPerChan)

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

htf.daqmx.core.DAQmxCfgSampClkTiming(taskHandle, source, rate, activeEdge, sampleMode, sampsPerChan)

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

htf.daqmx.core.DAQmxCfgWatchdogAOExpirStates(taskHandle, channelNames, expirStateArray, outputTypeArray, arraySize)

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

htf.daqmx.core.DAQmxCfgWatchdogCOExpirStates(taskHandle, channelNames, expirStateArray, arraySize)

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

htf.daqmx.core.DAQmxCfgWatchdogDOExpirStates(taskHandle, channelNames, expirStateArray, arraySize)

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

htf.daqmx.core.DAQmxChangeExtCalPassword(deviceName, password, newPassword)

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

htf.daqmx.core.DAQmxClearTEDS(physicalChannel)

int32 __CFUNC DAQmxClearTEDS (const char physicalChannel[]);

htf.daqmx.core.DAQmxClearTask(taskHandle)

int32 __CFUNC DAQmxClearTask (TaskHandle taskHandle);

htf.daqmx.core.DAQmxCloseExtCal(action)

int32 __CFUNC DAQmxCloseExtCal (CalHandle calHandle, int32 action);

htf.daqmx.core.DAQmxConfigureLogging(taskHandle, filePath, loggingMode, groupName, operation)

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

htf.daqmx.core.DAQmxConfigureTEDS(physicalChannel, filePath)

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

htf.daqmx.core.DAQmxConnectSCExpressCalAccChans(channelNames, connection)

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

htf.daqmx.core.DAQmxConnectTerms(sourceTerminal, destinationTerminal, signalModifiers)

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

htf.daqmx.core.DAQmxControlWatchdogTask(taskHandle, action)

int32 __CFUNC DAQmxControlWatchdogTask (TaskHandle taskHandle, int32 action);

htf.daqmx.core.DAQmxCreateAIAccelChan(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, sensitivity, sensitivityUnits, currentExcitSource, currentExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, shuntResistorLoc, extShuntResistorVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, shuntResistorLoc, extShuntResistorVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, units)

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

htf.daqmx.core.DAQmxCreateAIForceBridgePolynomialChan(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, forwardCoeffs, numForwardCoeffs, reverseCoeffs, numReverseCoeffs, electricalUnits, physicalUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, electricalVals, numElectricalVals, electricalUnits, physicalVals, numPhysicalVals, physicalUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, firstElectricalVal, secondElectricalVal, electricalUnits, firstPhysicalVal, secondPhysicalVal, physicalUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, sensitivity, sensitivityUnits, currentExcitSource, currentExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, thresholdLevel, hysteresis, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, units, micSensitivity, maxSndPressLevel, currentExcitSource, currentExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, sensitivity, sensitivityUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, sensitivity, sensitivityUnits, voltageExcitSource, voltageExcitVal, voltageExcitFreq, ACExcitWireMode, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, sensitivity, sensitivityUnits, voltageExcitSource, voltageExcitVal, voltageExcitFreq, ACExcitWireMode, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, forwardCoeffs, numForwardCoeffs, reverseCoeffs, numReverseCoeffs, electricalUnits, physicalUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, electricalVals, numElectricalVals, electricalUnits, physicalVals, numPhysicalVals, physicalUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, firstElectricalVal, secondElectricalVal, electricalUnits, firstPhysicalVal, secondPhysicalVal, physicalUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, rtdType, resistanceConfig, currentExcitSource, currentExcitVal, r0)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, resistanceConfig, currentExcitSource, currentExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, rosetteType, gageOrientation, rosetteMeasTypes, numRosetteMeasTypes, strainConfig, voltageExcitSource, voltageExcitVal, gageFactor, nominalGageResistance, poissonRatio, leadWireResistance)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, strainConfig, voltageExcitSource, voltageExcitVal, gageFactor, initialBridgeVoltage, nominalGageResistance, poissonRatio, leadWireResistance, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, units)

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

htf.daqmx.core.DAQmxCreateAIThrmcplChan(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, thermocoupleType, cjcSource, cjcVal, cjcChannel)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, resistanceConfig, currentExcitSource, currentExcitVal, a, b, c)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, resistanceConfig, voltageExcitSource, voltageExcitVal, a, b, c, r1)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, forwardCoeffs, numForwardCoeffs, reverseCoeffs, numReverseCoeffs, electricalUnits, physicalUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, electricalVals, numElectricalVals, electricalUnits, physicalVals, numPhysicalVals, physicalUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, nominalBridgeResistance, firstElectricalVal, secondElectricalVal, electricalUnits, firstPhysicalVal, secondPhysicalVal, physicalUnits, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, sensitivity, sensitivityUnits, currentExcitSource, currentExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, bridgeConfig, voltageExcitSource, voltageExcitVal, useExcitForScaling, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, customScaleName)

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

htf.daqmx.core.DAQmxCreateAOFuncGenChan(taskHandle, physicalChannel, nameToAssignToChannel, type, freq, amplitude, offset)

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

htf.daqmx.core.DAQmxCreateAOVoltageChan(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, customScaleName)

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

htf.daqmx.core.DAQmxCreateCIAngEncoderChan(taskHandle, counter, nameToAssignToChannel, decodingType, ZidxEnable, ZidxVal, ZidxPhase, units, pulsesPerRev, initialAngle, customScaleName)

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(taskHandle, counter, nameToAssignToChannel, edge, initialCount, countDirection)

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

htf.daqmx.core.DAQmxCreateCIFreqChan(taskHandle, counter, nameToAssignToChannel, minVal, maxVal, units, edge, measMethod, measTime, divisor, customScaleName)

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(taskHandle, counter, nameToAssignToChannel, units, syncMethod, customScaleName)

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

htf.daqmx.core.DAQmxCreateCILinEncoderChan(taskHandle, counter, nameToAssignToChannel, decodingType, ZidxEnable, ZidxVal, ZidxPhase, units, distPerPulse, initialPos, customScaleName)

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(taskHandle, counter, nameToAssignToChannel, minVal, maxVal, units, edge, measMethod, measTime, divisor, customScaleName)

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(taskHandle, counter, nameToAssignToChannel, minVal, maxVal, units)

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

htf.daqmx.core.DAQmxCreateCIPulseChanTicks(taskHandle, counter, nameToAssignToChannel, sourceTerminal, minVal, maxVal)

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

htf.daqmx.core.DAQmxCreateCIPulseChanTime(taskHandle, counter, nameToAssignToChannel, minVal, maxVal, units)

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

htf.daqmx.core.DAQmxCreateCIPulseWidthChan(taskHandle, counter, nameToAssignToChannel, minVal, maxVal, units, startingEdge, customScaleName)

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(taskHandle, counter, nameToAssignToChannel, minVal, maxVal, units, customScaleName)

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

htf.daqmx.core.DAQmxCreateCITwoEdgeSepChan(taskHandle, counter, nameToAssignToChannel, minVal, maxVal, units, firstEdge, secondEdge, customScaleName)

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(taskHandle, counter, nameToAssignToChannel, units, idleState, initialDelay, freq, dutyCycle)

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(taskHandle, counter, nameToAssignToChannel, sourceTerminal, idleState, initialDelay, lowTicks, highTicks)

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(taskHandle, counter, nameToAssignToChannel, units, idleState, initialDelay, lowTime, highTime)

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(taskHandle, lines, nameToAssignToLines, lineGrouping)

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

htf.daqmx.core.DAQmxCreateDOChan(taskHandle, lines, nameToAssignToLines, lineGrouping)

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

htf.daqmx.core.DAQmxCreateLinScale(name, slope, yIntercept, preScaledUnits, scaledUnits)

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

htf.daqmx.core.DAQmxCreateMapScale(name, prescaledMin, prescaledMax, scaledMin, scaledMax, preScaledUnits, scaledUnits)

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

htf.daqmx.core.DAQmxCreatePolynomialScale(name, forwardCoeffs, numForwardCoeffsIn, reverseCoeffs, numReverseCoeffsIn, preScaledUnits, scaledUnits)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, currentExcitSource, currentExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, voltageExcitSource, voltageExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, shuntResistorLoc, extShuntResistorVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, voltageExcitSource, voltageExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, currentExcitSource, currentExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, units, maxSndPressLevel, currentExcitSource, currentExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, voltageExcitSource, voltageExcitVal, voltageExcitFreq, ACExcitWireMode, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, voltageExcitSource, voltageExcitVal, voltageExcitFreq, ACExcitWireMode, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, voltageExcitSource, voltageExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, resistanceConfig, currentExcitSource, currentExcitVal)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, resistanceConfig, currentExcitSource, currentExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, voltageExcitSource, voltageExcitVal, initialBridgeVoltage, leadWireResistance, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, cjcSource, cjcVal, cjcChannel)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, resistanceConfig, currentExcitSource, currentExcitVal)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, resistanceConfig, voltageExcitSource, voltageExcitVal, r1)

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(taskHandle, physicalChannel, nameToAssignToChannel, minVal, maxVal, units, voltageExcitSource, voltageExcitVal, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, customScaleName)

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(taskHandle, physicalChannel, nameToAssignToChannel, terminalConfig, minVal, maxVal, units, voltageExcitSource, voltageExcitVal, customScaleName)

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(name, prescaledVals, numPrescaledValsIn, scaledVals, numScaledValsIn, preScaledUnits, scaledUnits)

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(taskName, taskHandle)

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

htf.daqmx.core.DAQmxCreateWatchdogTimerTask(deviceName, taskName, taskHandle, timeout, lines, expState)

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

htf.daqmx.core.DAQmxCreateWatchdogTimerTaskEx(deviceName, taskName, taskHandle, timeout)

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

htf.daqmx.core.DAQmxDSASetCalTemp(temperature)

int32 __CFUNC DAQmxDSASetCalTemp (CalHandle calHandle, float64 temperature);

htf.daqmx.core.DAQmxDeleteNetworkDevice(deviceName)

int32 __CFUNC DAQmxDeleteNetworkDevice(const char deviceName[]);

htf.daqmx.core.DAQmxDeleteSavedGlobalChan(channelName)

int32 __CFUNC DAQmxDeleteSavedGlobalChan (const char channelName[]);

htf.daqmx.core.DAQmxDeleteSavedScale(scaleName)

int32 __CFUNC DAQmxDeleteSavedScale (const char scaleName[]);

htf.daqmx.core.DAQmxDeleteSavedTask(taskName)

int32 __CFUNC DAQmxDeleteSavedTask (const char taskName[]);

htf.daqmx.core.DAQmxDeviceSupportsCal(deviceName, calSupported)

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

htf.daqmx.core.DAQmxDisableAdvTrig(taskHandle)

int32 __CFUNC DAQmxDisableAdvTrig (TaskHandle taskHandle);

htf.daqmx.core.DAQmxDisableRefTrig(taskHandle)

int32 __CFUNC DAQmxDisableRefTrig (TaskHandle taskHandle);

htf.daqmx.core.DAQmxDisableStartTrig(taskHandle)

int32 __CFUNC DAQmxDisableStartTrig (TaskHandle taskHandle);

htf.daqmx.core.DAQmxDisconnectSCExpressCalAccChans()

int32 __CFUNC DAQmxDisconnectSCExpressCalAccChans (CalHandle calHandle);

htf.daqmx.core.DAQmxDisconnectTerms(sourceTerminal, destinationTerminal)

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

htf.daqmx.core.DAQmxESeriesCalAdjust(referenceVoltage)

int32 __CFUNC DAQmxESeriesCalAdjust (CalHandle calHandle, float64 referenceVoltage);

htf.daqmx.core.DAQmxExportSignal(taskHandle, signalID, outputTerminal)

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

htf.daqmx.core.DAQmxGet4322CalAdjustPoints(outputType, adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9201CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9203CalAdjustPoints(rangeMin, rangeMax, adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9207CalAdjustPoints(channelNames, adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9208CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9213CalAdjustPoints(rangeMin, rangeMax, adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9214CalAdjustPoints(channelNames, adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9215CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9217CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9219CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9220CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9221CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9222CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9223CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9225CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9227CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9229CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9232CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9234CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9239CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9242CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9244CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9263CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9264CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9265CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGet9269CalAdjustPoints(adjustmentPoints, bufferSize)

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

htf.daqmx.core.DAQmxGetAIACExcitFreq(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIACExcitSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIACExcitWireMode(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIADCCustomTimingMode(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIADCTimingMode(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIAccelSensitivity(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIAccelSensitivityUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIAccelUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIAcceldBRef(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIAtten(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIAutoZeroMode(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIAveragingWinSize(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeBalanceCoarsePot(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeBalanceFinePot(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeCfg(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeElectricalUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeInitialRatio(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeInitialVoltage(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeNomResistance(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgePhysicalUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgePolyForwardCoeff(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIBridgePolyReverseCoeff(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIBridgeScaleType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeShuntCalEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeShuntCalGainAdjust(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeShuntCalSelect(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeShuntCalShuntCalAActualResistance(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeShuntCalShuntCalAResistance(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeTableElectricalVals(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIBridgeTablePhysicalVals(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIBridgeTwoPointLinFirstElectricalVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeTwoPointLinFirstPhysicalVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeTwoPointLinSecondElectricalVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeTwoPointLinSecondPhysicalVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIBridgeUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIChanCalApplyCalIfExp(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIChanCalCalDate(taskHandle, channelName, year, month, day, hour, minute)

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

htf.daqmx.core.DAQmxGetAIChanCalDesc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAIChanCalEnableCal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIChanCalExpDate(taskHandle, channelName, year, month, day, hour, minute)

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

htf.daqmx.core.DAQmxGetAIChanCalHasValidCalInfo(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIChanCalOperatorName(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAIChanCalPolyForwardCoeff(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIChanCalPolyReverseCoeff(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIChanCalScaleType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIChanCalTablePreScaledVals(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIChanCalTableScaledVals(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIChanCalVerifAcqVals(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIChanCalVerifRefVals(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIConvActiveEdge(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAIConvActiveEdgeEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetAIConvDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAIConvDigFltrEnableEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetAIConvDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAIConvDigFltrMinPulseWidthEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetAIConvDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAIConvDigFltrTimebaseRateEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetAIConvDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAIConvDigFltrTimebaseSrcEx(taskHandle, deviceNames, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAIConvDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAIConvDigSyncEnableEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetAIConvMaxRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAIConvMaxRateEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetAIConvRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAIConvRateEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetAIConvSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAIConvSrcEx(taskHandle, deviceNames, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAIConvTimebaseDiv(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAIConvTimebaseDivEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetAIConvTimebaseSrc(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAIConvTimebaseSrcEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetAICoupling(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAICurrentACRMSUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAICurrentShuntLoc(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAICurrentShuntResistance(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAICurrentUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAICustomScaleName(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAIDCOffset(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIDataXferCustomThreshold(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIDataXferMech(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIDataXferReqCond(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIDevScalingCoeff(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAIDitherEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIEddyCurrentProxProbeSensitivity(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIEddyCurrentProxProbeSensitivityUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIEddyCurrentProxProbeUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIEnhancedAliasRejectionEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIExcitActualVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIExcitDCorAC(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIExcitSrc(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIExcitUseForScaling(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIExcitUseMultiplexed(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIExcitVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIExcitVoltageOrCurrent(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIFilterDelay(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIFilterDelayAdjustment(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIFilterDelayUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIForceIEPESensorSensitivity(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIForceIEPESensorSensitivityUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIForceReadFromChan(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIForceUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIFreqHyst(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIFreqThreshVoltage(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIFreqUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIGain(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIImpedance(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIInputSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAIIsTEDS(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILVDTSensitivity(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILVDTSensitivityUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILVDTUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILeadWireResistance(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILossyLSBRemovalCompressedSampSize(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILowpassCutoffFreq(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILowpassEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILowpassSwitchCapClkSrc(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILowpassSwitchCapExtClkDiv(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILowpassSwitchCapExtClkFreq(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAILowpassSwitchCapOutClkDiv(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIMax(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIMeasType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIMemMapEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIMicrophoneSensitivity(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIMin(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIOpenThrmcplDetectEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIPressureUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIProbeAtten(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRTDA(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRTDB(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRTDC(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRTDR0(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRTDType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRVDTSensitivity(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRVDTSensitivityUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRVDTUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRawDataCompressionType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRawSampJustification(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRawSampSize(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRemoveFilterDelay(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIResistanceCfg(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIResistanceUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIResolution(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIResolutionUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRngHigh(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRngLow(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRosetteStrainGageOrientation(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRosetteStrainGageRosetteMeasType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRosetteStrainGageRosetteType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIRosetteStrainGageStrainChans(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAISampAndHoldEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAISoundPressureMaxSoundPressureLvl(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAISoundPressureUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAISoundPressuredBRef(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIStrainGageCfg(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIStrainGageForceReadFromChan(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIStrainGageGageFactor(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIStrainGagePoissonRatio(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIStrainUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAITEDSUnits(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAITempUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAITermCfg(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIThrmcplCJCChan(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAIThrmcplCJCSrc(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIThrmcplCJCVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIThrmcplLeadOffsetVoltage(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIThrmcplScaleType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIThrmcplType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIThrmstrA(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIThrmstrB(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIThrmstrC(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIThrmstrR1(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAITorqueUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIUsbXferReqCount(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIUsbXferReqSize(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIVelocityIEPESensorSensitivity(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIVelocityIEPESensorSensitivityUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIVelocityIEPESensordBRef(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIVelocityUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIVoltageACRMSUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIVoltageUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAIVoltagedBRef(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOCurrentUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOCustomScaleName(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAODACOffsetExtSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAODACOffsetSrc(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODACOffsetVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODACRefAllowConnToGnd(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODACRefConnToGnd(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODACRefExtSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAODACRefSrc(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODACRefVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODACRngHigh(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODACRngLow(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODataXferMech(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODataXferReqCond(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAODevScalingCoeff(taskHandle, channel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAOEnhancedImageRejectionEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFilterDelay(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFilterDelayAdjustment(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFilterDelayUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFuncGenAmplitude(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFuncGenFMDeviation(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFuncGenFreq(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFuncGenModulationType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFuncGenOffset(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFuncGenSquareDutyCycle(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOFuncGenType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOGain(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOIdleOutputBehavior(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOLoadImpedance(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOMax(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOMemMapEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOMin(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOOutputImpedance(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOOutputType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOPowerAmpChannelEnable(physicalChannel, data)

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

htf.daqmx.core.DAQmxGetAOPowerAmpGain(physicalChannel, data)

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

htf.daqmx.core.DAQmxGetAOPowerAmpOffset(physicalChannel, data)

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

htf.daqmx.core.DAQmxGetAOPowerAmpOvercurrent(physicalChannel, data)

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

htf.daqmx.core.DAQmxGetAOPowerAmpScalingCoeff(physicalChannel, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetAOReglitchEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOResolution(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOResolutionUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOTermCfg(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOUsbXferReqCount(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOUsbXferReqSize(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOUseOnlyOnBrdMem(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOVoltageCurrentLimit(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAOVoltageUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetAdvTrigType(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnalogPowerUpStates(deviceName, channelName, state, channelType)

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

htf.daqmx.core.DAQmxGetAnalogPowerUpStatesWithOutputType(channelNames, stateArray, channelTypeArray, arraySizePtr)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigCoupling(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigHyst(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigLvl(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigSlope(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeRefTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigCoupling(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigHyst(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigLvl(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigSlope(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgEdgeStartTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigCoupling(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigHyst(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigLvl(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgLvlPauseTrigWhen(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigBtm(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigCoupling(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigTop(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinPauseTrigWhen(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigBtm(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigCoupling(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigTop(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinRefTrigWhen(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigBtm(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigCoupling(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigTop(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAnlgWinStartTrigWhen(taskHandle, data)

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

htf.daqmx.core.DAQmxGetArmStartTerm(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetArmStartTrigType(taskHandle, data)

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

htf.daqmx.core.DAQmxGetAutoConfiguredCDAQSyncConnections(portList, portListSize)

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

htf.daqmx.core.DAQmxGetBufInputBufSize(taskHandle, data)

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

htf.daqmx.core.DAQmxGetBufInputOnbrdBufSize(taskHandle, data)

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

htf.daqmx.core.DAQmxGetBufOutputBufSize(taskHandle, data)

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

htf.daqmx.core.DAQmxGetBufOutputOnbrdBufSize(taskHandle, data)

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

htf.daqmx.core.DAQmxGetBufferAttribute(taskHandle, attribute, value)

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

htf.daqmx.core.DAQmxGetCIAngEncoderInitialAngle(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIAngEncoderPulsesPerRev(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIAngEncoderUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICount(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesActiveEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountDirDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountResetActiveEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountResetDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountResetEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountResetResetCount(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesCountResetTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCICountEdgesDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCICountEdgesDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesDir(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesDirTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCICountEdgesInitialCnt(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICountEdgesTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCICtrTimebaseActiveEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICtrTimebaseDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICtrTimebaseDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICtrTimebaseDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICtrTimebaseDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCICtrTimebaseDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICtrTimebaseMasterTimebaseDiv(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICtrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCICtrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCICustomScaleName(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIDataXferMech(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIDataXferReqCond(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIDupCountPrevent(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderAInputDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderAInputDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderAInputDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderAInputDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIEncoderAInputDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderAInputTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIEncoderBInputDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderBInputDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderBInputDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderBInputDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIEncoderBInputDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderBInputTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIEncoderDecodingType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderZIndexEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderZIndexPhase(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderZIndexVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderZInputDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderZInputDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderZInputDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderZInputDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIEncoderZInputDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIEncoderZInputTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIFreqDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIFreqDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIFreqDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIFreqDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIFreqDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIFreqDiv(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIFreqEnableAveraging(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIFreqMeasMeth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIFreqMeasTime(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIFreqStartingEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIFreqTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIFreqUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIGPSSyncMethod(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIGPSSyncSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCILinEncoderDistPerPulse(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCILinEncoderInitialPos(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCILinEncoderUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIMax(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIMeasType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIMemMapEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIMin(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCINumPossiblyInvalidSamps(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIOutputState(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPeriodDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodDiv(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodEnableAveraging(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodMeasMeth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodMeasTime(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodStartingEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPeriodTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPeriodUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPrescaler(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseFreqDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseFreqDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseFreqDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseFreqDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPulseFreqDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseFreqStartEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseFreqTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPulseFreqUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTicksDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTicksDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTicksDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTicksDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPulseTicksDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTicksStartEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTicksTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPulseTimeDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTimeDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTimeDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTimeDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPulseTimeDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTimeStartEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseTimeTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPulseTimeUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseWidthDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseWidthDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseWidthDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseWidthDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPulseWidthDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseWidthStartingEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIPulseWidthTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCIPulseWidthUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCISemiPeriodDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCISemiPeriodDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCISemiPeriodDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCISemiPeriodDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCISemiPeriodDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCISemiPeriodStartingEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCISemiPeriodTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCISemiPeriodUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITCReached(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITimestampInitialSeconds(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITimestampUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepFirstTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepSecondTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCITwoEdgeSepUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIUsbXferReqCount(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCIUsbXferReqSize(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOAutoIncrCnt(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOConstrainedGenMode(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOCount(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOCtrTimebaseActiveEdge(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCOCtrTimebaseDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOCtrTimebaseMasterTimebaseDiv(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOCtrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOCtrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCODataXferMech(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCODataXferReqCond(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOEnableInitialDelayOnRetrigger(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOMemMapEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOOutputState(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOOutputType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPrescaler(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseDone(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseDutyCyc(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseFreq(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseFreqInitialDelay(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseFreqUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseHighTicks(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseHighTime(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseIdleState(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseLowTicks(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseLowTime(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseTerm(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCOPulseTicksInitialDelay(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseTimeInitialDelay(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOPulseTimeUnits(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCORdyForNewVal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOUsbXferReqCount(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOUsbXferReqSize(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCOUseOnlyOnBrdMem(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetCalAccConnectionCount(deviceName, data)

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

htf.daqmx.core.DAQmxGetCalDevTemp(deviceName, data)

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

htf.daqmx.core.DAQmxGetCalInfoAttribute(deviceName, attribute, value)

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

htf.daqmx.core.DAQmxGetCalRecommendedAccConnectionCountLimit(deviceName, data)

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

htf.daqmx.core.DAQmxGetCalUserDefinedInfo(deviceName, data, bufferSize)

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

htf.daqmx.core.DAQmxGetCalUserDefinedInfoMaxSize(deviceName, data)

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

htf.daqmx.core.DAQmxGetCarrierSerialNum(device, data)

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

htf.daqmx.core.DAQmxGetChanAttribute(taskHandle, channel, attribute, value)

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

htf.daqmx.core.DAQmxGetChanDescr(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetChanIsGlobal(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetChanType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetChangeDetectDIFallingEdgePhysicalChans(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetChangeDetectDIRisingEdgePhysicalChans(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetChangeDetectDITristate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDIAcquireOn(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIDataXferMech(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIDataXferReqCond(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIDigFltrEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIDigFltrEnableBusMode(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIDigFltrMinPulseWidth(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIDigFltrTimebaseRate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIDigFltrTimebaseSrc(taskHandle, channel, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDIDigSyncEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIInvertLines(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDILogicFamily(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIMemMapEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDINumLines(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDITristate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIUsbXferReqCount(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDIUsbXferReqSize(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDODataXferMech(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDODataXferReqCond(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOGenerateOn(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOInvertLines(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOLineStatesDoneState(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOLineStatesPausedState(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOLineStatesStartState(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOLogicFamily(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOMemMapEnable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDONumLines(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOOutputDriveType(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOOvercurrentAutoReenable(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOOvercurrentLimit(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOOvercurrentReenablePeriod(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOTristate(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOUsbXferReqCount(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOUsbXferReqSize(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDOUseOnlyOnBrdMem(taskHandle, channel, data)

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

htf.daqmx.core.DAQmxGetDelayFromSampClkDelay(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDelayFromSampClkDelayEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetDelayFromSampClkDelayUnits(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDelayFromSampClkDelayUnitsEx(taskHandle, deviceNames, data)

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

htf.daqmx.core.DAQmxGetDevAIBridgeRngs(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAICouplings(device, data)

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

htf.daqmx.core.DAQmxGetDevAICurrentIntExcitDiscreteVals(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAICurrentRngs(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAIFreqRngs(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAIGains(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAILowpassCutoffFreqDiscreteVals(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAILowpassCutoffFreqRangeVals(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAIMaxMultiChanRate(device, data)

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

htf.daqmx.core.DAQmxGetDevAIMaxSingleChanRate(device, data)

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

htf.daqmx.core.DAQmxGetDevAIMinRate(device, data)

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

htf.daqmx.core.DAQmxGetDevAIPhysicalChans(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevAIResistanceRngs(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAISampModes(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAISimultaneousSamplingSupported(device, data)

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

htf.daqmx.core.DAQmxGetDevAISupportedMeasTypes(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAITrigUsage(device, data)

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

htf.daqmx.core.DAQmxGetDevAIVoltageIntExcitDiscreteVals(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAIVoltageIntExcitRangeVals(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAIVoltageRngs(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAOCurrentRngs(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAOGains(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAOMaxRate(device, data)

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

htf.daqmx.core.DAQmxGetDevAOMinRate(device, data)

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

htf.daqmx.core.DAQmxGetDevAOPhysicalChans(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevAOSampClkSupported(device, data)

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

htf.daqmx.core.DAQmxGetDevAOSampModes(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAOSupportedOutputTypes(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAOTrigUsage(device, data)

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

htf.daqmx.core.DAQmxGetDevAOVoltageRngs(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAccessoryProductNums(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAccessoryProductTypes(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevAccessorySerialNums(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevAnlgTrigSupported(device, data)

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

htf.daqmx.core.DAQmxGetDevBusType(device, data)

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

htf.daqmx.core.DAQmxGetDevCIMaxSize(device, data)

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

htf.daqmx.core.DAQmxGetDevCIMaxTimebase(device, data)

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

htf.daqmx.core.DAQmxGetDevCIPhysicalChans(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevCISampClkSupported(device, data)

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

htf.daqmx.core.DAQmxGetDevCISampModes(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevCISupportedMeasTypes(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevCITrigUsage(device, data)

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

htf.daqmx.core.DAQmxGetDevCOMaxSize(device, data)

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

htf.daqmx.core.DAQmxGetDevCOMaxTimebase(device, data)

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

htf.daqmx.core.DAQmxGetDevCOPhysicalChans(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevCOSampClkSupported(device, data)

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

htf.daqmx.core.DAQmxGetDevCOSampModes(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevCOSupportedOutputTypes(device, data, arraySizeInElements)

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

htf.daqmx.core.DAQmxGetDevCOTrigUsage(device, data)

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

htf.daqmx.core.DAQmxGetDevChassisModuleDevNames(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevCompactDAQChassisDevName(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevCompactDAQSlotNum(device, data)

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

htf.daqmx.core.DAQmxGetDevDILines(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevDIMaxRate(device, data)

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

htf.daqmx.core.DAQmxGetDevDIPorts(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevDITrigUsage(device, data)

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

htf.daqmx.core.DAQmxGetDevDOLines(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevDOMaxRate(device, data)

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

htf.daqmx.core.DAQmxGetDevDOPorts(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevDOTrigUsage(device, data)

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

htf.daqmx.core.DAQmxGetDevDigTrigSupported(device, data)

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

htf.daqmx.core.DAQmxGetDevIsSimulated(device, data)

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

htf.daqmx.core.DAQmxGetDevNumDMAChans(device, data)

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

htf.daqmx.core.DAQmxGetDevPCIBusNum(device, data)

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

htf.daqmx.core.DAQmxGetDevPCIDevNum(device, data)

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

htf.daqmx.core.DAQmxGetDevPXIChassisNum(device, data)

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

htf.daqmx.core.DAQmxGetDevPXISlotNum(device, data)

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

htf.daqmx.core.DAQmxGetDevProductCategory(device, data)

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

htf.daqmx.core.DAQmxGetDevProductNum(device, data)

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

htf.daqmx.core.DAQmxGetDevProductType(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevSerialNum(device, data)

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

htf.daqmx.core.DAQmxGetDevTCPIPEthernetIP(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevTCPIPHostname(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevTCPIPWirelessIP(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDevTEDSHWTEDSSupported(device, data)

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

htf.daqmx.core.DAQmxGetDevTerminals(device, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDeviceAttribute(deviceName, attribute, value)

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

htf.daqmx.core.DAQmxGetDigEdgeAdvTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeAdvTrigEdge(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeAdvTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigEdge(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeArmStartTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigEdgeRefTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeRefTrigEdge(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeRefTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigEdgeStartTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeStartTrigEdge(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeStartTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigEdgeWatchdogExpirTrigEdge(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigEdgeWatchdogExpirTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigFltrEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigFltrMinPulseWidth(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigFltrTimebaseRate(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigFltrTimebaseSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigLvlPauseTrigDigSyncEnable(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigLvlPauseTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigLvlPauseTrigWhen(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigPatternPauseTrigPattern(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigPatternPauseTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigPatternPauseTrigWhen(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigPatternRefTrigPattern(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigPatternRefTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigPatternRefTrigWhen(taskHandle, data)

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

htf.daqmx.core.DAQmxGetDigPatternStartTrigPattern(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigPatternStartTrigSrc(taskHandle, data, bufferSize)

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

htf.daqmx.core.DAQmxGetDigPatternStartTrigWhen(taskHandle, data)

int32 __CFUNC DAQmxGetDigPatternStartTrigWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetDigitalLogicFamilyPowerUpState(deviceName, logicFamily)

int32 __CFUNC DAQmxGetDigitalLogicFamilyPowerUpState(const char deviceName[], int32* logicFamily);

htf.daqmx.core.DAQmxGetDigitalPowerUpStates(deviceName, channelName, state)

int32 __CFUNC_C DAQmxGetDigitalPowerUpStates (const char deviceName[], const char channelName[], int32* state, …);

htf.daqmx.core.DAQmxGetDigitalPullUpPullDownStates(deviceName, channelName, state)

int32 __CFUNC_C DAQmxGetDigitalPullUpPullDownStates (const char deviceName[], const char channelName[], int32* state, …);

htf.daqmx.core.DAQmxGetDisconnectedCDAQSyncPorts(portList, portListSize)

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(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExported10MHzRefClkOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExported20MHzTimebaseOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExported20MHzTimebaseOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAIConvClkOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedAIConvClkOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAIConvClkPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedAIConvClkPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedAIHoldCmpltEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedAIHoldCmpltEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAIHoldCmpltEventPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedAIHoldCmpltEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedAdvCmpltEventDelay(taskHandle, data)

int32 __CFUNC DAQmxGetExportedAdvCmpltEventDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedAdvCmpltEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedAdvCmpltEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAdvCmpltEventPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedAdvCmpltEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedAdvCmpltEventPulseWidth(taskHandle, data)

int32 __CFUNC DAQmxGetExportedAdvCmpltEventPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedAdvTrigOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedAdvTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedAdvTrigPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedAdvTrigPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedAdvTrigPulseWidth(taskHandle, data)

int32 __CFUNC DAQmxGetExportedAdvTrigPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedAdvTrigPulseWidthUnits(taskHandle, data)

int32 __CFUNC DAQmxGetExportedAdvTrigPulseWidthUnits(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedChangeDetectEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedChangeDetectEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedChangeDetectEventPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedChangeDetectEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedCtrOutEventOutputBehavior(taskHandle, data)

int32 __CFUNC DAQmxGetExportedCtrOutEventOutputBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedCtrOutEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedCtrOutEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedCtrOutEventPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedCtrOutEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedCtrOutEventToggleIdleState(taskHandle, data)

int32 __CFUNC DAQmxGetExportedCtrOutEventToggleIdleState(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedDataActiveEventLvlActiveLvl(taskHandle, data)

int32 __CFUNC DAQmxGetExportedDataActiveEventLvlActiveLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedDataActiveEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedDataActiveEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedDividedSampClkTimebaseOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedDividedSampClkTimebaseOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedHshkEventDelay(taskHandle, data)

int32 __CFUNC DAQmxGetExportedHshkEventDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventInterlockedAssertOnStart(taskHandle, data)

int32 __CFUNC DAQmxGetExportedHshkEventInterlockedAssertOnStart(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventInterlockedAssertedLvl(taskHandle, data)

int32 __CFUNC DAQmxGetExportedHshkEventInterlockedAssertedLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventInterlockedDeassertDelay(taskHandle, data)

int32 __CFUNC DAQmxGetExportedHshkEventInterlockedDeassertDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventOutputBehavior(taskHandle, data)

int32 __CFUNC DAQmxGetExportedHshkEventOutputBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedHshkEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedHshkEventPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedHshkEventPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedHshkEventPulseWidth(taskHandle, data)

int32 __CFUNC DAQmxGetExportedHshkEventPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedPauseTrigLvlActiveLvl(taskHandle, data)

int32 __CFUNC DAQmxGetExportedPauseTrigLvlActiveLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedPauseTrigOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedPauseTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedRdyForStartEventLvlActiveLvl(taskHandle, data)

int32 __CFUNC DAQmxGetExportedRdyForStartEventLvlActiveLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedRdyForStartEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedRdyForStartEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedRdyForXferEventDeassertCond(taskHandle, data)

int32 __CFUNC DAQmxGetExportedRdyForXferEventDeassertCond(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedRdyForXferEventDeassertCondCustomThreshold(taskHandle, data)

int32 __CFUNC DAQmxGetExportedRdyForXferEventDeassertCondCustomThreshold (TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetExportedRdyForXferEventLvlActiveLvl(taskHandle, data)

int32 __CFUNC DAQmxGetExportedRdyForXferEventLvlActiveLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedRdyForXferEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedRdyForXferEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedRefTrigOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedRefTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedRefTrigPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedRefTrigPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedSampClkDelayOffset(taskHandle, data)

int32 __CFUNC DAQmxGetExportedSampClkDelayOffset(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetExportedSampClkOutputBehavior(taskHandle, data)

int32 __CFUNC DAQmxGetExportedSampClkOutputBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedSampClkOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedSampClkOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedSampClkPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedSampClkPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedSampClkTimebaseOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedSampClkTimebaseOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedSignalAttribute(taskHandle, attribute, value)

int32 __CFUNC_C DAQmxGetExportedSignalAttribute(TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetExportedStartTrigOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedStartTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedStartTrigPulsePolarity(taskHandle, data)

int32 __CFUNC DAQmxGetExportedStartTrigPulsePolarity(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetExportedSyncPulseEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedSyncPulseEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExportedWatchdogExpiredEventOutputTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetExportedWatchdogExpiredEventOutputTerm (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetExtCalLastDateAndTime(deviceName, year, month, day, hour, minute)

int32 __CFUNC DAQmxGetExtCalLastDateAndTime (const char deviceName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);

htf.daqmx.core.DAQmxGetExtCalLastTemp(deviceName, data)

int32 __CFUNC DAQmxGetExtCalLastTemp(const char deviceName[], float64 *data);

htf.daqmx.core.DAQmxGetExtCalRecommendedInterval(deviceName, data)

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(taskHandle, data)

int32 __CFUNC DAQmxGetHshkDelayAfterXfer(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetHshkSampleInputDataWhen(taskHandle, data)

int32 __CFUNC DAQmxGetHshkSampleInputDataWhen(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetHshkStartCond(taskHandle, data)

int32 __CFUNC DAQmxGetHshkStartCond(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetHshkTrigType(taskHandle, data)

int32 __CFUNC DAQmxGetHshkTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetImplicitUnderflowBehavior(taskHandle, data)

int32 __CFUNC DAQmxGetImplicitUnderflowBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetInterlockedHshkTrigAssertedLvl(taskHandle, data)

int32 __CFUNC DAQmxGetInterlockedHshkTrigAssertedLvl(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetInterlockedHshkTrigSrc(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetInterlockedHshkTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetLoggingFilePath(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetLoggingFilePath(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetLoggingFilePreallocationSize(taskHandle, data)

int32 __CFUNC DAQmxGetLoggingFilePreallocationSize(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetLoggingFileWriteSize(taskHandle, data)

int32 __CFUNC DAQmxGetLoggingFileWriteSize(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetLoggingMode(taskHandle, data)

int32 __CFUNC DAQmxGetLoggingMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetLoggingPause(taskHandle, data)

int32 __CFUNC DAQmxGetLoggingPause(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetLoggingSampsPerFile(taskHandle, data)

int32 __CFUNC DAQmxGetLoggingSampsPerFile(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetLoggingTDMSGroupName(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetLoggingTDMSGroupName(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetLoggingTDMSOperation(taskHandle, data)

int32 __CFUNC DAQmxGetLoggingTDMSOperation(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetMasterTimebaseRate(taskHandle, data)

int32 __CFUNC DAQmxGetMasterTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetMasterTimebaseSrc(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetMasterTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetNthTaskChannel(taskHandle, index, buffer, bufferSize)

int32 __CFUNC DAQmxGetNthTaskChannel (TaskHandle taskHandle, uInt32 index, char buffer[], int32 bufferSize);

htf.daqmx.core.DAQmxGetNthTaskDevice(taskHandle, index, buffer, bufferSize)

int32 __CFUNC DAQmxGetNthTaskDevice (TaskHandle taskHandle, uInt32 index, char buffer[], int32 bufferSize);

htf.daqmx.core.DAQmxGetNthTaskReadChannel(taskHandle, index, buffer, bufferSize)

int32 __CFUNC DAQmxGetNthTaskReadChannel (TaskHandle taskHandle, uInt32 index, char buffer[], int32 bufferSize);

htf.daqmx.core.DAQmxGetOnDemandSimultaneousAOEnable(taskHandle, data)

int32 __CFUNC DAQmxGetOnDemandSimultaneousAOEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetPauseTrigTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetPauseTrigTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPauseTrigType(taskHandle, data)

int32 __CFUNC DAQmxGetPauseTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetPersistedChanAllowInteractiveDeletion(channel, data)

int32 __CFUNC DAQmxGetPersistedChanAllowInteractiveDeletion(const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedChanAllowInteractiveEditing(channel, data)

int32 __CFUNC DAQmxGetPersistedChanAllowInteractiveEditing(const char channel[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedChanAttribute(channel, attribute, value)

int32 __CFUNC_C DAQmxGetPersistedChanAttribute (const char channel[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetPersistedChanAuthor(channel, data, bufferSize)

int32 __CFUNC DAQmxGetPersistedChanAuthor(const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPersistedScaleAllowInteractiveDeletion(scaleName, data)

int32 __CFUNC DAQmxGetPersistedScaleAllowInteractiveDeletion(const char scaleName[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedScaleAllowInteractiveEditing(scaleName, data)

int32 __CFUNC DAQmxGetPersistedScaleAllowInteractiveEditing(const char scaleName[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedScaleAttribute(scaleName, attribute, value)

int32 __CFUNC_C DAQmxGetPersistedScaleAttribute(const char scaleName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetPersistedScaleAuthor(scaleName, data, bufferSize)

int32 __CFUNC DAQmxGetPersistedScaleAuthor(const char scaleName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPersistedTaskAllowInteractiveDeletion(taskName, data)

int32 __CFUNC DAQmxGetPersistedTaskAllowInteractiveDeletion(const char taskName[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedTaskAllowInteractiveEditing(taskName, data)

int32 __CFUNC DAQmxGetPersistedTaskAllowInteractiveEditing(const char taskName[], bool32 *data);

htf.daqmx.core.DAQmxGetPersistedTaskAttribute(taskName, attribute, value)

int32 __CFUNC_C DAQmxGetPersistedTaskAttribute (const char taskName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetPersistedTaskAuthor(taskName, data, bufferSize)

int32 __CFUNC DAQmxGetPersistedTaskAuthor(const char taskName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPhysicalChanAIInputSrcs(physicalChannel, data, bufferSize)

int32 __CFUNC DAQmxGetPhysicalChanAIInputSrcs(const char physicalChannel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPhysicalChanAISupportedMeasTypes(physicalChannel, data, arraySizeInElements)

int32 __CFUNC DAQmxGetPhysicalChanAISupportedMeasTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanAITermCfgs(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanAITermCfgs(const char physicalChannel[], int32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOManualControlAmplitude(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanAOManualControlAmplitude(const char physicalChannel[], float64 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOManualControlEnable(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanAOManualControlEnable(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOManualControlFreq(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanAOManualControlFreq(const char physicalChannel[], float64 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOManualControlShortDetected(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanAOManualControlShortDetected(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAOSupportedOutputTypes(physicalChannel, data, arraySizeInElements)

int32 __CFUNC DAQmxGetPhysicalChanAOSupportedOutputTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanAOSupportedPowerUpOutputTypes(physicalChannel, data, arraySizeInElements)

int32 __CFUNC DAQmxGetPhysicalChanAOSupportedPowerUpOutputTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanAOTermCfgs(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanAOTermCfgs(const char physicalChannel[], int32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanAttribute(physicalChannel, attribute, value)

int32 __CFUNC_C DAQmxGetPhysicalChanAttribute (const char physicalChannel[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetPhysicalChanCISupportedMeasTypes(physicalChannel, data, arraySizeInElements)

int32 __CFUNC DAQmxGetPhysicalChanCISupportedMeasTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanCOSupportedOutputTypes(physicalChannel, data, arraySizeInElements)

int32 __CFUNC DAQmxGetPhysicalChanCOSupportedOutputTypes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanDIChangeDetectSupported(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanDIChangeDetectSupported(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDIPortWidth(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanDIPortWidth(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDISampClkSupported(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanDISampClkSupported(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDISampModes(physicalChannel, data, arraySizeInElements)

int32 __CFUNC DAQmxGetPhysicalChanDISampModes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanDOPortWidth(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanDOPortWidth(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDOSampClkSupported(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanDOSampClkSupported(const char physicalChannel[], bool32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanDOSampModes(physicalChannel, data, arraySizeInElements)

int32 __CFUNC DAQmxGetPhysicalChanDOSampModes (const char physicalChannel[], int32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanName(taskHandle, channel, data, bufferSize)

int32 __CFUNC DAQmxGetPhysicalChanName (TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSBitStream(physicalChannel, data, arraySizeInElements)

int32 __CFUNC DAQmxGetPhysicalChanTEDSBitStream (const char physicalChannel[], uInt8 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSMfgID(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanTEDSMfgID(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSModelNum(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanTEDSModelNum(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSSerialNum(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanTEDSSerialNum(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSTemplateIDs(physicalChannel, data, arraySizeInElements)

int32 __CFUNC DAQmxGetPhysicalChanTEDSTemplateIDs (const char physicalChannel[], uInt32 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSVersionLetter(physicalChannel, data, bufferSize)

int32 __CFUNC DAQmxGetPhysicalChanTEDSVersionLetter (const char physicalChannel[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetPhysicalChanTEDSVersionNum(physicalChannel, data)

int32 __CFUNC DAQmxGetPhysicalChanTEDSVersionNum(const char physicalChannel[], uInt32 *data);

htf.daqmx.core.DAQmxGetPossibleSCExpressCalAccConnections(deviceName, channelNames, connections, connectionsBufferSize)

int32 __CFUNC DAQmxGetPossibleSCExpressCalAccConnections (const char deviceName[], const char channelNames[], char *connections, uInt32 connectionsBufferSize);

htf.daqmx.core.DAQmxGetReadAccessoryInsertionOrRemovalDetected(taskHandle, data)

int32 __CFUNC DAQmxGetReadAccessoryInsertionOrRemovalDetected(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadAttribute(taskHandle, attribute, value)

int32 __CFUNC_C DAQmxGetReadAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetReadAutoStart(taskHandle, data)

int32 __CFUNC DAQmxGetReadAutoStart(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadAvailSampPerChan(taskHandle, data)

int32 __CFUNC DAQmxGetReadAvailSampPerChan(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetReadChangeDetectHasOverflowed(taskHandle, data)

int32 __CFUNC DAQmxGetReadChangeDetectHasOverflowed(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadChannelsToRead(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetReadChannelsToRead(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadCommonModeRangeErrorChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetReadCommonModeRangeErrorChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadCommonModeRangeErrorChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetReadCommonModeRangeErrorChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadCurrReadPos(taskHandle, data)

int32 __CFUNC DAQmxGetReadCurrReadPos(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetReadDevsWithInsertedOrRemovedAccessories(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetReadDevsWithInsertedOrRemovedAccessories (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadDigitalLinesBytesPerChan(taskHandle, data)

int32 __CFUNC DAQmxGetReadDigitalLinesBytesPerChan(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetReadNumChans(taskHandle, data)

int32 __CFUNC DAQmxGetReadNumChans(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetReadOffset(taskHandle, data)

int32 __CFUNC DAQmxGetReadOffset(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetReadOpenCurrentLoopChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetReadOpenCurrentLoopChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOpenCurrentLoopChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetReadOpenCurrentLoopChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadOpenThrmcplChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetReadOpenThrmcplChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOpenThrmcplChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetReadOpenThrmcplChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadOverWrite(taskHandle, data)

int32 __CFUNC DAQmxGetReadOverWrite(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetReadOvercurrentChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetReadOvercurrentChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOvercurrentChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetReadOvercurrentChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadOverloadedChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetReadOverloadedChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOverloadedChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetReadOverloadedChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadOvertemperatureChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetReadOvertemperatureChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetReadOvertemperatureChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetReadOvertemperatureChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadRawDataWidth(taskHandle, data)

int32 __CFUNC DAQmxGetReadRawDataWidth(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetReadReadAllAvailSamp(taskHandle, data)

int32 __CFUNC DAQmxGetReadReadAllAvailSamp(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetReadRelativeTo(taskHandle, data)

int32 __CFUNC DAQmxGetReadRelativeTo(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetReadSleepTime(taskHandle, data)

int32 __CFUNC DAQmxGetReadSleepTime(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetReadTotalSampPerChanAcquired(taskHandle, data)

int32 __CFUNC DAQmxGetReadTotalSampPerChanAcquired(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetReadWaitMode(taskHandle, data)

int32 __CFUNC DAQmxGetReadWaitMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetRealTimeAttribute(taskHandle, attribute, value)

int32 __CFUNC_C DAQmxGetRealTimeAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetRealTimeConvLateErrorsToWarnings(taskHandle, data)

int32 __CFUNC DAQmxGetRealTimeConvLateErrorsToWarnings(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetRealTimeNumOfWarmupIters(taskHandle, data)

int32 __CFUNC DAQmxGetRealTimeNumOfWarmupIters(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetRealTimeReportMissedSamp(taskHandle, data)

int32 __CFUNC DAQmxGetRealTimeReportMissedSamp(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetRealTimeWaitForNextSampClkWaitMode(taskHandle, data)

int32 __CFUNC DAQmxGetRealTimeWaitForNextSampClkWaitMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetRealTimeWriteRecoveryMode(taskHandle, data)

int32 __CFUNC DAQmxGetRealTimeWriteRecoveryMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetRefClkRate(taskHandle, data)

int32 __CFUNC DAQmxGetRefClkRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetRefClkSrc(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetRefClkSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetRefTrigAutoTrigEnable(taskHandle, data)

int32 __CFUNC DAQmxGetRefTrigAutoTrigEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetRefTrigAutoTriggered(taskHandle, data)

int32 __CFUNC DAQmxGetRefTrigAutoTriggered(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetRefTrigDelay(taskHandle, data)

int32 __CFUNC DAQmxGetRefTrigDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetRefTrigPretrigSamples(taskHandle, data)

int32 __CFUNC DAQmxGetRefTrigPretrigSamples(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetRefTrigTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetRefTrigTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetRefTrigType(taskHandle, data)

int32 __CFUNC DAQmxGetRefTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkActiveEdge(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkActiveEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkDigFltrEnable(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkDigFltrEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetSampClkDigFltrMinPulseWidth(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkDigFltrTimebaseRate(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkDigFltrTimebaseSrc(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetSampClkDigFltrTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkDigSyncEnable(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkDigSyncEnable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetSampClkMaxRate(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkMaxRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkOverrunBehavior(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkOverrunBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkRate(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkSrc(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetSampClkSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetSampClkTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkTimebaseActiveEdge(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkTimebaseActiveEdge(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkTimebaseDiv(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkTimebaseDiv(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetSampClkTimebaseMasterTimebaseDiv(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkTimebaseMasterTimebaseDiv(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetSampClkTimebaseRate(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkTimebaseRate(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSampClkTimebaseSrc(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetSampClkTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkTimebaseTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetSampClkTimebaseTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSampClkTimingResponseMode(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkTimingResponseMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampClkUnderflowBehavior(taskHandle, data)

int32 __CFUNC DAQmxGetSampClkUnderflowBehavior(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampQuantSampMode(taskHandle, data)

int32 __CFUNC DAQmxGetSampQuantSampMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSampQuantSampPerChan(taskHandle, data)

int32 __CFUNC DAQmxGetSampQuantSampPerChan(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetSampTimingEngine(taskHandle, data)

int32 __CFUNC DAQmxGetSampTimingEngine(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetSampTimingType(taskHandle, data)

int32 __CFUNC DAQmxGetSampTimingType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetScaleAttribute(scaleName, attribute, value)

int32 __CFUNC_C DAQmxGetScaleAttribute (const char scaleName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetScaleDescr(scaleName, data, bufferSize)

int32 __CFUNC DAQmxGetScaleDescr(const char scaleName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetScaleLinSlope(scaleName, data)

int32 __CFUNC DAQmxGetScaleLinSlope(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleLinYIntercept(scaleName, data)

int32 __CFUNC DAQmxGetScaleLinYIntercept(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleMapPreScaledMax(scaleName, data)

int32 __CFUNC DAQmxGetScaleMapPreScaledMax(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleMapPreScaledMin(scaleName, data)

int32 __CFUNC DAQmxGetScaleMapPreScaledMin(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleMapScaledMax(scaleName, data)

int32 __CFUNC DAQmxGetScaleMapScaledMax(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScaleMapScaledMin(scaleName, data)

int32 __CFUNC DAQmxGetScaleMapScaledMin(const char scaleName[], float64 *data);

htf.daqmx.core.DAQmxGetScalePolyForwardCoeff(scaleName, data, arraySizeInElements)

int32 __CFUNC DAQmxGetScalePolyForwardCoeff (const char scaleName[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetScalePolyReverseCoeff(scaleName, data, arraySizeInElements)

int32 __CFUNC DAQmxGetScalePolyReverseCoeff (const char scaleName[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetScalePreScaledUnits(scaleName, data)

int32 __CFUNC DAQmxGetScalePreScaledUnits(const char scaleName[], int32 *data);

htf.daqmx.core.DAQmxGetScaleScaledUnits(scaleName, data, bufferSize)

int32 __CFUNC DAQmxGetScaleScaledUnits(const char scaleName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetScaleTablePreScaledVals(scaleName, data, arraySizeInElements)

int32 __CFUNC DAQmxGetScaleTablePreScaledVals (const char scaleName[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetScaleTableScaledVals(scaleName, data, arraySizeInElements)

int32 __CFUNC DAQmxGetScaleTableScaledVals (const char scaleName[], float64 *data, uInt32 arraySizeInElements);

htf.daqmx.core.DAQmxGetScaleType(scaleName, data)

int32 __CFUNC DAQmxGetScaleType(const char scaleName[], int32 *data);

htf.daqmx.core.DAQmxGetSelfCalLastDateAndTime(deviceName, year, month, day, hour, minute)

int32 __CFUNC DAQmxGetSelfCalLastDateAndTime (const char deviceName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);

htf.daqmx.core.DAQmxGetSelfCalLastTemp(deviceName, data)

int32 __CFUNC DAQmxGetSelfCalLastTemp(const char deviceName[], float64 *data);

htf.daqmx.core.DAQmxGetSelfCalSupported(deviceName, data)

int32 __CFUNC DAQmxGetSelfCalSupported(const char deviceName[], bool32 *data);

htf.daqmx.core.DAQmxGetStartTrigDelay(taskHandle, data)

int32 __CFUNC DAQmxGetStartTrigDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetStartTrigDelayUnits(taskHandle, data)

int32 __CFUNC DAQmxGetStartTrigDelayUnits(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetStartTrigRetriggerable(taskHandle, data)

int32 __CFUNC DAQmxGetStartTrigRetriggerable(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetStartTrigTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetStartTrigTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetStartTrigType(taskHandle, data)

int32 __CFUNC DAQmxGetStartTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSwitchChanAnlgBusSharingEnable(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanAnlgBusSharingEnable(const char switchChannelName[], bool32 *data);

htf.daqmx.core.DAQmxGetSwitchChanAttribute(switchChannelName, attribute, value)

int32 __CFUNC_C DAQmxGetSwitchChanAttribute (const char switchChannelName[], int32 attribute, void *value);

htf.daqmx.core.DAQmxGetSwitchChanBandwidth(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanBandwidth(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanImpedance(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanImpedance(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACCarryCurrent(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxACCarryCurrent(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACCarryPwr(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxACCarryPwr(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACSwitchCurrent(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxACSwitchCurrent(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACSwitchPwr(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxACSwitchPwr(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxACVoltage(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxACVoltage(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCCarryCurrent(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxDCCarryCurrent(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCCarryPwr(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxDCCarryPwr(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCSwitchCurrent(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxDCSwitchCurrent(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCSwitchPwr(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxDCSwitchPwr(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanMaxDCVoltage(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanMaxDCVoltage(const char switchChannelName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchChanUsage(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanUsage(const char switchChannelName[], int32 *data);

htf.daqmx.core.DAQmxGetSwitchChanWireMode(switchChannelName, data)

int32 __CFUNC DAQmxGetSwitchChanWireMode(const char switchChannelName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevAutoConnAnlgBus(deviceName, data)

int32 __CFUNC DAQmxGetSwitchDevAutoConnAnlgBus(const char deviceName[], bool32 *data);

htf.daqmx.core.DAQmxGetSwitchDevNumColumns(deviceName, data)

int32 __CFUNC DAQmxGetSwitchDevNumColumns(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevNumRelays(deviceName, data)

int32 __CFUNC DAQmxGetSwitchDevNumRelays(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevNumRows(deviceName, data)

int32 __CFUNC DAQmxGetSwitchDevNumRows(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevNumSwitchChans(deviceName, data)

int32 __CFUNC DAQmxGetSwitchDevNumSwitchChans(const char deviceName[], uInt32 *data);

htf.daqmx.core.DAQmxGetSwitchDevPwrDownLatchRelaysAfterSettling(deviceName, data)

int32 __CFUNC DAQmxGetSwitchDevPwrDownLatchRelaysAfterSettling(const char deviceName[], bool32 *data);

htf.daqmx.core.DAQmxGetSwitchDevRelayList(deviceName, data, bufferSize)

int32 __CFUNC DAQmxGetSwitchDevRelayList(const char deviceName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSwitchDevSettled(deviceName, data)

int32 __CFUNC DAQmxGetSwitchDevSettled(const char deviceName[], bool32 *data);

htf.daqmx.core.DAQmxGetSwitchDevSettlingTime(deviceName, data)

int32 __CFUNC DAQmxGetSwitchDevSettlingTime(const char deviceName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchDevSwitchChanList(deviceName, data, bufferSize)

int32 __CFUNC DAQmxGetSwitchDevSwitchChanList(const char deviceName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSwitchDevTemperature(deviceName, data)

int32 __CFUNC DAQmxGetSwitchDevTemperature(const char deviceName[], float64 *data);

htf.daqmx.core.DAQmxGetSwitchDevTopology(deviceName, data, bufferSize)

int32 __CFUNC DAQmxGetSwitchDevTopology(const char deviceName[], char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSwitchDeviceAttribute(deviceName, attribute, value)

int32 __CFUNC_C DAQmxGetSwitchDeviceAttribute (const char deviceName[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetSwitchScanAttribute(taskHandle, attribute, value)

int32 __CFUNC_C DAQmxGetSwitchScanAttribute (TaskHandle taskHandle, int32 attribute, void *value);

htf.daqmx.core.DAQmxGetSwitchScanBreakMode(taskHandle, data)

int32 __CFUNC DAQmxGetSwitchScanBreakMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSwitchScanRepeatMode(taskHandle, data)

int32 __CFUNC DAQmxGetSwitchScanRepeatMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetSwitchScanWaitingForAdv(taskHandle, data)

int32 __CFUNC DAQmxGetSwitchScanWaitingForAdv(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetSyncClkInterval(taskHandle, data)

int32 __CFUNC DAQmxGetSyncClkInterval(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetSyncPulseMinDelayToStart(taskHandle, data)

int32 __CFUNC DAQmxGetSyncPulseMinDelayToStart(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSyncPulseResetDelay(taskHandle, data)

int32 __CFUNC DAQmxGetSyncPulseResetDelay(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSyncPulseResetTime(taskHandle, data)

int32 __CFUNC DAQmxGetSyncPulseResetTime(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSyncPulseSrc(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetSyncPulseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSyncPulseSyncTime(taskHandle, data)

int32 __CFUNC DAQmxGetSyncPulseSyncTime(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetSyncPulseTerm(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetSyncPulseTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSysDevNames(data, bufferSize)

int32 __CFUNC DAQmxGetSysDevNames(char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSysGlobalChans(data, bufferSize)

int32 __CFUNC DAQmxGetSysGlobalChans(char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSysNIDAQMajorVersion(data)

int32 __CFUNC DAQmxGetSysNIDAQMajorVersion(uInt32 *data);

htf.daqmx.core.DAQmxGetSysNIDAQMinorVersion(data)

int32 __CFUNC DAQmxGetSysNIDAQMinorVersion(uInt32 *data);

htf.daqmx.core.DAQmxGetSysNIDAQUpdateVersion(data)

int32 __CFUNC DAQmxGetSysNIDAQUpdateVersion(uInt32 *data);

htf.daqmx.core.DAQmxGetSysScales(data, bufferSize)

int32 __CFUNC DAQmxGetSysScales(char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSysTasks(data, bufferSize)

int32 __CFUNC DAQmxGetSysTasks(char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetSystemInfoAttribute(attribute, value)

int32 __CFUNC_C DAQmxGetSystemInfoAttribute (int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTaskAttribute(taskHandle, attribute, value)

int32 __CFUNC_C DAQmxGetTaskAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTaskChannels(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetTaskChannels(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetTaskComplete(taskHandle, data)

int32 __CFUNC DAQmxGetTaskComplete(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetTaskDevices(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetTaskDevices(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetTaskName(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetTaskName(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetTaskNumChans(taskHandle, data)

int32 __CFUNC DAQmxGetTaskNumChans(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetTaskNumDevices(taskHandle, data)

int32 __CFUNC DAQmxGetTaskNumDevices(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetTimingAttribute(taskHandle, attribute, value)

int32 __CFUNC_C DAQmxGetTimingAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTimingAttributeEx(taskHandle, deviceNames, attribute, value)

int32 __CFUNC_C DAQmxGetTimingAttributeEx (TaskHandle taskHandle, const char deviceNames[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTrigAttribute(taskHandle, attribute, value)

int32 __CFUNC_C DAQmxGetTrigAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetTriggerSyncType(taskHandle, data)

int32 __CFUNC DAQmxGetTriggerSyncType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWatchdogAOExpirState(taskHandle, lines, data)

int32 __CFUNC DAQmxGetWatchdogAOExpirState(TaskHandle taskHandle, const char lines[], float64 *data);

htf.daqmx.core.DAQmxGetWatchdogAOOutputType(taskHandle, lines, data)

int32 __CFUNC DAQmxGetWatchdogAOOutputType(TaskHandle taskHandle, const char lines[], int32 *data);

htf.daqmx.core.DAQmxGetWatchdogAttribute(taskHandle, lines, attribute, value)

int32 __CFUNC_C DAQmxGetWatchdogAttribute (TaskHandle taskHandle, const char lines[], int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetWatchdogCOExpirState(taskHandle, lines, data)

int32 __CFUNC DAQmxGetWatchdogCOExpirState(TaskHandle taskHandle, const char lines[], int32 *data);

htf.daqmx.core.DAQmxGetWatchdogDOExpirState(taskHandle, lines, data)

int32 __CFUNC DAQmxGetWatchdogDOExpirState(TaskHandle taskHandle, const char lines[], int32 *data);

htf.daqmx.core.DAQmxGetWatchdogExpirTrigTrigOnNetworkConnLoss(taskHandle, data)

int32 __CFUNC DAQmxGetWatchdogExpirTrigTrigOnNetworkConnLoss(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWatchdogExpirTrigType(taskHandle, data)

int32 __CFUNC DAQmxGetWatchdogExpirTrigType(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWatchdogHasExpired(taskHandle, data)

int32 __CFUNC DAQmxGetWatchdogHasExpired(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWatchdogTimeout(taskHandle, data)

int32 __CFUNC DAQmxGetWatchdogTimeout(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetWriteAccessoryInsertionOrRemovalDetected(taskHandle, data)

int32 __CFUNC DAQmxGetWriteAccessoryInsertionOrRemovalDetected(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteAttribute(taskHandle, attribute, value)

int32 __CFUNC_C DAQmxGetWriteAttribute (TaskHandle taskHandle, int32 attribute, void *value, …);

htf.daqmx.core.DAQmxGetWriteCurrWritePos(taskHandle, data)

int32 __CFUNC DAQmxGetWriteCurrWritePos(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetWriteDevsWithInsertedOrRemovedAccessories(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetWriteDevsWithInsertedOrRemovedAccessories (TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteDigitalLinesBytesPerChan(taskHandle, data)

int32 __CFUNC DAQmxGetWriteDigitalLinesBytesPerChan(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetWriteNextWriteIsLast(taskHandle, data)

int32 __CFUNC DAQmxGetWriteNextWriteIsLast(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteNumChans(taskHandle, data)

int32 __CFUNC DAQmxGetWriteNumChans(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetWriteOffset(taskHandle, data)

int32 __CFUNC DAQmxGetWriteOffset(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWriteOpenCurrentLoopChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetWriteOpenCurrentLoopChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteOpenCurrentLoopChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetWriteOpenCurrentLoopChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteOvercurrentChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetWriteOvercurrentChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteOvercurrentChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetWriteOvercurrentChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteOverloadedChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetWriteOverloadedChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteOverloadedChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetWriteOverloadedChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteOvertemperatureChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetWriteOvertemperatureChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWriteOvertemperatureChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetWriteOvertemperatureChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWritePowerSupplyFaultChans(taskHandle, data, bufferSize)

int32 __CFUNC DAQmxGetWritePowerSupplyFaultChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);

htf.daqmx.core.DAQmxGetWritePowerSupplyFaultChansExist(taskHandle, data)

int32 __CFUNC DAQmxGetWritePowerSupplyFaultChansExist(TaskHandle taskHandle, bool32 *data);

htf.daqmx.core.DAQmxGetWriteRawDataWidth(taskHandle, data)

int32 __CFUNC DAQmxGetWriteRawDataWidth(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetWriteRegenMode(taskHandle, data)

int32 __CFUNC DAQmxGetWriteRegenMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWriteRelativeTo(taskHandle, data)

int32 __CFUNC DAQmxGetWriteRelativeTo(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxGetWriteSleepTime(taskHandle, data)

int32 __CFUNC DAQmxGetWriteSleepTime(TaskHandle taskHandle, float64 *data);

htf.daqmx.core.DAQmxGetWriteSpaceAvail(taskHandle, data)

int32 __CFUNC DAQmxGetWriteSpaceAvail(TaskHandle taskHandle, uInt32 *data);

htf.daqmx.core.DAQmxGetWriteTotalSampPerChanGenerated(taskHandle, data)

int32 __CFUNC DAQmxGetWriteTotalSampPerChanGenerated(TaskHandle taskHandle, uInt64 *data);

htf.daqmx.core.DAQmxGetWriteWaitMode(taskHandle, data)

int32 __CFUNC DAQmxGetWriteWaitMode(TaskHandle taskHandle, int32 *data);

htf.daqmx.core.DAQmxInitExtCal(deviceName, password)

int32 __CFUNC DAQmxInitExtCal (const char deviceName[], const char password[], CalHandle *calHandle);

htf.daqmx.core.DAQmxIsReadOrWriteLate(errorCode)

bool32 __CFUNC DAQmxIsReadOrWriteLate (int32 errorCode);

htf.daqmx.core.DAQmxIsTaskDone(taskHandle, isTaskDone)

int32 __CFUNC DAQmxIsTaskDone (TaskHandle taskHandle, bool32 *isTaskDone);

htf.daqmx.core.DAQmxLoadTask(taskName, taskHandle)

int32 __CFUNC DAQmxLoadTask (const char taskName[], TaskHandle *taskHandle);

htf.daqmx.core.DAQmxMSeriesCalAdjust(referenceVoltage)

int32 __CFUNC DAQmxMSeriesCalAdjust (CalHandle calHandle, float64 referenceVoltage);

htf.daqmx.core.DAQmxPerformBridgeOffsetNullingCal(taskHandle, channel)

int32 __CFUNC DAQmxPerformBridgeOffsetNullingCal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxPerformBridgeOffsetNullingCalEx(taskHandle, channel, skipUnsupportedChannels)

int32 __CFUNC DAQmxPerformBridgeOffsetNullingCalEx (TaskHandle taskHandle, const char channel[], bool32 skipUnsupportedChannels);

htf.daqmx.core.DAQmxPerformBridgeShuntCal(taskHandle, channel, shuntResistorValue, shuntResistorLocation, bridgeResistance, skipUnsupportedChannels)

int32 __CFUNC DAQmxPerformBridgeShuntCal (TaskHandle taskHandle, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, float64 bridgeResistance, bool32 skipUnsupportedChannels);

htf.daqmx.core.DAQmxPerformStrainShuntCal(taskHandle, channel, shuntResistorValue, shuntResistorLocation, skipUnsupportedChannels)

int32 __CFUNC DAQmxPerformStrainShuntCal (TaskHandle taskHandle, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, bool32 skipUnsupportedChannels);

htf.daqmx.core.DAQmxPerformThrmcplLeadOffsetNullingCal(taskHandle, channel, skipUnsupportedChannels)

int32 __CFUNC DAQmxPerformThrmcplLeadOffsetNullingCal (TaskHandle taskHandle, const char channel[], bool32 skipUnsupportedChannels);

htf.daqmx.core.DAQmxReadAnalogF64(taskHandle, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadAnalogF64 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, float64 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadAnalogScalarF64(taskHandle, timeout, value, reserved)

int32 __CFUNC DAQmxReadAnalogScalarF64 (TaskHandle taskHandle, float64 timeout, float64 *value, bool32 *reserved);

htf.daqmx.core.DAQmxReadBinaryI16(taskHandle, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadBinaryI16 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, int16 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadBinaryI32(taskHandle, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadBinaryI32 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, int32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadBinaryU16(taskHandle, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadBinaryU16 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt16 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadBinaryU32(taskHandle, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadBinaryU32 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadCounterF64(taskHandle, numSampsPerChan, timeout, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadCounterF64 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, float64 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadCounterScalarF64(taskHandle, timeout, value, reserved)

int32 __CFUNC DAQmxReadCounterScalarF64 (TaskHandle taskHandle, float64 timeout, float64 *value, bool32 *reserved);

htf.daqmx.core.DAQmxReadCounterScalarU32(taskHandle, timeout, value, reserved)

int32 __CFUNC DAQmxReadCounterScalarU32 (TaskHandle taskHandle, float64 timeout, uInt32 *value, bool32 *reserved);

htf.daqmx.core.DAQmxReadCounterU32(taskHandle, numSampsPerChan, timeout, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadCounterU32 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, uInt32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadCtrFreq(taskHandle, numSampsPerChan, timeout, interleaved, readArrayFrequency, readArrayDutyCycle, arraySizeInSamps, sampsPerChanRead, reserved)

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(taskHandle, timeout, frequency, dutyCycle, reserved)

int32 __CFUNC DAQmxReadCtrFreqScalar (TaskHandle taskHandle, float64 timeout, float64 *frequency, float64 *dutyCycle, bool32 *reserved);

htf.daqmx.core.DAQmxReadCtrTicks(taskHandle, numSampsPerChan, timeout, interleaved, readArrayHighTicks, readArrayLowTicks, arraySizeInSamps, sampsPerChanRead, reserved)

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(taskHandle, timeout, highTicks, lowTicks, reserved)

int32 __CFUNC DAQmxReadCtrTicksScalar (TaskHandle taskHandle, float64 timeout, uInt32 *highTicks, uInt32 *lowTicks, bool32 *reserved);

htf.daqmx.core.DAQmxReadCtrTime(taskHandle, numSampsPerChan, timeout, interleaved, readArrayHighTime, readArrayLowTime, arraySizeInSamps, sampsPerChanRead, reserved)

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(taskHandle, timeout, highTime, lowTime, reserved)

int32 __CFUNC DAQmxReadCtrTimeScalar (TaskHandle taskHandle, float64 timeout, float64 *highTime, float64 *lowTime, bool32 *reserved);

htf.daqmx.core.DAQmxReadDigitalLines(taskHandle, numSampsPerChan, timeout, fillMode, readArray, arraySizeInBytes, sampsPerChanRead, numBytesPerSamp, reserved)

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(taskHandle, timeout, value, reserved)

int32 __CFUNC DAQmxReadDigitalScalarU32 (TaskHandle taskHandle, float64 timeout, uInt32 *value, bool32 *reserved);

htf.daqmx.core.DAQmxReadDigitalU16(taskHandle, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadDigitalU16 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt16 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadDigitalU32(taskHandle, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadDigitalU32 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadDigitalU8(taskHandle, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved)

int32 __CFUNC DAQmxReadDigitalU8 (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt8 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

htf.daqmx.core.DAQmxReadRaw(taskHandle, numSampsPerChan, timeout, readArray, arraySizeInBytes, sampsRead, numBytesPerSamp, reserved)

int32 __CFUNC DAQmxReadRaw (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, void *readArray, uInt32 arraySizeInBytes, int32 *sampsRead, int32 *numBytesPerSamp, bool32 *reserved);

htf.daqmx.core.DAQmxRegisterDoneEvent(task, options, callbackFunction, callbackData)

int32 __CFUNC DAQmxRegisterDoneEvent (TaskHandle task, uInt32 options, DAQmxDoneEventCallbackPtr callbackFunction, void *callbackData);

htf.daqmx.core.DAQmxRegisterEveryNSamplesEvent(task, everyNsamplesEventType, nSamples, options, callbackFunction, callbackData)

int32 __CFUNC DAQmxRegisterEveryNSamplesEvent (TaskHandle task, int32 everyNsamplesEventType, uInt32 nSamples, uInt32 options, DAQmxEveryNSamplesEventCallbackPtr callbackFunction, void *callbackData);

htf.daqmx.core.DAQmxRegisterSignalEvent(task, signalID, options, callbackFunction, callbackData)

int32 __CFUNC DAQmxRegisterSignalEvent (TaskHandle task, int32 signalID, uInt32 options, DAQmxSignalEventCallbackPtr callbackFunction, void *callbackData);

htf.daqmx.core.DAQmxRemoveCDAQSyncConnection(portList)

int32 __CFUNC DAQmxRemoveCDAQSyncConnection(const char portList[]);

htf.daqmx.core.DAQmxReserveNetworkDevice(deviceName, overrideReservation)

int32 __CFUNC DAQmxReserveNetworkDevice(const char deviceName[], bool32 overrideReservation);

htf.daqmx.core.DAQmxResetAIACExcitFreq(taskHandle, channel)

int32 __CFUNC DAQmxResetAIACExcitFreq(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIACExcitSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAIACExcitSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIACExcitWireMode(taskHandle, channel)

int32 __CFUNC DAQmxResetAIACExcitWireMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIADCCustomTimingMode(taskHandle, channel)

int32 __CFUNC DAQmxResetAIADCCustomTimingMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIADCTimingMode(taskHandle, channel)

int32 __CFUNC DAQmxResetAIADCTimingMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAccelSensitivity(taskHandle, channel)

int32 __CFUNC DAQmxResetAIAccelSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAccelSensitivityUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIAccelSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAccelUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIAccelUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAcceldBRef(taskHandle, channel)

int32 __CFUNC DAQmxResetAIAcceldBRef(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAtten(taskHandle, channel)

int32 __CFUNC DAQmxResetAIAtten(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAutoZeroMode(taskHandle, channel)

int32 __CFUNC DAQmxResetAIAutoZeroMode(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIAveragingWinSize(taskHandle, channel)

int32 __CFUNC DAQmxResetAIAveragingWinSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeBalanceCoarsePot(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeBalanceCoarsePot(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeBalanceFinePot(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeBalanceFinePot(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeCfg(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeElectricalUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeElectricalUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeInitialRatio(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeInitialRatio(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeInitialVoltage(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeInitialVoltage(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeNomResistance(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeNomResistance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgePhysicalUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgePhysicalUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgePolyForwardCoeff(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgePolyForwardCoeff(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgePolyReverseCoeff(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgePolyReverseCoeff(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeScaleType(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeScaleType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeShuntCalEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalGainAdjust(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeShuntCalGainAdjust(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalSelect(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeShuntCalSelect(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalShuntCalAActualResistance(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeShuntCalShuntCalAActualResistance (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeShuntCalShuntCalAResistance(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeShuntCalShuntCalAResistance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTableElectricalVals(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeTableElectricalVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTablePhysicalVals(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeTablePhysicalVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTwoPointLinFirstElectricalVal(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeTwoPointLinFirstElectricalVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTwoPointLinFirstPhysicalVal(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeTwoPointLinFirstPhysicalVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTwoPointLinSecondElectricalVal(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeTwoPointLinSecondElectricalVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeTwoPointLinSecondPhysicalVal(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeTwoPointLinSecondPhysicalVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIBridgeUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIBridgeUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalApplyCalIfExp(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalApplyCalIfExp(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalDesc(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalDesc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalEnableCal(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalEnableCal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalOperatorName(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalOperatorName(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalPolyForwardCoeff(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalPolyForwardCoeff(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalPolyReverseCoeff(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalPolyReverseCoeff(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalScaleType(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalScaleType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalTablePreScaledVals(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalTablePreScaledVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalTableScaledVals(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalTableScaledVals (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalVerifAcqVals(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalVerifAcqVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIChanCalVerifRefVals(taskHandle, channel)

int32 __CFUNC DAQmxResetAIChanCalVerifRefVals(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIConvActiveEdge(taskHandle)

int32 __CFUNC DAQmxResetAIConvActiveEdge(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvActiveEdgeEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvActiveEdgeEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigFltrEnable(taskHandle)

int32 __CFUNC DAQmxResetAIConvDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigFltrEnableEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvDigFltrEnableEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigFltrMinPulseWidth(taskHandle)

int32 __CFUNC DAQmxResetAIConvDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigFltrMinPulseWidthEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvDigFltrMinPulseWidthEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigFltrTimebaseRate(taskHandle)

int32 __CFUNC DAQmxResetAIConvDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigFltrTimebaseRateEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvDigFltrTimebaseRateEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigFltrTimebaseSrc(taskHandle)

int32 __CFUNC DAQmxResetAIConvDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigFltrTimebaseSrcEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvDigFltrTimebaseSrcEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvDigSyncEnable(taskHandle)

int32 __CFUNC DAQmxResetAIConvDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvDigSyncEnableEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvDigSyncEnableEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvRate(taskHandle)

int32 __CFUNC DAQmxResetAIConvRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvRateEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvRateEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvSrc(taskHandle)

int32 __CFUNC DAQmxResetAIConvSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvSrcEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvSrcEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvTimebaseDiv(taskHandle)

int32 __CFUNC DAQmxResetAIConvTimebaseDiv(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvTimebaseDivEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvTimebaseDivEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAIConvTimebaseSrc(taskHandle)

int32 __CFUNC DAQmxResetAIConvTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAIConvTimebaseSrcEx(taskHandle, deviceNames)

int32 __CFUNC DAQmxResetAIConvTimebaseSrcEx(TaskHandle taskHandle, const char deviceNames[]);

htf.daqmx.core.DAQmxResetAICoupling(taskHandle, channel)

int32 __CFUNC DAQmxResetAICoupling(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICurrentACRMSUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAICurrentACRMSUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICurrentShuntLoc(taskHandle, channel)

int32 __CFUNC DAQmxResetAICurrentShuntLoc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICurrentShuntResistance(taskHandle, channel)

int32 __CFUNC DAQmxResetAICurrentShuntResistance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICurrentUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAICurrentUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAICustomScaleName(taskHandle, channel)

int32 __CFUNC DAQmxResetAICustomScaleName(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDCOffset(taskHandle, channel)

int32 __CFUNC DAQmxResetAIDCOffset(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDataXferCustomThreshold(taskHandle, channel)

int32 __CFUNC DAQmxResetAIDataXferCustomThreshold(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDataXferMech(taskHandle, channel)

int32 __CFUNC DAQmxResetAIDataXferMech(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDataXferReqCond(taskHandle, channel)

int32 __CFUNC DAQmxResetAIDataXferReqCond(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIDitherEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAIDitherEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIEddyCurrentProxProbeSensitivity(taskHandle, channel)

int32 __CFUNC DAQmxResetAIEddyCurrentProxProbeSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIEddyCurrentProxProbeSensitivityUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIEddyCurrentProxProbeSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIEddyCurrentProxProbeUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIEddyCurrentProxProbeUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIEnhancedAliasRejectionEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAIEnhancedAliasRejectionEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitActualVal(taskHandle, channel)

int32 __CFUNC DAQmxResetAIExcitActualVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitDCorAC(taskHandle, channel)

int32 __CFUNC DAQmxResetAIExcitDCorAC(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetAIExcitSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitUseForScaling(taskHandle, channel)

int32 __CFUNC DAQmxResetAIExcitUseForScaling(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitUseMultiplexed(taskHandle, channel)

int32 __CFUNC DAQmxResetAIExcitUseMultiplexed(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitVal(taskHandle, channel)

int32 __CFUNC DAQmxResetAIExcitVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIExcitVoltageOrCurrent(taskHandle, channel)

int32 __CFUNC DAQmxResetAIExcitVoltageOrCurrent(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFilterDelayAdjustment(taskHandle, channel)

int32 __CFUNC DAQmxResetAIFilterDelayAdjustment(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFilterDelayUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIFilterDelayUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIForceIEPESensorSensitivity(taskHandle, channel)

int32 __CFUNC DAQmxResetAIForceIEPESensorSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIForceIEPESensorSensitivityUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIForceIEPESensorSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIForceReadFromChan(taskHandle, channel)

int32 __CFUNC DAQmxResetAIForceReadFromChan(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIForceUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIForceUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFreqHyst(taskHandle, channel)

int32 __CFUNC DAQmxResetAIFreqHyst(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFreqThreshVoltage(taskHandle, channel)

int32 __CFUNC DAQmxResetAIFreqThreshVoltage(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIFreqUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIFreqUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIGain(taskHandle, channel)

int32 __CFUNC DAQmxResetAIGain(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIImpedance(taskHandle, channel)

int32 __CFUNC DAQmxResetAIImpedance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIInputSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetAIInputSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILVDTSensitivity(taskHandle, channel)

int32 __CFUNC DAQmxResetAILVDTSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILVDTSensitivityUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAILVDTSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILVDTUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAILVDTUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILeadWireResistance(taskHandle, channel)

int32 __CFUNC DAQmxResetAILeadWireResistance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILossyLSBRemovalCompressedSampSize(taskHandle, channel)

int32 __CFUNC DAQmxResetAILossyLSBRemovalCompressedSampSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassCutoffFreq(taskHandle, channel)

int32 __CFUNC DAQmxResetAILowpassCutoffFreq(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAILowpassEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassSwitchCapClkSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetAILowpassSwitchCapClkSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassSwitchCapExtClkDiv(taskHandle, channel)

int32 __CFUNC DAQmxResetAILowpassSwitchCapExtClkDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassSwitchCapExtClkFreq(taskHandle, channel)

int32 __CFUNC DAQmxResetAILowpassSwitchCapExtClkFreq(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAILowpassSwitchCapOutClkDiv(taskHandle, channel)

int32 __CFUNC DAQmxResetAILowpassSwitchCapOutClkDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIMax(taskHandle, channel)

int32 __CFUNC DAQmxResetAIMax(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIMemMapEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAIMemMapEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIMicrophoneSensitivity(taskHandle, channel)

int32 __CFUNC DAQmxResetAIMicrophoneSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIMin(taskHandle, channel)

int32 __CFUNC DAQmxResetAIMin(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIOpenThrmcplDetectEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAIOpenThrmcplDetectEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIPressureUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIPressureUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIProbeAtten(taskHandle, channel)

int32 __CFUNC DAQmxResetAIProbeAtten(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDA(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRTDA(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDB(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRTDB(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDC(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRTDC(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDR0(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRTDR0(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRTDType(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRTDType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRVDTSensitivity(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRVDTSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRVDTSensitivityUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRVDTSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRVDTUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRVDTUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRawDataCompressionType(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRawDataCompressionType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRemoveFilterDelay(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRemoveFilterDelay(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIResistanceCfg(taskHandle, channel)

int32 __CFUNC DAQmxResetAIResistanceCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIResistanceUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIResistanceUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRngHigh(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRngHigh(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRngLow(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRngLow(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRosetteStrainGageOrientation(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRosetteStrainGageOrientation(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIRosetteStrainGageRosetteMeasType(taskHandle, channel)

int32 __CFUNC DAQmxResetAIRosetteStrainGageRosetteMeasType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAISampAndHoldEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAISampAndHoldEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAISoundPressureMaxSoundPressureLvl(taskHandle, channel)

int32 __CFUNC DAQmxResetAISoundPressureMaxSoundPressureLvl(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAISoundPressureUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAISoundPressureUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAISoundPressuredBRef(taskHandle, channel)

int32 __CFUNC DAQmxResetAISoundPressuredBRef(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainGageCfg(taskHandle, channel)

int32 __CFUNC DAQmxResetAIStrainGageCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainGageForceReadFromChan(taskHandle, channel)

int32 __CFUNC DAQmxResetAIStrainGageForceReadFromChan(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainGageGageFactor(taskHandle, channel)

int32 __CFUNC DAQmxResetAIStrainGageGageFactor(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainGagePoissonRatio(taskHandle, channel)

int32 __CFUNC DAQmxResetAIStrainGagePoissonRatio(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIStrainUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIStrainUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAITempUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAITempUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAITermCfg(taskHandle, channel)

int32 __CFUNC DAQmxResetAITermCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmcplCJCVal(taskHandle, channel)

int32 __CFUNC DAQmxResetAIThrmcplCJCVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmcplLeadOffsetVoltage(taskHandle, channel)

int32 __CFUNC DAQmxResetAIThrmcplLeadOffsetVoltage(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmcplScaleType(taskHandle, channel)

int32 __CFUNC DAQmxResetAIThrmcplScaleType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmcplType(taskHandle, channel)

int32 __CFUNC DAQmxResetAIThrmcplType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmstrA(taskHandle, channel)

int32 __CFUNC DAQmxResetAIThrmstrA(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmstrB(taskHandle, channel)

int32 __CFUNC DAQmxResetAIThrmstrB(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmstrC(taskHandle, channel)

int32 __CFUNC DAQmxResetAIThrmstrC(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIThrmstrR1(taskHandle, channel)

int32 __CFUNC DAQmxResetAIThrmstrR1(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAITorqueUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAITorqueUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIUsbXferReqCount(taskHandle, channel)

int32 __CFUNC DAQmxResetAIUsbXferReqCount(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIUsbXferReqSize(taskHandle, channel)

int32 __CFUNC DAQmxResetAIUsbXferReqSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVelocityIEPESensorSensitivity(taskHandle, channel)

int32 __CFUNC DAQmxResetAIVelocityIEPESensorSensitivity(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVelocityIEPESensorSensitivityUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIVelocityIEPESensorSensitivityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVelocityIEPESensordBRef(taskHandle, channel)

int32 __CFUNC DAQmxResetAIVelocityIEPESensordBRef(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVelocityUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIVelocityUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVoltageACRMSUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIVoltageACRMSUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVoltageUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAIVoltageUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAIVoltagedBRef(taskHandle, channel)

int32 __CFUNC DAQmxResetAIVoltagedBRef(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOCurrentUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAOCurrentUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOCustomScaleName(taskHandle, channel)

int32 __CFUNC DAQmxResetAOCustomScaleName(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACOffsetExtSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACOffsetExtSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACOffsetSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACOffsetSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACOffsetVal(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACOffsetVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefAllowConnToGnd(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACRefAllowConnToGnd(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefConnToGnd(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACRefConnToGnd(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefExtSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACRefExtSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACRefSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRefVal(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACRefVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRngHigh(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACRngHigh(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODACRngLow(taskHandle, channel)

int32 __CFUNC DAQmxResetAODACRngLow(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODataXferMech(taskHandle, channel)

int32 __CFUNC DAQmxResetAODataXferMech(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAODataXferReqCond(taskHandle, channel)

int32 __CFUNC DAQmxResetAODataXferReqCond(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOEnhancedImageRejectionEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAOEnhancedImageRejectionEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFilterDelay(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFilterDelay(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFilterDelayAdjustment(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFilterDelayAdjustment(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFilterDelayUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFilterDelayUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenAmplitude(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFuncGenAmplitude(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenFMDeviation(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFuncGenFMDeviation(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenFreq(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFuncGenFreq(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenModulationType(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFuncGenModulationType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenOffset(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFuncGenOffset(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenSquareDutyCycle(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFuncGenSquareDutyCycle(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOFuncGenType(taskHandle, channel)

int32 __CFUNC DAQmxResetAOFuncGenType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOGain(taskHandle, channel)

int32 __CFUNC DAQmxResetAOGain(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOIdleOutputBehavior(taskHandle, channel)

int32 __CFUNC DAQmxResetAOIdleOutputBehavior(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOLoadImpedance(taskHandle, channel)

int32 __CFUNC DAQmxResetAOLoadImpedance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOMax(taskHandle, channel)

int32 __CFUNC DAQmxResetAOMax(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOMemMapEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAOMemMapEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOMin(taskHandle, channel)

int32 __CFUNC DAQmxResetAOMin(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOOutputImpedance(taskHandle, channel)

int32 __CFUNC DAQmxResetAOOutputImpedance(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOPowerAmpChannelEnable(physicalChannel)

int32 __CFUNC DAQmxResetAOPowerAmpChannelEnable(const char physicalChannel[]);

htf.daqmx.core.DAQmxResetAOReglitchEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetAOReglitchEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOResolutionUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAOResolutionUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOTermCfg(taskHandle, channel)

int32 __CFUNC DAQmxResetAOTermCfg(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOUsbXferReqCount(taskHandle, channel)

int32 __CFUNC DAQmxResetAOUsbXferReqCount(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOUsbXferReqSize(taskHandle, channel)

int32 __CFUNC DAQmxResetAOUsbXferReqSize(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOUseOnlyOnBrdMem(taskHandle, channel)

int32 __CFUNC DAQmxResetAOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOVoltageCurrentLimit(taskHandle, channel)

int32 __CFUNC DAQmxResetAOVoltageCurrentLimit(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAOVoltageUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetAOVoltageUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetAdvTrigType(taskHandle)

int32 __CFUNC DAQmxResetAdvTrigType(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigCoupling(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigFltrEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigFltrMinPulseWidth(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseRate(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigDigSyncEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigHyst(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigHyst(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigLvl(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigLvl(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigSlope(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigSlope(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeRefTrigSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeRefTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigCoupling(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigFltrEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigFltrMinPulseWidth(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigFltrTimebaseRate(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigFltrTimebaseSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigDigSyncEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigHyst(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigHyst(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigLvl(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigLvl(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigSlope(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigSlope(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgEdgeStartTrigSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgEdgeStartTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigCoupling(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigFltrEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigFltrMinPulseWidth(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigFltrTimebaseRate(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigFltrTimebaseSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigDigSyncEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigHyst(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigHyst(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigLvl(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigLvl(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgLvlPauseTrigWhen(taskHandle)

int32 __CFUNC DAQmxResetAnlgLvlPauseTrigWhen(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigBtm(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigBtm(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigCoupling(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigFltrEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigFltrMinPulseWidth(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigFltrTimebaseRate(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigFltrTimebaseSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigDigSyncEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigTop(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigTop(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinPauseTrigWhen(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinPauseTrigWhen(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigBtm(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigBtm(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigCoupling(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigFltrEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigFltrMinPulseWidth(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigFltrTimebaseRate(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigFltrTimebaseSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigDigSyncEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigTop(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigTop(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinRefTrigWhen(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinRefTrigWhen(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigBtm(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigBtm(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigCoupling(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigCoupling(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigFltrEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigFltrEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigFltrMinPulseWidth(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigFltrTimebaseRate(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigFltrTimebaseRate(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigFltrTimebaseSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigDigSyncEnable(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigDigSyncEnable(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigSrc(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigSrc(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigTop(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigTop(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetAnlgWinStartTrigWhen(taskHandle)

int32 __CFUNC DAQmxResetAnlgWinStartTrigWhen(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetArmStartTrigType(taskHandle)

int32 __CFUNC DAQmxResetArmStartTrigType(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetBufInputBufSize(taskHandle)

int32 __CFUNC DAQmxResetBufInputBufSize(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetBufOutputBufSize(taskHandle)

int32 __CFUNC DAQmxResetBufOutputBufSize(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetBufOutputOnbrdBufSize(taskHandle)

int32 __CFUNC DAQmxResetBufOutputOnbrdBufSize(TaskHandle taskHandle);

htf.daqmx.core.DAQmxResetBufferAttribute(taskHandle, attribute)

int32 __CFUNC DAQmxResetBufferAttribute (TaskHandle taskHandle, int32 attribute);

htf.daqmx.core.DAQmxResetCIAngEncoderInitialAngle(taskHandle, channel)

int32 __CFUNC DAQmxResetCIAngEncoderInitialAngle(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIAngEncoderPulsesPerRev(taskHandle, channel)

int32 __CFUNC DAQmxResetCIAngEncoderPulsesPerRev(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIAngEncoderUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetCIAngEncoderUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesActiveEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesActiveEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountDirDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountDirDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetActiveEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountResetActiveEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigFltrMinPulseWidth (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigFltrTimebaseRate (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigFltrTimebaseSrc (TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountResetDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountResetEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetResetCount(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountResetResetCount(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesCountResetTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesCountResetTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDir(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesDir(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesDirTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesDirTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesInitialCnt(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesInitialCnt(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICountEdgesTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCICountEdgesTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseActiveEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCICtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCICtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseMasterTimebaseDiv(taskHandle, channel)

int32 __CFUNC DAQmxResetCICtrTimebaseMasterTimebaseDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCICtrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICtrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCICtrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCICustomScaleName(taskHandle, channel)

int32 __CFUNC DAQmxResetCICustomScaleName(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIDataXferMech(taskHandle, channel)

int32 __CFUNC DAQmxResetCIDataXferMech(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIDataXferReqCond(taskHandle, channel)

int32 __CFUNC DAQmxResetCIDataXferReqCond(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIDupCountPrevent(taskHandle, channel)

int32 __CFUNC DAQmxResetCIDupCountPrevent(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderAInputDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderAInputTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderAInputTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderBInputDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderBInputTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderBInputTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderDecodingType(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderDecodingType(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZIndexEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderZIndexEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZIndexPhase(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderZIndexPhase(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZIndexVal(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderZIndexVal(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderZInputDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIEncoderZInputTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCIEncoderZInputTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqDiv(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqEnableAveraging(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqEnableAveraging(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqMeasMeth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqMeasMeth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqMeasTime(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqMeasTime(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqStartingEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqStartingEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIFreqUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetCIFreqUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIGPSSyncMethod(taskHandle, channel)

int32 __CFUNC DAQmxResetCIGPSSyncMethod(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIGPSSyncSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIGPSSyncSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCILinEncoderDistPerPulse(taskHandle, channel)

int32 __CFUNC DAQmxResetCILinEncoderDistPerPulse(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCILinEncoderInitialPos(taskHandle, channel)

int32 __CFUNC DAQmxResetCILinEncoderInitialPos(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCILinEncoderUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetCILinEncoderUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIMax(taskHandle, channel)

int32 __CFUNC DAQmxResetCIMax(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIMemMapEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIMemMapEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIMin(taskHandle, channel)

int32 __CFUNC DAQmxResetCIMin(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodDiv(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodDiv(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodEnableAveraging(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodEnableAveraging(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodMeasMeth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodMeasMeth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodMeasTime(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodMeasTime(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodStartingEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodStartingEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPeriodUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPeriodUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPrescaler(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPrescaler(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseFreqDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseFreqDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseFreqDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseFreqDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseFreqDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqStartEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseFreqStartEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseFreqTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseFreqUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseFreqUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTicksDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTicksDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTicksDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTicksDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTicksDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksStartEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTicksStartEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTicksTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTicksTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTimeDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTimeDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTimeDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTimeDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTimeDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeStartEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTimeStartEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTimeTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseTimeUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseTimeUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseWidthDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseWidthDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseWidthDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseWidthDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseWidthDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthStartingEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseWidthStartingEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseWidthTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCIPulseWidthUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetCIPulseWidthUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCISemiPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCISemiPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCISemiPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCISemiPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCISemiPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodStartingEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCISemiPeriodStartingEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCISemiPeriodTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCISemiPeriodUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetCISemiPeriodUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITimestampInitialSeconds(taskHandle, channel)

int32 __CFUNC DAQmxResetCITimestampInitialSeconds(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITimestampUnits(taskHandle, channel)

int32 __CFUNC DAQmxResetCITimestampUnits(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstEdge(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepFirstTerm(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepFirstTerm(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigFltrEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigFltrMinPulseWidth(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseRate(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseSrc(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondDigSyncEnable(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigSyncEnable(TaskHandle taskHandle, const char channel[]);

htf.daqmx.core.DAQmxResetCITwoEdgeSepSecondEdge(taskHandle, channel)

int32 __CFUNC DAQmxResetCITwoEdgeSepSecondEdge(TaskHandle taskHandle, const char channel[]);