def NIDAQ_Trigger():
import numpy
import nidaqmx
from nidaqmx.stream_readers import (AnalogSingleChannelReader,
AnalogMultiChannelReader)
from nidaqmx.constants import (Edge, Slope)
from nidaqmx._task_modules.triggering.start_trigger import StartTrigger
#from nidaqmx.tests.fixtures import x_series_device
# import nidaqmx.task as task
data = numpy.zeros((3, 1000), dtype=numpy.float64)
with nidaqmx.Task() as read_task:
read_task.ai_channels.add_ai_voltage_chan(
"Dev1/ai0:2",
terminal_config=nidaqmx.constants.TerminalConfiguration.RSE)
read_task.timing.cfg_samp_clk_timing(1e4,
active_edge=Edge.RISING,
samps_per_chan=1000)
read_task.triggers.start_trigger.cfg_dig_edge_start_trig(
trigger_source="/Dev2/PFI0")
#read_task.timing.delay_from_samp_clk_delay=0
#s=nidaqmx.stream_readers.AnalogMultiChannelReader()
reader = AnalogMultiChannelReader(read_task.in_stream)
reader.read_many_sample(data,
number_of_samples_per_channel=1000,
timeout=1)
# print(data)
return (data)
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 test_manual():
with nidaqmx.Task() as write_task, nidaqmx.Task(
) as read_task, nidaqmx.Task() as sample_clk_task:
# pd_voltage_channel = write_task.ai_channels.add_ai_voltage_chan("Dev2/ai0")
# wavelength_channel = write_task.ai_channels.add_ai_voltage_chan("Dev2/ai1")
sample_rate = 1001
read_task.ai_channels.add_ai_voltage_chan("Dev2/ai0")
read_task.ai_channels.add_ai_voltage_chan("Dev2/ai1")
# read_task.timing.cfg_samp_clk_timing(
# sample_rate, source=samp_clk_terminal,
# active_edge=Edge.FALLING, samps_per_chan=number_of_samples)
reader = AnalogMultiChannelReader(read_task.in_stream)
read_task.start()
number_of_channels = 3
number_of_samples = 100
values_read = numpy.zeros((number_of_channels, number_of_samples),
dtype=numpy.float64)
reader.read_many_sample(
values_read,
number_of_samples_per_channel=number_of_samples,
timeout=2)
print(values_read)
plt.plot(values_read[0, :], values_read[1, :])
plt.show()
class Daq:
def __init__(self, number_of_samples, sample_rate):
read_task = nidaqmx.Task()
read_task.ai_channels.add_ai_voltage_chan("Dev2/ai0")
read_task.ai_channels.add_ai_voltage_chan("Dev2/ai1")
read_task.ai_channels.add_ai_voltage_chan("Dev2/ai2")
#read_task.in_stream.over_write = nidaqmx.constants.OverwriteMode.OVERWRITE_UNREAD_SAMPLES
# read_task.co_channels.add_co_pulse_chan_freq(
# '{0}/ctr0'.format(x_series_device.name), freq=sample_rate)
# read_task.timing.cfg_implicit_timing(
# samps_per_chan=number_of_samples)
#
# samp_clk_terminal = '/{0}/Ctr0InternalOutput'.format(
# x_series_device.name)
# read_task.timing.cfg_implicit_timing()
#
# read_task.timing.cfg_samp_clk_timing(
# sample_rate, source=samp_clk_terminal, active_edge=Edge.RISING,
# samps_per_chan=number_of_samples)
read_task.timing.cfg_samp_clk_timing(rate=sample_rate,
samps_per_chan=number_of_samples)
# read_task.timing.cfg_samp_clk_timing(
# sample_rate, source=samp_clk_terminal,
# active_edge=Edge.FALLING, samps_per_chan=number_of_samples)
self._reader = AnalogMultiChannelReader(read_task.in_stream)
read_task.start()
self._task = read_task
number_of_channels = 3
self._values_read = numpy.zeros(
(number_of_channels, number_of_samples), dtype=numpy.float64)
self._number_of_samples = number_of_samples
self._timeout = number_of_samples / sample_rate + 2
def aquire(self):
assert self._reader.verify_array_shape, "Preallocated array is the wrong size"
self._reader.read_many_sample(
self._values_read,
number_of_samples_per_channel=nidaqmx.constants.READ_ALL_AVAILABLE,
timeout=self._timeout)
#self._reader.read_many_sample(self._values_read, number_of_samples_per_channel=self._number_of_samples, timeout=self._timeout)
photodiode_voltage, wavelength_voltage, source_voltage = self._values_read[
0, :], self._values_read[1, :], self._values_read[2, :]
#self._task.in_stream.open_chans_exist
#assert self._task.in_stream.open_chans_exist is False, "Stream is still open"
self._task.close()
return photodiode_voltage, wavelength_voltage, source_voltage
def run(self):
"""Runs when the start method is called on the thread.
First, a nidaqmx is started using the Python with structure, which automatically stops the task when it is
exited. Next, the thread tries to open the channels, but if it fails, emits an error signal. Next, the timing
is set including the DAQ rate and sample mode. If not, again, it will emit an error.
A multi-channel reader is defined and attached to the in_stream according to the nidaqmx structure. The task is
start which then enables control over the reader. While the running bool is true, the thread waits for there to
be *readchunksize* values, then emits them as an array.
"""
self.running = True
with nidaqmx.Task() as readTask:
# Add input channels
for index, i in enumerate(self.readchannel_list):
channel_string = self.daq_name + '/' + i
try: # RSE = Referenced Single Ended
readTask.ai_channels.add_ai_voltage_chan(
channel_string,
terminal_config=nidaqmx.constants.
TerminalConfiguration.RSE)
except Exception as e:
if index == 0:
self.errorMessage.emit(
"Couldn't initialize the read channels - is the read device name correct? "
f'Devices connected: {find_ni_devices()}')
return
# Set timing and acquisition mode
try:
readTask.timing.cfg_samp_clk_timing(
rate=self.daq_rate,
sample_mode=nidaqmx.constants.AcquisitionType.CONTINUOUS)
except Exception as e:
self.errorMessage.emit(
"Couldn't start the read task - is the read device name correct? "
f'Devices connected: {find_ni_devices()}')
return
# Define the reader and start the *task*
reader = AnalogMultiChannelReader(readTask.in_stream)
readTask.start()
# Waits until there are *readchunksize* values in the buffer and emits the output array
while self.running:
try:
reader.read_many_sample(
data=self.output,
number_of_samples_per_channel=self.readchunksize)
self.output = np.around(self.output, 4)
self.newData.emit(self.output)
except Exception as e:
print(str(e))
pass
class ForceHandle(BaseInput):
@staticmethod
def samp_freq(**kwargs):
return kwargs.get('sampling_frequency', 240)
@staticmethod
def data_shapes(**kwargs):
return [[5, int(kwargs.get('sampling_frequency', 240)/60.0)]]
@staticmethod
def data_types(**kwargs):
return [c_double]
def __init__(self, **kwargs):
super(ForceHandle, self).__init__(**kwargs)
self.sampling_frequency = ForceHandle.samp_freq(**kwargs)
self.period = 1/self.sampling_frequency
self._data_buffer = np.full(ForceHandle.data_shapes(**kwargs)[0], np.nan)
self._tmp_buffer = np.copy(np.transpose(self._data_buffer)) # nidaqmx expects different shape
self._time = None
def __enter__(self):
self._device_name = nidaqmx.system.System.local().devices[0].name
self.channels = [self._device_name + '/ai' + str(n) for n in
[1, 2, 3, 4, 5]] # todo: check
self._device = nidaqmx.Task()
self._device.ai_channels.add_ai_voltage_chan(','.join(self.channels),
terminal_config=TerminalConfiguration.DIFFERENTIAL,
min_val=-10.0, max_val=10.0)
self._device.timing.cfg_samp_clk_timing(self.sampling_frequency,
sample_mode=AcquisitionType.CONTINUOUS)
self._reader = AnalogMultiChannelReader(self._device.in_stream)
self._device.register_every_n_samples_acquired_into_buffer_event(self._data_buffer.shape[1], self.callback)
self._device.start()
return self
def callback(self, task_handle, every_n_samples_event_type, number_of_samples, callback_data):
self._reader.read_many_sample(self._tmp_buffer,
number_of_samples_per_channel=self._data_buffer.shape[1],
timeout=0)
self._time = self.clock()
return 0
def read(self):
if not self._time:
return None, None
np.copyto(self._data_buffer, np.transpose(self._tmp_buffer))
tmptime = self._time
self._time = None
self._data_buffer.fill(np.nan)
return tmptime, self._data_buffer
def __exit__(self, exc_type, exc_val, exc_tb):
self._device.stop()
self._device.close()
def __init__(self, mouseID, name, version, session, sniffing, notes):
self.mouseID = mouseID
self.name = name
self.version = version
self.session = session
self.sniffing = sniffing
self.notes = notes
self.session_start = None
self.reader = AnalogMultiChannelReader(ni_data.in_stream)
self.data = np.zeros((channel_num, buffersize),
dtype=np.float64) #buffersize.value
class ForceHandle(BaseInput):
@staticmethod
def samp_freq(**kwargs):
return kwargs.get('sampling_frequency', 250)
@staticmethod
def data_shapes(**kwargs):
return [[6]] # presumably x, y, z, rx, ry, rz
@staticmethod
def data_types(**kwargs):
return [c_double]
def __init__(self, **kwargs):
super(ForceHandle, self).__init__(**kwargs)
self.sampling_frequency = ForceHandle.samp_freq(**kwargs)
self.period = 1 / self.sampling_frequency
self.t1 = 0
self._time = None
dims = ForceHandle.data_shapes(**kwargs)[0]
dims2 = dims.copy()
self._data_buffer = np.full(dims, np.nan)
self._tmp_buffer = np.full(dims2, np.nan)
def __enter__(self):
self._device_name = nidaqmx.system.System.local().devices[0].name
self.channels = [
self._device_name + '/ai' + str(n) for n in [1, 2, 3, 4, 5, 6]
]
# x is 7 - 8 (ai3 - ai11)
# y may be 3 - 4 (ai1 - ai9)
self._device = nidaqmx.Task()
self._device.ai_channels.add_ai_voltage_chan(
','.join(self.channels),
terminal_config=TerminalConfiguration.DIFFERENTIAL)
self._reader = AnalogMultiChannelReader(self._device.in_stream)
self._device.start()
return self
def read(self):
self._reader.read_one_sample(self._data_buffer)
time = self.clock()
while self.clock() < self.t1:
pass
self.t1 = self.clock() + self.period
return time, self._data_buffer
def __exit__(self, exc_type, exc_val, exc_tb):
self._device.stop()
self._device.close()
def __enter__(self):
self._device_name = nidaqmx.system.System.local().devices[0].name
self.channels = [
self._device_name + '/ai' + str(n) for n in [1, 2, 3, 4, 5, 6]
]
# x is 7 - 8 (ai3 - ai11)
# y may be 3 - 4 (ai1 - ai9)
self._device = nidaqmx.Task()
self._device.ai_channels.add_ai_voltage_chan(
','.join(self.channels),
terminal_config=TerminalConfiguration.DIFFERENTIAL)
self._reader = AnalogMultiChannelReader(self._device.in_stream)
self._device.start()
return self
def __enter__(self):
self._device_name = nidaqmx.system.System.local().devices[0].name
self.channels = [self._device_name + '/ai' + str(n) for n in
[1, 2, 3, 4, 5]] # todo: check
self._device = nidaqmx.Task()
self._device.ai_channels.add_ai_voltage_chan(','.join(self.channels),
terminal_config=TerminalConfiguration.DIFFERENTIAL,
min_val=-10.0, max_val=10.0)
self._device.timing.cfg_samp_clk_timing(self.sampling_frequency,
sample_mode=AcquisitionType.CONTINUOUS)
self._reader = AnalogMultiChannelReader(self._device.in_stream)
self._device.register_every_n_samples_acquired_into_buffer_event(self._data_buffer.shape[1], self.callback)
self._device.start()
return self
def read_multiple_data_from_an_ai_channel(name_device='Dev1', name_chans='Dev1/ai0'):
import nidaqmx.task as task
from nidaqmx.stream_readers import AnalogMultiChannelReader
from nidaqmx._task_modules.in_stream import InStream
import numpy as np
task_read_data = task.Task('task_in_stream')
task_read_data.ai_channels.add_ai_voltage_chan('Dev1/ai0:1')
task_read_data.read(number_of_samples_per_channel=512)
task_in_stream = InStream(task_read_data)
stored_data = np.empty((2, 512))
analog_multi_chan_reader = AnalogMultiChannelReader(task_in_stream)
analog_multi_chan_reader.read_many_sample(data=stored_data,
number_of_samples_per_channel=512)
task_read_data.close()
def niRead(self,dev,samples,indexs):
#buf = np.empty((len(indexs), 0), dtype=np.float64)
data = np.empty((len(indexs), samples), dtype=np.float64)
try:
with nidaqmx.Task() as task:
task.ai_channels.add_ai_voltage_chan(
','.join([dev + '/ai' + str(c) for c in indexs]))
task.timing.cfg_samp_clk_timing(samples, samps_per_chan=samples)
stream_task = AnalogMultiChannelReader(task.in_stream)
stream_task.read_many_sample(
data, number_of_samples_per_channel=samples)
s1 = data.mean(axis=1)
return s1.copy()
except:
return
class ForceHandle(BaseInput):
@staticmethod
def samp_freq(**kwargs):
return kwargs.get('sampling_frequency', 250)
@staticmethod
def data_shapes(**kwargs):
return [[6]] # presumably x, y, z, rx, ry, rz
@staticmethod
def data_types(**kwargs):
return [c_double]
def __init__(self, **kwargs):
super(ForceHandle, self).__init__(**kwargs)
self.sampling_frequency = ForceHandle.samp_freq(**kwargs)
self.period = 1/self.sampling_frequency
self.t1 = 0
self._time = None
dims = ForceHandle.data_shapes(**kwargs)[0]
dims2 = dims.copy()
self._data_buffer = np.full(dims, np.nan)
self._tmp_buffer = np.full(dims2, np.nan)
def __enter__(self):
self._device_name = nidaqmx.system.System.local().devices[0].name
self.channels = [self._device_name + '/ai' + str(n) for n in
[1, 2, 3, 4, 5, 6]]
# x is 7 - 8 (ai3 - ai11)
# y may be 3 - 4 (ai1 - ai9)
self._device = nidaqmx.Task()
self._device.ai_channels.add_ai_voltage_chan(','.join(self.channels),
terminal_config=TerminalConfiguration.DIFFERENTIAL)
self._reader = AnalogMultiChannelReader(self._device.in_stream)
self._device.start()
return self
def read(self):
self._reader.read_one_sample(self._data_buffer)
time = self.clock()
while self.clock() < self.t1:
pass
self.t1 = self.clock() + self.period
return time, self._data_buffer
def __exit__(self, exc_type, exc_val, exc_tb):
self._device.stop()
self._device.close()
def run(self):
"""
Starts writing a waveform continuously to the patchclamp. While reading
the buffer periodically
"""
self.patchVoltOutChan = self.configs["VpPatch"]
self.patchCurOutChan = self.configs["Ip"]
self.patchVoltInChan = self.configs["patchAO"]
# DAQ
with nidaqmx.Task() as writeTask, nidaqmx.Task() as readTask:
writeTask.ao_channels.add_ao_voltage_chan(self.patchVoltInChan)
readTask.ai_channels.add_ai_voltage_chan(self.patchVoltOutChan)
readTask.ai_channels.add_ai_voltage_chan(self.patchCurOutChan)
self.setTiming(writeTask, readTask)
reader = AnalogMultiChannelReader(readTask.in_stream)
writer = AnalogSingleChannelWriter(writeTask.out_stream)
writer.write_many_sample(self.wave)
"""Reading data from the buffer in a loop.
The idea is to let the task read more than could be loaded in the buffer for each iteration.
This way the task will have to wait slightly longer for incoming samples. And leaves the buffer
entirely clean. This way we always know the correct numpy size and are always left with an empty
buffer (and the buffer will not slowly fill up)."""
# output = np.zeros([2, self.readNumber])
writeTask.start() # Will wait for the readtask to start so it can use its clock
readTask.start()
def daq_acquisition():
global running
global reader
global daq_data
running = True
reader = AnalogMultiChannelReader(daq_read_task.in_stream)
daq_read_task.register_every_n_samples_acquired_into_buffer_event(
bufsize_callback, reading_task_callback)
def read_data(self, arr=None):
if not self.reader:
from nidaqmx.stream_readers import AnalogMultiChannelReader
self.reader = AnalogMultiChannelReader(self._task.in_stream)
#chan_names = stream._task.ai_channels.channel_names
number_of_channels = len(self.channels)
nsamp = self.samp_per_chan
data = np.empty((number_of_channels, nsamp), dtype=np.float64)
nread = self.reader.read_many_sample(
data, number_of_samples_per_channel=nsamp, timeout=self.timeout)
data_dict = {}
for k, chan in enumerate(self.channels):
#print(chan.phys_name)
#print(data[k,:])
data_dict[chan.phys_name] = data[k, :]
return data_dict
def measure(self):
"""
Starts writing a waveform continuously to the patchclamp. While reading
the buffer periodically.
"""
self.patchVoltOutChan = self.configs["Vp"]
self.patchCurOutChan = self.configs["Ip"]
self.patchVoltInChan = self.configs["patchAO"]
# DAQ
with nidaqmx.Task() as writeTask, nidaqmx.Task() as readTask:
writeTask.ao_channels.add_ao_voltage_chan(self.patchVoltInChan)
readTask.ai_channels.add_ai_voltage_chan(self.patchVoltOutChan)
readTask.ai_channels.add_ai_voltage_chan(self.patchCurOutChan)
self.setTiming(writeTask, readTask)
reader = AnalogMultiChannelReader(readTask.in_stream)
writer = AnalogSingleChannelWriter(writeTask.out_stream)
writer.write_many_sample(self.wave)
"""Reading data from the buffer in a loop.
The idea is to let the task read more than could be loaded in the buffer for each iteration.
This way the task will have to wait slightly longer for incoming samples. And leaves the buffer
entirely clean. This way we always know the correct numpy size and are always left with an empty
buffer (and the buffer will not slowly fill up)."""
if self.mode == 'voltageclamp':
output = np.zeros([2, self.readNumber])
writeTask.start() # Will wait for the readtask to start so it can use its clock
readTask.start()
self.isRunning = True
while self.isRunning:
reader.read_many_sample(data=output, number_of_samples_per_channel=self.readNumber)
# Emiting the data just received as a signal
self.measurement.emit(output[0,:], output[1,:])
elif self.mode == 'zap':
writeTask.start() # Will wait for the readtask to start so it can use its clock
readTask.start()
else:
pass
print('sealtest thread stopped')
def scan_loop(self, read_task, write_task):
writer = AnalogMultiChannelWriter(write_task.out_stream)
reader = AnalogMultiChannelReader(read_task.in_stream)
first_write = True
i_acquired = 0
while not self.stop_event.is_set() and (
not self.scanning_parameters.scanning_state
== ScanningState.EXPERIMENT_RUNNING
or i_acquired < self.scanning_parameters.n_frames):
# The first write has to be defined before the task starts
try:
writer.write_many_sample(self.write_signals)
if i_acquired == 0:
self.check_start_plane()
if first_write:
read_task.start()
write_task.start()
first_write = False
reader.read_many_sample(
self.read_buffer,
number_of_samples_per_channel=self.n_samples_in,
timeout=1,
)
i_acquired += 1
except nidaqmx.DaqError as e:
print(e)
break
self.data_queue.put(self.read_buffer[0, :])
# if new parameters have been received and changed, update
# them, breaking out of the loop if the experiment is not running
try:
self.new_parameters = self.parameter_queue.get(timeout=0.0001)
if self.new_parameters != self.scanning_parameters and (
self.scanning_parameters.scanning_state !=
ScanningState.EXPERIMENT_RUNNING
or self.new_parameters.scanning_state
== ScanningState.PREVIEW):
break
except Empty:
pass
# calculate duration
self.calculate_duration()
def __init__(self, number_of_samples, sample_rate):
read_task = nidaqmx.Task()
read_task.ai_channels.add_ai_voltage_chan("Dev2/ai0")
read_task.ai_channels.add_ai_voltage_chan("Dev2/ai1")
read_task.ai_channels.add_ai_voltage_chan("Dev2/ai2")
#read_task.in_stream.over_write = nidaqmx.constants.OverwriteMode.OVERWRITE_UNREAD_SAMPLES
# read_task.co_channels.add_co_pulse_chan_freq(
# '{0}/ctr0'.format(x_series_device.name), freq=sample_rate)
# read_task.timing.cfg_implicit_timing(
# samps_per_chan=number_of_samples)
#
# samp_clk_terminal = '/{0}/Ctr0InternalOutput'.format(
# x_series_device.name)
# read_task.timing.cfg_implicit_timing()
#
# read_task.timing.cfg_samp_clk_timing(
# sample_rate, source=samp_clk_terminal, active_edge=Edge.RISING,
# samps_per_chan=number_of_samples)
read_task.timing.cfg_samp_clk_timing(rate=sample_rate,
samps_per_chan=number_of_samples)
# read_task.timing.cfg_samp_clk_timing(
# sample_rate, source=samp_clk_terminal,
# active_edge=Edge.FALLING, samps_per_chan=number_of_samples)
self._reader = AnalogMultiChannelReader(read_task.in_stream)
read_task.start()
self._task = read_task
number_of_channels = 3
self._values_read = numpy.zeros(
(number_of_channels, number_of_samples), dtype=numpy.float64)
self._number_of_samples = number_of_samples
self._timeout = number_of_samples / sample_rate + 2
def perform_coarse_scan(self):
read_task = nidaqmx.Task()
self.add_ai_channels_to_task(read_task)
self.values_read = np.zeros(
(self.number_of_channels, self.samples_per_channel),
dtype=np.float64
) #create buffer to store samples in (this is required if samples>1000)
reader = AnalogMultiChannelReader(read_task.in_stream)
print('Start sweeping now.')
self.TL6800_sweep_start(printbool=False,
readbool=False) # start sweeping
read_task.start()
read_task.wait_until_done(timeout=4000)
reader.read_many_sample(
self.values_read,
number_of_samples_per_channel=self.samples_per_channel,
timeout=4000)
read_task.close()
self.TL6800_read_ascii(
) #readbool is flagged down in the sweep, now laser buffer has to be emptied
def __enter__(self):
self._device_name = nidaqmx.system.System.local().devices[0].name
self.channels = [self._device_name + '/ai' + str(n) for n in
[1, 2, 3, 4, 5, 6]]
# x is 7 - 8 (ai3 - ai11)
# y may be 3 - 4 (ai1 - ai9)
self._device = nidaqmx.Task()
self._device.ai_channels.add_ai_voltage_chan(','.join(self.channels),
terminal_config=TerminalConfiguration.DIFFERENTIAL)
self._reader = AnalogMultiChannelReader(self._device.in_stream)
self._device.start()
return self
def setup_DAQmx(self):
self.read_task = nidaqmx.Task()
self.write_task = nidaqmx.Task()
self.sample_clk_task = nidaqmx.Task()
# Use a counter output pulse train task as the sample clock source
# for both the AI and AO tasks.
self.sample_clk_task.co_channels.add_co_pulse_chan_freq('Dev1/ctr0', freq=self.sample_rate, idle_state=Level.LOW)
self.sample_clk_task.timing.cfg_implicit_timing(sample_mode=AcquisitionType.CONTINUOUS,samps_per_chan=self.number_of_samples)
self.sample_clk_task.control(TaskMode.TASK_COMMIT)
samp_clk_terminal = '/Dev1/Ctr0InternalOutput'
self.read_task.ai_channels.add_ai_voltage_chan(self.input_channel, max_val=10, min_val=-10)
self.read_task.timing.cfg_samp_clk_timing(self.sample_rate, source=samp_clk_terminal, active_edge=Edge.FALLING,sample_mode=AcquisitionType.CONTINUOUS, samps_per_chan=self.number_of_samples)
self.write_task.ao_channels.add_ao_voltage_chan(self.output_channel, max_val=10, min_val=-10)
self.write_task.timing.cfg_samp_clk_timing(self.sample_rate, source=samp_clk_terminal, active_edge=Edge.FALLING,sample_mode=AcquisitionType.CONTINUOUS, samps_per_chan=self.number_of_samples)
self.write_task.out_stream.regen_mode = RegenerationMode.DONT_ALLOW_REGENERATION
self.write_task.out_stream.auto_start = False
self.writer = AnalogSingleChannelWriter(self.write_task.out_stream)
self.reader = AnalogMultiChannelReader(self.read_task.in_stream)
def run(self):
"""
Starts writing a waveform continuously to the patchclamp. While reading
the buffer periodically
"""
self.patchVoltOutChan = self.configs.patchVoltOutChannel
self.patchCurOutChan = self.configs.patchCurOutChannel
self.patchVoltInChan = self.configs.patchVoltInChannel
#DAQ
with nidaqmx.Task() as writeTask, nidaqmx.Task() as readTask:
writeTask.ao_channels.add_ao_voltage_chan(self.patchVoltInChan)
readTask.ai_channels.add_ai_voltage_chan(self.patchVoltOutChan)
readTask.ai_channels.add_ai_voltage_chan(self.patchCurOutChan)
self.setTiming(writeTask, readTask)
reader = AnalogMultiChannelReader(readTask.in_stream)
writer = AnalogSingleChannelWriter(writeTask.out_stream)
writer.write_many_sample(self.wave)
"""Reading data from the buffer in a loop.
The idea is to let the task read more than could be loaded in the buffer for each iteration.
This way the task will have to wait slightly longer for incoming samples. And leaves the buffer
entirely clean. This way we always know the correct numpy size and are always left with an empty
buffer (and the buffer will not slowly fill up)."""
output = np.zeros([2, self.readNumber])
writeTask.start(
) #Will wait for the readtask to start so it can use its clock
readTask.start()
while not self.isInterruptionRequested():
reader.read_many_sample(
data=output, number_of_samples_per_channel=self.readNumber)
#Emiting the data just received as a signal
#output = np.around(output, 7) #Round all values
self.measurement.emit(output[0, :], output[1, :])
def test_one_sample(self, x_series_device, seed):
# Reset the pseudorandom number generator with seed.
random.seed(seed)
# Select a random loopback channel pair on the device.
loopback_channel_pairs = self._get_analog_loopback_channels(
x_series_device)
number_of_channels = random.randint(2, len(loopback_channel_pairs))
channels_to_test = random.sample(
loopback_channel_pairs, number_of_channels)
with nidaqmx.Task() as write_task, nidaqmx.Task() as read_task:
write_task.ao_channels.add_ao_voltage_chan(
flatten_channel_string(
[c.output_channel for c in channels_to_test]),
max_val=10, min_val=-10)
read_task.ai_channels.add_ai_voltage_chan(
flatten_channel_string(
[c.input_channel for c in channels_to_test]),
max_val=10, min_val=-10)
writer = AnalogMultiChannelWriter(write_task.out_stream)
reader = AnalogMultiChannelReader(read_task.in_stream)
values_to_test = numpy.array(
[random.uniform(-10, 10) for _ in range(number_of_channels)],
dtype=numpy.float64)
writer.write_one_sample(values_to_test)
time.sleep(0.001)
values_read = numpy.zeros(number_of_channels, dtype=numpy.float64)
reader.read_one_sample(values_read)
numpy.testing.assert_allclose(
values_read, values_to_test, rtol=0.05, atol=0.005)
def enter(self):
# assume first NI DAQ is the one we want
self._device_name = nidaqmx.system.System.local().devices[0].name
chans = [2, 9, 1, 8, 0, 10, 3, 11, 4, 12]
sub_chans = [chans[i] for i in self._indices]
channels = [self._device_name + ('/ai%i' % n) for n in sub_chans]
channels = ','.join(channels)
dev = nidaqmx.Task()
dev.ai_channels.add_ai_voltage_chan(
channels, terminal_config=TerminalConfiguration.RSE)
dev.timing.cfg_samp_clk_timing(self.sampling_frequency,
sample_mode=AcquisitionType.CONTINUOUS)
self._reader = AnalogMultiChannelReader(dev.in_stream)
dev.start()
self._device = dev
def openall(aoi=0, aof=3, aii=0, aif=31, read=True, write=False, clock=False, sample_rate=500000, initial_delay=0, duty_cycle=0.5, samps_per_chan=1):
'''
4 output channels, 32 input channels
duty cycle = pulse width / pulse period
clock must involve read and write
'''
ad = address()
rs = ad.lookup(mdlname) # Instrument's Address
print(type(rs))
read_task, write_task, clock_task, max_samp_rate, writer, reader = None, None, None, None, None, None
if read:
read_task = nidaqmx.Task()
read_task.ai_channels.add_ai_voltage_chan("%s/ai%s:%s" %(rs,aii,aif), terminal_config=TerminalConfiguration.RSE, min_val=-10, max_val=10)
if write:
write_task = nidaqmx.Task()
write_task.ao_channels.add_ao_voltage_chan("%s/ao%s:%s" %(rs,aoi,aof))
# write_task.ao_channels.add_ao_func_gen_chan
if clock and write and read:
# one-shot data streaming
# Use a counter output pulse train task as the sample clock source for both the AI and AO tasks.
max_samp_rate = read_task.timing.samp_clk_max_rate
print("Max reading rate: %s" %max_samp_rate)
sample_rate = floor(min(sample_rate, max_samp_rate))
clock_task = nidaqmx.Task()
clock_task.co_channels.add_co_pulse_chan_freq('{0}/ctr0'.format(rs), freq=sample_rate, initial_delay=initial_delay, duty_cycle=duty_cycle)
clock_task.timing.cfg_implicit_timing(sample_mode=AcquisitionType.FINITE, samps_per_chan=samps_per_chan)
samp_clk_terminal = '/{0}/Ctr0InternalOutput'.format(rs)
write_task.timing.cfg_samp_clk_timing(sample_rate, source=samp_clk_terminal, active_edge=Edge.RISING, samps_per_chan=samps_per_chan)
read_task.timing.cfg_samp_clk_timing(sample_rate, source=samp_clk_terminal, active_edge=Edge.FALLING, samps_per_chan=samps_per_chan)
# Single Channel:
writer = AnalogSingleChannelWriter(write_task.out_stream)
# reader = AnalogSingleChannelReader(read_task.in_stream)
# Multi Channel:
# writer = AnalogMultiChannelWriter(write_task.out_stream)
reader = AnalogMultiChannelReader(read_task.in_stream)
pack = dict(write_task=write_task, read_task=read_task, clock_task=clock_task, max_samp_rate=max_samp_rate, writer=writer, reader=reader)
return pack
class VITask(BaseDAQTask):
name = 'Voltage In'
def _add_channel_fired(self):
chan = MeasureVoltageChannel()
self.channels.append(chan)
def read_data(self, arr=None):
if not self.reader:
from nidaqmx.stream_readers import AnalogMultiChannelReader
self.reader = AnalogMultiChannelReader(self._task.in_stream)
#chan_names = stream._task.ai_channels.channel_names
number_of_channels = len(self.channels)
nsamp = self.samp_per_chan
data = np.empty((number_of_channels, nsamp), dtype=np.float64)
nread = self.reader.read_many_sample(
data, number_of_samples_per_channel=nsamp, timeout=self.timeout)
data_dict = {}
for k, chan in enumerate(self.channels):
#print(chan.phys_name)
#print(data[k,:])
data_dict[chan.phys_name] = data[k, :]
return data_dict
class ExpFlowSeparation():
def __init__(self, simlator_args):
self.get_setting(simlator_args)
def get_setting(self, arg):
# analog input
self.sample_rate = arg["sample_rate"]
self.number_of_samples = arg["number_of_samples"]
self.dynamic_pressre = arg["dynamic_pressure"]
self.reward_indicator = arg["reward_indicator"]
self.input_channel = arg["input_channels"]
sens_coff = np.array(
arg["sens_cofficients"]) / arg["unit_change"] * arg["gain"]
self.sens_coff = sens_coff.reshape(sens_coff.shape[0], 1)
self.num_i = len(self.sens_coff)
self.nb_actions = arg["nb_actions"]
# state channels for nueral network
self.state_channel = arg["state_channels"]
self.num_s = len(self.state_channel)
self.loc_100 = arg["reward_channel"]
# analog output
self.output_channel = arg["output_channel"]
# another parameters
self.timeout = arg["timeout"]
self.dt = 1 / self.sample_rate
self.total_time = arg["total_time"]
self.n_loop = int(self.sample_rate * self.total_time /
self.number_of_samples)
# plama actuator
self.burst_wave = self.get_burst_wave(arg["plasma_actuator_csv"])
def get_burst_wave(self, filename):
PA = np.zeros((self.nb_actions + 1, self.number_of_samples))
print(filename)
with open(filename, "r") as f:
reader = csv.reader(f)
for i, row in enumerate(reader):
PA[i, :] = row
return PA * 5
def load_args(self, filename):
with open(filename, "r") as f:
args = json.load(f)
return args
def setup_DAQmx(self):
self.read_task = nidaqmx.Task()
self.write_task = nidaqmx.Task()
self.sample_clk_task = nidaqmx.Task()
# Use a counter output pulse train task as the sample clock source
# for both the AI and AO tasks.
self.sample_clk_task.co_channels.add_co_pulse_chan_freq(
'Dev1/ctr0', freq=self.sample_rate, idle_state=Level.LOW)
self.sample_clk_task.timing.cfg_implicit_timing(
sample_mode=AcquisitionType.CONTINUOUS,
samps_per_chan=self.number_of_samples)
self.sample_clk_task.control(TaskMode.TASK_COMMIT)
samp_clk_terminal = '/Dev1/Ctr0InternalOutput'
self.read_task.ai_channels.add_ai_voltage_chan(self.input_channel,
max_val=10,
min_val=-10)
self.read_task.timing.cfg_samp_clk_timing(
self.sample_rate,
source=samp_clk_terminal,
active_edge=Edge.FALLING,
sample_mode=AcquisitionType.CONTINUOUS,
samps_per_chan=self.number_of_samples)
self.write_task.ao_channels.add_ao_voltage_chan(self.output_channel,
max_val=10,
min_val=-10)
self.write_task.timing.cfg_samp_clk_timing(
self.sample_rate,
source=samp_clk_terminal,
active_edge=Edge.FALLING,
sample_mode=AcquisitionType.CONTINUOUS,
samps_per_chan=self.number_of_samples)
self.write_task.out_stream.regen_mode = RegenerationMode.DONT_ALLOW_REGENERATION
self.write_task.out_stream.auto_start = False
self.writer = AnalogSingleChannelWriter(self.write_task.out_stream)
self.reader = AnalogMultiChannelReader(self.read_task.in_stream)
def reset(self):
self.env_memory = np.zeros((0, self.num_i))
self.buffer_memory = np.zeros((0, 4 + self.nb_actions))
self.step_count = 0
self.setup_DAQmx()
# start read analog
self._start_reading()
self._start_writing()
return self._reading()
def step(self, action):
self._writing(action)
observation = self._reading()
reward = np.average(observation[:, self.loc_100])
if action != self.nb_actions:
self.step_count += 1
if self.step_count < self.n_loop:
return observation, reward, False
else:
return observation, reward, True
def _start_reading(self):
# start read analog
self.read_task.start()
self.sample_clk_task.start()
def _start_writing(self):
self._writing(0)
self.write_task.start()
for _ in range(3):
self._writing(0)
def stop_DAQmx(self):
self.read_task.close()
self.write_task.close()
self.sample_clk_task.close()
def _reading(self):
values_read = np.zeros((self.num_i, self.number_of_samples),
dtype=np.float64)
self.reader.read_many_sample(
values_read,
number_of_samples_per_channel=self.number_of_samples,
timeout=2)
return (((values_read / self.sens_coff) + self.dynamic_pressre) /
self.dynamic_pressre).T
def _writing(self, action):
print(self.burst_wave[action].shape)
print(self.burst_wave[action])
self.writer.write_many_sample(self.burst_wave[action])
def runWaveforms(self, clock_source, sampling_rate, analog_signals, digital_signals, readin_channels):
"""
Input:
- samplingrate:
Sampling rate of the waveforms.
- analogsignals:
Signals for the analog channels.
It's a structured array with two fields:
1) 'Waveform': Raw 1-D np.array of actual float voltage signals.
2) 'Sepcification': string telling which device to control that help to specify the NI-daq port, check self.channel_LUT.
Multiple waveforms should be stack on top of each other using np.stack.
if empty, input can be a blank {}.
-digitalsignals:
Signals for the digital channels.
It's a structured array with two fields: 1) 'Waveform': Raw 1-D np.array of type bool.
2) 'Sepcification': string that specifies the NI-daq port.
for example: dtype = np.dtype([('Waveform', float, (self.reference_length,)), ('Sepcification', 'U20')])
-readinchannels:
A list that contains the readin channels wanted.
"""
# =============================================================================
# Setting up waveforms
# =============================================================================
Analog_channel_number = len(analog_signals)
Digital_channel_number = len(digital_signals)
self.readin_channels = readin_channels
self.sampling_rate = sampling_rate
#----------------------------------------------------------------------
# galvosx and galvosy as specification key words are already enough.
# Get the average number and y pixel number information from data
self.galvosx_originalkey = 'galvosx'
self.galvosy_originalkey = 'galvosy'
# If there are kyes with information like 'galvosxavgnum', extract the
# information and then convert the key to 'galvosx'.
if Analog_channel_number != 0:
for i in range(len(analog_signals['Sepcification'])):
if 'galvosxavgnum' in analog_signals['Sepcification'][i]:
self.averagenumber = int(analog_signals['Sepcification'][i][analog_signals['Sepcification'][i].index('_')+1:len(analog_signals['Sepcification'][i])])
self.galvosx_originalkey = analog_signals['Sepcification'][i]
analog_signals['Sepcification'][i] = 'galvosx'
elif 'galvosyypixels' in analog_signals['Sepcification'][i]:
self.ypixelnumber = int(analog_signals['Sepcification'][i][analog_signals['Sepcification'][i].index('_')+1:len(analog_signals['Sepcification'][i])])
self.galvosy_originalkey = analog_signals['Sepcification'][i]
analog_signals['Sepcification'][i] = 'galvosy'
elif 'galvos_X_contour' in analog_signals['Sepcification'][i]:
self.galvosx_originalkey = analog_signals['Sepcification'][i]
analog_signals['Sepcification'][i] = 'galvosx'
elif 'galvos_Y_contour' in analog_signals['Sepcification'][i]:
self.galvosy_originalkey = analog_signals['Sepcification'][i]
analog_signals['Sepcification'][i] = 'galvosy'
#----------------------------------------------------------------------
#-------------------Devide samples from Dev1 or 2----------------------
self.Dev1_analog_channel_list = []
self.Dev2_analog_channel_list = []
Dev1_analog_waveforms_list = []
Dev2_analog_waveforms_list = []
if Analog_channel_number != 0:
if len(analog_signals['Waveform']) != 0:
num_rows, num_cols = analog_signals['Waveform'].shape
for i in range(int(num_rows)):
if 'Dev1' in self.channel_LUT[analog_signals['Sepcification'][i]]:
self.Dev1_analog_channel_list.append(self.channel_LUT[analog_signals['Sepcification'][i]])
Dev1_analog_waveforms_list.append(analog_signals['Waveform'][i])
else:
self.Dev2_analog_channel_list.append(self.channel_LUT[analog_signals['Sepcification'][i]])
Dev2_analog_waveforms_list.append(analog_signals['Waveform'][i])
Dev1_analog_channel_number = len(self.Dev1_analog_channel_list)
Dev2_analog_channel_number = len(self.Dev2_analog_channel_list)
#----------------------------------------------------------------------
# See if only digital signal is involved.
if Analog_channel_number == 0 and Digital_channel_number != 0:
self.Only_Digital_signals = True
else:
self.Only_Digital_signals = False
# See if Dev1 is involved. If only Dev2 is involved in sending analog
# signals then the timing configs are different.
#------------------Number of samples in each waveform------------------
if self.Only_Digital_signals == False:
self.Waveforms_length = len(analog_signals['Waveform'][0])
num_rows, num_cols = analog_signals['Waveform'].shape
print("row number of analog signals: "+str(num_rows))
elif self.Only_Digital_signals == True:
self.Waveforms_length = len(digital_signals['Waveform'][0])
#----------------------------------------------------------------------
#-------Stack the Analog samples of dev1 and dev2 individually---------
# IN CASE OF ONLY ONE ARRAY, WE NEED TO CONVERT THE SHAPE TO (1,N) BY USING np.array([]) OUTSIDE THE ARRAY!!
if Dev1_analog_channel_number == 1:
Dev1_analog_samples_to_write = np.array([Dev1_analog_waveforms_list[0]])
elif Dev1_analog_channel_number == 0:
Dev1_analog_samples_to_write = []
else:
Dev1_analog_samples_to_write = Dev1_analog_waveforms_list[0]
for i in range(1, Dev1_analog_channel_number):
Dev1_analog_samples_to_write = np.vstack((Dev1_analog_samples_to_write, Dev1_analog_waveforms_list[i]))
if Dev2_analog_channel_number == 1:
Dev2_analog_samples_to_write = np.array([Dev2_analog_waveforms_list[0]])
elif Dev2_analog_channel_number == 0:
Dev2_analog_samples_to_write = []
else:
Dev2_analog_samples_to_write = Dev2_analog_waveforms_list[0]
for i in range(1, Dev2_analog_channel_number):
Dev2_analog_samples_to_write = np.vstack((Dev2_analog_samples_to_write, Dev2_analog_waveforms_list[i]))
# Stack the digital samples
if Digital_channel_number == 1:
Digital_samples_to_write = np.array([digital_signals['Waveform'][0]])
elif Digital_channel_number == 0:
Digital_samples_to_write = []
else:
Digital_samples_to_write = digital_signals['Waveform'][0]
for i in range(1, Digital_channel_number):
Digital_samples_to_write = np.vstack((Digital_samples_to_write, digital_signals['Waveform'][i]))
#----------------------------------------------------------------------
#------------------Set the dtype of digital signals--------------------
# For each digital waveform sample, it 0 or 1. To write to NI-daq, you
# need to send int number corresponding to the channel binary value,
# like write 8(2^3, 0001) to channel 4.
# The same as (0b1 << n)
Digital_samples_to_write = np.array(Digital_samples_to_write, dtype = 'uint32')
for i in range(Digital_channel_number):
convernum = int(self.channel_LUT[digital_signals['Sepcification'][i]]
[self.channel_LUT[digital_signals['Sepcification'][i]].index('line')+
4:len(self.channel_LUT[digital_signals['Sepcification'][i]])])
Digital_samples_to_write[i] = Digital_samples_to_write[i]*(2**(convernum))
# For example, to send commands to line 0 and line 3, you hava to write 1001 to digital port, convert to uint32 that is 9.
if Digital_channel_number > 1:
Digital_samples_to_write = np.sum(Digital_samples_to_write, axis = 0) # sum along the columns, for multiple lines
Digital_samples_to_write = np.array([Digital_samples_to_write]) # here convert the shape from (n,) to (1,n)
#------------Set up data holder for recording data---------------------
if len(self.readin_channels) != 0:
self.has_recording_channel = True
else:
self.has_recording_channel = False
if self.has_recording_channel == True:
self.Dataholder = np.zeros((len(self.readin_channels), self.Waveforms_length))
else:
self.Dataholder = np.zeros((1, self.Waveforms_length))
#----------------------------------------------------------------------
# =============================================================================
# Configure DAQ channels and execute waveforms
# =============================================================================
"""
# =============================================================================
# Analog signal in Dev 1 is involved
# =============================================================================
"""
if Dev1_analog_channel_number != 0:
with nidaqmx.Task() as slave_Task_1_analog_dev1, nidaqmx.Task() as slave_Task_1_analog_dev2, nidaqmx.Task() as master_Task_readin, nidaqmx.Task() as slave_Task_2_digitallines:
#------------------adding channels-------------------------
# Set tasks from different devices apart
for i in range(Dev1_analog_channel_number):
slave_Task_1_analog_dev1.ao_channels.add_ao_voltage_chan(self.Dev1_analog_channel_list[i])
slave_Task_2_digitallines.do_channels.add_do_chan("/Dev1/port0", line_grouping=LineGrouping.CHAN_FOR_ALL_LINES)
if self.has_recording_channel == True:
self.Dataholder = np.zeros((len(self.readin_channels), self.Waveforms_length))
else:
self.Dataholder = np.zeros((1, self.Waveforms_length))
master_Task_readin.ai_channels.add_ai_voltage_chan(self.channel_LUT['Vp']) # If no read-in channel is added, vp channel is added to keep code alive.
# print(self.Dataholder.shape)
if 'PMT' in self.readin_channels:
master_Task_readin.ai_channels.add_ai_voltage_chan(self.channel_LUT['PMT'])
if 'Vp' in self.readin_channels:
master_Task_readin.ai_channels.add_ai_voltage_chan(self.channel_LUT['Vp'])
if 'Ip' in self.readin_channels:
master_Task_readin.ai_channels.add_ai_current_chan(self.channel_LUT['Ip'])
#----------------------------------------------------------
#---------------get scaling coefficients-------------------
self.aichannelnames=master_Task_readin.ai_channels.channel_names
self.ai_dev_scaling_coeff_vp = []
self.ai_dev_scaling_coeff_ip = []
if "Vp" in self.readin_channels:
self.ai_dev_scaling_coeff_vp = nidaqmx._task_modules.channels.ai_channel.AIChannel(master_Task_readin._handle, self.channel_LUT['Vp'])
#https://knowledge.ni.com/KnowledgeArticleDetails?id=kA00Z0000019TuoSAE&l=nl-NL
#self.ai_dev_scaling_coeff.ai_dev_scaling_coeff
self.ai_dev_scaling_coeff_vp = np.array(self.ai_dev_scaling_coeff_vp.ai_dev_scaling_coeff)
if "Ip" in self.readin_channels:
self.ai_dev_scaling_coeff_ip = nidaqmx._task_modules.channels.ai_channel.AIChannel(master_Task_readin._handle, self.channel_LUT['Ip'])
#https://knowledge.ni.com/KnowledgeArticleDetails?id=kA00Z0000019TuoSAE&l=nl-NL
#self.ai_dev_scaling_coeff.ai_dev_scaling_coeff
self.ai_dev_scaling_coeff_ip = np.array(self.ai_dev_scaling_coeff_ip.ai_dev_scaling_coeff)
self.ai_dev_scaling_coeff_list = np.append(self.ai_dev_scaling_coeff_vp, self.ai_dev_scaling_coeff_ip)
#----------------------------------------------------------
#----------------------setting clock-----------------------
if clock_source == "DAQ": # If NI-DAQ is set as master clock source
# Analog clock USE clock on Dev1 as center clock
slave_Task_1_analog_dev1.timing.cfg_samp_clk_timing(self.sampling_rate, source='ai/SampleClock', sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
master_Task_readin.timing.cfg_samp_clk_timing(self.sampling_rate, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
# Export the clock timing of Dev1 to specific port, use BNC cable to bridge this port
# and clock receiving port on Dev2.
master_Task_readin.export_signals.samp_clk_output_term = self.channel_LUT['clock1Channel']#'/Dev1/PFI1'#
master_Task_readin.export_signals.start_trig_output_term = self.channel_LUT["trigger1Channel"]#'/Dev1/PFI2'
# If dev2 is involved, set the timing for dev2.
if Dev2_analog_channel_number != 0:
# By default assume that read master task is in dev1
for i in range(Dev2_analog_channel_number):
slave_Task_1_analog_dev2.ao_channels.add_ao_voltage_chan(self.Dev2_analog_channel_list[i])
# Set the clock of Dev2 to the receiving port from Dev1.
dev2Clock = self.channel_LUT['clock2Channel']#/Dev2/PFI1
slave_Task_1_analog_dev2.timing.cfg_samp_clk_timing(self.sampling_rate, source=dev2Clock, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
AnalogWriter = nidaqmx.stream_writers.AnalogMultiChannelWriter(slave_Task_1_analog_dev1.out_stream, auto_start= False)
AnalogWriter.auto_start = False
AnalogWriter_dev2 = nidaqmx.stream_writers.AnalogMultiChannelWriter(slave_Task_1_analog_dev2.out_stream, auto_start= False)
AnalogWriter_dev2.auto_start = False
#----------------------Digital clock-----------------------
if Digital_channel_number != 0:
slave_Task_2_digitallines.timing.cfg_samp_clk_timing(self.sampling_rate, source='ai/SampleClock', sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
#slave_Task_2_digitallines.triggers.sync_type.SLAVE = True
#----------------------------------------------------------
elif clock_source == "Camera":# All the clock should refer to camera output trigger
# Set all clock source to camera trigger receiving port.
self.cam_trigger_receiving_port = '/Dev1/PFI0'
slave_Task_1_analog_dev1.timing.cfg_samp_clk_timing(self.sampling_rate, source=self.cam_trigger_receiving_port, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
slave_Task_1_analog_dev1.triggers.start_trigger.cfg_dig_edge_start_trig(self.cam_trigger_receiving_port)
master_Task_readin.timing.cfg_samp_clk_timing(self.sampling_rate, source=self.cam_trigger_receiving_port, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
master_Task_readin.export_signals.samp_clk_output_term = self.channel_LUT['clock1Channel']#'/Dev1/PFI1'#
master_Task_readin.export_signals.start_trig_output_term = self.channel_LUT['trigger1Channel']#'/Dev1/PFI2'
master_Task_readin.triggers.start_trigger.cfg_dig_edge_start_trig(self.cam_trigger_receiving_port)
if Dev2_analog_channel_number != 0:
# By default assume that read master task is in dev1
for i in range(Dev2_analog_channel_number):
slave_Task_1_analog_dev2.ao_channels.add_ao_voltage_chan(self.Dev2_analog_channel_list[i])
# Set clock of dev2 to the input from dev1 timing output.
dev2Clock = self.channel_LUT['clock2Channel']#/Dev2/PFI1
slave_Task_1_analog_dev2.timing.cfg_samp_clk_timing(self.sampling_rate, source=dev2Clock, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
#slave_Task_1_analog_dev2.triggers.sync_type.SLAVE = True
#slave_Task_1_analog_dev2.triggers.start_trigger.cfg_dig_edge_start_trig(self.channel_LUT["trigger2Channel"])#'/Dev2/PFI7'
AnalogWriter = nidaqmx.stream_writers.AnalogMultiChannelWriter(slave_Task_1_analog_dev1.out_stream, auto_start= False)
AnalogWriter.auto_start = False
AnalogWriter_dev2 = nidaqmx.stream_writers.AnalogMultiChannelWriter(slave_Task_1_analog_dev2.out_stream, auto_start= False)
AnalogWriter_dev2.auto_start = False
#----------------------Digital clock-----------------------
if Digital_channel_number != 0:
slave_Task_2_digitallines.timing.cfg_samp_clk_timing(self.sampling_rate, source=self.cam_trigger_receiving_port, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
slave_Task_2_digitallines.triggers.start_trigger.cfg_dig_edge_start_trig(self.cam_trigger_receiving_port)
#slave_Task_2_digitallines.triggers.sync_type.SLAVE = True
#----------------------------------------------------------
#------------Configure the writer and reader---------------
AnalogWriter = nidaqmx.stream_writers.AnalogMultiChannelWriter(slave_Task_1_analog_dev1.out_stream, auto_start= False)
AnalogWriter.auto_start = False
if Digital_channel_number != 0:
DigitalWriter = nidaqmx.stream_writers.DigitalMultiChannelWriter(slave_Task_2_digitallines.out_stream, auto_start= False)
DigitalWriter.auto_start = False
reader = AnalogMultiChannelReader(master_Task_readin.in_stream)
reader.auto_start = False
# ---------------------------------------------------------------------------------------------------------------------
#-----------------------------------------------------Begin to execute in DAQ------------------------------------------
AnalogWriter.write_many_sample(Dev1_analog_samples_to_write, timeout = 605.0)
if Dev2_analog_channel_number != 0:
AnalogWriter_dev2.write_many_sample(Dev2_analog_samples_to_write, timeout = 605.0)
if Digital_channel_number != 0:
DigitalWriter.write_many_sample_port_uint32(Digital_samples_to_write, timeout = 605.0)
print('^^^^^^^^^^^^^^^^^^Daq tasks start^^^^^^^^^^^^^^^^^^')
if Dev2_analog_channel_number != 0:
slave_Task_1_analog_dev2.start()
slave_Task_1_analog_dev1.start()
if Digital_channel_number != 0:
slave_Task_2_digitallines.start()
master_Task_readin.start() #!!!!!!!!!!!!!!!!!!!! READIN TASK HAS TO START AHEAD OF READ MANY SAMPLES, OTHERWISE ITS NOT SYN!!!
reader.read_many_sample(data = self.Dataholder, number_of_samples_per_channel = self.Waveforms_length, timeout=605.0)
#self.data_PMT = []
slave_Task_1_analog_dev1.wait_until_done()
if Dev2_analog_channel_number != 0:
slave_Task_1_analog_dev2.wait_until_done()
if Digital_channel_number != 0:
slave_Task_2_digitallines.wait_until_done()
master_Task_readin.wait_until_done()
slave_Task_1_analog_dev1.stop()
if Dev2_analog_channel_number != 0:
slave_Task_1_analog_dev2.stop()
if Digital_channel_number != 0:
slave_Task_2_digitallines.stop()
master_Task_readin.stop()
if self.has_recording_channel == True:
self.collected_data.emit(self.Dataholder)
self.finishSignal.emit()
print('^^^^^^^^^^^^^^^^^^Daq tasks finish^^^^^^^^^^^^^^^^^^')
# set the keys of galvos back for next round
if Analog_channel_number != 0:
for i in range(len(analog_signals['Sepcification'])):
if 'galvosx' in analog_signals['Sepcification'][i]:
analog_signals['Sepcification'][i] = self.galvosx_originalkey
elif 'galvosy' in analog_signals['Sepcification'][i]:
analog_signals['Sepcification'][i] = self.galvosy_originalkey
"""
# =============================================================================
# Only Dev 2 is involved in sending analog signals
# =============================================================================
"""
elif Dev2_analog_channel_number != 0:
with nidaqmx.Task() as slave_Task_1_analog_dev2, nidaqmx.Task() as master_Task_readin, nidaqmx.Task() as slave_Task_2_digitallines:
# adding channels
# Set tasks from different devices apart
slave_Task_2_digitallines.do_channels.add_do_chan("/Dev1/port0", line_grouping=LineGrouping.CHAN_FOR_ALL_LINES)
if self.has_recording_channel == True:
self.Dataholder = np.zeros((len(self.readin_channels), self.Waveforms_length))
else:
self.Dataholder = np.zeros((1, self.Waveforms_length))
master_Task_readin.ai_channels.add_ai_voltage_chan(self.channel_LUT['Vp']) # If no read-in channel is added, vp channel is added to keep code alive.
# print(self.Dataholder.shape)
if 'PMT' in self.readin_channels:
master_Task_readin.ai_channels.add_ai_voltage_chan(self.channel_LUT['PMT'])
if 'Vp' in self.readin_channels:
master_Task_readin.ai_channels.add_ai_voltage_chan(self.channel_LUT['Vp'])
if 'Ip' in self.readin_channels:
master_Task_readin.ai_channels.add_ai_current_chan(self.channel_LUT['Ip'])
#get scaling coefficients
self.aichannelnames=master_Task_readin.ai_channels.channel_names
self.ai_dev_scaling_coeff_vp = []
self.ai_dev_scaling_coeff_ip = []
if "Vp" in self.readin_channels:
self.ai_dev_scaling_coeff_vp = nidaqmx._task_modules.channels.ai_channel.AIChannel(master_Task_readin._handle, self.channel_LUT['Vp'])
#self.ai_dev_scaling_coeff.ai_dev_scaling_coeff
self.ai_dev_scaling_coeff_vp = np.array(self.ai_dev_scaling_coeff_vp.ai_dev_scaling_coeff)
if "Ip" in self.readin_channels:
self.ai_dev_scaling_coeff_ip = nidaqmx._task_modules.channels.ai_channel.AIChannel(master_Task_readin._handle, self.channel_LUT['Ip'])
#self.ai_dev_scaling_coeff.ai_dev_scaling_coeff
self.ai_dev_scaling_coeff_ip = np.array(self.ai_dev_scaling_coeff_ip.ai_dev_scaling_coeff)
self.ai_dev_scaling_coeff_list = np.append(self.ai_dev_scaling_coeff_vp, self.ai_dev_scaling_coeff_ip)
#----------------------------------------------------------
#----------------------setting clock-----------------------
if clock_source == "DAQ": # If NI-DAQ is set as master clock source
# setting clock
master_Task_readin.timing.cfg_samp_clk_timing(self.sampling_rate, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
master_Task_readin.export_signals.samp_clk_output_term = self.channel_LUT['clock1Channel']#'/Dev1/PFI1'#
master_Task_readin.export_signals.start_trig_output_term = self.channel_LUT['trigger1Channel']#'/Dev1/PFI2'
if Dev2_analog_channel_number != 0:
# By default assume that read master task is in dev1
for i in range(Dev2_analog_channel_number):
slave_Task_1_analog_dev2.ao_channels.add_ao_voltage_chan(self.Dev2_analog_channel_list[i])
dev2Clock = self.channel_LUT['clock2Channel']#/Dev2/PFI1
slave_Task_1_analog_dev2.timing.cfg_samp_clk_timing(self.sampling_rate, source=dev2Clock, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
AnalogWriter_dev2 = nidaqmx.stream_writers.AnalogMultiChannelWriter(slave_Task_1_analog_dev2.out_stream, auto_start= False)
AnalogWriter_dev2.auto_start = False
# Digital clock
if Digital_channel_number != 0:
slave_Task_2_digitallines.timing.cfg_samp_clk_timing(self.sampling_rate, source='ai/SampleClock', sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
elif clock_source == "Camera":
# All the clock should refer to camera output trigger
self.cam_trigger_receiving_port = '/Dev1/PFI0'
master_Task_readin.timing.cfg_samp_clk_timing(self.sampling_rate, source=self.cam_trigger_receiving_port, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
master_Task_readin.triggers.start_trigger.cfg_dig_edge_start_trig(self.cam_trigger_receiving_port)
master_Task_readin.export_signals.samp_clk_output_term = self.channel_LUT['clock1Channel']#'/Dev1/PFI1'#
master_Task_readin.export_signals.start_trig_output_term = self.channel_LUT['trigger1Channel']#'/Dev1/PFI2'
if Dev2_analog_channel_number != 0:
# By default assume that read master task is in dev1
for i in range(Dev2_analog_channel_number):
slave_Task_1_analog_dev2.ao_channels.add_ao_voltage_chan(self.Dev2_analog_channel_list[i])
dev2Clock = self.channel_LUT['clock2Channel']#/Dev2/PFI1
slave_Task_1_analog_dev2.timing.cfg_samp_clk_timing(self.sampling_rate, source=dev2Clock, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
slave_Task_1_analog_dev2.triggers.start_trigger.cfg_dig_edge_start_trig(self.cam_trigger_receiving_port)
AnalogWriter_dev2 = nidaqmx.stream_writers.AnalogMultiChannelWriter(slave_Task_1_analog_dev2.out_stream, auto_start= False)
AnalogWriter_dev2.auto_start = False
#--------------------Digital clock---------------------
if Digital_channel_number != 0:
slave_Task_2_digitallines.timing.cfg_samp_clk_timing(self.sampling_rate, source=self.cam_trigger_receiving_port, sample_mode= AcquisitionType.FINITE, samps_per_chan=self.Waveforms_length)
slave_Task_2_digitallines.triggers.start_trigger.cfg_dig_edge_start_trig(self.cam_trigger_receiving_port)
#----------------------------------------------------------
# Configure the writer and reader
if Digital_channel_number != 0:
DigitalWriter = nidaqmx.stream_writers.DigitalMultiChannelWriter(slave_Task_2_digitallines.out_stream, auto_start= False)
DigitalWriter.auto_start = False
reader = AnalogMultiChannelReader(master_Task_readin.in_stream)
reader.auto_start = False
# ---------------------------------------------------------------------------------------------------------------------
#-----------------------------------------------------Begin to execute in DAQ------------------------------------------
if Dev2_analog_channel_number != 0:
AnalogWriter_dev2.write_many_sample(Dev2_analog_samples_to_write, timeout = 605.0)
if Digital_channel_number != 0:
DigitalWriter.write_many_sample_port_uint32(Digital_samples_to_write, timeout = 605.0)
print('^^^^^^^^^^^^^^^^^^Daq tasks start^^^^^^^^^^^^^^^^^^')
if Dev2_analog_channel_number != 0:
slave_Task_1_analog_dev2.start()
if Digital_channel_number != 0:
slave_Task_2_digitallines.start()
master_Task_readin.start() #!!!!!!!!!!!!!!!!!!!! READIN TASK HAS TO START AHEAD OF READ MANY SAMPLES, OTHERWISE ITS NOT SYN!!!
reader.read_many_sample(data = self.Dataholder, number_of_samples_per_channel = self.Waveforms_length, timeout=605.0)
#self.data_PMT = []
if Dev2_analog_channel_number != 0:
slave_Task_1_analog_dev2.wait_until_done()
if Digital_channel_number != 0:
slave_Task_2_digitallines.wait_until_done()
master_Task_readin.wait_until_done()
if Dev2_analog_channel_number != 0:
slave_Task_1_analog_dev2.stop()
if Digital_channel_number != 0:
slave_Task_2_digitallines.stop()
master_Task_readin.stop()
if self.has_recording_channel == True:
self.collected_data.emit(self.Dataholder)
self.finishSignal.emit()
print('^^^^^^^^^^^^^^^^^^Daq tasks finish^^^^^^^^^^^^^^^^^^')
# set the keys of galvos back for next round
if Analog_channel_number != 0:
for i in range(len(analog_signals['Sepcification'])):
if 'galvosx' in analog_signals['Sepcification'][i]:
analog_signals['Sepcification'][i] = self.galvosx_originalkey
elif 'galvosy' in analog_signals['Sepcification'][i]:
analog_signals['Sepcification'][i] = self.galvosy_originalkey
"""
# =============================================================================
# Only digital signals
# =============================================================================
"""
elif self.Only_Digital_signals == True:
# some preparations for digital lines
Waveforms_length = len(digital_signals['Waveform'][0])
digitalsignalslinenumber = len(digital_signals['Waveform'])
# Assume that dev1 is always employed
with nidaqmx.Task() as slave_Task_2_digitallines:
# adding channels
# Set tasks from different devices apart
slave_Task_2_digitallines.do_channels.add_do_chan("/Dev1/port0", line_grouping=LineGrouping.CHAN_FOR_ALL_LINES)
# Digital clock
slave_Task_2_digitallines.timing.cfg_samp_clk_timing(self.sampling_rate, sample_mode= AcquisitionType.FINITE, samps_per_chan=Waveforms_length)
# Configure the writer and reader
DigitalWriter = nidaqmx.stream_writers.DigitalMultiChannelWriter(slave_Task_2_digitallines.out_stream, auto_start= False)
DigitalWriter.auto_start = False
# ---------------------------------------------------------------------------------------------------------------------
#-----------------------------------------------------Begin to execute in DAQ------------------------------------------
print('^^^^^^^^^^^^^^^^^^Daq tasks start^^^^^^^^^^^^^^^^^^')
DigitalWriter.write_many_sample_port_uint32(Digital_samples_to_write, timeout = 605.0)
slave_Task_2_digitallines.start()
slave_Task_2_digitallines.wait_until_done(timeout = 605.0)
slave_Task_2_digitallines.stop()
print('^^^^^^^^^^^^^^^^^^Daq tasks finish^^^^^^^^^^^^^^^^^^')
write_task.timing.cfg_samp_clk_timing(sample_rate,
source=samp_clk_terminal,
active_edge=Edge.RISING,
samps_per_chan=number_of_samples)
read_task.ai_channels.add_ai_voltage_chan(flatten_channel_string(
[c.input_channel for c in channels_to_test]),
max_val=10,
min_val=-10)
read_task.timing.cfg_samp_clk_timing(sample_rate,
source=samp_clk_terminal,
active_edge=Edge.FALLING,
samps_per_chan=number_of_samples)
writer = AnalogMultiChannelWriter(write_task.out_stream)
reader = AnalogMultiChannelReader(read_task.in_stream)
values_to_test = np.array([waveform for _ in range(number_of_channels)],
dtype=np.float64)
writer.write_many_sample(values_to_test)
# Start the read and write tasks before starting the sample clock
# source task.
read_task.start()
write_task.start()
sample_clk_task.start()
values_read = np.zeros((number_of_channels, number_of_samples),
dtype=np.float64)
reader.read_many_sample(values_read,
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
class Simulator():
def __init__(self, args, Property):
self.property = Property
self.dynamic_pressre = 57
self.reward_indicator = -0.55
self.sample_rate, self.number_of_samples = self.property.rate()
self.input_channel, self.sens_coff = self.property.i_channels()
self.output_channel = self.property.output()
self.state_channel, self.loc_100 = self.property.s_channels()
self.total_time, self.n_loop = self.property.control()
self.burst_wave_file_name = self.property.get_burst_wave_file()
self.num_i = len(self.sens_coff)
self.num_s = len(self.state_channel)
self.frame_width = args.frame_width
self.frame_height = args.frame_height
self.state_length = args.state_length
self.num_actions = args.n_actions
# 10 moving averege
self.num_mave = 10
self.b = np.ones(self.num_mave) / self.num_mave
self.burst_wave = self.get_burst_wave()
self.before_reward = 0
self.attachment_count = 0
def get_burst_wave(self):
PA = np.zeros((self.num_actions, self.number_of_samples))
with open(self.burst_wave_file_name, 'r') as f:
reader = csv.reader(f)
for i, row in enumerate(reader):
PA[i, :] = row
return PA
def setup_DAQmx(self):
self.read_task = nidaqmx.Task()
self.write_task = nidaqmx.Task()
self.sample_clk_task = nidaqmx.Task()
# Use a counter output pulse train task as the sample clock source
# for both the AI and AO tasks.
self.sample_clk_task.co_channels.add_co_pulse_chan_freq(
'Dev1/ctr0', freq=self.sample_rate, idle_state=Level.LOW)
self.sample_clk_task.timing.cfg_implicit_timing(
sample_mode=AcquisitionType.CONTINUOUS,
samps_per_chan=self.number_of_samples)
self.sample_clk_task.control(TaskMode.TASK_COMMIT)
samp_clk_terminal = '/Dev1/Ctr0InternalOutput'
self.read_task.ai_channels.add_ai_voltage_chan(self.input_channel,
max_val=10,
min_val=-10)
self.read_task.timing.cfg_samp_clk_timing(
self.sample_rate,
source=samp_clk_terminal,
active_edge=Edge.FALLING,
sample_mode=AcquisitionType.CONTINUOUS,
samps_per_chan=self.number_of_samples)
self.write_task.ao_channels.add_ao_voltage_chan(self.output_channel,
max_val=10,
min_val=-10)
self.write_task.timing.cfg_samp_clk_timing(
self.sample_rate,
source=samp_clk_terminal,
active_edge=Edge.FALLING,
sample_mode=AcquisitionType.CONTINUOUS,
samps_per_chan=self.number_of_samples)
self.write_task.out_stream.regen_mode = RegenerationMode.DONT_ALLOW_REGENERATION
self.write_task.out_stream.auto_start = False
self.writer = AnalogSingleChannelWriter(self.write_task.out_stream)
self.reader = AnalogMultiChannelReader(self.read_task.in_stream)
def start_reading(self):
# start read analog
self.read_task.start()
time.sleep(0.1)
self.sample_clk_task.start()
def stop_DAQmx(self):
self.read_task.close()
self.write_task.close()
self.sample_clk_task.close()
def get_observation(self):
values_read = np.zeros((self.num_i, self.number_of_samples),
dtype=np.float64)
self.reader.read_many_sample(
values_read,
number_of_samples_per_channel=self.number_of_samples,
timeout=2)
return (((values_read / self.sens_coff) + self.dynamic_pressre) /
self.dynamic_pressre).T
def get_initial_state(self):
return np.zeros(
(self.state_length * self.frame_height, self.frame_width))
def preprocess(self, observation):
state_t = np.array([
np.convolve(observation[:, self.state_channel[i]],
self.b,
mode='same') for i in range(self.num_s)
]).T
return np.round(
(np.average(np.split(state_t, self.frame_height, 0), axis=1)),
2).reshape(self.frame_height, self.frame_width)
def write_daqmx_zero(self):
values_zero = np.zeros(self.number_of_samples)
self.writer.write_many_sample(values_zero)
def write_daqmx(self, action):
self.writer.write_many_sample(self.burst_wave[action] * 5)
def get_reward(self, reward_ori):
reward = self.reward_indicator < reward_ori
return reward.astype(np.int)
def get_reward_with_punish(self, reward_ori, action):
reward = self.reward_indicator < reward_ori
if reward:
return reward.astype(np.int) * 0.7 - (action - 1) * 0.3
else:
return reward.astype(np.int) * 0.7
def get_reward_with_keep_attachment(self, reward_ori, action):
reward = self.reward_indicator < reward_ori
if (reward.astype(np.int) - self.before_reward) >= 0 and reward:
self.attachment_count += 0.01
else:
self.attachment_count = 0.0
if reward:
return self.attachment_count - (action - 1) * 0.1
else:
return self.attachment_count
