Background generation and acquisition in nidaqmx-python

[PalBrateen]

Hi everyone,
Is there any way to perform background generation and acquisition in python something similar to the ones in the following links for MATLAB?
https://in.mathworks.com/help/daq/generate-continuous-and-background-signals-using-ni-devices.html
https://in.mathworks.com/help/daq/acquire-continuous-and-background-data-using-ni-devices.html

[zhindes]

Yes, Acquire Continuous and Background Data Using NI Devices is effectively the same as the every_n_samples_event.py example. You can add plotting with a 3rd party Python package and add code to do data threshold detection, etc.

[PalBrateen]

Thanks, @zhindes, for your reply. That was the kind of functionality I was looking for. I tried to implement the MATLAB equivalent of generation and acquisition. I have some further questions regarding the every_n_samples_event.py example example as are listed below.

1. Is it required for the callback function to be completed within a stipulated time? The function is called every 1000 samples in the example with a rate of 1000 Sa/s, hence a time of 1 second in this case. I would expect that if that does not happen, the buffer might be replaced with newer data.

2. In the continuous generation case, I tried to implement the Python equivalent of the MATLAB code below with NI-9263 with chassis cDAQ-9162:

dq = daq("ni");
dq.Rate = 10000;
addoutput(dq, "Dev1", 0:2, "Voltage");
%%
outputData = (linspace(-1,1,5000)');
data0 = sin(linspace(0, 2*pi, 1001))';
data1 = sin(linspace(0, 2*pi, 1001) + pi/4)';
data2 = sin(linspace(0, 2*pi*10, 1001))';
data0(end) = [];
data1(end) = [];
data2(end) = [];

preload(dq,repmat([data0, data1, data2], 5, 1));
start(dq, "repeatoutput")

%%
stop(dq)

The Python equivalent of the code will need to use:
task.register_every_n_samples_transferred_from_buffer_event(sample_interval, callback)
where the callback function included only the write() command:

def callback(task_handle, every_n_samples_event_type, number_of_samples, callback_data):
        task.write(data, auto_start=False)
        return 0

The documentation for register_every_n_samples_transferred_from_buffer_event() says: This function only works with devices that support buffered tasks.

Although the MATLAB code runs as expected, the Python version gives the error: DaqError: DAQmx Every N Samples Transferred from Buffer Event is not supported by the channel types or devices in your task. Status Code: -200980. Why does this error appear?

Also, I was curious to know if there are any differences in the two implementations (MATLAB/Python) of background generation. Can I expect to get the same functionality as MATLAB with this DAQ in Python?

[zhindes]

Is it required for the callback function to be completed within a stipulated time? The function is called every 1000 samples in the example with a rate of 1000 Sa/s, hence a time of 1 second in this case. I would expect that if that does not happen, the buffer might be replaced with newer data.

Strictly speaking, no it isn't required for the read to take less than a specific amount of time. However, practically, yes, you should ensure you're keeping up. If you do not, and the data you are trying to read has been overwritten by the acquisition, you will get an error. Some topics that help explain some of that behavior:

• Continuous Acquisition and Generation with Finite Buffer Size
• Controlling Where in the Buffer to Read Samples

Although the MATLAB code runs as expected, the Python version gives the error: DaqError: DAQmx Every N Samples Transferred from Buffer Event is not supported by the channel types or devices in your task. Status Code: -200980. Why does this error appear?

Either because the device doesn't support that operation (which I don't think is true), or you're not creating a hardware-timed buffered task. To do that you typically write a buffer of data before you start the task. Then I think you can register for that event...

Also, I was curious to know if there are any differences in the two implementations (MATLAB/Python) of background generation. Can I expect to get the same functionality as MATLAB with this DAQ in Python?

I don't know how the MATLAB source is written, but I can guess based on the names of their operations.

preload(dq,repmat([data0, data1, data2], 5, 1));
start(dq, "repeatoutput")

This sounds like what I described. They write the data0-2 buffer to the task, then call start. repeatoutput sounds like they do not do an register_every_n_samples_transferred_from_buffer_event operation. Instead it looks like they let the DAQmx buffer be regenerated continuously as was written before the task started.