Hello,
The following Python for Windows program demonstrates how to collect data with a USB-205. The while...loop that reads the data controls how long it will run. It does not write to a file but it does print one row of data from each buffer read - this is done for simplicity. Use your Python skills to modify it adding a routine that can write a List along with a timestamp to the file. Do take note, there is very little memory used because you do not need a bigger buffer to continuously read data. Copy this example (attached) to the Console example program folder.
best regards,
John
from __future__ import absolute_import, division, print_function
import time
from builtins import * # @UnusedWildImport
from time import sleep
from ctypes import cast, POINTER, c_double, c_ushort, c_ulong
from mcculw import ul
from mcculw.enums import ScanOptions, FunctionType, Status
from mcculw.ul import ULError, a_input_mode
from mcculw.enums import InterfaceType
from mcculw.enums import ULRange
from mcculw.enums import AnalogInputMode
use_device_detection = True
def run_example():
board_num = 0
board_index = 0
find_device = "USB-205"
if use_device_detection:
board_num = -1
ul.ignore_instacal()
dev_list = ul.get_daq_device_inventory(InterfaceType.USB)
if len(dev_list) > 0:
for device in dev_list:
if str(device) == find_device:
print(f"Found {find_device} board number = {board_index}")
print(f"Serial number: {device.unique_id}")
print(f"Product type: {hex(device.product_id)}")
board_num = board_index
ul.create_daq_device(board_num, device)
board_index = board_index + 1
if board_num == -1:
print(f"Device {find_device} not found")
return
else:
print("No devices detected")
return
# **********End of Discovery************
rate = 10000
# buffer sized to hold one second of data. Make larger if your data handling requires more.
points_per_channel = 10000
low_chan = 0
high_chan = 3
num_chans = 4
total_count = points_per_channel * num_chans
half_count = int(total_count / 2)
# The SCALEDATA option, returns volts instead of A/D counts
scan_options = ScanOptions.CONTINUOUS | ScanOptions.BACKGROUND | ScanOptions.SCALEDATA
memhandle = ul.scaled_win_buf_alloc(total_count)
buf_data = cast(memhandle, POINTER(c_double))
# 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, ULRange.BIP10VOLTS, memhandle, scan_options)
# Create a format string that aligns the data in columns
# plus two for curr_index and curr_count
row_format = "{:8}" * (num_chans + 3)
# Print the channel name headers
labels = []
for ch_num in range(low_chan, high_chan + 1):
labels.append("CH" + str(ch_num) + "\t")
labels.append("index\t")
labels.append("count\t")
labels.append("diff")
print(row_format.format(*labels))
# boolean flag used to toggle reading upper and lower buffer
read_lower = True
# Start updating the displayed values
status, curr_count, curr_index = ul.get_status(
board_num, FunctionType.AIFUNCTION)
last = 0
diff = 0
while status != Status.IDLE and curr_count < 200000:
# 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 = []
if (curr_index > half_count) and (read_lower == True):
diff = curr_count - last
ul.scaled_win_buf_to_array(memhandle, buf_data, 0, int(half_count))
print(
'{:.3f}\t {:.3f}\t {:.3f}\t {:.3f}\t {:d}\t {:d}'.format(buf_data[0], buf_data[1],
buf_data[2],
buf_data[3],
curr_index,
curr_count))
read_lower = False
elif (curr_index < half_count) and (read_lower == False):
diff = curr_count - last
ul.scaled_win_buf_to_array(memhandle, buf_data, int(half_count), int(half_count))
print(
'{:.3f}\t {:.3f}\t {:.3f}\t {:.3f}\t {:d}\t {:d}'.format(buf_data[0], buf_data[1],
buf_data[2],
buf_data[3],
curr_index,
curr_count))
read_lower = True
sleep(0.1)
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:
print(e.message)
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)
Hello,
You must have InstaCal 6.73 install on Windows 11 for it to work. The first time you run InstaCal with the USB-TEMP/TC you should get a window indicating you must perform an update. After running the update, either restart Windows or repower the device by plugging it back in. Run InstaCal again and it should recognize your device and allow you to configure it.
If you do not have InstaCal 6.73, download our latest DAQ Software CD using the following:
https://www.mccdaq.com/downloads/MCCDaqCD/mccdaq.exe
Regards,
John
Hello Marcel,
Use the following https://www.mccdaq.com/downloads/LabVIEW2021_ULx/. The installation will find both of version of LabVIEW. My suggestion is to install to 2021 instead of letting the installer update both. I'm not sure which device of ours you have, but you will also need the InstaCal utility. Make sure it is in InstaCal's board list.
Best regards,
John
