NIDAQmx read write sync.py

import numpy as np
import matplotlib.pyplot as plt

from scipy import constants as const
import nidaqmx

# Creating the actuation signal

max_displacement = 250*1e-9
f_displacement = 10000

fs = 1e6
# fs = 100e3
tmax = 1e-3
tmax = 10e-3
N = int(tmax*fs)
t = np.linspace(0,tmax,N)

A = max_displacement/2
x = A+A*np.cos(2*np.pi*t*f_displacement-np.pi)

V_actuation = linearization_function(x)
# data = V

N_samples = len(x)

print("max voltage:",max(V_actuation), "samples",N_samples)

fig,ax = plt.subplots(2,1, sharex=True, figsize=(5,1))
plt.sca(ax[0])
plt.plot(t*1e3,x/1e-9)
plt.ylabel("x(t) [m]")
plt.sca(ax[1])
plt.plot(t*1e3,V_actuation)
plt.ylabel("V(t) [V]")
plt.xlabel("t [ms]")

data = V_actuation








physical_channel = "Dev1/ai0"
chan_output = "Dev1/ao0"
term_output_trigger = "/Dev1/ao/StartTrigger"
term_output_trigger = "/Dev1/PFI12"


chan_input = "Dev1/ai0"
term_input_trigger = "/Dev1/PFI12"
term_trigger = "/Dev1/PFI12"
# chan_input_trigger = "/Dev1/ao/StartTrigger"
# chan_input_trigger = chan_output_trigger

# chan_trigger = "Dev1/PFI0"




sample_mode_input = ni.constants.AcquisitionType.FINITE
sample_mode_output = ni.constants.AcquisitionType.CONTINUOUS

fs_output = 1e6
fs_input = 100e3

read_samples = 1e3
read_samples = int(read_samples)

with ni.Task() as read_task, ni.Task() as write_task, ni.Task() as trigger_task:

    # set channels
    read_task.ai_channels.add_ai_voltage_chan(chan_input)
    write_task.ao_channels.add_ao_voltage_chan(chan_output)
    
    # trigger_task.do_channels.add_do_chan(chan_trigger)
    
    

    # Set sampling frequency and mode
    write_task.timing.cfg_samp_clk_timing(fs_output, sample_mode=sample_mode_output)
    
    read_task.timing.cfg_samp_clk_timing(fs_input, sample_mode=sample_mode_input, samps_per_chan=read_samples)

    # set trigger of output to start reading
    # read_task.triggers.start_trigger.cfg_dig_edge_start_trig(term_input_trigger, trigger_edge=ni.constants.Edge.RISING)
    write_task.triggers.start_trigger.cfg_dig_edge_start_trig(term_trigger, trigger_edge=ni.constants.Edge.RISING)
    read_task.triggers.start_trigger.cfg_dig_edge_start_trig(write_task.triggers.start_trigger.term)
    
    
    # write_task.triggers.start_trigger.cfg_dig_edge_start_trig(read_task.triggers.start_trigger.term)
    # write_task.triggers.start_trigger.cfg_dig_edge_start_trig(chan_output_trigger, trigger_edge=ni.constants.Edge.RISING)
    
    
    # Write waveform data to output buffer
    write_task.write(data)

    sample_clk_rate = read_task.timing.samp_clk_rate
    dt = 1/sample_clk_rate
    print(sample_clk_rate, dt)

    read_task.start()
    
    write_task.start()
    
    # tasks are armed, waiting for trigger
    
    print("tasks armed and waiting for trigger")
    
    # Read data
    data = read_task.read(number_of_samples_per_channel=ni.constants.READ_ALL_AVAILABLE)

#     for i in range(10):
    
#         # read the data
#         data = read_task.read(number_of_samples_per_channel=read_samples)
#         print(data)

    print(read_task.export_signals)
    # read_task.stop()
    # write_task.wait_until_done()
    # write_task.stop()
    
    
plt.figure(figsize=(10,2))


t = np.arange(len(data))*dt
plt.plot(t,data, '-')