# Do not edit this file; it was automatically generated.
import ctypes
import numpy
from nidaqmx._lib import (
lib_importer, wrapped_ndpointer, ctypes_byte_str, c_bool32)
from nidaqmx.scale import Scale
from nidaqmx.errors import (
check_for_error, is_string_buffer_too_small, is_array_buffer_too_small)
from nidaqmx._task_modules.channels.channel import Channel
from nidaqmx.utils import unflatten_channel_string
from nidaqmx.constants import (
ACExcitWireMode, ADCTimingMode, AccelChargeSensitivityUnits,
AccelSensitivityUnits, AccelUnits, AngleUnits, AutoZeroType,
BridgeConfiguration, BridgeElectricalUnits, BridgePhysicalUnits,
BridgeShuntCalSource, BridgeUnits, CJCSource, ChargeUnits, Coupling,
CurrentShuntResistorLocation, CurrentUnits, DataJustification,
DataTransferActiveTransferMode, DigitalWidthUnits,
EddyCurrentProxProbeSensitivityUnits, ExcitationDCorAC,
ExcitationIdleOutputBehavior, ExcitationSource,
ExcitationVoltageOrCurrent, FilterResponse, FilterType,
ForceIEPESensorSensitivityUnits, ForceUnits, FrequencyUnits, Impedance1,
InputDataTransferCondition, LVDTSensitivityUnits, LengthUnits,
PowerIdleOutputBehavior, PowerOutputState, PressureUnits, RTDType,
RVDTSensitivityUnits, RawDataCompressionType, ResistanceConfiguration,
ResistanceUnits, ResolutionType, ScaleType, Sense, SensorPowerCfg,
SensorPowerType, ShuntCalSelect, SoundPressureUnits, SourceSelection,
StrainGageBridgeType, StrainGageRosetteMeasurementType,
StrainGageRosetteType, StrainUnits, TemperatureUnits,
TerminalConfiguration, ThermocoupleType, TorqueUnits, UsageTypeAI,
VelocityIEPESensorSensitivityUnits, VelocityUnits, VoltageUnits)
[docs]class AIChannel(Channel):
"""
Represents one or more analog input virtual channels and their properties.
"""
__slots__ = []
def __repr__(self):
return 'AIChannel(name={0})'.format(self._name)
@property
def ai_ac_excit_freq(self):
"""
float: Specifies the AC excitation frequency in Hertz.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIACExcitFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_ac_excit_freq.setter
def ai_ac_excit_freq(self, val):
cfunc = lib_importer.windll.DAQmxSetAIACExcitFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_ac_excit_freq.deleter
def ai_ac_excit_freq(self):
cfunc = lib_importer.windll.DAQmxResetAIACExcitFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_ac_excit_sync_enable(self):
"""
bool: Specifies whether to synchronize the AC excitation source
of the channel to that of another channel. Synchronize the
excitation sources of multiple channels to use multichannel
sensors. Set this property to False for the master channel
and to True for the slave channels.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIACExcitSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_ac_excit_sync_enable.setter
def ai_ac_excit_sync_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIACExcitSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_ac_excit_sync_enable.deleter
def ai_ac_excit_sync_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIACExcitSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_ac_excit_wire_mode(self):
"""
:class:`nidaqmx.constants.ACExcitWireMode`: Specifies the number
of leads on the LVDT or RVDT. Some sensors require you to
tie leads together to create a four- or five- wire sensor.
Refer to the sensor documentation for more information.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIACExcitWireMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ACExcitWireMode(val.value)
@ai_ac_excit_wire_mode.setter
def ai_ac_excit_wire_mode(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIACExcitWireMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_ac_excit_wire_mode.deleter
def ai_ac_excit_wire_mode(self):
cfunc = lib_importer.windll.DAQmxResetAIACExcitWireMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_accel_4_wire_dc_voltage_sensitivity(self):
"""
float: Specifies the sensitivity of the 4 wire DC voltage
acceleration sensor connected to the channel. This value is
the units you specify with
AI.Accel.4WireDCVoltage.SensitivityUnits. Refer to the
sensor documentation to determine this value.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIAccel4WireDCVoltageSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_accel_4_wire_dc_voltage_sensitivity.setter
def ai_accel_4_wire_dc_voltage_sensitivity(self, val):
cfunc = lib_importer.windll.DAQmxSetAIAccel4WireDCVoltageSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_accel_4_wire_dc_voltage_sensitivity.deleter
def ai_accel_4_wire_dc_voltage_sensitivity(self):
cfunc = lib_importer.windll.DAQmxResetAIAccel4WireDCVoltageSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_accel_4_wire_dc_voltage_sensitivity_units(self):
"""
:class:`nidaqmx.constants.AccelSensitivityUnits`: Specifies the
units of AI.Accel.4WireDCVoltage.Sensitivity.
"""
val = ctypes.c_int()
cfunc = (lib_importer.windll.
DAQmxGetAIAccel4WireDCVoltageSensitivityUnits)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return AccelSensitivityUnits(val.value)
@ai_accel_4_wire_dc_voltage_sensitivity_units.setter
def ai_accel_4_wire_dc_voltage_sensitivity_units(self, val):
val = val.value
cfunc = (lib_importer.windll.
DAQmxSetAIAccel4WireDCVoltageSensitivityUnits)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_accel_4_wire_dc_voltage_sensitivity_units.deleter
def ai_accel_4_wire_dc_voltage_sensitivity_units(self):
cfunc = (lib_importer.windll.
DAQmxResetAIAccel4WireDCVoltageSensitivityUnits)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_accel_charge_sensitivity(self):
"""
float: Specifies the sensitivity of the charge acceleration
sensor connected to the channel. This value is the units you
specify with AI.Accel.Charge.SensitivityUnits. Refer to the
sensor documentation to determine this value.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIAccelChargeSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_accel_charge_sensitivity.setter
def ai_accel_charge_sensitivity(self, val):
cfunc = lib_importer.windll.DAQmxSetAIAccelChargeSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_accel_charge_sensitivity.deleter
def ai_accel_charge_sensitivity(self):
cfunc = lib_importer.windll.DAQmxResetAIAccelChargeSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_accel_charge_sensitivity_units(self):
"""
:class:`nidaqmx.constants.AccelChargeSensitivityUnits`:
Specifies the units of AI.Accel.Charge.Sensitivity.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIAccelChargeSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return AccelChargeSensitivityUnits(val.value)
@ai_accel_charge_sensitivity_units.setter
def ai_accel_charge_sensitivity_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIAccelChargeSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_accel_charge_sensitivity_units.deleter
def ai_accel_charge_sensitivity_units(self):
cfunc = lib_importer.windll.DAQmxResetAIAccelChargeSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_accel_sensitivity(self):
"""
float: Specifies the sensitivity of the accelerometer. This
value is in the units you specify with
**ai_accel_sensitivity_units**. Refer to the sensor
documentation to determine this value.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIAccelSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_accel_sensitivity.setter
def ai_accel_sensitivity(self, val):
cfunc = lib_importer.windll.DAQmxSetAIAccelSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_accel_sensitivity.deleter
def ai_accel_sensitivity(self):
cfunc = lib_importer.windll.DAQmxResetAIAccelSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_accel_sensitivity_units(self):
"""
:class:`nidaqmx.constants.AccelSensitivityUnits`: Specifies the
units of **ai_accel_sensitivity**.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIAccelSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return AccelSensitivityUnits(val.value)
@ai_accel_sensitivity_units.setter
def ai_accel_sensitivity_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIAccelSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_accel_sensitivity_units.deleter
def ai_accel_sensitivity_units(self):
cfunc = lib_importer.windll.DAQmxResetAIAccelSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_accel_units(self):
"""
:class:`nidaqmx.constants.AccelUnits`: Specifies the units to
use to return acceleration measurements from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIAccelUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return AccelUnits(val.value)
@ai_accel_units.setter
def ai_accel_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIAccelUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_accel_units.deleter
def ai_accel_units(self):
cfunc = lib_importer.windll.DAQmxResetAIAccelUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_acceld_b_ref(self):
"""
float: Specifies the decibel reference level in the units of the
channel. When you read samples as a waveform, the decibel
reference level is included in the waveform attributes.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIAcceldBRef
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_acceld_b_ref.setter
def ai_acceld_b_ref(self, val):
cfunc = lib_importer.windll.DAQmxSetAIAcceldBRef
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_acceld_b_ref.deleter
def ai_acceld_b_ref(self):
cfunc = lib_importer.windll.DAQmxResetAIAcceldBRef
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_adc_custom_timing_mode(self):
"""
int: Specifies the timing mode of the ADC when
**ai_adc_timing_mode** is **ADCTimingMode.CUSTOM**.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetAIADCCustomTimingMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_adc_custom_timing_mode.setter
def ai_adc_custom_timing_mode(self, val):
cfunc = lib_importer.windll.DAQmxSetAIADCCustomTimingMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_adc_custom_timing_mode.deleter
def ai_adc_custom_timing_mode(self):
cfunc = lib_importer.windll.DAQmxResetAIADCCustomTimingMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_adc_timing_mode(self):
"""
:class:`nidaqmx.constants.ADCTimingMode`: Specifies the ADC
timing mode, controlling the tradeoff between speed and
effective resolution. Some ADC timing modes provide
increased powerline noise rejection. On devices that have an
AI Convert clock, this setting affects both the maximum and
default values for **ai_conv_rate**. You must use the same
ADC timing mode for all channels on a device, but you can
use different ADC timing modes for different devices in the
same task.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIADCTimingMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ADCTimingMode(val.value)
@ai_adc_timing_mode.setter
def ai_adc_timing_mode(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIADCTimingMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_adc_timing_mode.deleter
def ai_adc_timing_mode(self):
cfunc = lib_importer.windll.DAQmxResetAIADCTimingMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_atten(self):
"""
float: Specifies the amount of attenuation to use.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIAtten
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_atten.setter
def ai_atten(self, val):
cfunc = lib_importer.windll.DAQmxSetAIAtten
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_atten.deleter
def ai_atten(self):
cfunc = lib_importer.windll.DAQmxResetAIAtten
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_auto_zero_mode(self):
"""
:class:`nidaqmx.constants.AutoZeroType`: Specifies how often to
measure ground. NI-DAQmx subtracts the measured ground
voltage from every sample.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIAutoZeroMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return AutoZeroType(val.value)
@ai_auto_zero_mode.setter
def ai_auto_zero_mode(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIAutoZeroMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_auto_zero_mode.deleter
def ai_auto_zero_mode(self):
cfunc = lib_importer.windll.DAQmxResetAIAutoZeroMode
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_averaging_win_size(self):
"""
int: Specifies the number of samples to average while acquiring
data. Increasing the number of samples to average reduces
noise in your measurement.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetAIAveragingWinSize
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_averaging_win_size.setter
def ai_averaging_win_size(self, val):
cfunc = lib_importer.windll.DAQmxSetAIAveragingWinSize
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_averaging_win_size.deleter
def ai_averaging_win_size(self):
cfunc = lib_importer.windll.DAQmxResetAIAveragingWinSize
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_balance_coarse_pot(self):
"""
int: Specifies by how much to compensate for offset in the
signal. This value can be between 0 and 127.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIBridgeBalanceCoarsePot
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_balance_coarse_pot.setter
def ai_bridge_balance_coarse_pot(self, val):
cfunc = lib_importer.windll.DAQmxSetAIBridgeBalanceCoarsePot
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_balance_coarse_pot.deleter
def ai_bridge_balance_coarse_pot(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeBalanceCoarsePot
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_balance_fine_pot(self):
"""
int: Specifies by how much to compensate for offset in the
signal. This value can be between 0 and 4095.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIBridgeBalanceFinePot
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_balance_fine_pot.setter
def ai_bridge_balance_fine_pot(self, val):
cfunc = lib_importer.windll.DAQmxSetAIBridgeBalanceFinePot
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_balance_fine_pot.deleter
def ai_bridge_balance_fine_pot(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeBalanceFinePot
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_cfg(self):
"""
:class:`nidaqmx.constants.BridgeConfiguration`: Specifies the
type of Wheatstone bridge connected to the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIBridgeCfg
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return BridgeConfiguration(val.value)
@ai_bridge_cfg.setter
def ai_bridge_cfg(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIBridgeCfg
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_cfg.deleter
def ai_bridge_cfg(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeCfg
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_electrical_units(self):
"""
:class:`nidaqmx.constants.BridgeElectricalUnits`: Specifies from
which electrical unit to scale data. Select the same unit
that the sensor data sheet or calibration certificate uses
for electrical values.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIBridgeElectricalUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return BridgeElectricalUnits(val.value)
@ai_bridge_electrical_units.setter
def ai_bridge_electrical_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIBridgeElectricalUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_electrical_units.deleter
def ai_bridge_electrical_units(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeElectricalUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_initial_ratio(self):
"""
float: Specifies in volts per volt the ratio of output voltage
from the bridge to excitation voltage supplied to the bridge
while not under load. NI-DAQmx subtracts this value from any
measurements before applying scaling equations. If you set
**ai_bridge_initial_voltage**, NI-DAQmx coerces this
property to **ai_bridge_initial_voltage** divided by
**ai_excit_actual_val**. If you set this property, NI-DAQmx
coerces **ai_bridge_initial_voltage** to the value of this
property times **ai_excit_actual_val**. If you set both this
property and **ai_bridge_initial_voltage**, and their values
conflict, NI-DAQmx returns an error. To avoid this error,
reset one property to its default value before setting the
other.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIBridgeInitialRatio
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_initial_ratio.setter
def ai_bridge_initial_ratio(self, val):
cfunc = lib_importer.windll.DAQmxSetAIBridgeInitialRatio
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_initial_ratio.deleter
def ai_bridge_initial_ratio(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeInitialRatio
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_initial_voltage(self):
"""
float: Specifies in volts the output voltage of the bridge while
not under load. NI-DAQmx subtracts this value from any
measurements before applying scaling equations. If you set
**ai_bridge_initial_ratio**, NI-DAQmx coerces this property
to **ai_bridge_initial_ratio** times
**ai_excit_actual_val**. This property is set by DAQmx
Perform Bridge Offset Nulling Calibration. If you set this
property, NI-DAQmx coerces **ai_bridge_initial_ratio** to
the value of this property divided by
**ai_excit_actual_val**. If you set both this property and
**ai_bridge_initial_ratio**, and their values conflict, NI-
DAQmx returns an error. To avoid this error, reset one
property to its default value before setting the other.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIBridgeInitialVoltage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_initial_voltage.setter
def ai_bridge_initial_voltage(self, val):
cfunc = lib_importer.windll.DAQmxSetAIBridgeInitialVoltage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_initial_voltage.deleter
def ai_bridge_initial_voltage(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeInitialVoltage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_nom_resistance(self):
"""
float: Specifies in ohms the resistance of the bridge while not
under load.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIBridgeNomResistance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_nom_resistance.setter
def ai_bridge_nom_resistance(self, val):
cfunc = lib_importer.windll.DAQmxSetAIBridgeNomResistance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_nom_resistance.deleter
def ai_bridge_nom_resistance(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeNomResistance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_physical_units(self):
"""
:class:`nidaqmx.constants.BridgePhysicalUnits`: Specifies to
which physical unit to scale electrical data. Select the
same unit that the sensor data sheet or calibration
certificate uses for physical values.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIBridgePhysicalUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return BridgePhysicalUnits(val.value)
@ai_bridge_physical_units.setter
def ai_bridge_physical_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIBridgePhysicalUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_physical_units.deleter
def ai_bridge_physical_units(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgePhysicalUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_poly_forward_coeff(self):
"""
List[float]: Specifies an list of coefficients for the
polynomial that converts electrical values to physical
values. Each element of the list corresponds to a term of
the equation. For example, if index three of the list is 9,
the fourth term of the equation is 9x^3.
"""
cfunc = lib_importer.windll.DAQmxGetAIBridgePolyForwardCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._handle, self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@ai_bridge_poly_forward_coeff.setter
def ai_bridge_poly_forward_coeff(self, val):
val = numpy.float64(val)
cfunc = lib_importer.windll.DAQmxSetAIBridgePolyForwardCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val, len(val))
check_for_error(error_code)
@ai_bridge_poly_forward_coeff.deleter
def ai_bridge_poly_forward_coeff(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgePolyForwardCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_poly_reverse_coeff(self):
"""
List[float]: Specifies an list of coefficients for the
polynomial that converts physical values to electrical
values. Each element of the list corresponds to a term of
the equation. For example, if index three of the list is 9,
the fourth term of the equation is 9x^3.
"""
cfunc = lib_importer.windll.DAQmxGetAIBridgePolyReverseCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._handle, self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@ai_bridge_poly_reverse_coeff.setter
def ai_bridge_poly_reverse_coeff(self, val):
val = numpy.float64(val)
cfunc = lib_importer.windll.DAQmxSetAIBridgePolyReverseCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val, len(val))
check_for_error(error_code)
@ai_bridge_poly_reverse_coeff.deleter
def ai_bridge_poly_reverse_coeff(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgePolyReverseCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_scale_type(self):
"""
:class:`nidaqmx.constants.ScaleType`: Specifies the scaling type
to use when scaling electrical values from the sensor to
physical units.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIBridgeScaleType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ScaleType(val.value)
@ai_bridge_scale_type.setter
def ai_bridge_scale_type(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIBridgeScaleType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_scale_type.deleter
def ai_bridge_scale_type(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeScaleType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_shunt_cal_enable(self):
"""
bool: Specifies whether to enable a shunt calibration switch.
Use **ai_bridge_shunt_cal_select** to select the switch(es)
to enable.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIBridgeShuntCalEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_shunt_cal_enable.setter
def ai_bridge_shunt_cal_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIBridgeShuntCalEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_shunt_cal_enable.deleter
def ai_bridge_shunt_cal_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeShuntCalEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_shunt_cal_gain_adjust(self):
"""
float: Specifies the result of a shunt calibration. This
property is set by DAQmx Perform Shunt Calibration. NI-DAQmx
multiplies data read from the channel by the value of this
property. This value should be close to 1.0.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIBridgeShuntCalGainAdjust
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_shunt_cal_gain_adjust.setter
def ai_bridge_shunt_cal_gain_adjust(self, val):
cfunc = lib_importer.windll.DAQmxSetAIBridgeShuntCalGainAdjust
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_shunt_cal_gain_adjust.deleter
def ai_bridge_shunt_cal_gain_adjust(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeShuntCalGainAdjust
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_shunt_cal_select(self):
"""
:class:`nidaqmx.constants.ShuntCalSelect`: Specifies which shunt
calibration switch(es) to enable. Use
**ai_bridge_shunt_cal_enable** to enable the switch(es) you
specify with this property.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIBridgeShuntCalSelect
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ShuntCalSelect(val.value)
@ai_bridge_shunt_cal_select.setter
def ai_bridge_shunt_cal_select(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIBridgeShuntCalSelect
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_shunt_cal_select.deleter
def ai_bridge_shunt_cal_select(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeShuntCalSelect
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_shunt_cal_shunt_cal_a_actual_resistance(self):
"""
float: Specifies in ohms the actual value of the internal shunt
calibration A resistor.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIBridgeShuntCalShuntCalAActualResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_shunt_cal_shunt_cal_a_actual_resistance.setter
def ai_bridge_shunt_cal_shunt_cal_a_actual_resistance(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIBridgeShuntCalShuntCalAActualResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_shunt_cal_shunt_cal_a_actual_resistance.deleter
def ai_bridge_shunt_cal_shunt_cal_a_actual_resistance(self):
cfunc = (lib_importer.windll.
DAQmxResetAIBridgeShuntCalShuntCalAActualResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_shunt_cal_shunt_cal_a_resistance(self):
"""
float: Specifies in ohms the desired value of the internal shunt
calibration A resistor.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIBridgeShuntCalShuntCalAResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_shunt_cal_shunt_cal_a_resistance.setter
def ai_bridge_shunt_cal_shunt_cal_a_resistance(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIBridgeShuntCalShuntCalAResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_shunt_cal_shunt_cal_a_resistance.deleter
def ai_bridge_shunt_cal_shunt_cal_a_resistance(self):
cfunc = (lib_importer.windll.
DAQmxResetAIBridgeShuntCalShuntCalAResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_shunt_cal_shunt_cal_a_src(self):
"""
:class:`nidaqmx.constants.BridgeShuntCalSource`: Specifies
whether to use internal or external shunt when Shunt Cal A
is selected.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIBridgeShuntCalShuntCalASrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return BridgeShuntCalSource(val.value)
@ai_bridge_shunt_cal_shunt_cal_a_src.setter
def ai_bridge_shunt_cal_shunt_cal_a_src(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIBridgeShuntCalShuntCalASrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_shunt_cal_shunt_cal_a_src.deleter
def ai_bridge_shunt_cal_shunt_cal_a_src(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeShuntCalShuntCalASrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_shunt_cal_shunt_cal_b_actual_resistance(self):
"""
float: Specifies in ohms the actual value of the internal shunt
calibration B resistor.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIBridgeShuntCalShuntCalBActualResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_shunt_cal_shunt_cal_b_actual_resistance.setter
def ai_bridge_shunt_cal_shunt_cal_b_actual_resistance(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIBridgeShuntCalShuntCalBActualResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_shunt_cal_shunt_cal_b_actual_resistance.deleter
def ai_bridge_shunt_cal_shunt_cal_b_actual_resistance(self):
cfunc = (lib_importer.windll.
DAQmxResetAIBridgeShuntCalShuntCalBActualResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_shunt_cal_shunt_cal_b_resistance(self):
"""
float: Specifies in ohms the desired value of the internal shunt
calibration B resistor.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIBridgeShuntCalShuntCalBResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_shunt_cal_shunt_cal_b_resistance.setter
def ai_bridge_shunt_cal_shunt_cal_b_resistance(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIBridgeShuntCalShuntCalBResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_shunt_cal_shunt_cal_b_resistance.deleter
def ai_bridge_shunt_cal_shunt_cal_b_resistance(self):
cfunc = (lib_importer.windll.
DAQmxResetAIBridgeShuntCalShuntCalBResistance)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_table_electrical_vals(self):
"""
List[float]: Specifies the list of electrical values that map to
the values in **ai_bridge_table_physical_vals**. Specify
this value in the unit indicated by
**ai_bridge_electrical_units**.
"""
cfunc = lib_importer.windll.DAQmxGetAIBridgeTableElectricalVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._handle, self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@ai_bridge_table_electrical_vals.setter
def ai_bridge_table_electrical_vals(self, val):
val = numpy.float64(val)
cfunc = lib_importer.windll.DAQmxSetAIBridgeTableElectricalVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val, len(val))
check_for_error(error_code)
@ai_bridge_table_electrical_vals.deleter
def ai_bridge_table_electrical_vals(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeTableElectricalVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_table_physical_vals(self):
"""
List[float]: Specifies the list of physical values that map to
the values in **ai_bridge_table_electrical_vals**. Specify
this value in the unit indicated by
**ai_bridge_physical_units**.
"""
cfunc = lib_importer.windll.DAQmxGetAIBridgeTablePhysicalVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._handle, self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@ai_bridge_table_physical_vals.setter
def ai_bridge_table_physical_vals(self, val):
val = numpy.float64(val)
cfunc = lib_importer.windll.DAQmxSetAIBridgeTablePhysicalVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val, len(val))
check_for_error(error_code)
@ai_bridge_table_physical_vals.deleter
def ai_bridge_table_physical_vals(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeTablePhysicalVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_two_point_lin_first_electrical_val(self):
"""
float: Specifies the first electrical value, corresponding to
**ai_bridge_two_point_lin_first_physical_val**. Specify this
value in the unit indicated by
**ai_bridge_electrical_units**.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIBridgeTwoPointLinFirstElectricalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_two_point_lin_first_electrical_val.setter
def ai_bridge_two_point_lin_first_electrical_val(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIBridgeTwoPointLinFirstElectricalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_two_point_lin_first_electrical_val.deleter
def ai_bridge_two_point_lin_first_electrical_val(self):
cfunc = (lib_importer.windll.
DAQmxResetAIBridgeTwoPointLinFirstElectricalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_two_point_lin_first_physical_val(self):
"""
float: Specifies the first physical value, corresponding to
**ai_bridge_two_point_lin_first_electrical_val**. Specify
this value in the unit indicated by
**ai_bridge_physical_units**.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIBridgeTwoPointLinFirstPhysicalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_two_point_lin_first_physical_val.setter
def ai_bridge_two_point_lin_first_physical_val(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIBridgeTwoPointLinFirstPhysicalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_two_point_lin_first_physical_val.deleter
def ai_bridge_two_point_lin_first_physical_val(self):
cfunc = (lib_importer.windll.
DAQmxResetAIBridgeTwoPointLinFirstPhysicalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_two_point_lin_second_electrical_val(self):
"""
float: Specifies the second electrical value, corresponding to
**ai_bridge_two_point_lin_second_physical_val**. Specify
this value in the unit indicated by
**ai_bridge_electrical_units**.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIBridgeTwoPointLinSecondElectricalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_two_point_lin_second_electrical_val.setter
def ai_bridge_two_point_lin_second_electrical_val(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIBridgeTwoPointLinSecondElectricalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_two_point_lin_second_electrical_val.deleter
def ai_bridge_two_point_lin_second_electrical_val(self):
cfunc = (lib_importer.windll.
DAQmxResetAIBridgeTwoPointLinSecondElectricalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_two_point_lin_second_physical_val(self):
"""
float: Specifies the second physical value, corresponding to
**ai_bridge_two_point_lin_second_electrical_val**. Specify
this value in the unit indicated by
**ai_bridge_physical_units**.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIBridgeTwoPointLinSecondPhysicalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_bridge_two_point_lin_second_physical_val.setter
def ai_bridge_two_point_lin_second_physical_val(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIBridgeTwoPointLinSecondPhysicalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_two_point_lin_second_physical_val.deleter
def ai_bridge_two_point_lin_second_physical_val(self):
cfunc = (lib_importer.windll.
DAQmxResetAIBridgeTwoPointLinSecondPhysicalVal)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_bridge_units(self):
"""
:class:`nidaqmx.constants.BridgeUnits`: Specifies in which unit
to return voltage ratios from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIBridgeUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return BridgeUnits(val.value)
@ai_bridge_units.setter
def ai_bridge_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIBridgeUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_bridge_units.deleter
def ai_bridge_units(self):
cfunc = lib_importer.windll.DAQmxResetAIBridgeUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_charge_units(self):
"""
:class:`nidaqmx.constants.ChargeUnits`: Specifies the units to
use to return charge measurements from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIChargeUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ChargeUnits(val.value)
@ai_charge_units.setter
def ai_charge_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIChargeUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_charge_units.deleter
def ai_charge_units(self):
cfunc = lib_importer.windll.DAQmxResetAIChargeUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_chop_enable(self):
"""
bool: Specifies whether the device will chop its inputs.
Chopping removes offset voltages and other low frequency
errors.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIChopEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_chop_enable.setter
def ai_chop_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIChopEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_chop_enable.deleter
def ai_chop_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIChopEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_coupling(self):
"""
:class:`nidaqmx.constants.Coupling`: Specifies the coupling for
the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAICoupling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return Coupling(val.value)
@ai_coupling.setter
def ai_coupling(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAICoupling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_coupling.deleter
def ai_coupling(self):
cfunc = lib_importer.windll.DAQmxResetAICoupling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_current_acrms_units(self):
"""
:class:`nidaqmx.constants.CurrentUnits`: Specifies the units to
use to return current RMS measurements from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAICurrentACRMSUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return CurrentUnits(val.value)
@ai_current_acrms_units.setter
def ai_current_acrms_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAICurrentACRMSUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_current_acrms_units.deleter
def ai_current_acrms_units(self):
cfunc = lib_importer.windll.DAQmxResetAICurrentACRMSUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_current_shunt_loc(self):
"""
:class:`nidaqmx.constants.CurrentShuntResistorLocation`:
Specifies the shunt resistor location for current
measurements.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAICurrentShuntLoc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return CurrentShuntResistorLocation(val.value)
@ai_current_shunt_loc.setter
def ai_current_shunt_loc(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAICurrentShuntLoc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_current_shunt_loc.deleter
def ai_current_shunt_loc(self):
cfunc = lib_importer.windll.DAQmxResetAICurrentShuntLoc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_current_shunt_resistance(self):
"""
float: Specifies in ohms the external shunt resistance for
current measurements.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAICurrentShuntResistance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_current_shunt_resistance.setter
def ai_current_shunt_resistance(self, val):
cfunc = lib_importer.windll.DAQmxSetAICurrentShuntResistance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_current_shunt_resistance.deleter
def ai_current_shunt_resistance(self):
cfunc = lib_importer.windll.DAQmxResetAICurrentShuntResistance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_current_units(self):
"""
:class:`nidaqmx.constants.CurrentUnits`: Specifies the units to
use to return current measurements from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAICurrentUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return CurrentUnits(val.value)
@ai_current_units.setter
def ai_current_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAICurrentUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_current_units.deleter
def ai_current_units(self):
cfunc = lib_importer.windll.DAQmxResetAICurrentUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_custom_scale(self):
"""
:class:`nidaqmx.system.scale.Scale`: Specifies the name of a
custom scale for the channel.
"""
cfunc = lib_importer.windll.DAQmxGetAICustomScaleName
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_char_p, ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, self._name, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return Scale(val.value.decode('ascii'))
@ai_custom_scale.setter
def ai_custom_scale(self, val):
val = val.name
cfunc = lib_importer.windll.DAQmxSetAICustomScaleName
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes_byte_str]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_custom_scale.deleter
def ai_custom_scale(self):
cfunc = lib_importer.windll.DAQmxResetAICustomScaleName
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_data_xfer_custom_threshold(self):
"""
int: Specifies the number of samples that must be in the FIFO to
transfer data from the device if **ai_data_xfer_req_cond**
is
**InputDataTransferCondition.ONBOARD_MEMORY_CUSTOM_THRESHOLD**.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetAIDataXferCustomThreshold
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_data_xfer_custom_threshold.setter
def ai_data_xfer_custom_threshold(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDataXferCustomThreshold
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_data_xfer_custom_threshold.deleter
def ai_data_xfer_custom_threshold(self):
cfunc = lib_importer.windll.DAQmxResetAIDataXferCustomThreshold
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_data_xfer_max_rate(self):
"""
float: Specifies the rate in B/s to transfer data from the
device. If this value is not set, then the device will
transfer data at a rate based on the bus detected. Modify
this value to affect performance under different
combinations of operating system, configuration, and device.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIDataXferMaxRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_data_xfer_max_rate.setter
def ai_data_xfer_max_rate(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDataXferMaxRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_data_xfer_max_rate.deleter
def ai_data_xfer_max_rate(self):
cfunc = lib_importer.windll.DAQmxResetAIDataXferMaxRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_data_xfer_mech(self):
"""
:class:`nidaqmx.constants.DataTransferActiveTransferMode`:
Specifies the data transfer mode for the device.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIDataXferMech
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return DataTransferActiveTransferMode(val.value)
@ai_data_xfer_mech.setter
def ai_data_xfer_mech(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIDataXferMech
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_data_xfer_mech.deleter
def ai_data_xfer_mech(self):
cfunc = lib_importer.windll.DAQmxResetAIDataXferMech
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_data_xfer_req_cond(self):
"""
:class:`nidaqmx.constants.InputDataTransferCondition`: Specifies
under what condition to transfer data from the onboard
memory of the device to the buffer.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIDataXferReqCond
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return InputDataTransferCondition(val.value)
@ai_data_xfer_req_cond.setter
def ai_data_xfer_req_cond(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIDataXferReqCond
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_data_xfer_req_cond.deleter
def ai_data_xfer_req_cond(self):
cfunc = lib_importer.windll.DAQmxResetAIDataXferReqCond
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dc_offset(self):
"""
float: Specifies the DC value to add to the input range of the
device. Use **ai_rng_high** and **ai_rng_low** to specify
the input range. This offset is in the native units of the
device .
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIDCOffset
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dc_offset.setter
def ai_dc_offset(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDCOffset
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dc_offset.deleter
def ai_dc_offset(self):
cfunc = lib_importer.windll.DAQmxResetAIDCOffset
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dev_scaling_coeff(self):
"""
List[float]: Indicates the coefficients of a polynomial equation
that NI-DAQmx uses to scale values from the native format of
the device to volts. Each element of the list corresponds to
a term of the equation. For example, if index two of the
list is 4, the third term of the equation is 4x^2. Scaling
coefficients do not account for any custom scales or sensors
contained by the channel.
"""
cfunc = lib_importer.windll.DAQmxGetAIDevScalingCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._handle, self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_dig_fltr_bandpass_center_freq(self):
"""
float: Specifies the center frequency of the passband for the
digital filter.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrBandpassCenterFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dig_fltr_bandpass_center_freq.setter
def ai_dig_fltr_bandpass_center_freq(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDigFltrBandpassCenterFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_bandpass_center_freq.deleter
def ai_dig_fltr_bandpass_center_freq(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrBandpassCenterFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_bandpass_width(self):
"""
float: Specifies the width of the passband centered around the
center frequency for the digital filter.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrBandpassWidth
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dig_fltr_bandpass_width.setter
def ai_dig_fltr_bandpass_width(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDigFltrBandpassWidth
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_bandpass_width.deleter
def ai_dig_fltr_bandpass_width(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrBandpassWidth
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_coeff(self):
"""
List[float]: Specifies the digital filter coefficients.
"""
cfunc = lib_importer.windll.DAQmxGetAIDigFltrCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._handle, self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@ai_dig_fltr_coeff.setter
def ai_dig_fltr_coeff(self, val):
val = numpy.float64(val)
cfunc = lib_importer.windll.DAQmxSetAIDigFltrCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val, len(val))
check_for_error(error_code)
@ai_dig_fltr_coeff.deleter
def ai_dig_fltr_coeff(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrCoeff
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_enable(self):
"""
bool: Specifies whether the digital filter is enabled or
disabled.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dig_fltr_enable.setter
def ai_dig_fltr_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_enable.deleter
def ai_dig_fltr_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_highpass_cutoff_freq(self):
"""
float: Specifies the highpass cutoff frequency of the digital
filter.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrHighpassCutoffFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dig_fltr_highpass_cutoff_freq.setter
def ai_dig_fltr_highpass_cutoff_freq(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDigFltrHighpassCutoffFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_highpass_cutoff_freq.deleter
def ai_dig_fltr_highpass_cutoff_freq(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrHighpassCutoffFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_lowpass_cutoff_freq(self):
"""
float: Specifies the lowpass cutoff frequency of the digital
filter.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrLowpassCutoffFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dig_fltr_lowpass_cutoff_freq.setter
def ai_dig_fltr_lowpass_cutoff_freq(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDigFltrLowpassCutoffFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_lowpass_cutoff_freq.deleter
def ai_dig_fltr_lowpass_cutoff_freq(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrLowpassCutoffFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_notch_center_freq(self):
"""
float: Specifies the center frequency of the stopband for the
digital filter.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrNotchCenterFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dig_fltr_notch_center_freq.setter
def ai_dig_fltr_notch_center_freq(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDigFltrNotchCenterFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_notch_center_freq.deleter
def ai_dig_fltr_notch_center_freq(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrNotchCenterFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_notch_width(self):
"""
float: Specifies the width of the stopband centered around the
center frequency for the digital filter.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrNotchWidth
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dig_fltr_notch_width.setter
def ai_dig_fltr_notch_width(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDigFltrNotchWidth
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_notch_width.deleter
def ai_dig_fltr_notch_width(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrNotchWidth
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_order(self):
"""
int: Specifies the order of the digital filter.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrOrder
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dig_fltr_order.setter
def ai_dig_fltr_order(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDigFltrOrder
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_order.deleter
def ai_dig_fltr_order(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrOrder
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_response(self):
"""
:class:`nidaqmx.constants.FilterResponse`: Specifies the digital
filter response.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrResponse
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return FilterResponse(val.value)
@ai_dig_fltr_response.setter
def ai_dig_fltr_response(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIDigFltrResponse
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_response.deleter
def ai_dig_fltr_response(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrResponse
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dig_fltr_type(self):
"""
:class:`nidaqmx.constants.FilterType`: Specifies the digital
filter type.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIDigFltrType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return FilterType(val.value)
@ai_dig_fltr_type.setter
def ai_dig_fltr_type(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIDigFltrType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dig_fltr_type.deleter
def ai_dig_fltr_type(self):
cfunc = lib_importer.windll.DAQmxResetAIDigFltrType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_dither_enable(self):
"""
bool: Specifies whether to enable dithering. Dithering adds
Gaussian noise to the input signal. You can use dithering to
achieve higher resolution measurements by over sampling the
input signal and averaging the results.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIDitherEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_dither_enable.setter
def ai_dither_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIDitherEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_dither_enable.deleter
def ai_dither_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIDitherEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_eddy_current_prox_sensitivity(self):
"""
float: Specifies the sensitivity of the eddy current proximity
probe . This value is in the units you specify with
**ai_eddy_current_prox_sensitivity_units**. Refer to the
sensor documentation to determine this value.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIEddyCurrentProxProbeSensitivity)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_eddy_current_prox_sensitivity.setter
def ai_eddy_current_prox_sensitivity(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIEddyCurrentProxProbeSensitivity)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_eddy_current_prox_sensitivity.deleter
def ai_eddy_current_prox_sensitivity(self):
cfunc = (lib_importer.windll.
DAQmxResetAIEddyCurrentProxProbeSensitivity)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_eddy_current_prox_sensitivity_units(self):
"""
:class:`nidaqmx.constants.EddyCurrentProxProbeSensitivityUnits`:
Specifies the units of **ai_eddy_current_prox_sensitivity**.
"""
val = ctypes.c_int()
cfunc = (lib_importer.windll.
DAQmxGetAIEddyCurrentProxProbeSensitivityUnits)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return EddyCurrentProxProbeSensitivityUnits(val.value)
@ai_eddy_current_prox_sensitivity_units.setter
def ai_eddy_current_prox_sensitivity_units(self, val):
val = val.value
cfunc = (lib_importer.windll.
DAQmxSetAIEddyCurrentProxProbeSensitivityUnits)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_eddy_current_prox_sensitivity_units.deleter
def ai_eddy_current_prox_sensitivity_units(self):
cfunc = (lib_importer.windll.
DAQmxResetAIEddyCurrentProxProbeSensitivityUnits)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_eddy_current_prox_units(self):
"""
:class:`nidaqmx.constants.LengthUnits`: Specifies the units to
use to return proximity measurements from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIEddyCurrentProxProbeUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return LengthUnits(val.value)
@ai_eddy_current_prox_units.setter
def ai_eddy_current_prox_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIEddyCurrentProxProbeUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_eddy_current_prox_units.deleter
def ai_eddy_current_prox_units(self):
cfunc = lib_importer.windll.DAQmxResetAIEddyCurrentProxProbeUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_enhanced_alias_rejection_enable(self):
"""
bool: Specifies whether to enable enhanced alias rejection.
Leave this property set to the default value for most
applications.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIEnhancedAliasRejectionEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_enhanced_alias_rejection_enable.setter
def ai_enhanced_alias_rejection_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIEnhancedAliasRejectionEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_enhanced_alias_rejection_enable.deleter
def ai_enhanced_alias_rejection_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIEnhancedAliasRejectionEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_excit_actual_val(self):
"""
float: Specifies the actual amount of excitation supplied by an
internal excitation source. If you read an internal
excitation source more precisely with an external device,
set this property to the value you read. NI-DAQmx ignores
this value for external excitation. When performing shunt
calibration, some devices set this property automatically.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIExcitActualVal
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_excit_actual_val.setter
def ai_excit_actual_val(self, val):
cfunc = lib_importer.windll.DAQmxSetAIExcitActualVal
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_excit_actual_val.deleter
def ai_excit_actual_val(self):
cfunc = lib_importer.windll.DAQmxResetAIExcitActualVal
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_excit_d_cor_ac(self):
"""
:class:`nidaqmx.constants.ExcitationDCorAC`: Specifies if the
excitation supply is DC or AC.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIExcitDCorAC
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ExcitationDCorAC(val.value)
@ai_excit_d_cor_ac.setter
def ai_excit_d_cor_ac(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIExcitDCorAC
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_excit_d_cor_ac.deleter
def ai_excit_d_cor_ac(self):
cfunc = lib_importer.windll.DAQmxResetAIExcitDCorAC
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_excit_idle_output_behavior(self):
"""
:class:`nidaqmx.constants.ExcitationIdleOutputBehavior`:
Specifies whether this channel will disable excitation after
the task is uncommitted. Setting this to Zero Volts or Amps
disables excitation after task uncommit. Setting this
attribute to Maintain Existing Value leaves the excitation
on after task uncommit.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIExcitIdleOutputBehavior
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ExcitationIdleOutputBehavior(val.value)
@ai_excit_idle_output_behavior.setter
def ai_excit_idle_output_behavior(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIExcitIdleOutputBehavior
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_excit_idle_output_behavior.deleter
def ai_excit_idle_output_behavior(self):
cfunc = lib_importer.windll.DAQmxResetAIExcitIdleOutputBehavior
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_excit_sense(self):
"""
:class:`nidaqmx.constants.Sense`: Specifies whether to use local
or remote sense to sense excitation.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIExcitSense
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return Sense(val.value)
@ai_excit_sense.setter
def ai_excit_sense(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIExcitSense
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_excit_sense.deleter
def ai_excit_sense(self):
cfunc = lib_importer.windll.DAQmxResetAIExcitSense
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_excit_src(self):
"""
:class:`nidaqmx.constants.ExcitationSource`: Specifies the
source of excitation.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIExcitSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ExcitationSource(val.value)
@ai_excit_src.setter
def ai_excit_src(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIExcitSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_excit_src.deleter
def ai_excit_src(self):
cfunc = lib_importer.windll.DAQmxResetAIExcitSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_excit_use_for_scaling(self):
"""
bool: Specifies if NI-DAQmx divides the measurement by the
excitation. You should typically set this property to True
for ratiometric transducers. If you set this property to
True, set **ai_max** and **ai_min** to reflect the scaling.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIExcitUseForScaling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_excit_use_for_scaling.setter
def ai_excit_use_for_scaling(self, val):
cfunc = lib_importer.windll.DAQmxSetAIExcitUseForScaling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_excit_use_for_scaling.deleter
def ai_excit_use_for_scaling(self):
cfunc = lib_importer.windll.DAQmxResetAIExcitUseForScaling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_excit_use_multiplexed(self):
"""
bool: Specifies if the SCXI-1122 multiplexes the excitation to
the upper half of the channels as it advances through the
scan list.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIExcitUseMultiplexed
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_excit_use_multiplexed.setter
def ai_excit_use_multiplexed(self, val):
cfunc = lib_importer.windll.DAQmxSetAIExcitUseMultiplexed
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_excit_use_multiplexed.deleter
def ai_excit_use_multiplexed(self):
cfunc = lib_importer.windll.DAQmxResetAIExcitUseMultiplexed
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_excit_val(self):
"""
float: Specifies the amount of excitation that the sensor
requires. If **ai_excit_voltage_or_current** is
**ExcitationVoltageOrCurrent.USE_VOLTAGE**, this value is in
volts. If **ai_excit_voltage_or_current** is
**ExcitationVoltageOrCurrent.USE_CURRENT**, this value is in
amperes.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIExcitVal
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_excit_val.setter
def ai_excit_val(self, val):
cfunc = lib_importer.windll.DAQmxSetAIExcitVal
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_excit_val.deleter
def ai_excit_val(self):
cfunc = lib_importer.windll.DAQmxResetAIExcitVal
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_excit_voltage_or_current(self):
"""
:class:`nidaqmx.constants.ExcitationVoltageOrCurrent`: Specifies
if the channel uses current or voltage excitation.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIExcitVoltageOrCurrent
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ExcitationVoltageOrCurrent(val.value)
@ai_excit_voltage_or_current.setter
def ai_excit_voltage_or_current(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIExcitVoltageOrCurrent
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_excit_voltage_or_current.deleter
def ai_excit_voltage_or_current(self):
cfunc = lib_importer.windll.DAQmxResetAIExcitVoltageOrCurrent
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_filter_delay(self):
"""
float: Indicates the amount of time between when the ADC samples
data and when the sample is read by the host device. This
value is in the units you specify with
**ai_filter_delay_units**. You can adjust this amount of
time using **ai_filter_delay_adjustment**.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIFilterDelay
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ai_filter_delay_adjustment(self):
"""
float: Specifies the amount of filter delay that gets removed if
**ai_remove_filter_delay** is enabled. This delay adjustment
is in addition to the value indicated by
**ai_filter_delay**. This delay adjustment is in the units
you specify with **ai_filter_delay_units**.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIFilterDelayAdjustment
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_filter_delay_adjustment.setter
def ai_filter_delay_adjustment(self, val):
cfunc = lib_importer.windll.DAQmxSetAIFilterDelayAdjustment
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_filter_delay_adjustment.deleter
def ai_filter_delay_adjustment(self):
cfunc = lib_importer.windll.DAQmxResetAIFilterDelayAdjustment
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_filter_delay_units(self):
"""
:class:`nidaqmx.constants.DigitalWidthUnits`: Specifies the
units of **ai_filter_delay** and
**ai_filter_delay_adjustment**.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIFilterDelayUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return DigitalWidthUnits(val.value)
@ai_filter_delay_units.setter
def ai_filter_delay_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIFilterDelayUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_filter_delay_units.deleter
def ai_filter_delay_units(self):
cfunc = lib_importer.windll.DAQmxResetAIFilterDelayUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_filter_enable(self):
"""
bool: Specifies the corresponding filter enable/disable state.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIFilterEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_filter_enable.setter
def ai_filter_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIFilterEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_filter_enable.deleter
def ai_filter_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIFilterEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_filter_freq(self):
"""
float: Specifies the corresponding filter frequency (cutoff or
center) of the filter response.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIFilterFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_filter_freq.setter
def ai_filter_freq(self, val):
cfunc = lib_importer.windll.DAQmxSetAIFilterFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_filter_freq.deleter
def ai_filter_freq(self):
cfunc = lib_importer.windll.DAQmxResetAIFilterFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_filter_order(self):
"""
int: Specifies the corresponding filter order and defines the
slope of the filter response.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetAIFilterOrder
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_filter_order.setter
def ai_filter_order(self, val):
cfunc = lib_importer.windll.DAQmxSetAIFilterOrder
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_filter_order.deleter
def ai_filter_order(self):
cfunc = lib_importer.windll.DAQmxResetAIFilterOrder
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_filter_response(self):
"""
:class:`nidaqmx.constants.FilterResponse`: Specifies the
corresponding filter response and defines the shape of the
filter response.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIFilterResponse
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return FilterResponse(val.value)
@ai_filter_response.setter
def ai_filter_response(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIFilterResponse
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_filter_response.deleter
def ai_filter_response(self):
cfunc = lib_importer.windll.DAQmxResetAIFilterResponse
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_force_iepe_sensor_sensitivity(self):
"""
float: Specifies the sensitivity of the IEPE force sensor
connected to the channel. Specify this value in the unit
indicated by **ai_force_iepe_sensor_sensitivity_units**.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIForceIEPESensorSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_force_iepe_sensor_sensitivity.setter
def ai_force_iepe_sensor_sensitivity(self, val):
cfunc = lib_importer.windll.DAQmxSetAIForceIEPESensorSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_force_iepe_sensor_sensitivity.deleter
def ai_force_iepe_sensor_sensitivity(self):
cfunc = lib_importer.windll.DAQmxResetAIForceIEPESensorSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_force_iepe_sensor_sensitivity_units(self):
"""
:class:`nidaqmx.constants.ForceIEPESensorSensitivityUnits`:
Specifies the units for
**ai_force_iepe_sensor_sensitivity**.
"""
val = ctypes.c_int()
cfunc = (lib_importer.windll.
DAQmxGetAIForceIEPESensorSensitivityUnits)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ForceIEPESensorSensitivityUnits(val.value)
@ai_force_iepe_sensor_sensitivity_units.setter
def ai_force_iepe_sensor_sensitivity_units(self, val):
val = val.value
cfunc = (lib_importer.windll.
DAQmxSetAIForceIEPESensorSensitivityUnits)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_force_iepe_sensor_sensitivity_units.deleter
def ai_force_iepe_sensor_sensitivity_units(self):
cfunc = (lib_importer.windll.
DAQmxResetAIForceIEPESensorSensitivityUnits)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_force_read_from_chan(self):
"""
bool: Specifies whether to read from the channel if it is a
cold-junction compensation channel. By default, DAQmx Read
does not return data from cold-junction compensation
channels. Setting this property to True forces read
operations to return the cold-junction compensation channel
data with the other channels in the task.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIForceReadFromChan
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_force_read_from_chan.setter
def ai_force_read_from_chan(self, val):
cfunc = lib_importer.windll.DAQmxSetAIForceReadFromChan
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_force_read_from_chan.deleter
def ai_force_read_from_chan(self):
cfunc = lib_importer.windll.DAQmxResetAIForceReadFromChan
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_force_units(self):
"""
:class:`nidaqmx.constants.ForceUnits`: Specifies in which unit
to return force or load measurements from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIForceUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ForceUnits(val.value)
@ai_force_units.setter
def ai_force_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIForceUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_force_units.deleter
def ai_force_units(self):
cfunc = lib_importer.windll.DAQmxResetAIForceUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_freq_hyst(self):
"""
float: Specifies in volts a window below
**ai_freq_thresh_voltage**. The input voltage must pass
below **ai_freq_thresh_voltage** minus this value before NI-
DAQmx recognizes a waveform repetition at
**ai_freq_thresh_voltage**. Hysteresis can improve the
measurement accuracy when the signal contains noise or
jitter.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIFreqHyst
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_freq_hyst.setter
def ai_freq_hyst(self, val):
cfunc = lib_importer.windll.DAQmxSetAIFreqHyst
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_freq_hyst.deleter
def ai_freq_hyst(self):
cfunc = lib_importer.windll.DAQmxResetAIFreqHyst
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_freq_thresh_voltage(self):
"""
float: Specifies the voltage level at which to recognize
waveform repetitions. You should select a voltage level that
occurs only once within the entire period of a waveform. You
also can select a voltage that occurs only once while the
voltage rises or falls.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIFreqThreshVoltage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_freq_thresh_voltage.setter
def ai_freq_thresh_voltage(self, val):
cfunc = lib_importer.windll.DAQmxSetAIFreqThreshVoltage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_freq_thresh_voltage.deleter
def ai_freq_thresh_voltage(self):
cfunc = lib_importer.windll.DAQmxResetAIFreqThreshVoltage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_freq_units(self):
"""
:class:`nidaqmx.constants.FrequencyUnits`: Specifies the units
to use to return frequency measurements from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIFreqUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return FrequencyUnits(val.value)
@ai_freq_units.setter
def ai_freq_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIFreqUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_freq_units.deleter
def ai_freq_units(self):
cfunc = lib_importer.windll.DAQmxResetAIFreqUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_gain(self):
"""
float: Specifies a gain factor to apply to the channel.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIGain
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_gain.setter
def ai_gain(self, val):
cfunc = lib_importer.windll.DAQmxSetAIGain
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_gain.deleter
def ai_gain(self):
cfunc = lib_importer.windll.DAQmxResetAIGain
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_impedance(self):
"""
:class:`nidaqmx.constants.Impedance1`: Specifies the input
impedance of the channel.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIImpedance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return Impedance1(val.value)
@ai_impedance.setter
def ai_impedance(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIImpedance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_impedance.deleter
def ai_impedance(self):
cfunc = lib_importer.windll.DAQmxResetAIImpedance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_input_limits_fault_detect_enable(self):
"""
bool: Specifies whether to enable input limits fault detection.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIInputLimitsFaultDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_input_limits_fault_detect_enable.setter
def ai_input_limits_fault_detect_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIInputLimitsFaultDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_input_limits_fault_detect_enable.deleter
def ai_input_limits_fault_detect_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIInputLimitsFaultDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_input_limits_fault_detect_lower_limit(self):
"""
float: Specifies the level of the lower limit for input limits
detection. An input sample outside the upper and lower
bounds causes a fault. Note: Fault detection applies to both
positive and negative inputs. For instance, if you specify a
lower limit of 2 mA and an upper limit of 12 mA, NI-DAQmx
detects a fault at 15 mA and -15 mA, but not at -6 mA
because it is in the range of -12 mA to -2 mA.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIInputLimitsFaultDetectLowerLimit)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_input_limits_fault_detect_lower_limit.setter
def ai_input_limits_fault_detect_lower_limit(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIInputLimitsFaultDetectLowerLimit)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_input_limits_fault_detect_lower_limit.deleter
def ai_input_limits_fault_detect_lower_limit(self):
cfunc = (lib_importer.windll.
DAQmxResetAIInputLimitsFaultDetectLowerLimit)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_input_limits_fault_detect_upper_limit(self):
"""
float: Specifies the level of the upper limit for input limits
detection. An input sample outside the upper and lower
bounds causes a fault. Note: Fault detection applies to both
positive and negative inputs. For instance, if you specify a
lower limit of 2 mA and an upper limit of 12 mA, NI-DAQmx
detects a fault at 15 mA and -15 mA, but not at -6 mA
because it is in the range of -12 mA to -2 mA.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAIInputLimitsFaultDetectUpperLimit)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_input_limits_fault_detect_upper_limit.setter
def ai_input_limits_fault_detect_upper_limit(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAIInputLimitsFaultDetectUpperLimit)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_input_limits_fault_detect_upper_limit.deleter
def ai_input_limits_fault_detect_upper_limit(self):
cfunc = (lib_importer.windll.
DAQmxResetAIInputLimitsFaultDetectUpperLimit)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_input_src(self):
"""
str: Specifies the source of the channel. You can use the signal
from the I/O connector or one of several calibration
signals. Certain devices have a single calibration signal
bus. For these devices, you must specify the same
calibration signal for all channels you connect to a
calibration signal.
"""
cfunc = lib_importer.windll.DAQmxGetAIInputSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_char_p, ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, self._name, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@ai_input_src.setter
def ai_input_src(self, val):
cfunc = lib_importer.windll.DAQmxSetAIInputSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes_byte_str]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_input_src.deleter
def ai_input_src(self):
cfunc = lib_importer.windll.DAQmxResetAIInputSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lead_wire_resistance(self):
"""
float: Specifies in ohms the resistance of the wires that lead
to the sensor.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAILeadWireResistance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_lead_wire_resistance.setter
def ai_lead_wire_resistance(self, val):
cfunc = lib_importer.windll.DAQmxSetAILeadWireResistance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lead_wire_resistance.deleter
def ai_lead_wire_resistance(self):
cfunc = lib_importer.windll.DAQmxResetAILeadWireResistance
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lossy_lsb_removal_compressed_samp_size(self):
"""
int: Specifies the number of bits to return in a raw sample when
**ai_raw_data_compression_type** is set to
**RawDataCompressionType.LOSSY_LSB_REMOVAL**.
"""
val = ctypes.c_uint()
cfunc = (lib_importer.windll.
DAQmxGetAILossyLSBRemovalCompressedSampSize)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_lossy_lsb_removal_compressed_samp_size.setter
def ai_lossy_lsb_removal_compressed_samp_size(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAILossyLSBRemovalCompressedSampSize)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lossy_lsb_removal_compressed_samp_size.deleter
def ai_lossy_lsb_removal_compressed_samp_size(self):
cfunc = (lib_importer.windll.
DAQmxResetAILossyLSBRemovalCompressedSampSize)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lowpass_cutoff_freq(self):
"""
float: Specifies the frequency in Hertz that corresponds to the
-3dB cutoff of the filter.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAILowpassCutoffFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_lowpass_cutoff_freq.setter
def ai_lowpass_cutoff_freq(self, val):
cfunc = lib_importer.windll.DAQmxSetAILowpassCutoffFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lowpass_cutoff_freq.deleter
def ai_lowpass_cutoff_freq(self):
cfunc = lib_importer.windll.DAQmxResetAILowpassCutoffFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lowpass_enable(self):
"""
bool: Specifies whether to enable the lowpass filter of the
channel.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAILowpassEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_lowpass_enable.setter
def ai_lowpass_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAILowpassEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lowpass_enable.deleter
def ai_lowpass_enable(self):
cfunc = lib_importer.windll.DAQmxResetAILowpassEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lowpass_switch_cap_clk_src(self):
"""
:class:`nidaqmx.constants.SourceSelection`: Specifies the source
of the filter clock. If you need a higher resolution for the
filter, you can supply an external clock to increase the
resolution. Refer to the SCXI-1141/1142/1143 User Manual for
more information.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAILowpassSwitchCapClkSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return SourceSelection(val.value)
@ai_lowpass_switch_cap_clk_src.setter
def ai_lowpass_switch_cap_clk_src(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAILowpassSwitchCapClkSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lowpass_switch_cap_clk_src.deleter
def ai_lowpass_switch_cap_clk_src(self):
cfunc = lib_importer.windll.DAQmxResetAILowpassSwitchCapClkSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lowpass_switch_cap_ext_clk_div(self):
"""
int: Specifies the divisor for the external clock when you set
**ai_lowpass_switch_cap_clk_src** to
**SourceSelection.EXTERNAL**. On the SCXI-1141, SCXI-1142,
and SCXI-1143, NI-DAQmx determines the filter cutoff by
using the equation f/(100*n), where f is the external
frequency, and n is the external clock divisor. Refer to the
SCXI-1141/1142/1143 User Manual for more information.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetAILowpassSwitchCapExtClkDiv
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_lowpass_switch_cap_ext_clk_div.setter
def ai_lowpass_switch_cap_ext_clk_div(self, val):
cfunc = lib_importer.windll.DAQmxSetAILowpassSwitchCapExtClkDiv
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lowpass_switch_cap_ext_clk_div.deleter
def ai_lowpass_switch_cap_ext_clk_div(self):
cfunc = lib_importer.windll.DAQmxResetAILowpassSwitchCapExtClkDiv
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lowpass_switch_cap_ext_clk_freq(self):
"""
float: Specifies the frequency of the external clock when you
set **ai_lowpass_switch_cap_clk_src** to
**SourceSelection.EXTERNAL**. NI-DAQmx uses this frequency
to set the pre- and post- filters on the SCXI-1141,
SCXI-1142, and SCXI-1143. On those devices, NI-DAQmx
determines the filter cutoff by using the equation
f/(100*n), where f is the external frequency, and n is the
external clock divisor. Refer to the SCXI-1141/1142/1143
User Manual for more information.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAILowpassSwitchCapExtClkFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_lowpass_switch_cap_ext_clk_freq.setter
def ai_lowpass_switch_cap_ext_clk_freq(self, val):
cfunc = lib_importer.windll.DAQmxSetAILowpassSwitchCapExtClkFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lowpass_switch_cap_ext_clk_freq.deleter
def ai_lowpass_switch_cap_ext_clk_freq(self):
cfunc = lib_importer.windll.DAQmxResetAILowpassSwitchCapExtClkFreq
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lowpass_switch_cap_out_clk_div(self):
"""
int: Specifies the divisor for the output clock. NI-DAQmx uses
the cutoff frequency to determine the output clock
frequency. Refer to the SCXI-1141/1142/1143 User Manual for
more information.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetAILowpassSwitchCapOutClkDiv
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_lowpass_switch_cap_out_clk_div.setter
def ai_lowpass_switch_cap_out_clk_div(self, val):
cfunc = lib_importer.windll.DAQmxSetAILowpassSwitchCapOutClkDiv
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_uint]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lowpass_switch_cap_out_clk_div.deleter
def ai_lowpass_switch_cap_out_clk_div(self):
cfunc = lib_importer.windll.DAQmxResetAILowpassSwitchCapOutClkDiv
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lvdt_sensitivity(self):
"""
float: Specifies the sensitivity of the LVDT. This value is in
the units you specify with **ai_lvdt_sensitivity_units**.
Refer to the sensor documentation to determine this value.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAILVDTSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_lvdt_sensitivity.setter
def ai_lvdt_sensitivity(self, val):
cfunc = lib_importer.windll.DAQmxSetAILVDTSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lvdt_sensitivity.deleter
def ai_lvdt_sensitivity(self):
cfunc = lib_importer.windll.DAQmxResetAILVDTSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lvdt_sensitivity_units(self):
"""
:class:`nidaqmx.constants.LVDTSensitivityUnits`: Specifies the
units of **ai_lvdt_sensitivity**.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAILVDTSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return LVDTSensitivityUnits(val.value)
@ai_lvdt_sensitivity_units.setter
def ai_lvdt_sensitivity_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAILVDTSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lvdt_sensitivity_units.deleter
def ai_lvdt_sensitivity_units(self):
cfunc = lib_importer.windll.DAQmxResetAILVDTSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_lvdt_units(self):
"""
:class:`nidaqmx.constants.LengthUnits`: Specifies the units to
use to return linear position measurements from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAILVDTUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return LengthUnits(val.value)
@ai_lvdt_units.setter
def ai_lvdt_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAILVDTUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_lvdt_units.deleter
def ai_lvdt_units(self):
cfunc = lib_importer.windll.DAQmxResetAILVDTUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_max(self):
"""
float: Specifies the maximum value you expect to measure. This
value is in the units you specify with a units property.
When you query this property, it returns the coerced maximum
value that the device can measure with the current settings.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIMax
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_max.setter
def ai_max(self, val):
cfunc = lib_importer.windll.DAQmxSetAIMax
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_max.deleter
def ai_max(self):
cfunc = lib_importer.windll.DAQmxResetAIMax
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_meas_type(self):
"""
:class:`nidaqmx.constants.UsageTypeAI`: Indicates the
measurement to take with the analog input channel and in
some cases, such as for temperature measurements, the sensor
to use.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIMeasType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return UsageTypeAI(val.value)
@property
def ai_mem_map_enable(self):
"""
bool: Specifies for NI-DAQmx to map hardware registers to the
memory space of the application, if possible. Normally, NI-
DAQmx maps hardware registers to memory accessible only to
the kernel. Mapping the registers to the memory space of the
application increases performance. However, if the
application accesses the memory space mapped to the
registers, it can adversely affect the operation of the
device and possibly result in a system crash.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIMemMapEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_mem_map_enable.setter
def ai_mem_map_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIMemMapEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_mem_map_enable.deleter
def ai_mem_map_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIMemMapEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_microphone_sensitivity(self):
"""
float: Specifies the sensitivity of the microphone. This value
is in mV/Pa. Refer to the sensor documentation to determine
this value.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIMicrophoneSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_microphone_sensitivity.setter
def ai_microphone_sensitivity(self, val):
cfunc = lib_importer.windll.DAQmxSetAIMicrophoneSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_microphone_sensitivity.deleter
def ai_microphone_sensitivity(self):
cfunc = lib_importer.windll.DAQmxResetAIMicrophoneSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_min(self):
"""
float: Specifies the minimum value you expect to measure. This
value is in the units you specify with a units property.
When you query this property, it returns the coerced minimum
value that the device can measure with the current settings.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIMin
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_min.setter
def ai_min(self, val):
cfunc = lib_importer.windll.DAQmxSetAIMin
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_min.deleter
def ai_min(self):
cfunc = lib_importer.windll.DAQmxResetAIMin
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_open_chan_detect_enable(self):
"""
bool: Specifies whether to enable open channel detection.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIOpenChanDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_open_chan_detect_enable.setter
def ai_open_chan_detect_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIOpenChanDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_open_chan_detect_enable.deleter
def ai_open_chan_detect_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIOpenChanDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_open_thrmcpl_detect_enable(self):
"""
bool: Specifies whether to apply the open thermocouple detection
bias voltage to the channel. Changing the value of this
property on a channel may require settling time before the
data returned is valid. To compensate for this settling
time, discard unsettled data or add a delay between
committing and starting the task. Refer to your device
specifications for the required settling time. When open
thermocouple detection is enabled, use
**open_thrmcpl_chans_exist** to determine if any channels
were open.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIOpenThrmcplDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_open_thrmcpl_detect_enable.setter
def ai_open_thrmcpl_detect_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIOpenThrmcplDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_open_thrmcpl_detect_enable.deleter
def ai_open_thrmcpl_detect_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIOpenThrmcplDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_overcurrent_detect_enable(self):
"""
bool: Specifies whether to enable overcurrent detection.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIOvercurrentDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_overcurrent_detect_enable.setter
def ai_overcurrent_detect_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIOvercurrentDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_overcurrent_detect_enable.deleter
def ai_overcurrent_detect_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIOvercurrentDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_power_supply_fault_detect_enable(self):
"""
bool: Specifies whether to enable power supply fault detection.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIPowerSupplyFaultDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_power_supply_fault_detect_enable.setter
def ai_power_supply_fault_detect_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAIPowerSupplyFaultDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_power_supply_fault_detect_enable.deleter
def ai_power_supply_fault_detect_enable(self):
cfunc = lib_importer.windll.DAQmxResetAIPowerSupplyFaultDetectEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_pressure_units(self):
"""
:class:`nidaqmx.constants.PressureUnits`: Specifies in which
unit to return pressure measurements from the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIPressureUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return PressureUnits(val.value)
@ai_pressure_units.setter
def ai_pressure_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIPressureUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_pressure_units.deleter
def ai_pressure_units(self):
cfunc = lib_importer.windll.DAQmxResetAIPressureUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_probe_atten(self):
"""
float: Specifies the amount of attenuation provided by the probe
connected to the channel. Specify this attenuation as a
ratio.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIProbeAtten
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_probe_atten.setter
def ai_probe_atten(self, val):
cfunc = lib_importer.windll.DAQmxSetAIProbeAtten
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_probe_atten.deleter
def ai_probe_atten(self):
cfunc = lib_importer.windll.DAQmxResetAIProbeAtten
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_raw_data_compression_type(self):
"""
:class:`nidaqmx.constants.RawDataCompressionType`: Specifies the
type of compression to apply to raw samples returned from
the device.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIRawDataCompressionType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return RawDataCompressionType(val.value)
@ai_raw_data_compression_type.setter
def ai_raw_data_compression_type(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIRawDataCompressionType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_raw_data_compression_type.deleter
def ai_raw_data_compression_type(self):
cfunc = lib_importer.windll.DAQmxResetAIRawDataCompressionType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_raw_samp_justification(self):
"""
:class:`nidaqmx.constants.DataJustification`: Indicates the
justification of a raw sample from the device.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIRawSampJustification
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return DataJustification(val.value)
@property
def ai_raw_samp_size(self):
"""
int: Indicates in bits the size of a raw sample from the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetAIRawSampSize
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ai_remove_filter_delay(self):
"""
bool: Specifies if filter delay removal is enabled on the
device.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAIRemoveFilterDelay
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_remove_filter_delay.setter
def ai_remove_filter_delay(self, val):
cfunc = lib_importer.windll.DAQmxSetAIRemoveFilterDelay
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_remove_filter_delay.deleter
def ai_remove_filter_delay(self):
cfunc = lib_importer.windll.DAQmxResetAIRemoveFilterDelay
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_resistance_cfg(self):
"""
:class:`nidaqmx.constants.ResistanceConfiguration`: Specifies
the resistance configuration for the channel. NI-DAQmx uses
this value for any resistance-based measurements, including
temperature measurement using a thermistor or RTD.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIResistanceCfg
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ResistanceConfiguration(val.value)
@ai_resistance_cfg.setter
def ai_resistance_cfg(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIResistanceCfg
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_resistance_cfg.deleter
def ai_resistance_cfg(self):
cfunc = lib_importer.windll.DAQmxResetAIResistanceCfg
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_resistance_units(self):
"""
:class:`nidaqmx.constants.ResistanceUnits`: Specifies the units
to use to return resistance measurements.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIResistanceUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ResistanceUnits(val.value)
@ai_resistance_units.setter
def ai_resistance_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIResistanceUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_resistance_units.deleter
def ai_resistance_units(self):
cfunc = lib_importer.windll.DAQmxResetAIResistanceUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_resolution(self):
"""
float: Indicates the resolution of the analog-to-digital
converter of the channel. This value is in the units you
specify with **ai_resolution_units**.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIResolution
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ai_resolution_units(self):
"""
:class:`nidaqmx.constants.ResolutionType`: Indicates the units
of **ai_resolution**.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIResolutionUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return ResolutionType(val.value)
@property
def ai_rng_high(self):
"""
float: Specifies the upper limit of the input range of the
device. This value is in the native units of the device. On
E Series devices, for example, the native units is volts.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIRngHigh
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_rng_high.setter
def ai_rng_high(self, val):
cfunc = lib_importer.windll.DAQmxSetAIRngHigh
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rng_high.deleter
def ai_rng_high(self):
cfunc = lib_importer.windll.DAQmxResetAIRngHigh
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rng_low(self):
"""
float: Specifies the lower limit of the input range of the
device. This value is in the native units of the device. On
E Series devices, for example, the native units is volts.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIRngLow
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_rng_low.setter
def ai_rng_low(self, val):
cfunc = lib_importer.windll.DAQmxSetAIRngLow
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rng_low.deleter
def ai_rng_low(self):
cfunc = lib_importer.windll.DAQmxResetAIRngLow
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rosette_strain_gage_gage_orientation(self):
"""
float: Specifies gage orientation in degrees with respect to the
X axis.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIRosetteStrainGageOrientation
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_rosette_strain_gage_gage_orientation.setter
def ai_rosette_strain_gage_gage_orientation(self, val):
cfunc = lib_importer.windll.DAQmxSetAIRosetteStrainGageOrientation
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rosette_strain_gage_gage_orientation.deleter
def ai_rosette_strain_gage_gage_orientation(self):
cfunc = lib_importer.windll.DAQmxResetAIRosetteStrainGageOrientation
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rosette_strain_gage_rosette_meas_type(self):
"""
:class:`nidaqmx.constants.StrainGageRosetteMeasurementType`:
Specifies the type of rosette measurement.
"""
val = ctypes.c_int()
cfunc = (lib_importer.windll.
DAQmxGetAIRosetteStrainGageRosetteMeasType)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return StrainGageRosetteMeasurementType(val.value)
@ai_rosette_strain_gage_rosette_meas_type.setter
def ai_rosette_strain_gage_rosette_meas_type(self, val):
val = val.value
cfunc = (lib_importer.windll.
DAQmxSetAIRosetteStrainGageRosetteMeasType)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rosette_strain_gage_rosette_meas_type.deleter
def ai_rosette_strain_gage_rosette_meas_type(self):
cfunc = (lib_importer.windll.
DAQmxResetAIRosetteStrainGageRosetteMeasType)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rosette_strain_gage_rosette_type(self):
"""
:class:`nidaqmx.constants.StrainGageRosetteType`: Indicates the
type of rosette gage.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIRosetteStrainGageRosetteType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return StrainGageRosetteType(val.value)
@property
def ai_rosette_strain_gage_strain_chans(self):
"""
List[str]: Indicates the raw strain channels that comprise the
strain rosette.
"""
cfunc = lib_importer.windll.DAQmxGetAIRosetteStrainGageStrainChans
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_char_p, ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, self._name, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return unflatten_channel_string(val.value.decode('ascii'))
@property
def ai_rtd_a(self):
"""
float: Specifies the 'A' constant of the Callendar-Van Dusen
equation. NI-DAQmx requires this value when you use a custom
RTD.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIRTDA
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_rtd_a.setter
def ai_rtd_a(self, val):
cfunc = lib_importer.windll.DAQmxSetAIRTDA
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rtd_a.deleter
def ai_rtd_a(self):
cfunc = lib_importer.windll.DAQmxResetAIRTDA
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rtd_b(self):
"""
float: Specifies the 'B' constant of the Callendar-Van Dusen
equation. NI-DAQmx requires this value when you use a custom
RTD.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIRTDB
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_rtd_b.setter
def ai_rtd_b(self, val):
cfunc = lib_importer.windll.DAQmxSetAIRTDB
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rtd_b.deleter
def ai_rtd_b(self):
cfunc = lib_importer.windll.DAQmxResetAIRTDB
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rtd_c(self):
"""
float: Specifies the 'C' constant of the Callendar-Van Dusen
equation. NI-DAQmx requires this value when you use a custom
RTD.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIRTDC
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_rtd_c.setter
def ai_rtd_c(self, val):
cfunc = lib_importer.windll.DAQmxSetAIRTDC
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rtd_c.deleter
def ai_rtd_c(self):
cfunc = lib_importer.windll.DAQmxResetAIRTDC
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rtd_r_0(self):
"""
float: Specifies in ohms the sensor resistance at 0 deg C. The
Callendar-Van Dusen equation requires this value. Refer to
the sensor documentation to determine this value.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIRTDR0
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_rtd_r_0.setter
def ai_rtd_r_0(self, val):
cfunc = lib_importer.windll.DAQmxSetAIRTDR0
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rtd_r_0.deleter
def ai_rtd_r_0(self):
cfunc = lib_importer.windll.DAQmxResetAIRTDR0
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rtd_type(self):
"""
:class:`nidaqmx.constants.RTDType`: Specifies the type of RTD
connected to the channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIRTDType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return RTDType(val.value)
@ai_rtd_type.setter
def ai_rtd_type(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIRTDType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rtd_type.deleter
def ai_rtd_type(self):
cfunc = lib_importer.windll.DAQmxResetAIRTDType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rvdt_sensitivity(self):
"""
float: Specifies the sensitivity of the RVDT. This value is in
the units you specify with **ai_rvdt_sensitivity_units**.
Refer to the sensor documentation to determine this value.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAIRVDTSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_rvdt_sensitivity.setter
def ai_rvdt_sensitivity(self, val):
cfunc = lib_importer.windll.DAQmxSetAIRVDTSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rvdt_sensitivity.deleter
def ai_rvdt_sensitivity(self):
cfunc = lib_importer.windll.DAQmxResetAIRVDTSensitivity
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rvdt_sensitivity_units(self):
"""
:class:`nidaqmx.constants.RVDTSensitivityUnits`: Specifies the
units of **ai_rvdt_sensitivity**.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIRVDTSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return RVDTSensitivityUnits(val.value)
@ai_rvdt_sensitivity_units.setter
def ai_rvdt_sensitivity_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIRVDTSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rvdt_sensitivity_units.deleter
def ai_rvdt_sensitivity_units(self):
cfunc = lib_importer.windll.DAQmxResetAIRVDTSensitivityUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_rvdt_units(self):
"""
:class:`nidaqmx.constants.AngleUnits`: Specifies the units to
use to return angular position measurements from the
channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAIRVDTUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return AngleUnits(val.value)
@ai_rvdt_units.setter
def ai_rvdt_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAIRVDTUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_rvdt_units.deleter
def ai_rvdt_units(self):
cfunc = lib_importer.windll.DAQmxResetAIRVDTUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_samp_and_hold_enable(self):
"""
bool: Specifies whether to enable the sample and hold circuitry
of the device. When you disable sample and hold circuitry, a
small voltage offset might be introduced into the signal.
You can eliminate this offset by using **ai_auto_zero_mode**
to perform an auto zero on the channel.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAISampAndHoldEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_samp_and_hold_enable.setter
def ai_samp_and_hold_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAISampAndHoldEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str, c_bool32]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_samp_and_hold_enable.deleter
def ai_samp_and_hold_enable(self):
cfunc = lib_importer.windll.DAQmxResetAISampAndHoldEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_sensor_power_cfg(self):
"""
:class:`nidaqmx.constants.SensorPowerCfg`: Specifies whether to
turn on the sensor's power supply or to leave the
configuration unchanged.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAISensorPowerCfg
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return SensorPowerCfg(val.value)
@ai_sensor_power_cfg.setter
def ai_sensor_power_cfg(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAISensorPowerCfg
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_sensor_power_cfg.deleter
def ai_sensor_power_cfg(self):
cfunc = lib_importer.windll.DAQmxResetAISensorPowerCfg
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_sensor_power_type(self):
"""
:class:`nidaqmx.constants.SensorPowerType`: Specifies the type
of power supplied to the sensor.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAISensorPowerType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return SensorPowerType(val.value)
@ai_sensor_power_type.setter
def ai_sensor_power_type(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAISensorPowerType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_sensor_power_type.deleter
def ai_sensor_power_type(self):
cfunc = lib_importer.windll.DAQmxResetAISensorPowerType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_sensor_power_voltage(self):
"""
float: Specifies the voltage level for the sensor's power
supply.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAISensorPowerVoltage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_sensor_power_voltage.setter
def ai_sensor_power_voltage(self, val):
cfunc = lib_importer.windll.DAQmxSetAISensorPowerVoltage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_sensor_power_voltage.deleter
def ai_sensor_power_voltage(self):
cfunc = lib_importer.windll.DAQmxResetAISensorPowerVoltage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_sound_pressure_max_sound_pressure_lvl(self):
"""
float: Specifies the maximum instantaneous sound pressure level
you expect to measure. This value is in decibels, referenced
to 20 micropascals. NI-DAQmx uses the maximum sound pressure
level to calculate values in pascals for **ai_max** and
**ai_min** for the channel.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAISoundPressureMaxSoundPressureLvl)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_sound_pressure_max_sound_pressure_lvl.setter
def ai_sound_pressure_max_sound_pressure_lvl(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAISoundPressureMaxSoundPressureLvl)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_double]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_sound_pressure_max_sound_pressure_lvl.deleter
def ai_sound_pressure_max_sound_pressure_lvl(self):
cfunc = (lib_importer.windll.
DAQmxResetAISoundPressureMaxSoundPressureLvl)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_sound_pressure_units(self):
"""
:class:`nidaqmx.constants.SoundPressureUnits`: Specifies the
units to use to return sound pressure measurements from the
channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAISoundPressureUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return SoundPressureUnits(val.value)
@ai_sound_pressure_units.setter
def ai_sound_pressure_units(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAISoundPressureUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int]
error_code = cfunc(
self._handle, self._name, val)
check_for_error(error_code)
@ai_sound_pressure_units.deleter
def ai_sound_pressure_units(self):
cfunc = lib_importer.windll.DAQmxResetAISoundPressureUnits
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, self._name)
check_for_error(error_code)
@property
def ai_sound_pressured_b_ref(self):
"""
float: Specifies the decibel reference level in the units of the
channel. When you read samples as a waveform, the decibel
reference level is included in the waveform attributes. NI-
DAQmx also uses the decibel reference level when converting
**ai_sound_pressure_max_sound_pressure_lvl** to a voltage
level.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAISoundPressuredBRef
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@ai_sound_pressured_b_ref.setter
def ai_sound_pressured_b_ref(self, val):
cfunc = lib_importer.windll.DAQmxSetAISoundPressuredBRef
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc