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