def main(self): try: try: _a=self.inputs[:] trigger="external" except AttributeError: trigger="internal" timer=time.time() print "mesureagilent " , os.getpid() while True: data=[] #print "-1" if trigger=="internal": #print "-2" if self.freq!=None: while time.time()-timer< 1./self.freq: delay(1./(100*1000*self.freq)) timer=time.time() data=[timer-self.t0] ret=self.agilentSensor.getData() if ret!= False: # if there is data data.append(ret) enable_sending=True #Data=pd.DataFrame([data],columns=self.labels) #print self.labels, data Data=OrderedDict(zip(self.labels,data)) #print zip(self.labels,[data]) else: enable_sending=False # no data means no sending if trigger=="external": #print "-3" Data = self.inputs[0].recv() # wait for a signal #print "data agilent : ", Data if Data is not None: ret=self.agilentSensor.getData() #print "ret :", ret if ret != False: Data[self.labels[0]] = (time.time()-self.t0) #TODO verify if timestamps really differ and delete this line Data[self.labels[1]] = ret # add one column enable_sending=True else: enable_sending=False if enable_sending: #or Data is not None: try: for output in self.outputs: output.send(Data) except TimeoutError: raise except AttributeError: #if no outputs pass except (Exception,KeyboardInterrupt) as e: print "Exception in measureAgilent34420A : ", e self.agilentSensor.close()
def main(self):
try:
print "PathGenerator!" ,os.getpid()
last_t=self.t0
cycle=0
first=True
first_of_step=True
t_step=self.t0
Data=pd.DataFrame()
while self.step<self.nb_step:
current_step=self.path[self.step]
print "current step : ", self.step
try:
self.waveform=current_step["waveform"]
if self.waveform=='hold':
self.time=current_step["time"]
elif self.waveform=='limit':
self.gain=current_step["gain"]
self.cycles=current_step["cycles"]
self.phase=current_step["phase"]
self.lower_limit=current_step["lower_limit"]
self.upper_limit=current_step["upper_limit"]
elif self.waveform=='goto':
self.direction=current_step["direction"]
self.value=current_step["value"]
self.offset=current_step["offset"]
#print "goto 1"
elif self.waveform=='protection':
self.gain=current_step["gain"]
#self.cycles=current_step["cycles"]
#self.phase=current_step["phase"]
self.lower_limit=current_step["lower_limit"]
self.upper_limit=current_step["upper_limit"]
else:
#print "test"
self.time=current_step["time"]
self.phase=current_step["phase"]
self.amplitude=current_step["amplitude"]
self.offset=current_step["offset"]
self.freq=current_step["freq"]
except KeyError as e:
print "You didn't define parameter %s for step number %s" %(e,self.step)
raise
if self.waveform=="goto": # signal defined by a lower and upper limit
#print "goto 2"
cycle=0
security=0
while cycle==0:
while time.time()-last_t<1./self.send_freq or first:
for input_ in self.inputs:
if input_.in_.poll() or first: # if there is data waiting
recv=input_.recv()
#print recv
df=pd.DataFrame([recv.values()],columns=recv.keys())
Data=pd.concat([Data,df],ignore_index=True)
security+=1
if security>=2:
first=False
#first=False
delay(1./(100*1000*self.send_freq))
last_t=time.time()
#print "goto 3"
last_upper = (Data[self.value[1]]).last_valid_index()
last_lower=(Data[self.value[1]]).last_valid_index()
first_lower=(Data[self.value[1]]).first_valid_index()
first_upper=(Data[self.value[1]]).first_valid_index()
alpha=self.direction
#print Data,self.value
#print abs(Data[self.value[1]][last_upper]-self.value[0])
if abs(Data[self.value[1]][last_upper]-self.value[0])<self.offset: # if value > high_limit
alpha=0
cycle=1
if last_upper!=first_upper and last_lower!=first_lower: # clean old data
Data=Data[min(last_upper,last_lower):]
Array=OrderedDict(zip(self.labels,[last_t-self.t0,alpha,cycle]))
#print "goto 4"
try:
for output in self.outputs:
output.send(Array)
except TimeoutError:
raise
except AttributeError: #if no outputs
pass
self.step+=1
first=True
first_of_step=True
cycle=0
#print "end goto"
t_step=time.time()
elif self.waveform=="limit": # signal defined by a lower and upper limit
alpha=np.sign(np.cos(self.phase))
while self.cycles is None or cycle<self.cycles:
while time.time()-last_t<1./self.send_freq or first:
for input_ in self.inputs:
if input_.in_.poll() or first: # if there is data waiting
recv=input_.recv()
#print recv
df=pd.DataFrame([recv.values()],columns=recv.keys())
Data=pd.concat([Data,df],ignore_index=True)
first=False
delay(1./(100*1000*self.send_freq))
#print "here" , df, Data
last_t=time.time()
last_upper = (Data[self.upper_limit[1]]).last_valid_index()
last_lower=(Data[self.lower_limit[1]]).last_valid_index()
first_lower=(Data[self.lower_limit[1]]).first_valid_index()
first_upper=(Data[self.upper_limit[1]]).first_valid_index()
#print Data
#print "here2"
if first_of_step:
if alpha>0:
if Data[self.upper_limit[1]][last_upper]>self.upper_limit[0]: # if value > high_limit
alpha=-1
elif alpha <0:
if Data[self.lower_limit[1]][last_lower]<self.lower_limit[0]: # if value < low_limit
alpha=1
first_of_step=False
#if self.step==1:
#print Data
#print alpha
#print last_upper,last_lower,first_lower,first_upper
#print self.cycles
#print self.lower_limit
#print self.upper_limit
if self.upper_limit==self.lower_limit: # if same limits
alpha=0
cycle=time.time()-t_step
if alpha>0:
if Data[self.upper_limit[1]][last_upper]>self.upper_limit[0]: # if value > high_limit
alpha=-1
cycle+=0.5
elif alpha <0:
if Data[self.lower_limit[1]][last_lower]<self.lower_limit[0]: # if value < low_limit
alpha=1
cycle+=0.5
if last_upper!=first_upper and last_lower!=first_lower: # clean old data
Data=Data[min(last_upper,last_lower):]
#Array=pd.DataFrame([[last_t-self.t0,alpha*self.gain,cycle]],columns=self.labels)
Array=OrderedDict(zip(self.labels,[last_t-self.t0,alpha*self.gain,cycle]))
try:
for output in self.outputs:
output.send(Array)
except TimeoutError:
raise
except AttributeError: #if no outputs
pass
self.step+=1
first=True
first_of_step=True
cycle=0
#if self.repeat and self.step==self.nb_step:
#self.step=0
t_step=time.time()
elif self.waveform=="protection": # signal defined by a lower and upper limit
while True:
while time.time()-last_t<1./self.send_freq or first:
for input_ in self.inputs:
if input_.in_.poll() or first: # if there is data waiting
recv=input_.recv()
#print recv
df=pd.DataFrame([recv.values()],columns=recv.keys())
Data=pd.concat([Data,df],ignore_index=True)
first=False
delay(1./(100*1000*self.send_freq))
#print "here" , df, Data
last_t=time.time()
last_upper = (Data[self.upper_limit[1]]).last_valid_index()
last_lower=(Data[self.lower_limit[1]]).last_valid_index()
first_lower=(Data[self.lower_limit[1]]).first_valid_index()
first_upper=(Data[self.upper_limit[1]]).first_valid_index()
if Data[self.upper_limit[1]][last_upper]>self.upper_limit[0]: # if value > high_limit
alpha=-1
elif Data[self.lower_limit[1]][last_lower]<self.lower_limit[0]: # if value < low_limit
alpha=1
else: #if in between the values
alpha=0
cycle=-1
if last_upper!=first_upper and last_lower!=first_lower: # clean old data
Data=Data[min(last_upper,last_lower):]
#Array=pd.DataFrame([[last_t-self.t0,alpha*self.gain,cycle]],columns=self.labels)
Array=OrderedDict(zip(self.labels,[last_t-self.t0,alpha*self.gain,cycle]))
try:
for output in self.outputs:
output.send(Array)
except TimeoutError:
raise
except AttributeError: #if no outputs
pass
self.step+=1
first=True
first_of_step=True
cycle=0
#if self.repeat and self.step==self.nb_step:
#self.step=0
t_step=time.time()
elif self.waveform=="hold":
#print "holding"
while self.time is None or (time.time()-t_step)<self.time:
while time.time()-last_t<1./self.send_freq:
try:
for input_ in self.inputs:
recv=input_.recv(blocking=False)
#first=False
except AttributeError: #if no inputs
pass
#first=False
delay(1./(100*1000*self.send_freq))
last_t=time.time()
#last_upper = (Data[self.upper_limit[1]]).last_valid_index()
#last_lower=(Data[self.lower_limit[1]]).last_valid_index()
#first_lower=(Data[self.lower_limit[1]]).first_valid_index()
#first_upper=(Data[self.upper_limit[1]]).first_valid_index()
if self.step==0:
self.alpha=0
else:
if self.path[self.step-1]["waveform"]=="limit":
self.alpha=0
elif self.path[self.step-1]["waveform"]=="goto":
self.alpha=0
else:
pass
#if last_upper!=first_upper and last_lower!=first_lower: # clean old data
#Data=Data[min(last_upper,last_lower):]
#Array=pd.DataFrame([[last_t-self.t0,self.alpha,0]],columns=self.labels)
Array=OrderedDict(zip(self.labels,[last_t-self.t0,self.alpha,0]))
try:
for output in self.outputs:
output.send(Array)
except TimeoutError:
raise
except AttributeError: #if no outputs
pass
self.step+=1
first_of_step=True
cycle=0
first=True
#if self.repeat and self.step==self.nb_step:
#self.step=0
t_step=time.time()
else:
#print self.waveform
t_add=self.phase/(2*np.pi*self.freq)
#sleep_max=0
#sleep_min=500
#sleep_avg=0
#sleep_tot=0
#t_sleep=0
#t_calc=0
#t_send=0
#loop_max=0
#j=1
#t_loop=self.t0
#t_loop_mean=0
while self.time is None or (time.time()-t_step)<self.time:
#t1=time.time()
while time.time()-last_t<1./self.send_freq:
try:
for input_ in self.inputs:
recv=input_.recv(blocking=False)
#first=False
except AttributeError:
pass
delay(1./(100*1000*self.send_freq))
#time.sleep(0.0001)
#select.select([],[],[],0.0001)
#time.sleep(1./(100*self.send_freq))
last_t=time.time()
#t_sleep=max(last_t-t1,t_sleep)
t=last_t+t_add
if self.waveform=="sinus":
self.alpha=self.amplitude*np.sin(2*np.pi*(t-t_step)*self.freq)+self.offset
elif self.waveform=="triangle":
self.alpha=(4*self.amplitude*self.freq)*((t-t_step)-(np.floor(2*self.freq*(t-t_step)+0.5))/(2*self.freq))*(-1)**(np.floor(2*self.freq*(t-t_step)+0.5))+self.offset
elif self.waveform=="square":
self.alpha=self.amplitude*np.sign(np.cos(2*np.pi*(t-t_step)*
self.freq))+self.offset
else:
raise Exception("invalid waveform : use sinus,triangle or square")
#t2=time.time()
#t_calc=max(t2-last_t,t_calc)
cycle=0.5*np.floor(2*((t-t_step)*self.freq+0.25))
#Array=pd.DataFrame([[t-self.t0,self.alpha,cycle]],columns=self.labels)
Array=OrderedDict(zip(self.labels,[t-self.t0,self.alpha,cycle]))
try:
for output in self.outputs:
output.send(Array)
except TimeoutError:
raise
except AttributeError: #if no outputs
pass
#t3=time.time()
#t_send=max(t3-t2,t_send)
#loop_max=max(loop_max,t3-t_loop)
#t_loop_mean+=t3-t_loop
#if j%500==0:
#loop_max=0
#t_sleep=0
#t_calc=0
#t_send=0
#t_loop=t3
#j+=1
self.step+=1
t_step=time.time()
first=True
first_of_step=True
if self.repeat and self.step==self.nb_step:
self.step=0
raise Exception("Completed !")
except (Exception,KeyboardInterrupt) as e:
exc_type, exc_obj, tb = sys.exc_info()
lineno = tb.tb_lineno
print "Exception in PathGenerator %s: %s line %s" %(os.getpid(),e,lineno)
