def __init__(
self,
dt=1e-3,
Nchannel_analog_in=2,
Nchannel_digital_in=1,
max_time=10,
buffer_time=0.5,
filename=None,
device=None,
outputs=None,
output_steps=[], # should be a set of dictionaries, output_steps=[{'channel':0, 'onset': 2.3, 'duration': 1., 'value':5}]
verbose=False):
self.running, self.data_saved = False, False
self.dt = dt
self.max_time = max_time
self.sampling_rate = 1. / self.dt
self.buffer_size = int(buffer_time / self.dt)
self.Nchannel_analog_in = Nchannel_analog_in
self.Nchannel_digital_in = Nchannel_digital_in
self.filename = filename
self.select_device()
# preparing input channels
# - analog:
self.analog_data = np.zeros((Nchannel_analog_in, 1), dtype=np.float64)
if self.Nchannel_analog_in > 0:
self.analog_input_channels = get_analog_input_channels(
self.device)[:Nchannel_analog_in]
# - digital:
self.digital_data = np.zeros((1, 1), dtype=np.uint32)
if self.Nchannel_digital_in > 0:
self.digital_input_channels = get_digital_input_channels(
self.device)[:Nchannel_digital_in]
# preparing output channels
if outputs is not None: # used as a flag for output or not
self.output_channels = get_analog_output_channels(
self.device)[:outputs.shape[0]]
elif len(output_steps) > 0:
Nchannel = max([d['channel'] for d in output_steps]) + 1
# have to be elements
t = np.arange(int(self.max_time / self.dt)) * self.dt
outputs = np.zeros((Nchannel, len(t)))
# add as many channels as necessary
for step in output_steps:
if step['channel'] > outputs.shape[0]:
outputs = np.append(outputs, np.zeros((1, len(t))), axis=0)
for step in output_steps:
cond = (t > step['onset']) & (t <=
step['onset'] + step['duration'])
outputs[step['channel']][cond] = step['value']
self.output_channels = get_analog_output_channels(
self.device)[:outputs.shape[0]]
self.outputs = outputs
def stim_and_rec(device,
t_array,
analog_inputs,
analog_outputs,
N_digital_inputs=0):
dt = t_array[1] - t_array[0]
sampling_rate = 1. / dt
# if analog_outputs.shape[0]>0:
output_analog_channels = get_analog_output_channels(
device)[:analog_outputs.shape[0]]
input_analog_channels = get_analog_input_channels(
device)[:analog_inputs.shape[0]]
if N_digital_inputs > 0:
input_digital_channels = get_digital_input_channels(
device)[:N_digital_inputs]
with nidaqmx.Task() as write_analog_task, nidaqmx.Task() as read_analog_task,\
nidaqmx.Task() as read_digital_task, nidaqmx.Task() as sample_clk_task:
# Use a counter output pulse train task as the sample clock source
# for both the AI and AO tasks.
sample_clk_task.co_channels.add_co_pulse_chan_freq('{0}/ctr0'.format(
device.name),
freq=sampling_rate)
sample_clk_task.timing.cfg_implicit_timing(samps_per_chan=len(t_array))
samp_clk_terminal = '/{0}/Ctr0InternalOutput'.format(device.name)
### ---- OUTPUTS ---- ##
write_analog_task.ao_channels.add_ao_voltage_chan(
flatten_channel_string(output_analog_channels),
max_val=10,
min_val=-10)
write_analog_task.timing.cfg_samp_clk_timing(
sampling_rate,
source=samp_clk_terminal,
active_edge=Edge.RISING,
samps_per_chan=len(t_array))
### ---- INPUTS ---- ##
read_analog_task.ai_channels.add_ai_voltage_chan(
flatten_channel_string(input_analog_channels),
max_val=10,
min_val=-10)
if N_digital_inputs > 0:
read_digital_task.di_channels.add_di_chan(
flatten_channel_string(input_digital_channels))
read_analog_task.timing.cfg_samp_clk_timing(
sampling_rate,
source=samp_clk_terminal,
active_edge=Edge.FALLING,
samps_per_chan=len(t_array))
if N_digital_inputs > 0:
read_digital_task.timing.cfg_samp_clk_timing(
sampling_rate,
source=samp_clk_terminal,
active_edge=Edge.FALLING,
samps_per_chan=len(t_array))
analog_writer = AnalogMultiChannelWriter(write_analog_task.out_stream)
analog_reader = AnalogMultiChannelReader(read_analog_task.in_stream)
if N_digital_inputs > 0:
digital_reader = DigitalMultiChannelReader(
read_digital_task.in_stream)
analog_writer.write_many_sample(analog_outputs)
# Start the read and write tasks before starting the sample clock
# source task.
read_analog_task.start()
if N_digital_inputs > 0:
read_digital_task.start()
write_analog_task.start()
sample_clk_task.start()
analog_reader.read_many_sample(
analog_inputs,
number_of_samples_per_channel=len(t_array),
timeout=t_array[-1] + 2 * dt)
if N_digital_inputs > 0:
digital_inputs = np.zeros((1, len(t_array)), dtype=np.uint32)
digital_reader.read_many_sample_port_uint32(
digital_inputs,
number_of_samples_per_channel=len(t_array),
timeout=t_array[-1] + 2 * dt)
else:
digital_inputs = None
return analog_inputs, digital_inputs
"--filename",
help="filename",
type=str,
default='data.npy')
parser.add_argument('-d',
"--device",
help="device name",
type=str,
default='')
args = parser.parse_args()
if args.device == '':
args.device = find_m_series_devices()[0]
print(args.device)
print('Digital input channels: ', get_digital_input_channels(args.device))
t_array = np.arange(int(
args.recording_time / args.acq_time_step)) * args.acq_time_step
analog_inputs = np.zeros((args.Nchannel_analog_rec, len(t_array)))
analog_outputs = 100 * np.array([
5e-2 * np.sin(2 * np.pi * t_array), 2e-2 * np.sin(2 * np.pi * t_array)
])
print('running rec & stim [...]')
analog_inputs, digital_inputs = stim_and_rec(args.device, t_array,
analog_inputs, analog_outputs,
args.Nchannel_digital_rec)
print(digital_inputs)
# tstart = 1e3*time.time()