def run_example():
# By default, the example detects and displays all available devices and
# selects the first device listed. Use the dev_id_list variable to filter
# detected devices by device ID (see UL documentation for device IDs).
# If use_device_detection is set to False, the board_num variable needs to
# match the desired board number configured with Instacal.
use_device_detection = True
dev_id_list = []
board_num = 0
try:
if use_device_detection:
config_first_detected_device(board_num, dev_id_list)
daq_dev_info = DaqDeviceInfo(board_num)
if not daq_dev_info.supports_digital_io:
raise Exception('Error: The DAQ device does not support '
'digital I/O')
print('\nActive DAQ device: ',
daq_dev_info.product_name,
' (',
daq_dev_info.unique_id,
')\n',
sep='')
dio_info = daq_dev_info.get_dio_info()
# Find the first port that supports input, defaulting to None
# if one is not found.
port = next(
(port for port in dio_info.port_info if port.supports_output),
None)
if not port:
raise Exception('Error: The DAQ device does not support '
'digital output')
# If the port is configurable, configure it for output.
if port.is_port_configurable:
ul.d_config_port(board_num, port.type, DigitalIODirection.OUT)
port_value = 0xFF
print('Setting', port.type.name, 'to', port_value)
# Output the value to the port
ul.d_out(board_num, port.type, port_value)
bit_num = 0
bit_value = 0
print('Setting', port.type.name, 'bit', bit_num, 'to', bit_value)
# Output the value to the bit
ul.d_bit_out(board_num, port.type, bit_num, bit_value)
except Exception as e:
print('\n', e)
finally:
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
board_num = 0
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device(board_num):
print("Could not find device.")
return
channel = 0
ao_props = AnalogOutputProps(board_num)
if ao_props.num_chans < 1:
util.print_unsupported_example(board_num)
return
ao_range = ao_props.available_ranges[0]
data_value = ao_range.range_max / 2
try:
print("Outputting " + str(data_value) + " Volts to channel " +
str(channel) + ".")
# Send the value to the device (optional parameter omitted)
ul.v_out(board_num, channel, ao_range, data_value)
except ULError as e:
util.print_ul_error(e)
finally:
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
# By default, the example detects and displays all available devices and
# selects the first device listed. Use the dev_id_list variable to filter
# detected devices by device ID (see UL documentation for device IDs).
# If use_device_detection is set to False, the board_num variable needs to
# match the desired board number configured with Instacal.
use_device_detection = True
dev_id_list = []
board_num = 0
try:
if use_device_detection:
config_first_detected_device(board_num, dev_id_list)
daq_dev_info = DaqDeviceInfo(board_num)
if not daq_dev_info.supports_counters:
raise Exception('Error: The DAQ device does not support counters')
print('\nActive DAQ device: ',
daq_dev_info.product_name,
' (',
daq_dev_info.unique_id,
')\n',
sep='')
ctr_info = daq_dev_info.get_ctr_info()
# Use the first counter channel on the board (some boards start channel
# numbering at 1 instead of 0, the CtrInfo class is used here to find
# the first one).
counter_num = ctr_info.chan_info[0].channel_num
ul.c_clear(board_num, counter_num)
print('Please enter CTRL + C to terminate the process\n')
try:
while True:
try:
# Read and display the data.
counter_value = ul.c_in_32(board_num, counter_num)
print('\r Counter ',
counter_num,
':',
str(counter_value).rjust(12),
sep='',
end='')
stdout.flush()
sleep(0.1)
except (ValueError, NameError, SyntaxError):
break
except KeyboardInterrupt:
pass
except Exception as e:
print('\n', e)
finally:
if use_device_detection:
ul.release_daq_device(board_num)
def configure(self): if not hasattr(self, 'board_num'): #incase an old session is running: ul.release_daq_device(0) #initialization vals board_num = 0 ul_range = ULRange.BIP10VOLTS ul.set_trigger(board_num, TrigType.TRIG_POS_EDGE, 2000, 2000) self.board_num = board_num self.ul_range = ul_range return
def run_example():
board_num = 0
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device(board_num):
print("Could not find device.")
return
ctr_props = CounterProps(board_num)
# Find a pulse timer channel on the board
first_chan = next(
(channel for channel in ctr_props.counter_info
if channel.type == CounterChannelType.CTRPULSE), None)
if first_chan == None:
util.print_unsupported_example(board_num)
return
timer_num = first_chan.channel_num
frequency = 100
duty_cycle = 0.5
try:
# Start the pulse timer output (optional parameters omitted)
actual_frequency, actual_duty_cycle, _ = ul.pulse_out_start(
board_num, timer_num, frequency, duty_cycle)
# Print information about the output
print(
"Outputting " + str(actual_frequency)
+ " Hz with a duty cycle of " + str(actual_duty_cycle)
+ " to pulse timer channel " + str(timer_num) + ".")
# Wait for 5 seconds
time.sleep(5)
# Stop the pulse timer output
ul.pulse_out_stop(board_num, timer_num)
print("Timer output stopped.")
except ULError as e:
util.print_ul_error(e)
finally:
if use_device_detection:
ul.release_daq_device(board_num)
def selected_device_changed(self, *args):
selected_index = self.devices_combobox.current()
inventory_count = len(self.inventory)
if self.device_created:
ul.release_daq_device(self.board_num)
self.device_created = False
if inventory_count > 0 and selected_index < inventory_count:
descriptor = self.inventory[selected_index]
self.device_id_label["text"] = descriptor.unique_id
ul.create_daq_device(self.board_num, descriptor)
self.device_created = True
def run_example():
# By default, the example detects and displays all available devices and
# selects the first device listed. Use the dev_id_list variable to filter
# detected devices by device ID (see UL documentation for device IDs).
# If use_device_detection is set to False, the board_num variable needs to
# match the desired board number configured with Instacal.
use_device_detection = True
dev_id_list = []
board_num = 0
try:
if use_device_detection:
config_first_detected_device(board_num, dev_id_list)
daq_dev_info = DaqDeviceInfo(board_num)
if not daq_dev_info.supports_analog_input:
raise Exception('Error: The DAQ device does not support '
'analog input')
print('\nActive DAQ device: ',
daq_dev_info.product_name,
' (',
daq_dev_info.unique_id,
')\n',
sep='')
ai_info = daq_dev_info.get_ai_info()
if ai_info.num_temp_chans <= 0:
raise Exception('Error: The DAQ device does not support '
'temperature input')
channel = 0
# Get the value from the device (optional parameters omitted)
value = ul.t_in(board_num, channel, TempScale.CELSIUS)
# Display the value
print('Channel', channel, 'Value (deg C):', value)
except Exception as e:
print('\n', e)
finally:
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
board_num = 0
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device(board_num):
print("Could not find device.")
return
channel = 0
ai_props = AnalogInputProps(board_num)
if ai_props.num_ai_chans < 1:
util.print_unsupported_example(board_num)
return
ai_range = ai_props.available_ranges[0]
try:
# Get a value from the device
if ai_props.resolution <= 16:
# Use the a_in method for devices with a resolution <= 16
value = ul.a_in(board_num, channel, ai_range)
# Convert the raw value to engineering units
eng_units_value = ul.to_eng_units(board_num, ai_range, value)
else:
# Use the a_in_32 method for devices with a resolution > 16
# (optional parameter omitted)
value = ul.a_in_32(board_num, channel, ai_range)
# Convert the raw value to engineering units
eng_units_value = ul.to_eng_units_32(board_num, ai_range, value)
# Display the raw value
print("Raw Value: " + str(value))
# Display the engineering value
print("Engineering Value: " + '{:.3f}'.format(eng_units_value))
except ULError as e:
util.print_ul_error(e)
finally:
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
board_num = 0
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device(board_num):
print("Could not find device.")
return
digital_props = DigitalProps(board_num)
# Find the first port that supports input, defaulting to None
# if one is not found.
port = next(
(port for port in digital_props.port_info if port.supports_input),
None)
if port == None:
util.print_unsupported_example(board_num)
return
try:
# If the port is configurable, configure it for input.
if port.is_port_configurable:
ul.d_config_port(board_num, port.type, DigitalIODirection.IN)
# Get a value from the digital port
port_value = ul.d_in(board_num, port.type)
# Get a value from the first digital bit
bit_num = 0
bit_value = ul.d_bit_in(board_num, port.type, bit_num)
# Display the port value
print(port.type.name + " Value: " + str(port_value))
# Display the bit value
print("Bit " + str(bit_num) + " Value: " + str(bit_value))
except ULError as e:
util.print_ul_error(e)
finally:
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
# By default, the example detects and displays all available devices and
# selects the first device listed. Use the dev_id_list variable to filter
# detected devices by device ID (see UL documentation for device IDs).
# If use_device_detection is set to False, the board_num variable needs to
# match the desired board number configured with Instacal.
use_device_detection = True
dev_id_list = []
board_num = 0
try:
if use_device_detection:
config_first_detected_device(board_num, dev_id_list)
daq_dev_info = DaqDeviceInfo(board_num)
if not daq_dev_info.supports_analog_output:
raise Exception('Error: The DAQ device does not support '
'analog output')
print('\nActive DAQ device: ',
daq_dev_info.product_name,
' (',
daq_dev_info.unique_id,
')\n',
sep='')
ao_info = daq_dev_info.get_ao_info()
ao_range = ao_info.supported_ranges[0]
channel = 0
data_value = ao_range.range_max / 2
print('Outputting', data_value, 'Volts to channel', channel)
# Send the value to the device (optional parameter omitted)
ul.v_out(board_num, channel, ao_range, data_value)
except Exception as e:
print('\n', e)
finally:
if use_device_detection:
ul.release_daq_device(board_num)
def selected_device_changed(self, *args): # @UnusedVariable
selected_index = self.devices_combobox.current()
inventory_count = len(self.inventory)
if self.device_created:
# Release any previously configured DAQ device from the UL.
ul.release_daq_device(self.board_num)
self.device_created = False
if inventory_count > 0 and selected_index < inventory_count:
descriptor = self.inventory[selected_index]
# Update the device ID label
self.device_id_label["text"] = descriptor.unique_id
# Create the DAQ device from the descriptor
# For performance reasons, it is not recommended to create
# and release the device every time hardware communication is
# required. Instead, create the device once and do not release
# it until no additional library calls will be made for this
# device
ul.create_daq_device(self.board_num, descriptor)
self.device_created = True
def run():
DaqDeviceScan(master=tk.Tk()).mainloop()
board_num = 0
rate = 1000
points_per_channel = 30
if use_device_detection:
ul.ignore_instacal()
if not configDevice(board_num):
print("Gerät konnte nicht gefunden werden!")
return
ai_props = aiProps(board_num)
low_channel = 0
high_channel = min(7, ai_props.num_ai_chans - 1)
num_channels = high_channel - low_channel + 1
total_amount = points_per_channel * num_channels
ai_range = ai_props.available_ranges[0]
scan_opt = ScanOptions.FOREGROUND
if ScanOptions.SCALEDATA in ai_props.supported_scan_options:
scan_opt |= ScanOptions.SCALEDATA
memhandle = ul.scaled_win_buf_alloc(total_amount)
c_array = memhandle_as_ctypes_array_scaled(memhandle)
elif ai_props.resolution <= 16:
memhandle = ul.win_buf_alloc(total_amount)
c_array = memhandle_as_ctypes_array(memhandle)
else: memhandle = ul.win_buf_alloc_32(memhandle)
if not memhandle:
print("Speicher konnte nicht allokiert werden")
restart = False
try:
wr = csv.writer(open("test5.csv","w"),delimiter=";")
ul.a_in_scan(board_num, low_channel, high_channel, total_amount, rate, ai_range, memhandle, scan_opt)
print("Scan erfolgreich!")
print("Daten: ")
test = ul.a_in_32(board_num, 0, ai_range, scan_opt)
test = ul.to_eng_units_32(board_num, ai_range, test)
print("test value:")
print(test)
row_format = "{:>5}" + "{:>10}" * num_channels
labels = []
labels.append("Index")
for ch_num in range(low_channel, high_channel + 1):
labels.append("CH" + str(ch_num))
print(row_format.format(*labels))
data_index = 0
for index in range(points_per_channel):
display_data = [index]
for _ in range(num_channels):
if ScanOptions.SCALEDATA in scan_opt:
eng_value = c_array[data_index]
else:
eng_value = ul.to_eng_units(
board_num, ai_range, c_array[data_index])
data_index += 1
display_data.append('{:.3f}'.format(eng_value))
wr.writerow(display_data)
print(row_format.format(*display_data))
except ULError as e:
pass
finally:
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
board_num = 0
rate = 100
points_per_channel = 10
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device(board_num):
print("Could not find device.")
return
ai_props = AnalogInputProps(board_num)
if ai_props.num_ai_chans < 1:
util.print_unsupported_example(board_num)
return
low_chan = 0
high_chan = min(3, ai_props.num_ai_chans - 1)
num_chans = high_chan - low_chan + 1
total_count = points_per_channel * num_chans
ai_range = ai_props.available_ranges[0]
scan_options = ScanOptions.FOREGROUND
if ScanOptions.SCALEDATA in ai_props.supported_scan_options:
# If the hardware supports the SCALEDATA option, it is easiest to
# use it.
scan_options |= ScanOptions.SCALEDATA
memhandle = ul.scaled_win_buf_alloc(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array_scaled method for scaled
# buffers.
ctypes_array = util.memhandle_as_ctypes_array_scaled(memhandle)
elif ai_props.resolution <= 16:
# Use the win_buf_alloc method for devices with a resolution <= 16
memhandle = ul.win_buf_alloc(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array method for devices with a
# resolution <= 16.
ctypes_array = util.memhandle_as_ctypes_array(memhandle)
else:
# Use the win_buf_alloc_32 method for devices with a resolution > 16
memhandle = ul.win_buf_alloc_32(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array_32 method for devices with a
# resolution > 16
ctypes_array = util.memhandle_as_ctypes_array_32(memhandle)
# Note: the ctypes array will no longer be valid after win_buf_free is
# called.
# A copy of the buffer can be created using win_buf_to_array or
# win_buf_to_array_32 before the memory is freed. The copy can be used
# at any time.
# Check if the buffer was successfully allocated
if not memhandle:
print("Failed to allocate memory.")
return
try:
# Start the scan
ul.a_in_scan(board_num, low_chan, high_chan, total_count, rate,
ai_range, memhandle, scan_options)
print("Scan completed successfully. Data:")
# Create a format string that aligns the data in columns
row_format = "{:>5}" + "{:>10}" * num_chans
# Print the channel name headers
labels = []
labels.append("Index")
for ch_num in range(low_chan, high_chan + 1):
labels.append("CH" + str(ch_num))
print(row_format.format(*labels))
# Print the data
data_index = 0
for index in range(points_per_channel):
display_data = [index]
for _ in range(num_chans):
if ScanOptions.SCALEDATA in scan_options:
# If the SCALEDATA ScanOption was used, the values
# in the array are already in engineering units.
eng_value = ctypes_array[data_index]
else:
# If the SCALEDATA ScanOption was NOT used, the
# values in the array must be converted to
# engineering units using ul.to_eng_units().
eng_value = ul.to_eng_units(board_num, ai_range,
ctypes_array[data_index])
data_index += 1
display_data.append('{:.3f}'.format(eng_value))
# Print this row
print(row_format.format(*display_data))
except ULError as e:
util.print_ul_error(e)
finally:
# Free the buffer in a finally block to prevent errors from causing
# a memory leak.
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
board_num = 0
rate = 100
points_per_channel = 1000
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device(board_num):
print("Could not find device.")
return
ai_props = AnalogInputProps(board_num)
if ai_props.num_ai_chans < 1:
util.print_unsupported_example(board_num)
return
low_chan = 0
high_chan = min(3, ai_props.num_ai_chans - 1)
num_chans = high_chan - low_chan + 1
total_count = points_per_channel * num_chans
ai_range = ai_props.available_ranges[0]
scan_options = ScanOptions.BACKGROUND
if ScanOptions.SCALEDATA in ai_props.supported_scan_options:
# If the hardware supports the SCALEDATA option, it is easiest to
# use it.
scan_options |= ScanOptions.SCALEDATA
memhandle = ul.scaled_win_buf_alloc(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array_scaled method for scaled
# buffers.
ctypes_array = util.memhandle_as_ctypes_array_scaled(memhandle)
elif ai_props.resolution <= 16:
# Use the win_buf_alloc method for devices with a resolution <= 16
memhandle = ul.win_buf_alloc(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array method for devices with a
# resolution <= 16.
ctypes_array = util.memhandle_as_ctypes_array(memhandle)
else:
# Use the win_buf_alloc_32 method for devices with a resolution > 16
memhandle = ul.win_buf_alloc_32(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array_32 method for devices with a
# resolution > 16
ctypes_array = util.memhandle_as_ctypes_array_32(memhandle)
# Note: the ctypes array will no longer be valid after win_buf_free is
# called.
# A copy of the buffer can be created using win_buf_to_array or
# win_buf_to_array_32 before the memory is freed. The copy can be used
# at any time.
# Check if the buffer was successfully allocated
if not memhandle:
print("Failed to allocate memory.")
return
try:
# Start the scan
ul.a_in_scan(board_num, low_chan, high_chan, total_count, rate,
ai_range, memhandle, scan_options)
# Create a format string that aligns the data in columns
row_format = "{:>12}" * num_chans
# Print the channel name headers
labels = []
for ch_num in range(low_chan, high_chan + 1):
labels.append("CH" + str(ch_num))
print(row_format.format(*labels))
# Start updating the displayed values
status, curr_count, curr_index = ul.get_status(board_num,
FunctionType.AIFUNCTION)
while status != Status.IDLE:
# Make sure a data point is available for display.
if curr_count > 0:
# curr_index points to the start of the last completed
# channel scan that was transferred between the board and
# the data buffer. Display the latest value for each
# channel.
display_data = []
for data_index in range(curr_index, curr_index + num_chans):
if ScanOptions.SCALEDATA in scan_options:
# If the SCALEDATA ScanOption was used, the values
# in the array are already in engineering units.
eng_value = ctypes_array[data_index]
else:
# If the SCALEDATA ScanOption was NOT used, the
# values in the array must be converted to
# engineering units using ul.to_eng_units().
eng_value = ul.to_eng_units(board_num, ai_range,
ctypes_array[data_index])
display_data.append('{:.3f}'.format(eng_value))
print(row_format.format(*display_data))
# Wait a while before adding more values to the display.
time.sleep(0.5)
status, curr_count, curr_index = ul.get_status(
board_num, FunctionType.AIFUNCTION)
# Stop the background operation (this is required even if the
# scan completes successfully)
ul.stop_background(board_num, FunctionType.AIFUNCTION)
print("Scan completed successfully.")
except ULError as e:
util.print_ul_error(e)
finally:
# Free the buffer in a finally block to prevent errors from causing
# a memory leak.
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
board_num = 0
rate = 100
file_name = 'scan_data.csv'
# The size of the UL buffer to create, in seconds
buffer_size_seconds = 2
# The number of buffers to write. After this number of UL buffers are
# written to file, the example will be stopped.
num_buffers_to_write = 5
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device(board_num):
print("Could not find device.")
return
ai_props = AnalogInputProps(board_num)
if (ai_props.num_ai_chans < 1 or
not ScanOptions.SCALEDATA in ai_props.supported_scan_options):
util.print_unsupported_example(board_num)
return
low_chan = 0
high_chan = min(3, ai_props.num_ai_chans - 1)
num_chans = high_chan - low_chan + 1
# Create a circular buffer that can hold buffer_size_seconds worth of
# data, or at least 10 points (this may need to be adjusted to prevent
# a buffer overrun)
points_per_channel = max(rate * buffer_size_seconds, 10)
# Some hardware requires that the total_count is an integer multiple
# of the packet size. For this case, calculate a points_per_channel
# that is equal to or just above the points_per_channel selected
# which matches that requirement.
if ai_props.continuous_requires_packet_size_multiple:
packet_size = ai_props.packet_size
remainder = points_per_channel % packet_size
if remainder != 0:
points_per_channel += packet_size - remainder
ul_buffer_count = points_per_channel * num_chans
# Write the UL buffer to the file num_buffers_to_write times.
points_to_write = ul_buffer_count * num_buffers_to_write
# When handling the buffer, we will read 1/10 of the buffer at a time
write_chunk_size = int(ul_buffer_count / 10)
ai_range = ai_props.available_ranges[0]
scan_options = (ScanOptions.BACKGROUND | ScanOptions.CONTINUOUS |
ScanOptions.SCALEDATA)
memhandle = ul.scaled_win_buf_alloc(ul_buffer_count)
# Allocate an array of doubles temporary storage of the data
write_chunk_array = (c_double * write_chunk_size)()
# Check if the buffer was successfully allocated
if not memhandle:
print("Failed to allocate memory.")
return
try:
# Start the scan
ul.a_in_scan(
board_num, low_chan, high_chan, ul_buffer_count,
rate, ai_range, memhandle, scan_options)
status = Status.IDLE
# Wait for the scan to start fully
while(status == Status.IDLE):
status, _, _ = ul.get_status(
board_num, FunctionType.AIFUNCTION)
# Create a file for storing the data
with open(file_name, 'w') as f:
print('Writing data to ' + file_name, end='')
# Write a header to the file
for chan_num in range(low_chan, high_chan + 1):
f.write('Channel ' + str(chan_num) + ',')
f.write(u'\n')
# Start the write loop
prev_count = 0
prev_index = 0
write_ch_num = low_chan
while status != Status.IDLE:
# Get the latest counts
status, curr_count, _ = ul.get_status(
board_num, FunctionType.AIFUNCTION)
new_data_count = curr_count - prev_count
# Check for a buffer overrun before copying the data, so
# that no attempts are made to copy more than a full buffer
# of data
if new_data_count > ul_buffer_count:
# Print an error and stop writing
ul.stop_background(board_num, FunctionType.AIFUNCTION)
print("A buffer overrun occurred")
break
# Check if a chunk is available
if new_data_count > write_chunk_size:
wrote_chunk = True
# Copy the current data to a new array
# Check if the data wraps around the end of the UL
# buffer. Multiple copy operations will be required.
if prev_index + write_chunk_size > ul_buffer_count - 1:
first_chunk_size = ul_buffer_count - prev_index
second_chunk_size = (
write_chunk_size - first_chunk_size)
# Copy the first chunk of data to the
# write_chunk_array
ul.scaled_win_buf_to_array(
memhandle, write_chunk_array, prev_index,
first_chunk_size)
# Create a pointer to the location in
# write_chunk_array where we want to copy the
# remaining data
second_chunk_pointer = cast(
addressof(write_chunk_array) + first_chunk_size
* sizeof(c_double), POINTER(c_double))
# Copy the second chunk of data to the
# write_chunk_array
ul.scaled_win_buf_to_array(
memhandle, second_chunk_pointer,
0, second_chunk_size)
else:
# Copy the data to the write_chunk_array
ul.scaled_win_buf_to_array(
memhandle, write_chunk_array, prev_index,
write_chunk_size)
# Check for a buffer overrun just after copying the data
# from the UL buffer. This will ensure that the data was
# not overwritten in the UL buffer before the copy was
# completed. This should be done before writing to the
# file, so that corrupt data does not end up in it.
status, curr_count, _ = ul.get_status(
board_num, FunctionType.AIFUNCTION)
if curr_count - prev_count > ul_buffer_count:
# Print an error and stop writing
ul.stop_background(board_num, FunctionType.AIFUNCTION)
print("A buffer overrun occurred")
break
for i in range(write_chunk_size):
f.write(str(write_chunk_array[i]) + ',')
write_ch_num += 1
if write_ch_num == high_chan + 1:
write_ch_num = low_chan
f.write(u'\n')
else:
wrote_chunk = False
if wrote_chunk:
# Increment prev_count by the chunk size
prev_count += write_chunk_size
# Increment prev_index by the chunk size
prev_index += write_chunk_size
# Wrap prev_index to the size of the UL buffer
prev_index %= ul_buffer_count
if prev_count >= points_to_write:
break
print('.', end='')
else:
# Wait a short amount of time for more data to be
# acquired.
time.sleep(0.1)
ul.stop_background(board_num, FunctionType.AIFUNCTION)
except ULError as e:
util.print_ul_error(e)
finally:
print('Done')
# Free the buffer in a finally block to prevent errors from causing
# a memory leak.
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
board_num = 0
rate = 100
points_per_channel = 100
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device_of_type(
board_num, supported_pids):
print("Could not find a supported device.")
return
scan_options = ScanOptions.FOREGROUND | ScanOptions.SCALEDATA
# Create the daq_in_scan channel configuration lists
chan_list = []
chan_type_list = []
gain_list = []
# Analog channels must be first in the list
chan_list.append(1)
chan_type_list.append(ChannelType.ANALOG_SE)
gain_list.append(ULRange.BIP10VOLTS)
chan_list.append(2)
chan_type_list.append(ChannelType.ANALOG_DIFF)
gain_list.append(ULRange.BIP10VOLTS)
chan_list.append(DigitalPortType.AUXPORT)
chan_type_list.append(ChannelType.DIGITAL)
gain_list.append(ULRange.NOTUSED)
chan_list.append(0)
chan_type_list.append(ChannelType.CTR)
gain_list.append(ULRange.NOTUSED)
num_chans = len(chan_list)
total_count = num_chans * points_per_channel
# Allocate memory for the scan and cast it to a ctypes array pointer
memhandle = ul.scaled_win_buf_alloc(total_count)
ctypes_array = util.memhandle_as_ctypes_array_scaled(memhandle)
# Note: the ctypes array will no longer be valid after win_buf_free is
# called.
# A copy of the buffer can be created using win_buf_to_array or
# win_buf_to_array_32 before the memory is freed. The copy can be used
# at any time.
# Check if the buffer was successfully allocated
if not memhandle:
print("Failed to allocate memory.")
return
try:
# Start the scan
ul.daq_in_scan(board_num, chan_list, chan_type_list, gain_list,
num_chans, rate, 0, total_count, memhandle,
scan_options)
print("Scan completed successfully. Data:")
# Create a format string that aligns the data in columns
row_format = "{:>5}" + "{:>10}" * num_chans
# Print the channel name headers
labels = []
labels.append("Index")
for ch_index in range(num_chans):
channel_label = {
ChannelType.ANALOG: lambda: "AI" + str(chan_list[ch_index]),
ChannelType.ANALOG_DIFF:
lambda: "AI" + str(chan_list[ch_index]),
ChannelType.ANALOG_SE: lambda: "AI" + str(chan_list[ch_index]),
ChannelType.DIGITAL: lambda: chan_list[ch_index].name,
ChannelType.CTR: lambda: "CI" + str(chan_list[ch_index]),
}[chan_type_list[ch_index]]()
labels.append(channel_label)
print(row_format.format(*labels))
# Print the data
data_index = 0
for index in range(points_per_channel):
display_data = [index]
for ch_index in range(num_chans):
data_label = {
ChannelType.ANALOG:
lambda: '{:.3f}'.format(ctypes_array[data_index]),
ChannelType.ANALOG_DIFF:
lambda: '{:.3f}'.format(ctypes_array[data_index]),
ChannelType.ANALOG_SE:
lambda: '{:.3f}'.format(ctypes_array[data_index]),
ChannelType.DIGITAL:
lambda: '{:d}'.format(int(ctypes_array[data_index])),
ChannelType.CTR:
lambda: '{:d}'.format(int(ctypes_array[data_index])),
}[chan_type_list[ch_index]]()
display_data.append(data_label)
data_index += 1
# Print this row
print(row_format.format(*display_data))
except ULError as e:
util.print_ul_error(e)
finally:
# Free the buffer in a finally block to prevent errors from causing
# a memory leak.
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def disconnect(self):
ul.release_daq_device(self.board_num)
return True
def run_example():
# By default, the example detects and displays all available devices and
# selects the first device listed. Use the dev_id_list variable to filter
# detected devices by device ID (see UL documentation for device IDs).
# If use_device_detection is set to False, the board_num variable needs to
# match the desired board number configured with Instacal.
use_device_detection = True
dev_id_list = []
board_num = 0
rate = 100
file_name = 'scan_data.csv'
memhandle = None
# The size of the UL buffer to create, in seconds
buffer_size_seconds = 2
# The number of buffers to write. After this number of UL buffers are
# written to file, the example will be stopped.
num_buffers_to_write = 5
try:
if use_device_detection:
config_first_detected_device(board_num, dev_id_list)
daq_dev_info = DaqDeviceInfo(board_num)
if not daq_dev_info.supports_analog_input:
raise Exception('Error: The DAQ device does not support '
'analog input')
print('\nActive DAQ device: ', daq_dev_info.product_name, ' (',
daq_dev_info.unique_id, ')\n', sep='')
ai_info = daq_dev_info.get_ai_info()
low_chan = 0
high_chan = min(3, ai_info.num_chans - 1)
num_chans = high_chan - low_chan + 1
# Create a circular buffer that can hold buffer_size_seconds worth of
# data, or at least 10 points (this may need to be adjusted to prevent
# a buffer overrun)
points_per_channel = max(rate * buffer_size_seconds, 10)
# Some hardware requires that the total_count is an integer multiple
# of the packet size. For this case, calculate a points_per_channel
# that is equal to or just above the points_per_channel selected
# which matches that requirement.
if ai_info.packet_size != 1:
packet_size = ai_info.packet_size
remainder = points_per_channel % packet_size
if remainder != 0:
points_per_channel += packet_size - remainder
ul_buffer_count = points_per_channel * num_chans
# Write the UL buffer to the file num_buffers_to_write times.
points_to_write = ul_buffer_count * num_buffers_to_write
# When handling the buffer, we will read 1/10 of the buffer at a time
write_chunk_size = int(ul_buffer_count / 10)
ai_range = ai_info.supported_ranges[0]
scan_options = (ScanOptions.BACKGROUND | ScanOptions.CONTINUOUS |
ScanOptions.SCALEDATA)
memhandle = ul.scaled_win_buf_alloc(ul_buffer_count)
# Allocate an array of doubles temporary storage of the data
write_chunk_array = (c_double * write_chunk_size)()
# Check if the buffer was successfully allocated
if not memhandle:
raise Exception('Failed to allocate memory')
# Start the scan
ul.a_in_scan(
board_num, low_chan, high_chan, ul_buffer_count,
rate, ai_range, memhandle, scan_options)
status = Status.IDLE
# Wait for the scan to start fully
while status == Status.IDLE:
status, _, _ = ul.get_status(board_num, FunctionType.AIFUNCTION)
# Create a file for storing the data
with open(file_name, 'w') as f:
print('Writing data to ' + file_name, end='')
# Write a header to the file
for chan_num in range(low_chan, high_chan + 1):
f.write('Channel ' + str(chan_num) + ',')
f.write(u'\n')
# Start the write loop
prev_count = 0
prev_index = 0
write_ch_num = low_chan
while status != Status.IDLE:
# Get the latest counts
status, curr_count, _ = ul.get_status(board_num,
FunctionType.AIFUNCTION)
new_data_count = curr_count - prev_count
# Check for a buffer overrun before copying the data, so
# that no attempts are made to copy more than a full buffer
# of data
if new_data_count > ul_buffer_count:
# Print an error and stop writing
ul.stop_background(board_num, FunctionType.AIFUNCTION)
print('A buffer overrun occurred')
break
# Check if a chunk is available
if new_data_count > write_chunk_size:
wrote_chunk = True
# Copy the current data to a new array
# Check if the data wraps around the end of the UL
# buffer. Multiple copy operations will be required.
if prev_index + write_chunk_size > ul_buffer_count - 1:
first_chunk_size = ul_buffer_count - prev_index
second_chunk_size = (
write_chunk_size - first_chunk_size)
# Copy the first chunk of data to the
# write_chunk_array
ul.scaled_win_buf_to_array(
memhandle, write_chunk_array, prev_index,
first_chunk_size)
# Create a pointer to the location in
# write_chunk_array where we want to copy the
# remaining data
second_chunk_pointer = cast(addressof(write_chunk_array)
+ first_chunk_size
* sizeof(c_double),
POINTER(c_double))
# Copy the second chunk of data to the
# write_chunk_array
ul.scaled_win_buf_to_array(
memhandle, second_chunk_pointer,
0, second_chunk_size)
else:
# Copy the data to the write_chunk_array
ul.scaled_win_buf_to_array(
memhandle, write_chunk_array, prev_index,
write_chunk_size)
# Check for a buffer overrun just after copying the data
# from the UL buffer. This will ensure that the data was
# not overwritten in the UL buffer before the copy was
# completed. This should be done before writing to the
# file, so that corrupt data does not end up in it.
status, curr_count, _ = ul.get_status(
board_num, FunctionType.AIFUNCTION)
if curr_count - prev_count > ul_buffer_count:
# Print an error and stop writing
ul.stop_background(board_num, FunctionType.AIFUNCTION)
print('A buffer overrun occurred')
break
for i in range(write_chunk_size):
f.write(str(write_chunk_array[i]) + ',')
write_ch_num += 1
if write_ch_num == high_chan + 1:
write_ch_num = low_chan
f.write(u'\n')
else:
wrote_chunk = False
if wrote_chunk:
# Increment prev_count by the chunk size
prev_count += write_chunk_size
# Increment prev_index by the chunk size
prev_index += write_chunk_size
# Wrap prev_index to the size of the UL buffer
prev_index %= ul_buffer_count
if prev_count >= points_to_write:
break
print('.', end='')
else:
# Wait a short amount of time for more data to be
# acquired.
sleep(0.1)
ul.stop_background(board_num, FunctionType.AIFUNCTION)
except Exception as e:
print('\n', e)
finally:
print('Done')
if memhandle:
# Free the buffer in a finally block to prevent a memory leak.
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
board_num = 0
low_chan = 0
high_chan = 3
num_chans = high_chan - low_chan + 1
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device_of_type(
board_num, supported_pids):
print("Could not find a supported device.")
return
rate = 10
points_per_channel = 10
total_count = points_per_channel * num_chans
scan_options = ScanOptions.FOREGROUND | ScanOptions.SCALEDATA
memhandle = ul.scaled_win_buf_alloc(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array_scaled method for scaled
# buffers.
ctypes_array = util.memhandle_as_ctypes_array_scaled(memhandle)
# Note: the ctypes array will no longer be valid after win_buf_free is
# called.
# A copy of the buffer can be created using win_buf_to_array or
# win_buf_to_array_32 before the memory is freed. The copy can be used
# at any time.
# Check if the buffer was successfully allocated
if not memhandle:
print("Failed to allocate memory.")
return
try:
# Set channel settings
set_channel_settings(board_num)
# Start the scan
ul.a_in_scan(
board_num, low_chan, high_chan, total_count,
rate, ULRange.BIP10VOLTS, memhandle, scan_options)
print("Scan completed successfully. Data:")
# Create a format string that aligns the data in columns
row_format = "{:>5}" + "{:>10}" * num_chans
# Print the channel name headers
labels = []
labels.append("Index")
for ch_num in range(low_chan, high_chan + 1):
labels.append("CH" + str(ch_num))
print(row_format.format(*labels))
# Print the data
data_index = 0
for index in range(points_per_channel):
display_data = [index]
for _ in range(num_chans):
display_data.append(
'{:.3f}'.format(ctypes_array[data_index]))
data_index += 1
# Print this row
print(row_format.format(*display_data))
except ULError as e:
util.print_ul_error(e)
finally:
# Free the buffer in a finally block to prevent errors from causing
# a memory leak.
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
# By default, the example detects and displays all available devices and
# selects the first device listed. Use the dev_id_list variable to filter
# detected devices by device ID (see UL documentation for device IDs).
# If use_device_detection is set to False, the board_num variable needs to
# match the desired board number configured with Instacal.
use_device_detection = True
dev_id_list = [317, 318] # USB-1808 = 317, USB-1808X = 318
board_num = 0
# Supported PIDs for the USB-1808 Series
rate = 100
points_per_channel = 100
memhandle = None
try:
if use_device_detection:
config_first_detected_device(board_num, dev_id_list)
daq_dev_info = DaqDeviceInfo(board_num)
print('\nActive DAQ device: ', daq_dev_info.product_name, ' (',
daq_dev_info.unique_id, ')\n', sep='')
scan_options = ScanOptions.FOREGROUND | ScanOptions.SCALEDATA
# Create the daq_in_scan channel configuration lists
chan_list = []
chan_type_list = []
gain_list = []
# Analog channels must be first in the list
chan_list.append(1)
chan_type_list.append(ChannelType.ANALOG_SE)
gain_list.append(ULRange.BIP10VOLTS)
chan_list.append(2)
chan_type_list.append(ChannelType.ANALOG_DIFF)
gain_list.append(ULRange.BIP10VOLTS)
chan_list.append(DigitalPortType.AUXPORT)
chan_type_list.append(ChannelType.DIGITAL)
gain_list.append(ULRange.NOTUSED)
chan_list.append(0)
chan_type_list.append(ChannelType.CTR)
gain_list.append(ULRange.NOTUSED)
num_chans = len(chan_list)
total_count = num_chans * points_per_channel
# Allocate memory for the scan and cast it to a ctypes array pointer
memhandle = ul.scaled_win_buf_alloc(total_count)
ctypes_array = cast(memhandle, POINTER(c_double))
# Note: the ctypes array will no longer be valid after win_buf_free is
# called.
# A copy of the buffer can be created using win_buf_to_array or
# win_buf_to_array_32 before the memory is freed. The copy can be used
# at any time.
# Check if the buffer was successfully allocated
if not memhandle:
raise Exception('Error: Failed to allocate memory')
# Start the scan
ul.daq_in_scan(
board_num, chan_list, chan_type_list, gain_list, num_chans,
rate, 0, total_count, memhandle, scan_options)
print('Scan completed successfully. Data:')
# Create a format string that aligns the data in columns
row_format = '{:>5}' + '{:>10}' * num_chans
# Print the channel name headers
labels = ['Index']
for ch_index in range(num_chans):
channel_label = {
ChannelType.ANALOG: lambda:
'AI' + str(chan_list[ch_index]),
ChannelType.ANALOG_DIFF: lambda:
'AI' + str(chan_list[ch_index]),
ChannelType.ANALOG_SE: lambda:
'AI' + str(chan_list[ch_index]),
ChannelType.DIGITAL: lambda:
chan_list[ch_index].name,
ChannelType.CTR: lambda:
'CI' + str(chan_list[ch_index]),
}[chan_type_list[ch_index]]()
labels.append(channel_label)
print(row_format.format(*labels))
# Print the data
data_index = 0
for index in range(points_per_channel):
display_data = [index]
for ch_index in range(num_chans):
data_label = {
ChannelType.ANALOG: lambda:
'{:.3f}'.format(ctypes_array[data_index]),
ChannelType.ANALOG_DIFF: lambda:
'{:.3f}'.format(ctypes_array[data_index]),
ChannelType.ANALOG_SE: lambda:
'{:.3f}'.format(ctypes_array[data_index]),
ChannelType.DIGITAL: lambda:
'{:d}'.format(int(ctypes_array[data_index])),
ChannelType.CTR: lambda:
'{:d}'.format(int(ctypes_array[data_index])),
}[chan_type_list[ch_index]]()
display_data.append(data_label)
data_index += 1
# Print this row
print(row_format.format(*display_data))
except Exception as e:
print('\n', e)
finally:
if memhandle:
# Free the buffer in a finally block to prevent a memory leak.
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
# By default, the example detects and displays all available devices and
# selects the first device listed. Use the dev_id_list variable to filter
# detected devices by device ID (see UL documentation for device IDs).
# If use_device_detection is set to False, the board_num variable needs to
# match the desired board number configured with Instacal.
use_device_detection = True
# Supported Device IDs for the USB-2408 and USB-2416 Series
# USB-2408 = 253, USB-2408-2AO = 254, USB-2416 = 208, USB-2416-4AO = 209
dev_id_list = [253, 254, 208, 209]
board_num = 0
low_chan = 0
high_chan = 3
num_chans = high_chan - low_chan + 1
memhandle = None
try:
if use_device_detection:
config_first_detected_device(board_num, dev_id_list)
daq_dev_info = DaqDeviceInfo(board_num)
print('\nActive DAQ device: ',
daq_dev_info.product_name,
' (',
daq_dev_info.unique_id,
')\n',
sep='')
rate = 10
points_per_channel = 10
total_count = points_per_channel * num_chans
scan_options = ScanOptions.FOREGROUND | ScanOptions.SCALEDATA
memhandle = ul.scaled_win_buf_alloc(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array_scaled method for scaled buffers.
ctypes_array = cast(memhandle, POINTER(c_double))
# Note: the ctypes array will no longer be valid after win_buf_free is
# called.
# A copy of the buffer can be created using win_buf_to_array or
# win_buf_to_array_32 before the memory is freed. The copy can be used
# at any time.
# Check if the buffer was successfully allocated
if not memhandle:
raise Exception('Error: Failed to allocate memory')
# Set channel settings
set_channel_settings(board_num)
# Start the scan
ul.a_in_scan(board_num, low_chan, high_chan, total_count, rate,
ULRange.BIP10VOLTS, memhandle, scan_options)
print('Scan completed successfully. Data:')
# Create a format string that aligns the data in columns
row_format = '{:>5}' + '{:>10}' * num_chans
# Print the channel name headers
labels = ['Index']
for ch_num in range(low_chan, high_chan + 1):
labels.append('CH' + str(ch_num))
print(row_format.format(*labels))
# Print the data
for index in range(points_per_channel):
display_data = [index]
for data_index in range(num_chans):
display_data.append('{:.3f}'.format(ctypes_array[data_index]))
# Print this row
print(row_format.format(*display_data))
except Exception as e:
print('\n', e)
finally:
# Free the buffer in a finally block to prevent a memory leak.
if memhandle:
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
board_num = 0
if use_device_detection:
ul.ignore_instacal()
if not util.config_first_detected_device(board_num):
print("Could not find device.")
return
ao_props = AnalogOutputProps(board_num)
if ao_props.num_chans < 1:
util.print_unsupported_example(board_num)
return
low_chan = 0
high_chan = min(3, ao_props.num_chans - 1)
num_chans = high_chan - low_chan + 1
rate = 100
points_per_channel = 1000
total_count = points_per_channel * num_chans
ao_range = ao_props.available_ranges[0]
# Allocate a buffer for the scan
memhandle = ul.win_buf_alloc(total_count)
# Convert the memhandle to a ctypes array
# Note: the ctypes array will no longer be valid after win_buf_free
# is called.
# A copy of the buffer can be created using win_buf_to_array
# before the memory is freed. The copy can be used at any time.
ctypes_array = util.memhandle_as_ctypes_array(memhandle)
# Check if the buffer was successfully allocated
if not memhandle:
print("Failed to allocate memory.")
return
frequencies = add_example_data(board_num, ctypes_array, ao_range,
num_chans, rate, points_per_channel)
for ch_num in range(low_chan, high_chan + 1):
print("Channel " + str(ch_num) + " Output Signal Frequency: " +
str(frequencies[ch_num - low_chan]))
try:
# Start the scan
ul.a_out_scan(board_num, low_chan, high_chan, total_count, rate,
ao_range, memhandle, ScanOptions.BACKGROUND)
# Wait for the scan to complete
print("Waiting for output scan to complete...", end="")
status = Status.RUNNING
while status != Status.IDLE:
print(".", end="")
# Slow down the status check so as not to flood the CPU
time.sleep(0.5)
status, _, _ = ul.get_status(board_num, FunctionType.AOFUNCTION)
print("")
print("Scan completed successfully.")
except ULError as e:
util.print_ul_error(e)
finally:
# Free the buffer in a finally block to prevent errors from causing
# a memory leak.
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)
def run_example():
# By default, the example detects and displays all available devices and
# selects the first device listed. Use the dev_id_list variable to filter
# detected devices by device ID (see UL documentation for device IDs).
# If use_device_detection is set to False, the board_num variable needs to
# match the desired board number configured with Instacal.
use_device_detection = True
dev_id_list = []
board_num = 0
rate = 100
points_per_channel = 10
memhandle = None
try:
if use_device_detection:
config_first_detected_device(board_num, dev_id_list)
daq_dev_info = DaqDeviceInfo(board_num)
if not daq_dev_info.supports_analog_input:
raise Exception('Error: The DAQ device does not support '
'analog input')
print('\nActive DAQ device: ',
daq_dev_info.product_name,
' (',
daq_dev_info.unique_id,
')\n',
sep='')
ai_info = daq_dev_info.get_ai_info()
low_chan = 0
high_chan = min(3, ai_info.num_chans - 1)
num_chans = high_chan - low_chan + 1
total_count = points_per_channel * num_chans
ai_range = ai_info.supported_ranges[0]
scan_options = ScanOptions.FOREGROUND
if ScanOptions.SCALEDATA in ai_info.supported_scan_options:
# If the hardware supports the SCALEDATA option, it is easiest to
# use it.
scan_options |= ScanOptions.SCALEDATA
memhandle = ul.scaled_win_buf_alloc(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array_scaled method for scaled
# buffers.
ctypes_array = cast(memhandle, POINTER(c_double))
elif ai_info.resolution <= 16:
# Use the win_buf_alloc method for devices with a resolution <= 16
memhandle = ul.win_buf_alloc(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array method for devices with a
# resolution <= 16.
ctypes_array = cast(memhandle, POINTER(c_ushort))
else:
# Use the win_buf_alloc_32 method for devices with a resolution > 16
memhandle = ul.win_buf_alloc_32(total_count)
# Convert the memhandle to a ctypes array.
# Use the memhandle_as_ctypes_array_32 method for devices with a
# resolution > 16
ctypes_array = cast(memhandle, POINTER(c_ulong))
# Note: the ctypes array will no longer be valid after win_buf_free is
# called.
# A copy of the buffer can be created using win_buf_to_array or
# win_buf_to_array_32 before the memory is freed. The copy can be used
# at any time.
# Check if the buffer was successfully allocated
if not memhandle:
raise Exception('Error: Failed to allocate memory')
# Start the scan
ul.a_in_scan(board_num, low_chan, high_chan, total_count, rate,
ai_range, memhandle, scan_options)
print('Scan completed successfully. Data:')
# Create a format string that aligns the data in columns
row_format = '{:>5}' + '{:>10}' * num_chans
# Print the channel name headers
labels = ['Index']
for ch_num in range(low_chan, high_chan + 1):
labels.append('CH' + str(ch_num))
print(row_format.format(*labels))
# Print the data
data_index = 0
for index in range(points_per_channel):
display_data = [index]
for _ in range(num_chans):
if ScanOptions.SCALEDATA in scan_options:
# If the SCALEDATA ScanOption was used, the values
# in the array are already in engineering units.
eng_value = ctypes_array[data_index]
else:
# If the SCALEDATA ScanOption was NOT used, the
# values in the array must be converted to
# engineering units using ul.to_eng_units().
eng_value = ul.to_eng_units(board_num, ai_range,
ctypes_array[data_index])
data_index += 1
display_data.append('{:.3f}'.format(eng_value))
# Print this row
print(row_format.format(*display_data))
except Exception as e:
print('\n', e)
finally:
if memhandle:
# Free the buffer in a finally block to prevent a memory leak.
ul.win_buf_free(memhandle)
if use_device_detection:
ul.release_daq_device(board_num)