def main(period):
taskHandle = daqmx.TaskHandle()
daqmx.CreateTask("", taskHandle)
physicalChannel = "Dev1/ao0"
t = np.linspace(0, 2 * pi / period, 1000)
data = 2 * np.sin(t)
daqmx.CreateAOVoltageChan(taskHandle, physicalChannel, "", -10.0, 10.0,
daqmx.Val_Volts, None)
daqmx.CfgSampClkTiming(taskHandle, "", 1000.0, daqmx.Val_Rising,
daqmx.Val_ContSamps, 1000)
daqmx.WriteAnalogF64(taskHandle, 1000, 0, 10.0, daqmx.Val_GroupByChannel,
data)
daqmx.StartTask(taskHandle)
for n in range(100):
time.sleep(0.3)
daqmx.StopTask(taskHandle)
daqmx.ClearTask(taskHandle)
def start_daq(self):
# Task parameters
self.th = daqmx.TaskHandle()
daqmx.CreateTask("", self.th)
self.sr = 100.0
daqmx.CreateAIVoltageChan(self.th, self.phys_chan, "",
daqmx.Val_Diff, -10.0, 10.0,
daqmx.Val_Volts, None)
daqmx.CfgSampClkTiming(self.th, "", self.sr, daqmx.Val_Rising,
daqmx.Val_ContSamps, 1000)
daqmx.StartTask(self.th, fatalerror=False)
def main():
# Initializing task
taskhandle = daqmx.TaskHandle()
daqmx.CreateTask("", taskhandle)
phys_chan = "Dev1/ctr0"
#Timing parameters
rate = 200.0
initialdelay = 0
lowtime = 1 / rate / 2
hightime = 1 / rate / 2
daqmx.CreateCOPulseChanTime(taskhandle, phys_chan, "", daqmx.Val_Seconds,
daqmx.Val_Low, initialdelay, lowtime, hightime,
False)
print "Sending trigger pulse to", phys_chan + "..."
daqmx.StartTask(taskhandle, fatalerror=True)
print "Success!"
daqmx.WaitUntilTaskDone(taskhandle, timeout=10, fatalerror=False)
daqmx.ClearTask(taskhandle, fatalerror=False)
def main():
taskhandle = daqmx.TaskHandle()
daqmx.CreateTask("", taskhandle)
phys_chan = "cDAQ9188-16D66BBMod3/ctr2"
globalchan = "VecPulse"
#Timing parameters
rate = 200 # Pulse rate in Hz
initialdelay = 0
lowtime = 1 / rate / 2
hightime = 1 / rate / 2
# daqmx.CreateCOPulseChanTime(taskhandle, phys_chan, "", daqmx.Val_Seconds,
# daqmx.Val_Low, initialdelay, lowtime, hightime,
# False)
daqmx.AddGlobalChansToTask(taskhandle, globalchan)
daqmx.CfgImplicitTiming(taskhandle, daqmx.Val_FiniteSamps, 1)
# Set up communication with motion controller
simulator = False
# Parameters for plotting
plotting = False
plot_dynamic = False
if simulator == True:
hcomm = acsc.OpenCommDirect()
else:
hcomm = acsc.OpenCommEthernetTCP("10.0.0.100", 701)
axis = 5
buffno = 7
target = 0
timeout = 10
# Initialize arrays for storing time and position
t = np.array(0)
x = np.array(0)
if plotting == True and plot_dynamic == True:
plt.ioff()
fig = plt.figure()
ax = fig.add_subplot(111)
# plt.xlim(0, timeout)
# plt.ylim(0, target)
line, = ax.plot([], [])
fig.show()
if hcomm == acsc.INVALID:
print "Cannot connect to controller. Error:", acsc.GetLastError()
else:
# acsc.Enable(hcomm, axis)
rpos = acsc.GetRPosition(hcomm, axis)
x = rpos
t0 = time.time()
if simulator == True:
acsc.ToPoint(hcomm, 0, axis, target + 50000)
else:
acsc.RunBuffer(hcomm, buffno, None, None)
while True:
rpos = acsc.GetRPosition(hcomm, axis)
if rpos >= target: break
x = np.append(x, rpos)
t = np.append(t, time.time() - t0)
if plotting == True and plot_dynamic == True:
line.set_xdata(t)
line.set_ydata(x)
ax.relim()
ax.autoscale_view()
fig.canvas.draw()
print "Axis is", acsc.GetAxisState(hcomm, axis) + '...'
if time.time() - t0 > timeout:
print "Motion timeout"
print "Final axis position:", rpos
break
time.sleep(0.001)
print "Target reached. Sending trigger pulse to", globalchan + "..."
daqmx.StartTask(taskhandle, fatalerror=False)
daqmx.WaitUntilTaskDone(taskhandle, timeout=10, fatalerror=False)
daqmx.ClearTask(taskhandle, fatalerror=False)
acsc.CloseComm(hcomm)
print "Triggered at", np.max(x)
if plotting == True:
if plot_dynamic == False:
plt.plot(t, x)
plt.show()
return t, x
def start_reading(self):
# start read analog
daqmx.StartTask(self.AItask, fatalerror=False)
def start(self):
if not self.sample_clock_configured:
self.configure_sample_clock()
daqmx.StartTask(self.handle)
daqmx.CreateAOVoltageChan(AOtaskHandle, "Dev1/ao0", "", -10.0, 10.0,
daqmx.Val_Volts, None)
daqmx.CfgSampClkTiming(AOtaskHandle, "", sr, daqmx.Val_Rising,
daqmx.Val_ContSamps, 1000)
daqmx.CreateAIVoltageChan(AItaskHandle, "Dev1/ai1", "", daqmx.Val_Diff, -10.0,
10.0, daqmx.Val_Volts, None)
daqmx.CfgSampClkTiming(AItaskHandle, "", sr, daqmx.Val_Rising,
daqmx.Val_ContSamps, 1000)
written = daqmx.WriteAnalogF64(AOtaskHandle, 1000, 0, 10.0,
daqmx.Val_GroupByChannel, data)
dataread, nread = daqmx.ReadAnalogF64(AItaskHandle, 1000, 10.0,
daqmx.Val_GroupByChannel, 1000, 1)
daqmx.StartTask(AOtaskHandle)
daqmx.StartTask(AItaskHandle)
print written, "samples written"
print nread, "samples read"
plt.plot(dataread)
daqmx.StopTask(AItaskHandle)
daqmx.ClearTask(AItaskHandle)
daqmx.StopTask(AOtaskHandle)
daqmx.ClearTask(AOtaskHandle)
def main():
# Task parameters
taskhandle = daqmx.TaskHandle()
daqmx.CreateTask("", taskhandle)
phys_chan = b"Dev1/ai0"
nchan = 1
sr = 100.0
dt = 1 / sr
totaltime = 3
nloops = int(sr * totaltime / 10)
# Analog read parameters
samps_per_chan = 10
timeout = 10
fillmode = daqmx.Val_GroupByChannel
array_size_samps = 1000
daqmx.CreateAIVoltageChan(taskhandle, phys_chan, "", daqmx.Val_Diff, -10.0,
10.0, daqmx.Val_Volts, None)
daqmx.CfgSampClkTiming(taskhandle, "", sr, daqmx.Val_Rising,
daqmx.Val_ContSamps, 1000)
# Parameters for plotting
plotting = True
plot_dynamic = True
if plotting == True and plot_dynamic == True:
plt.ioff()
fig = plt.figure()
ax = fig.add_subplot(111)
line, = ax.plot([], )
fig.show()
daqmx.StartTask(taskhandle, fatalerror=False)
v = np.array([])
for n in range(nloops):
data, spc = daqmx.ReadAnalogF64(taskhandle, samps_per_chan, timeout,
fillmode, array_size_samps, nchan)
v = np.append(v, data[:, 0])
time.sleep(0.001)
t = np.float64(range(len(v))) * dt
if plotting == True and plot_dynamic == True:
line.set_xdata(t)
line.set_ydata(v)
ax.relim()
ax.autoscale_view()
fig.canvas.draw()
daqmx.ClearTask(taskhandle)
print("Task complete")
if plotting == True:
if plot_dynamic == False:
plt.plot(t, v)
plt.show()
return t, data
def run(self, dur):
"""Start DAQmx tasks."""
# Acquire and throwaway samples for alignment
# Need to set these up on a different task?
# Callback code from PyDAQmx
class MyList(list):
pass
# List where the data are stored
data = MyList()
id_data = daqmx.create_callbackdata_id(data)
def EveryNCallback_py(taskHandle, everyNsamplesEventType, nSamples,
callbackData_ptr):
"""Function called every N samples"""
callbackdata = daqmx.get_callbackdata_from_id(callbackData_ptr)
data, npoints = daqmx.ReadAnalogF64(taskHandle, self.nsamps, 10.0,
daqmx.Val_GroupByChannel,
self.nsamps,
len(self.analogchans))
callbackdata.extend(data.tolist())
self.data["torque_trans"] = np.append(self.data["torque_trans"],
data[:, 0],
axis=0)
self.data["torque_arm"] = np.append(self.data["torque_arm"],
data[:, 1],
axis=0)
self.data["drag_left"] = np.append(self.data["drag_left"],
data[:, 2],
axis=0)
self.data["drag_right"] = np.append(self.data["drag_right"],
data[:, 3],
axis=0)
self.data["t"] = np.arange(len(self.data["torque_trans"]),
dtype=float) / self.sr
carpos, cpoints = daqmx.ReadCounterF64(self.carpostask,
self.nsamps, 10.0,
self.nsamps)
self.data["carriage_pos"] = np.append(self.data["carriage_pos"],
carpos)
turbang, cpoints = daqmx.ReadCounterF64(self.turbangtask,
self.nsamps, 10.0,
self.nsamps)
self.data["turbine_angle"] = np.append(self.data["turbine_angle"],
turbang)
self.data["turbine_rpm"] \
= ts.smooth(fdiff.second_order_diff(self.data["turbine_angle"],
self.data["t"])/6.0, 50)
return 0 # The function should return an integer
# Convert the python callback function to a CFunction
EveryNCallback = daqmx.EveryNSamplesEventCallbackPtr(EveryNCallback_py)
daqmx.RegisterEveryNSamplesEvent(self.analogtask,
daqmx.Val_Acquired_Into_Buffer,
self.nsamps, 0, EveryNCallback,
id_data)
def DoneCallback_py(taskHandle, status, callbackData_ptr):
print("Status", status.value)
return 0
DoneCallback = daqmx.DoneEventCallbackPtr(DoneCallback_py)
daqmx.RegisterDoneEvent(self.analogtask, 0, DoneCallback, None)
# Start the tasks
daqmx.StartTask(self.carpostask)
daqmx.StartTask(self.turbangtask)
daqmx.StartTask(self.analogtask)
time.sleep(dur)
self.clear()
def run(self, Nepisode, targetQN, train=True):
self.setup_DAQmx()
# Parameters for plotting
# initiate
seq = np.zeros((self.num,self.NICH))
read = np.zeros((0,self.NCH))
state_t = np.zeros((self.SPC,self.NICH))
b = np.ones(self.num_mave)/self.num_mave
tilen = int(self.intispn / 0.01)
# start read analog
daqmx.StartTask(self.AItask, fatalerror=False)
# first loop
# you read
# you do not act
# this loop is for caliburation of reward
# you need to satrt writeanalog in first loop
# 'cause the function takes time to start
for n in range(self.nloops):
read_t, _ = daqmx.ReadAnalogF64(self.AItask,self.SPC,self.TO,self.MODE,self.ASS,self.NCH)
read_t = read_t/self.sensor_coff
# moving average filter
for ich in range(self.NICH):
state_t[self.num_mave-1:,ich] = np.convolve(read_t[:,self.IAIs[ich]], b, mode='vaild')
state_ave = ( np.average(np.split(state_t,int(self.num/tilen),0),axis=1) + self.dynamic_pressre )/self.dynamic_pressre
seq[self.num-int(self.num/tilen):self.num,:] = np.round(state_ave,2)
# action
# adopt output timing and action zero
if n!=10 or n!=20 or n!=40 or n!=50 or n!=60 or n!=80 or n!=90:
daqmx.WriteAnalogF64(self.AOtask,self.OB,1,self.TO,daqmx.Val_GroupByChannel,np.zeros(self.OB))
# reward
reward_t = np.average(read_t[:,self.CH100])
self.memory.add_local(seq,0,reward_t,0)
read = np.append(read,read_t,axis=0)
seq = shift(seq,[-self.num/tilen,0],cval=0)
# calibulate
self.memory.calc_calibulation()
# second loop
# you read
# you act
for n in range(self.nloops):
read_t, _ = daqmx.ReadAnalogF64(self.AItask,self.SPC,self.TO,self.MODE,self.ASS,self.NCH)
read_t = read_t/self.sensor_coff
# moving average filter
for ich in range(self.NICH):
state_t[self.num_mave-1:,ich] = np.convolve(read_t[:,self.IAIs[ich]], b, mode='vaild')
state_ave = ( np.average(np.split(state_t,int(self.num/tilen),0),axis=1) + self.dynamic_pressre )/self.dynamic_pressre
seq[self.num-int(self.num/tilen):self.num,:] = np.round(state_ave,2)
# action
ai = self.actor.get_action(seq.reshape(-1,self.num,self.NICH), self.QN,train)
daqmx.WriteAnalogF64(self.AOtask,self.OB,1,self.TO,daqmx.Val_GroupByChannel,self.PA[ai,:]*3)
# reward
reward_t = np.average(read_t[:,self.CH100])
self.memory.add_local(seq,ai,reward_t,0)
read = np.append(read,read_t,axis=0)
seq = shift(seq,[-self.num/tilen,0],cval=0)
# third loop
# you read
# you do not act
# make sure PA turn off
for n in range(self.nloops):
read_t, _ = daqmx.ReadAnalogF64(self.AItask,self.SPC,self.TO,self.MODE,self.ASS,self.NCH)
read_t = read_t/self.sensor_coff
# moving average filter
for ich in range(self.NICH):
state_t[self.num_mave-1:,ich] = np.convolve(read_t[:,self.IAIs[ich]], b, mode='vaild')
state_ave = ( np.average(np.split(state_t,int(self.num/tilen),0),axis=1) + self.dynamic_pressre )/self.dynamic_pressre
seq[self.num-int(self.num/tilen):self.num,:] = np.round(state_ave,2)
# action
# action zero
daqmx.WriteAnalogF64(self.AOtask,self.OB,1,self.TO,daqmx.Val_GroupByChannel,np.zeros(self.OB))
# reward
reward_t = np.average(read_t[:,self.CH100])
self.memory.add_local(seq,0,reward_t,0)
read = np.append(read,read_t,axis=0)
seq = shift(seq,[-self.num/tilen,0],cval=0)
# stop DAQmx
self.stop_DAQmx()
# edit experience in buffer
self.memory.edit_experience_local()
self.save(read,Nepisode)
total_reward = self.memory.totalreward()
# move current experience to global buffer
self.memory.add_global(total_reward)
if (self.memory.len() > self.batch_num) and train:
self.loss=self.QN.replay(self.memory,self.batch_num,self.gamma,targetQN)
self.actor.reduce_epsilon()
return total_reward, self.loss
diTaskHandle = daqmx.TaskHandle()
daqmx.CreateTask("", aiTaskHandle)
daqmx.CreateAIVoltageChan(aiTaskHandle, "Dev1/ai0", "", daqmx.Val_Diff, 0.0,
10.0, daqmx.Val_Volts)
daqmx.CfgSampClkTiming(aiTaskHandle, "", 100.0, daqmx.Val_Rising,
daqmx.Val_ContSamps, 1000)
trigname = daqmx.GetTerminalNameWithDevPrefix(aiTaskHandle, "ai/SampleClock")
daqmx.CreateTask("", diTaskHandle)
daqmx.CreateDIChan(diTaskHandle, "Dev1/port0", "", daqmx.Val_ChanForAllLines)
daqmx.CfgSampClkTiming(diTaskHandle, trigname, 100.0, daqmx.Val_Rising,
daqmx.Val_ContSamps, 1000)
daqmx.StartTask(diTaskHandle)
daqmx.StartTask(aiTaskHandle)
adata = daqmx.ReadAnalogF64(aiTaskHandle, 1000, 10.0, daqmx.Val_GroupByChannel,
1000, 1)
ddata = daqmx.ReadDigitalU32(diTaskHandle, 1000, 10.0,
daqmx.Val_GroupByChannel, 1000, 1)
print adata
print ddata
daqmx.StopTask(diTaskHandle)
daqmx.StopTask(aiTaskHandle)
daqmx.ClearTask(diTaskHandle)
daqmx.ClearTask(aiTaskHandle)
def run(self):
self.rampeddown = False
self.cleared = False
self.making = False
# Compute the voltage time series associated with the wave
self.wave.gen_ts_volts()
# Get parameters from the wave object
self.period = self.wave.period
self.height = self.wave.height
self.buffsize = self.wave.sbuffsize
self.sr = self.wave.sr
# Get data to write from the wave object
self.ts_plot = self.wave.ts_elev
self.dataw = self.wave.ts_volts
# If random waves, divide up time series into 120 256 sample parts
if self.wavetype != "Regular":
tsparts = np.reshape(self.dataw, (120, 256))
self.dataw = tsparts[0, :]
# Compute spectrum for plot
if self.wavetype == "Regular":
self.outf, self.outspec = self.wave.comp_spec()
else:
self.outf, self.outspec = self.wave.f, self.wave.spec
# Ramp time series
rampup_ts = ramp_ts(self.dataw, "up")
# Set making variable true
self.making = True
self.AOtaskHandle = daqmx.TaskHandle()
daqmx.CreateTask("", self.AOtaskHandle)
daqmx.CreateAOVoltageChan(self.AOtaskHandle, "Dev1/ao0", "", -10.0,
10.0, daqmx.Val_Volts, None)
daqmx.CfgSampClkTiming(self.AOtaskHandle, "", self.sr,
daqmx.Val_Rising, daqmx.Val_ContSamps,
self.buffsize)
daqmx.SetWriteRegenMode(self.AOtaskHandle, daqmx.Val_DoNotAllowRegen)
# Setup a callback function to run once the DAQmx driver finishes
def DoneCallback_py(taskHandle, status, callbackData_ptr):
self.rampeddown = True
return 0
DoneCallback = daqmx.DoneEventCallbackPtr(DoneCallback_py)
daqmx.RegisterDoneEvent(self.AOtaskHandle, 0, DoneCallback, None)
# Output the rampup time series
daqmx.WriteAnalogF64(self.AOtaskHandle, self.buffsize, False, 10.0,
daqmx.Val_GroupByChannel, rampup_ts)
daqmx.StartTask(self.AOtaskHandle)
# Wait a second to allow the DAQmx buffer to empty
if self.wavetype == "Regular":
time.sleep(self.period * 0.99) # was self.period*0.4
else:
time.sleep(0.99)
# Set iteration variable to keep track of how many chunks of data
# have been written
i = 1
# Main running loop that writes data to DAQmx buffer
while self.enable:
writeSpaceAvail = daqmx.GetWriteSpaceAvail(self.AOtaskHandle)
if writeSpaceAvail >= self.buffsize:
if self.wavetype != "Regular":
if i >= 120:
self.dataw = tsparts[i % 120, :]
else:
self.dataw = tsparts[i, :]
daqmx.WriteAnalogF64(self.AOtaskHandle, self.buffsize, False,
10.0, daqmx.Val_GroupByChannel,
self.dataw)
i += 1
if self.wavetype == "Regular":
time.sleep(0.99 * self.period)
else:
time.sleep(0.99) # Was self.period
# After disabled, initiate rampdown time series
if self.wavetype != "Regular":
if i >= 120:
self.rampdown_ts = ramp_ts(tsparts[i % 120, :], "down")
else:
self.rampdown_ts = ramp_ts(tsparts[i, :], "down")
else:
self.rampdown_ts = ramp_ts(self.dataw, "down")
# Write rampdown time series
daqmx.WriteAnalogF64(self.AOtaskHandle, self.buffsize, False, 10.0,
daqmx.Val_GroupByChannel, self.rampdown_ts)
# Keep running, part of PyDAQmx callback syntax
while True:
pass
