def rx(self, size: int = 8) -> Tuple[int, bool, bool, bytes, int]: """Receive incoming CAN bus data. Returns: Tuple[int, bool, bool, bytes, int]: A tuple (vID, extended, remote, data, status) Raises: DwfLibraryError: An error occurred while executing the operation. """ c_vID = typespec_ctypes.c_int() c_extended = typespec_ctypes.c_int() c_remote = typespec_ctypes.c_int() c_dlc = typespec_ctypes.c_int() c_data = ctypes.create_string_buffer(size) c_status = typespec_ctypes.c_int() result = self.lib.FDwfDigitalCanRx( self.hdwf, c_vID, c_extended, c_remote, c_dlc, ctypes.cast(c_data, typespec_ctypes.c_unsigned_char_ptr), size, c_status) if result != RESULT_SUCCESS: raise self.dwf.exception() vID = c_vID.value extended = bool(c_extended.value) remote = bool(c_remote.value) dlc = c_dlc.value data = c_data.value[:dlc] status = c_status.value return (vID, extended, remote, data, status)
def enableInfo(self) -> Tuple[bool, bool]: """Verify if *Master Enable* and/or *Master Enable Status* are supported. The *Master Enable* is a software switch that enable the |AnalogIO| voltage sources. If supported, the current value of this *Master Enable* switch (Enabled/Disabled) can be set by the :py:meth:`enableSet` method and queried by the :py:meth:`enableGet` method. The *Master Enable Status* that can be queried by the :py:meth:`enableStatus` method may be different from the *Master Enable* value if e.g. an over-current protection circuit has been triggered. Returns: Tuple[bool, bool]: The tuple elements indicate whether *Master Enable Set* and *Master Enable Status*, respectively, are supported by the |AnalogIO| device. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_set_supported = typespec_ctypes.c_int() c_status_supported = typespec_ctypes.c_int() result = self.lib.FDwfAnalogIOEnableInfo(self.hdwf, c_set_supported, c_status_supported) if result != RESULT_SUCCESS: raise self.dwf.exception() set_supported = bool(c_set_supported.value) status_supported = bool(c_status_supported.value) return (set_supported, status_supported)
def rx(self, rx_max: int) -> Tuple[bytes, int]: """Receive UART data or prepare for reception. Important: This method must be called with value 0 prior to receiving data, to initialize the receiver. Parameters: rx_max (int): If 0, initialize the receiver. Otherwise, receive the specified number of characters. Returns: Tuple[bytes, int]: Bytes received and parity error indication. Todo: The meaning of the parity error indication is currently unclear. This needs to be investigated. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_rx_count = typespec_ctypes.c_int() c_parity_error = typespec_ctypes.c_int() c_rx_buffer = ctypes.create_string_buffer(rx_max) result = self.lib.FDwfDigitalUartRx(self.hdwf, c_rx_buffer, rx_max, c_rx_count, c_parity_error) if result != RESULT_SUCCESS: raise self.dwf.exception() rx_count = c_rx_count.value rx_buffer = c_rx_buffer.value[:rx_count] parity_error = c_parity_error.value return (rx_buffer, parity_error)
def triggerInfo(self) -> List[DwfTriggerSource]: """Return the available trigger source options for the global trigger bus. Refer to the section on |triggering:link| for more information. The four main instruments (|AnalogIn|, |AnalogOut|, |DigitalIn|, and |DigitalOut|) can be configured to start their operation (data acquisition for the *In* instruments; signal generation for the *Out* instruments) immediately after some event happens. This is called *triggering*. Each of the instruments can be configured independently to use any of the trigger sources available inside the device. This method returns a list of all trigger sources that are available to each of the instruments. Returns: List[DwfTriggerSource]: A list of available trigger sources. Raises: DwfLibraryError: The list of supported trigger sources cannot be retrieved. """ c_trigger_source_bitset = typespec_ctypes.c_int() result = self.lib.FDwfDeviceTriggerInfo(self.hdwf, c_trigger_source_bitset) if result != RESULT_SUCCESS: raise self.dwf.exception() trigger_source_bitset = c_trigger_source_bitset.value trigger_source_list = [ trigger_source for trigger_source in DwfTriggerSource if trigger_source_bitset & (1 << trigger_source.value) ] return trigger_source_list
def paramGet(self, device_parameter: DwfDeviceParameter) -> int: """Return a default device parameter value. Device parameters are settings of a specific |DwfDevice|. Refer to the |device parameters:link| section for more information. This method retrieves device parameter values at the library level (i.e., not tied to a specific device). They are used as default device parameter values for devices that are opened subsequently. See Also: To get the parameter value of a specific |DwfDevice|, use the :py:meth:`DwfDevice.paramGet <pydwf.core.DwfDevice.paramGet>` method. Parameters: device_parameter (DwfParameter): The device parameter for which to get the value. Returns: int: The retrieved device parameter value. Raises: DwfLibraryError: The device parameter value cannot be retrieved. """ c_value = typespec_ctypes.c_int() result = self._lib.FDwfParamGet(device_parameter.value, c_value) if result != RESULT_SUCCESS: raise self.exception() value = c_value.value return value
def enumerateDevices(self, enum_filter: Optional[DwfEnumFilter] = None) -> int: """Build an internal list of available Digilent Waveforms devices and return the count of devices found. This method must be called before using other |DeviceEnumeration| methods described below, because they obtain information about the enumerated devices from the internal device list that is built by this method. Note: This method can take several seconds to complete. Parameters: enum_filter (Optional[DwfEnumFilter]): Specify which devices to enumerate. If None, enumerate all devices. Returns: int: The number of Digilent Waveforms devices detected. Raises: DwfLibraryError: The Digilent Waveforms devices cannot be enumerated. """ if enum_filter is None: enum_filter = DwfEnumFilter.All c_device_count = typespec_ctypes.c_int() result = self.lib.FDwfEnum(enum_filter.value, c_device_count) if result != RESULT_SUCCESS: raise self.dwf.exception() device_count = c_device_count.value return device_count
def analogInBufferSize(self, device_index: int) -> int: """Retrieve the analog input buffer size of the selected Digilent Waveforms device. Warning: **This method is obsolete.** Use either of the following instead: * method :py:meth:`configInfo` to obtain the |DwfEnumConfigInfo.AnalogInBufferSize:link| configuration value; * |AnalogIn.bufferSizeGet:link| Parameters: device_index (int): Zero-based index of the previously enumerated Digilent Waveforms device (see the :py:meth:`enumerateDevices` method). Returns: int: The analog input buffer size of the selected Digilent Waveforms device. Raises: DwfLibraryError: The analog-in buffer size of the Digilent Waveforms device cannot be retrieved. """ c_buffer_size = typespec_ctypes.c_int() result = self.lib.FDwfEnumAnalogInBufferSize(device_index, c_buffer_size) if result != RESULT_SUCCESS: raise self.dwf.exception() buffer_size = c_buffer_size.value return buffer_size
def channelNodeSetInfo(self, channel_index: int, node_index: int) -> Tuple[float, float, int]: """Return the limits of the value that can be assigned to the specified |AnalogIO| channel node. Since a node can represent many things (power supply, temperature sensor, etc.), the *minimum*, *maximum*, and *steps* parameters also represent different types of values. The :py:meth:`channelNodeInfo` method returns the type of values to expect and the :py:meth:`channelNodeName` method returns the units of these values. Parameters: channel_index (int): The channel from which we want to get the currently configured value. node_index (int): The node from which we want to get the currently configured value. Returns: Tuple[float, float, int]: The minimum and maximum values for the specified node's value, and the number of resolution steps. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_min_value = typespec_ctypes.c_double() c_max_value = typespec_ctypes.c_double() c_num_steps = typespec_ctypes.c_int() result = self.lib.FDwfAnalogIOChannelNodeSetInfo( self.hdwf, channel_index, node_index, c_min_value, c_max_value, c_num_steps) if result != RESULT_SUCCESS: raise self.dwf.exception() min_value = c_min_value.value max_value = c_max_value.value num_steps = c_num_steps.value return (min_value, max_value, num_steps)
def channelNodeStatusInfo(self, channel_index: int, node_index: int) -> Tuple[float, float, int]: """Return the range of status values for the specified |AnalogIO| channel node. Parameters: channel_index (int): The channel from which we want to get status information. node_index (int): The node from which we want to get status information. Returns: Tuple[float, float, int]: The minimum and maximum status values for the specified node, and the number of resolution steps. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_min_value = typespec_ctypes.c_double() c_max_value = typespec_ctypes.c_double() c_num_steps = typespec_ctypes.c_int() result = self.lib.FDwfAnalogIOChannelNodeStatusInfo( self.hdwf, channel_index, node_index, c_min_value, c_max_value, c_num_steps) if result != RESULT_SUCCESS: raise self.dwf.exception() min_value = c_min_value.value max_value = c_max_value.value num_steps = c_num_steps.value return (min_value, max_value, num_steps)
def write(self, address: int, tx: List[int]) -> int: """Perform an I²C write operation. Parameters: address (int): The I²C address of the target device. tx (List[int]): The octets to send. Returns: int: The NAK indication. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_nak = typespec_ctypes.c_int() tx_list = list(tx) number_of_words = len(tx_list) buffer_type = typespec_ctypes.c_unsigned_char * number_of_words tx_buffer = buffer_type(*tx_list) result = self.lib.FDwfDigitalI2cWrite(self.hdwf, address, tx_buffer, number_of_words, c_nak) if result != RESULT_SUCCESS: raise self.dwf.exception() nak = c_nak.value return nak
def read(self, address: int, number_of_words: int) -> Tuple[int, List[int]]: """Perform an I²C read operation. Parameters: address (int): The I²C address of the target device. number_of_words (int): The number of octets to receive. Returns: Tuple[int, List[int]: The first element is the NAK indication; the second element is a list of octet values received. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_nak = typespec_ctypes.c_int() buffer_type = typespec_ctypes.c_unsigned_char * number_of_words rx_buffer = buffer_type() result = self.lib.FDwfDigitalI2cRead(self.hdwf, address, rx_buffer, number_of_words, c_nak) if result != RESULT_SUCCESS: raise self.dwf.exception() nak = c_nak.value rx_list = list(rx_buffer) return (nak, rx_list)
def repeatTriggerGet(self) -> bool: """Get if each |DigitalOut| pulse sequence run should wait for its own trigger. Returns: bool: If True, not only the first, both also every successive run of the pulse output sequence will wait until it receives a trigger. """ c_repeat_trigger = typespec_ctypes.c_int() result = self.lib.FDwfDigitalOutRepeatTriggerGet(self.hdwf, c_repeat_trigger) if result != RESULT_SUCCESS: raise self.dwf.exception() repeat_trigger_flag = bool(c_repeat_trigger.value) return repeat_trigger_flag
def sampleFormatGet(self) -> int: """Get the |DigitalIn| sample format (number of bits). Returns: int: The currently configured number of bits per sample (8, 16, or 32). Raises: DwfLibraryError: An error occurred while executing the operation. """ c_num_bits = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInSampleFormatGet(self.hdwf, c_num_bits) if result != RESULT_SUCCESS: raise self.dwf.exception() num_bits = c_num_bits.value return num_bits
def bitsInfo(self) -> int: """Get the number of |DigitalIn| bits. Returns: The number of digital input bits available. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_num_bits = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInBitsInfo(self.hdwf, c_num_bits) if result != RESULT_SUCCESS: raise self.dwf.exception() num_bits = c_num_bits.value return num_bits
def statusRecord(self) -> Tuple[int, int, int]: """Get the recording status. Returns: Tuple[int, int, int]: A three-element tuple containing the counts for *available*, *lost*, and *corrupt* data samples, in that order. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_data_available = typespec_ctypes.c_int() c_data_lost = typespec_ctypes.c_int() c_data_corrupt = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInStatusRecord( self.hdwf, c_data_available, c_data_lost, c_data_corrupt) if result != RESULT_SUCCESS: raise self.dwf.exception() data_free = c_data_available.value data_lost = c_data_lost.value data_corrupt = c_data_corrupt.value return (data_free, data_lost, data_corrupt)
def statusSamplesValid(self) -> int: """Retrieve the number of valid/acquired data samples. Returns: int: The number of valid samples. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_samples_valid = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInStatusSamplesValid(self.hdwf, c_samples_valid) if result != RESULT_SUCCESS: raise self.dwf.exception() samples_valid = c_samples_valid.value return samples_valid
def statusAutoTriggered(self) -> bool: """Check if the current acquisition is auto-triggered. Returns: bool: True if the current acquisition is auto-triggered, False otherwise. Raises: DwfLibraryError: An error occurred while retrieving the auto-triggered status. """ c_auto_triggered = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInStatusAutoTriggered(self.hdwf, c_auto_triggered) if result != RESULT_SUCCESS: raise self.dwf.exception() auto_triggered = bool(c_auto_triggered.value) return auto_triggered
def enableGet(self) -> bool: """Return the current value of the *Master Enable* setting. Returns: The value of the *Master Enable* setting. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_master_enable = typespec_ctypes.c_int() result = self.lib.FDwfAnalogIOEnableGet(self.hdwf, c_master_enable) if result != RESULT_SUCCESS: raise self.dwf.exception() master_enable = bool(c_master_enable.value) return master_enable
def bufferSizeGet(self) -> int: """Get the |DigitalIn| instrument buffer size. Returns: int: The currently configured buffer size. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_buffer_size = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInBufferSizeGet(self.hdwf, c_buffer_size) if result != RESULT_SUCCESS: raise self.dwf.exception() buffer_size = c_buffer_size.value return buffer_size
def channelCount(self) -> int: """Return the number of |AnalogIO| channels available on the device. Returns: int: The number of |AnalogIO| channels. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_channel_count = typespec_ctypes.c_int() result = self.lib.FDwfAnalogIOChannelCount(self.hdwf, c_channel_count) if result != RESULT_SUCCESS: raise self.dwf.exception() channel_count = c_channel_count.value return channel_count
def count(self) -> int: """Get the |DigitalOut| instrument channel (digital pin) count. Returns: int: The number of digital output channels. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_channel_count = typespec_ctypes.c_int() result = self.lib.FDwfDigitalOutCount(self.hdwf, c_channel_count) if result != RESULT_SUCCESS: raise self.dwf.exception() channel_count = c_channel_count.value return channel_count
def typeInfo(self, channel_index: int) -> List[DwfDigitalOutType]: """Get valid |DigitalOut| output signal types. Returns: List[DwfDigitalOutType]: A list of valid digital output types. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_type_bitset = typespec_ctypes.c_int() result = self.lib.FDwfDigitalOutTypeInfo(self.hdwf, channel_index, c_type_bitset) if result != RESULT_SUCCESS: raise self.dwf.exception() type_bitset = c_type_bitset.value type_list = [type_ for type_ in DwfDigitalOutType if type_bitset & (1 << type_.value)] return type_list
def idleInfo(self, channel_index: int) -> List[DwfDigitalOutIdle]: """Get valid |DigitalOut| idle output values. Returns: List[DwfDigitalOutIdle]: A list of valid idle output values. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_idle_bitset = typespec_ctypes.c_int() result = self.lib.FDwfDigitalOutIdleInfo(self.hdwf, channel_index, c_idle_bitset) if result != RESULT_SUCCESS: raise self.dwf.exception() idle_bitset = c_idle_bitset.value idle_list = [idle for idle in DwfDigitalOutIdle if idle_bitset & (1 << idle.value)] return idle_list
def outputInfo(self, channel_index: int) -> List[DwfDigitalOutOutput]: """Get valid |DigitalOut| output choices (e.g. Push/Pull, tristate). Returns: List[DwfDigitalOutOutput]: A list of valid output settings. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_output_bitset = typespec_ctypes.c_int() result = self.lib.FDwfDigitalOutOutputInfo(self.hdwf, channel_index, c_output_bitset) if result != RESULT_SUCCESS: raise self.dwf.exception() output_bitset = c_output_bitset.value output_list = [output for output in DwfDigitalOutOutput if output_bitset & (1 << output.value)] return output_list
def statusSamplesLeft(self) -> int: """Retrieve the number of samples left in the acquisition, in samples. Returns: int: In case a finite-duration acquisition is active, the number of samples remaining to be acquired in the acquisition. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_samplesLeft = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInStatusSamplesLeft(self.hdwf, c_samplesLeft) if result != RESULT_SUCCESS: raise self.dwf.exception() samplesLeft = c_samplesLeft.value return samplesLeft
def acquisitionModeInfo(self) -> List[DwfAcquisitionMode]: """Get the valid |DigitalIn| acquisition modes. Returns: List[DwfAcquisitionMode]: A list of valid acquisition modes. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_acquisition_mode_bitset = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInAcquisitionModeInfo(self.hdwf, c_acquisition_mode_bitset) if result != RESULT_SUCCESS: raise self.dwf.exception() acquisition_mode_bitset = c_acquisition_mode_bitset.value acquisition_mode_list = [acquisition_mode for acquisition_mode in DwfAcquisitionMode if acquisition_mode_bitset & (1 << acquisition_mode.value)] return acquisition_mode_list
def clockSourceInfo(self) -> List[DwfDigitalInClockSource]: """Get the valid clock sources for the |DigitalIn| instrument. Returns: List[DwfDigitalInClockSource]: A list of valid clock sources. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_clock_source_bitset = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInClockSourceInfo(self.hdwf, c_clock_source_bitset) if result != RESULT_SUCCESS: raise self.dwf.exception() clock_source_bitset = c_clock_source_bitset.value clock_source_list = [clock_source for clock_source in DwfDigitalInClockSource if clock_source_bitset & (1 << clock_source.value)] return clock_source_list
def sampleModeInfo(self) -> List[DwfDigitalInSampleMode]: """Get the valid |DigitalIn| instrument sample modes. Returns: List[DwfDigitalInSampleMode]: A list of valid sample modes. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_sample_mode_bitset = typespec_ctypes.c_int() result = self.lib.FDwfDigitalInSampleModeInfo(self.hdwf, c_sample_mode_bitset) if result != RESULT_SUCCESS: raise self.dwf.exception() sample_mode_bitset = c_sample_mode_bitset.value sample_mode_list = [sample_mode for sample_mode in DwfDigitalInSampleMode if sample_mode_bitset & (1 << sample_mode.value)] return sample_mode_list
def periodGet(self) -> int: """Get the |AnalogImpedance| measurement period. Todo: Figure out what this setting is for, why it's an *int*, and what its physical unit is. Returns: int: The measurement period. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_period = typespec_ctypes.c_int() result = self.lib.FDwfAnalogImpedancePeriodGet(self.hdwf, c_period) if result != RESULT_SUCCESS: raise self.dwf.exception() period = c_period.value return period
def enableGet(self, channel_index: int) -> bool: """Check if a specific |DigitalOut| channel (pin) is enabled for output. Parameters: channel_index (int): The digital pin. Returns: bool: Whether the digital pin is enabled as an output. Raises: DwfLibraryError: An error occurred while executing the operation. """ c_enable_flag = typespec_ctypes.c_int() result = self.lib.FDwfDigitalOutEnableGet(self.hdwf, channel_index, c_enable_flag) if result != RESULT_SUCCESS: raise self.dwf.exception() enable_flag = bool(c_enable_flag.value) return enable_flag