DAQman

Hello,
Inside the USB-TC is a known millivolt reference. During calibration the channels are first connected to ground to measure offset. Then they are connected to the millivolt reference and with the two values, gain and offset coefficients are calculate and stored. This allows it to measure the thermcouple voltage accuractely. 
During operation, it measures the thermcouple voltage, the CJC sensor and from these to values it determines temperature for the particular thermcouple type.
As for the calibration date, 11/26/15 is the last factory calibration date, which happens to be the manufactured data. I check, and this particular USB-TC has never been sent in for a factory calibration. One thing to keep in mind, the millivolt reference used in the self calibration does eventually drift. The factory calibration reset the reference so that future self calibration are accurate. The current price for a calibration is $62.75 plus shipping. Email your contact info and model/serial number to info@mccdaq.com to receive a quote.
Best regards,
John
 

Hey Sam,
There is no canned solution that we offer. The digital outputs are 3.3 volt compatible and can only source about 1mA. They work well when interfaced to 3.3 volt logic.
You could try using the output as a switch to ground. Connect the SSR (+) control line to (+) Power (external power supply) and the (-) to the USB-1616HS-4 output. Connect (-) Power to the USB-1616HS-4 ground. When the output is set high, the SSR will be off but when it is set low current will flow from (+) Power down through the output to ground, which is (-) Power and this turns on the SSR. Test the output with a load on the SSR output because they need some current to flow to stay on.
Best regards,
John

Hello,
Fixing the .XML error simple, just make sure DASYLab is configured to run as an administrator. This is because the default IOtech XML hardware file is kept in the DASYLab folder which under Program Files (x86) and that requires permission to read/write. After you correct the XML error, if the remaining errors are the Action modules check if you have DASYLab FULL or PrO. You need at least FULL to use Action modules. For this run the DASYLab Configurator utility. There should be listed a serial number which is a 26 character string. If you provide the last six digits, I can use it to investigate to see if it is FULL/PRO version.
Best regards,
John
 

Hello @e_reed
t_in and t_in_scan are polling functions, in fact t_in_scan calls t_in for each in the list.
However, the USB-1616HS series has another function called DaqInScan that can scan both thermocouple and voltage inputs. For an example of how it works, take a look at the C# example DaqInScan03. In this example, you can see how to setup the channel arrays and how to convert the data. There is a DaqInScan Python example but it doesn't include thermocouples so you would need to modify. Once you have it working you could make the whole operation run in the background with the BACKGROUND|CONTINUOUS option.
Best regards,
John

Hello @Ariel
Nothing for the USB-CTR04-OEM but it's the same size as our USB-1808-OEM and I do have a file for it - see attached zip file.
Best regards,
John
1808_OEM_Drawings.zip

Select the Options (Gear/Cog) and on the menu uncheck Acquire Noise

Hello,
I've looked into your application further and using the ULx Timing VI to achieve higher throughput will not work in PID applications. This is because the underlying resources were designed to stream waveforms not single values. The waveform output works by first preloading the output buffer using the ULx Write Vi. For a clock rate of 1000, the buffer must be at least 5000 otherwise an error will occur. The buffer is not directly accessible and all additional ULx Writes get appended to the end.
Take a look at the ULx Cont Gen Voltage Wfm-Int Clk-Non Regeneration.vi for an example of this. It is located in the \National Instruments\LabVIEW 2021\Examples\ULx\Analog Out\Generate Voltage.llb library.
regards,
 

Hello,
First, see if you can get your PID control to work using single sample input/output which doesn't require the ULx Timing VI's. Instead, the timing will be control by the while loop speed. Below is an example of what I'm describing - it uses a 10mS delay to control the loop speed. 
regards...

pid_ctrl_example2.vi

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)

if __name__ == '__main__':
    run_example()
 
a_in_scan_USB200.py

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

Hi Marcel,
See if you have a ULx folder in \National Instruments\Shared\ and in \National Instruments\LabVIEW 2021\Examples\. If the ULx folders are present the support is install. However, the menu file somehow vanished. The following KB article addresses this topic:
https://kb.mccdaq.com/KnowledgebaseArticle50382.aspx
The help file should be in C:\Program Files (x86)\National Instruments\Shared\ULx. If it is there, you could make your own shortcut.
Best regards,
John

Hello Alexandre,
It makes no sense that the storage temperature is less than the operating temperature. Therefore, I am thinking that the storage specification is incorrect. From what I can tell, it uses the FT232HQ chip and its specification lists a storage temperature of -65 to 150 Degrees C - see below.
Here is a link to the data sheet I found: https://ftdichip.com/products/ft232hq/

Best regards,
John