def rec_only(device, t_array, inputs): dt = t_array[1] - t_array[0] sampling_rate = 1. / dt # if outputs.shape[0]>0: input_channels = get_analog_input_channels(device)[:inputs.shape[0]] with nidaqmx.Task() as read_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) read_task.ai_channels.add_ai_voltage_chan( flatten_channel_string(input_channels), max_val=10, min_val=-10) read_task.timing.cfg_samp_clk_timing(sampling_rate, source=samp_clk_terminal, active_edge=Edge.FALLING, samps_per_chan=len(t_array)) reader = AnalogMultiChannelReader(read_task.in_stream) # Start the read task before starting the sample clock source task. read_task.start() sample_clk_task.start() reader.read_many_sample(inputs, number_of_samples_per_channel=len(t_array), timeout=t_array[-1] + 2 * dt)
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