def is_global(self): """ bool: Indicates whether the channel is a global channel. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetChanIsGlobal 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
def ai_power_control_enable(self): """ bool: Specifies whether to turn on the sensor's power supply. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetPhysicalChanAIPowerControlEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def do_samp_clk_supported(self): """ bool: Indicates if the sample clock timing type is supported for the digital output physical channel. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetPhysicalChanDOSampClkSupported if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def ao_power_amp_overcurrent(self): """ bool: Indicates if the channel detected an overcurrent condition. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetAOPowerAmpOvercurrent if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def dig_edge_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetDigEdgeArmStartTrigDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._handle, ctypes.byref(val)) check_for_error(error_code) return val.value
def ao_power_amp_channel_enable(self): """ bool: Specifies whether to enable or disable a channel for amplification. This property can also be used to check if a channel is enabled. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetAOPowerAmpChannelEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def expired(self): """ bool: Indicates if the watchdog timer expired. You can read this property only while the task is running. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetWatchdogHasExpired if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._handle, ctypes.byref(val)) check_for_error(error_code) return val.value
def ao_manual_control_short_detected(self): """ bool: Indicates whether the physical channel is currently disabled due to a short detected on the channel. """ val = c_bool32() cfunc = (lib_importer.windll. DAQmxGetPhysicalChanAOManualControlShortDetected) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def allow_interactive_deletion(self): """ bool: Indicates whether the global channel can be deleted through MAX. """ val = c_bool32() cfunc = (lib_importer.windll. DAQmxGetPersistedChanAllowInteractiveDeletion) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def allow_interactive_editing(self): """ bool: Indicates whether the task can be edited in the DAQ Assistant. """ val = c_bool32() cfunc = (lib_importer.windll. DAQmxGetPersistedTaskAllowInteractiveEditing) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def ai_sensor_power_open_chan(self): """ bool: Indicates whether there is an open channel or undercurrent condition on the channel. """ val = c_bool32() cfunc = (lib_importer.windll.DAQmxGetPhysicalChanAISensorPowerOpenChan) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def di_change_detect_supported(self): """ bool: Indicates if the change detection timing type is supported for the digital input physical channel. """ val = c_bool32() cfunc = (lib_importer.windll. DAQmxGetPhysicalChanDIChangeDetectSupported) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def timestamp_enable(self): """ bool: Specifies whether the arm start trigger timestamp is enabled. If the timestamp is enabled but no resources are available, an error will be returned at run time. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetArmStartTrigTimestampEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._handle, ctypes.byref(val)) check_for_error(error_code) return val.value
def sync_unlocked_chans_exist(self): """ bool: Indicates whether the target is currently locked to the grand master. Devices may report PLL Unlock either during acquisition or after acquisition. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetWriteSyncUnlockedChansExist if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._handle, ctypes.byref(val)) check_for_error(error_code) return val.value
def do_overcurrent_auto_reenable(self): """ bool: Specifies whether to automatically reenable channels after they no longer exceed the current limit specified by **do_overcurrent_limit**. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetDOOvercurrentAutoReenable 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
def dig_edge_dig_sync_enable(self): """ bool: Specifies whether to synchronize recognition of transitions in the signal to the internal timebase of the device. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetDigEdgeArmStartTrigDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._handle, ctypes.byref(val)) check_for_error(error_code) return val.value
def do_tristate(self): """ bool: Specifies whether to stop driving the channel and set it to a high-impedance state. You must commit the task for this setting to take effect. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetDOTristate 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
def do_invert_lines(self): """ bool: Specifies whether to invert the lines in the channel. If you set this property to True, the lines are at high logic when off and at low logic when on. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetDOInvertLines 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
def is_task_done(self): """ Queries the status of the task and indicates if it completed execution. Use this function to ensure that the specified operation is complete before you stop the task. Returns: bool: Indicates if the measurement or generation completed. """ is_task_done = c_bool32() cfunc = lib_importer.windll.DAQmxIsTaskDone cfunc.argtypes = [ lib_importer.task_handle, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, ctypes.byref(is_task_done)) check_for_error(error_code) return is_task_done.value
def ao_manual_control_enable(self): """ bool: Specifies if you can control the physical channel externally via a manual control located on the device. You cannot simultaneously control a channel manually and with NI-DAQmx. """ val = c_bool32() cfunc = (lib_importer.windll. DAQmxGetPhysicalChanAOManualControlEnable) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._name, ctypes.byref(val)) check_for_error(error_code) return val.value
def do_use_only_on_brd_mem(self): """ bool: Specifies whether to write samples directly to the onboard memory of the device, bypassing the memory buffer. Generally, you cannot update onboard memory after you start the task. Onboard memory includes data FIFOs. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetDOUseOnlyOnBrdMem 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
def di_dig_fltr_enable(self): """ bool: Specifies whether to enable the digital filter for the line(s) or port(s). You can enable the filter on a line-by- line basis. You do not have to enable the filter for all lines in a channel. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetDIDigFltrEnable 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
def expir_trig_trig_on_network_conn_loss(self): """ bool: Specifies the watchdog timer behavior when the network connection is lost between the host and the chassis. If set to true, the watchdog timer expires when the chassis detects the loss of network connection. """ val = c_bool32() cfunc = (lib_importer.windll. DAQmxGetWatchdogExpirTrigTrigOnNetworkConnLoss) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, ctypes.byref(val)) check_for_error(error_code) return val.value
def overloaded_chans_exist(self): """ bool: Indicates if the device(s) detected an overload in any virtual channel in the task. Reading this property clears the overload status for all channels in the task. You must read this property before you read **overloaded_chans**. Otherwise, you will receive an error. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetWriteOverloadedChansExist if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes.POINTER(c_bool32) ] error_code = cfunc(self._handle, ctypes.byref(val)) check_for_error(error_code) return val.value
def di_tristate(self): """ bool: Specifies whether to tristate the lines in the channel. If you set this property to True, NI-DAQmx tristates the lines in the channel. If you set this property to False, NI-DAQmx does not modify the configuration of the lines even if the lines were previously tristated. Set this property to False to read lines in other tasks or to read output-only lines. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetDITristate 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
def are_configured_cdaq_sync_ports_disconnected( self, chassis_devices_ports="", timeout=WAIT_INFINITELY): """ Verifies configured cDAQ Sync connections between devices. Failures generally indicate a wiring issue or that a device has been powered off or removed. Stop all NI-DAQmx tasks running on the devices prior to running this function because any running tasks cause the verification process to fail. Args: chassis_devices_ports (Optional[str]): Specifies the names of the CompactDAQ chassis, C Series modules, or cDAQ Sync ports in comma separated form to search. If no names are specified, all cDAQ Sync ports on connected, non-simulated devices are scanned. timeout (Optional[float]): Specifies the time in seconds to wait for the device to respond before timing out. Returns: List[nidaqmx.types.CDAQSyncConnection]: Returns the port-to-port connections that failed verification. """ disconnected_ports_exist = c_bool32() cfunc = lib_importer.windll.DAQmxAreConfiguredCDAQSyncPortsDisconnected if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes_byte_str, ctypes.c_double, ctypes.POINTER(c_bool32)] error_code = cfunc( chassis_devices_ports, timeout, ctypes.byref(disconnected_ports_exist)) check_for_error(error_code) cfunc = lib_importer.windll.DAQmxGetDisconnectedCDAQSyncPorts if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ ctypes.c_char_p, ctypes.POINTER(ctypes.c_uint)] port_list_size = ctypes.c_uint() while True: size_or_code = cfunc( None, ctypes.byref(port_list_size)) if size_or_code < 0: break port_list = ctypes.create_string_buffer(size_or_code) size_or_code = cfunc( port_list, ctypes.byref(port_list_size)) if is_string_buffer_too_small(size_or_code): # Buffer size must have changed between calls; check again. continue else: break check_for_error(size_or_code) ports = unflatten_channel_string(port_list.value.decode('ascii')) output_ports = ports[::2] input_ports = ports[1::2] connections = [] for output_port, input_port in zip(output_ports, input_ports): connections.append( CDAQSyncConnection(output_port=output_port, input_port=input_port)) return connections