def store(self):
eventStr = "STORE " + str(self.id.data())
print(eventStr)
Event.setevent(self.getEventName(), eventStr)
#sleep(10)
sleep(2)
return 1
def run(self):
while not self.stopReq:
readyFds = self.poll.poll(1000)
for fdTuple in readyFds:
readyFd = fdTuple[0]
event = fdTuple[1]
print('EVENT: ', fdTuple, select.EPOLLIN)
if event & select.EPOLLIN == 0:
print('NO DATA')
if event & select.EPOLLERR != 0:
print('POLL ERROR!!')
return
timestamp = c_ulonglong()
status = NI6683.niLib.nisync_read_timestamps_ns(
c_int(readyFd), byref(timestamp), c_int(1))
self.device.checkStatus(status, 'Cannot get current time')
termName = self.nameDict[readyFd]
recorderNid = getattr(self.device,
termName.lower() + '_raw_events')
eventRelTime = self.device.getRelTime(timestamp.value)
recorderNid.putRow(10, Float64(eventRelTime),
Float64(eventRelTime))
try:
eventNameNid = getattr(
self.device,
termName.lower() + '_event_name')
eventName = eventNameNid.data()
Event.setevent(eventName, Uint64(timestamp.value))
except:
pass
def init(self):
eventStr = "SETUP " + str(self.id.data()) + " " + Tree.getTree().name
eventStr = eventStr + " " + str(Tree.getTree().shot)
try:
eventStr = eventStr + " " + str(self.frequency.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot read frequency')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.trig_source.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read trigger source')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.sampl_start.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read Sampling start')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.sampl_end.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read Sampling end')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.offset_start.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read Offset start')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.offset_end.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid,
'Cannot read Offset end')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
eventStr = eventStr + " " + str(self.duration.data())
except:
Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot read Duration')
raise mdsExceptions.TclFAILED_ESSENTIAL
eventStr = eventStr + " " + str(self.params.getNid())
eventStr = eventStr + " " + str(self.wave_params.getNid())
eventStr = eventStr + " " + str(self.input_cal.getNid())
eventStr = eventStr + " " + str(self.output_cal.getNid())
try:
eventStr = eventStr + " " + self.control.data()
except:
Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot read Control')
raise mdsExceptions.TclFAILED_ESSENTIAL
eventStr = eventStr + " " + str(self.signals_adc_in.getNid())
eventStr = eventStr + " " + str(self.signals_dac_out.getNid())
eventStr = eventStr + " " + str(self.signals_user.getNid())
print(eventStr)
Event.setevent(self.getEventName(), eventStr)
sleep(3)
return
def run(self):
DataArray = c_short * self.NUM_CHUNK_SAMPLES
rawChan = DataArray()
self.dataNode.deleteData()
while not self.stopped:
status = self.deviceLib.acquireChunk(
c_char_p(self.addr), byref(rawChan), c_int(self.NUM_CHUNK_SAMPLES))
if status == -1:
print ('Acquisition Failed')
return
Event.stream(0, 'demostream_chan', Float32(self.currTime), Float32(rawChan[0]))
dataArr = Int16Array(rawChan)
startTime = Float64(self.currTime)
endTime = Float64(
self.currTime + self.period * self.NUM_CHUNK_SAMPLES)
dim = Range(startTime, endTime, Float64(self.period))
self.dataNode.makeSegment(startTime, endTime, dim, dataArr)
self.currTime += self.period * self.NUM_CHUNK_SAMPLES
currSecond = time.time()
if currSecond > self.prevSecond + 2:
Event.setevent('DEMOSTREAM_READY')
self.prevSecond = currSecond
def store(self):
eventStr = "STORE " + str(self.id.data())
eventStr = eventStr + " " + str(self.signals_adc_in.getNid())
eventStr = eventStr + " " + str(self.signals_dac_out.getNid())
eventStr = eventStr + " " + str(self.signals_user.getNid())
Event.setevent("MARTE", eventStr)
sleep(3)
return
def load(self):
"""load method
will send a LOAD event forcing reporting in MARTe confirguration
the actual value of MDSplus parameters.
GAM field MdsId will specify the target device
for every GAM taking MDSplus parameters
"""
eventStr = "LOAD"
Event.setevent(self.getEventName(), eventStr)
return 1
def store(self):
"""store method
will force flush buffered data.
Typially called after COLLECTION_COMPLETE event
"""
eventStr = "STORE " + str(self.id.data())
print(eventStr)
Event.setevent(self.getEventName(), eventStr)
sleep(2)
return 1
def run(self):
for evIdx in range(len(self.evTimes)):
currAbsTime = self.device.getAbsTime(self.evTimes[evIdx])
currAbsTime = currAbsTime - self.advanceTime * 1000000000
retval = SOFT_TRIGGER.tcnLib.tcn_wait_until(
c_ulonglong(currAbsTime))
if retval == 0:
for eventName in self.eventDict[self.evTimes[evIdx]]:
print('EVENT ' + eventName + ' AT ' +
str(self.evTimes[evIdx]))
Event.setevent(eventName, Float64(self.evTimes[evIdx]))
def init(self):
eventStr = "SETUP " + self.tree.name + " " + self.control.data(
) + " " + str(self.tree.shot) + " " + str(self.id.data()) + " "
eventStr = eventStr + " " + str(self.params.nid)
eventStr = eventStr + " " + str(self.wave_params.nid)
eventStr = eventStr + " " + str(self.signals.nid)
print(eventStr)
Event.setevent(self.getEventName(), eventStr)
sleep(1)
return 1
def init(self):
""" init method
will send a SETUP event with the required information to allow
MDSInterface service retrieving parameter and signal information
"""
eventStr = "SETUP " + self.tree.name + " " + self.control.data() + " " + str(self.tree.shot) + " " + str(self.id.data()) + " "
eventStr = eventStr + " " + str(self.params.nid)
eventStr = eventStr + " " + str(self.wave_params.nid)
eventStr = eventStr + " " + str(self.signals.nid)
print(eventStr)
Event.setevent(self.getEventName(), eventStr)
sleep(1)
return 1
def run(self):
self.device.setTree(
Tree(self.device.getTree().name,
self.device.getTree().shot))
self.device = self.device.copy()
while not self.stopReq:
readyFds = self.poll.poll(1000)
for fdTuple in readyFds:
readyFd = fdTuple[0]
event = fdTuple[1]
print('EVENT: ', fdTuple, select.EPOLLIN)
if event & select.EPOLLIN == 0:
print('NO DATA')
if event & select.EPOLLERR != 0:
print('POLL ERROR!!')
return
timestamp = self.nisync_timestamp_nanos(0, 0)
status = NI6683.niLib.nisync_read_timestamps_ns(
c_int(readyFd), byref(timestamp), c_int(1))
print("TIMESTAMP: ", timestamp.nanos)
self.device.checkStatus(status, 'Cannot get current time')
termName = self.nameDict[readyFd]
recorderNid = getattr(self.device,
termName.lower() + '_raw_events')
eventRelTime = self.getRelTime(timestamp.nanos)
recorderNid.putRow(10, Float64(eventRelTime),
Float64(eventRelTime))
print("DEBUG -> TIMESTAMP: " + str(timestamp.nanos))
print("DEBUG -> TIMESTAMP REL: " + str(eventRelTime))
try:
eventNameNid = getattr(
self.device,
termName.lower() + '_event_name')
eventName = eventNameNid.data()
Event.setevent(eventName, Uint64(eventRelTime))
except:
pass
def __cmdEvent__(self, cmd):
try:
cmdEventName = self.cmd_event.data()
except Exception as ex:
Data.execute('DevLogErr($1,$2)', self.getNid(),
'Invalid update event')
return self.ERROR
Event.setevent(cmdEventName, cmd)
rep = self.waitForAnswer(cmdEventName + '_REPLY')
timeout = 5
rep.join(timeout)
time.sleep(.1)
if rep.isAlive():
rep.cancel()
Data.execute(
'DevLogErr($1,$2)', self.getNid(),
'Time out, command reply not received within the last %f [sec]'
% (timeout))
return self.ERROR
return self.NO_ERROR
def abort(self):
eventStr = "ABORT"
Event.setevent(self.getEventName(), eventStr)
return
def post_req(self):
eventStr = "POST_REQ"
Event.setevent(self.getEventName(), eventStr)
return
def collection_complete(self):
eventStr = "COLLECTION_COMPLETE"
Event.setevent(self.getEventName(), eventStr)
return
def pre_req(self):
eventStr = "PRE_REQ " + str(self.id.data())
Event.setevent(self.getEventName(), eventStr)
return
def pulse_req(self):
eventStr = "PULSE_REQ"
Event.setevent(self.getEventName(), eventStr)
return
def trigger(self):
eventStr = "TRIGGER " + str(self.id.data())
Event.setevent(self.getEventName(), eventStr)
return
def stream(self):
import socket
import numpy as np
import datetime
import time
import sys
from MDSplus import Event,Range
def lcm(a,b):
from fractions import gcd
return (a * b / gcd(int(a), int(b)))
def lcma(arr):
ans = 1.
for e in arr:
ans = lcm(ans, e)
return int(ans)
print("starting streamer for %s %s %s\nat: %s"%(self.tree, self.tree.shot, self.path, datetime.datetime.now()))
event_name = self.seg_event.data()
dt = 1./self.freq.data()
chans = []
decim = []
nchans = self.sites*32
for i in range(nchans):
chans.append(getattr(self, 'input_%3.3d'%(i+1)))
decim.append(getattr(self, 'input_%3.3d_decimate' %(i+1)).data())
decimator = lcma(decim)
seg_length = self.seg_length.data()
if seg_length % decimator:
seg_length = (seg_length // decimator + 1) * decimator
segment_bytes = seg_length*nchans*4
dims=[]
for i in range(nchans):
dims.append(Range(0., (seg_length-1)*dt, dt*decim[i]))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((self.node.data(),4210))
s.settimeout(6)
segment = 0
running = self.running
max_segments = self.max_segments.data()
first = True
buf = bytearray(segment_bytes)
while running.on and segment < max_segments:
toread=segment_bytes
try:
view = memoryview(buf)
while toread:
nbytes = s.recv_into(view, min(4096,toread))
if first:
self.trig_time.record=time.time()
first = False
view = view[nbytes:] # slicing views is cheap
toread -= nbytes
except socket.timeout as e:
print("got a timeout")
err = e.args[0]
# this next if/else is a bit redundant, but illustrates how the
# timeout exception is setup
if err == 'timed out':
time.sleep(1)
print ('recv timed out, retry later')
if not running.on:
break
else:
continue
else:
print (e)
break
except socket.error as e:
# Something else happened, handle error, exit, etc.
print("socket error", e)
break
else:
if toread != 0:
print ('orderly shutdown on server end')
break
else:
buffer = np.frombuffer(buf, dtype='int16')
i = 0
for c in chans:
if c.on:
b = buffer[i::nchans*decim[i]]
c.makeSegment(dims[i].begin, dims[i].ending, dims[i], b)
dims[i] = Range(dims[i].begin + seg_length*dt, dims[i].ending + seg_length*dt, dt*decim[i])
i += 1
segment += 1
Event.setevent(event_name)
if self.log_output.on:
print("%s\tAll Done"%(datetime.datetime.now(),))
sys.stdout.flush()
def run(self):
msg = "Operation Executed"
print("Event %s occurred at %s with data: %s " %
(str(self.event), str(self.qtime.date), str(self.raw)))
jcmd = self.raw.deserialize()
print(jcmd)
cmdEventName = self.device.cmd_event.data()
if jcmd["command"] == 'pause':
try:
self.device.__stopGeneration__()
except Exception as ex:
Event.setevent(
cmdEventName + '_REPLY',
'Cannot pause waveform generation : ' + str(ex))
elif jcmd["command"] == 'resume':
try:
self.device.configChannels(False)
self.device.__startGeneration__(isUpdate=True)
except Exception as ex:
Event.setevent(
cmdEventName + '_REPLY',
'Cannot resume waveform generation : ' + str(ex))
elif jcmd["command"] == 'update':
wavePoint = self.device.wave_point.data()
gain = self.device.gain.data()
chStateAr = np.asarray(jcmd['chState'])
chMaxAr = np.asarray(jcmd['chMax'])
chMinAr = np.asarray(jcmd['chMin'])
chTypeAr = np.asarray(jcmd['chType'])
chAOXAr = np.asarray(jcmd['chAOX'])
chAOYAr = np.asarray(jcmd['chAOY'])
chFreqAr = np.asarray(jcmd['chFreq'])
minFreq = 1e6
for ch in range(4):
if chStateAr[ch]:
if chFreqAr[ch] < minFreq:
minFreq = chFreqAr[ch]
numPeriod = (np.asarray(chFreqAr) / minFreq + 0.5).astype(int)
periodPoint = []
for ch in range(4):
if getattr(self, 'ao_%d' % (ch + 1)).isOn():
fr = getattr(self, 'ao_%d_freq' % (ch + 1)).data()
periodPoint.append(self.DAC_MAX_FREQ / fr)
else:
periodPoint.append(0)
wavePoint = (np.asarray(periodPoint) + 0.5).astype(int)
print('Wave point ', wavePoint)
try:
self.device.__stopGeneration__()
self.device.closeInfo()
if self.device.restoreInfo(True) == self.ERROR:
Data.execute('DevLogErr($1,$2)', self.device.getNid(),
'Cannot open device')
raise mdsExceptions.DevINV_SETUP
self.device.saveInfo()
for ch in range(4):
self.device.configChannel(ch, False, wavePoint[ch],
chMaxAr[ch], chMinAr[ch],
chTypeAr[ch].strip(),
chAOXAr[ch], chAOXAr[ch], 1)
self.device.__startGeneration__(isUpdate=True)
except Exception as ex:
Event.setevent(
cmdEventName + '_REPLY',
'Cannot update waveforms generation : ' + str(ex))
Event.setevent(cmdEventName + '_REPLY', msg)
return
def cacca(self):
eventStr = "COLLECTION_COMPLETE"
Event.setevent(self.getEventName(), eventStr)
return
def load(self):
eventStr = "LOAD"
Event.setevent(self.getEventName(), eventStr)
return 1
def run(self):
# EVENT data as json object
# { "command": 'pause'|'update'|'resume' , "type" : , "Max" : , "Min" : , "Freq" :}
#
msg = "Operation Executed"
print("Event %s occurred at %s with data: %s " %
(str(self.event), str(self.qtime.date), str(self.raw)))
jcmd = self.raw.deserialize()
print(jcmd)
cmdEventName = self.device.cmd_event.data()
if jcmd["command"] == 'pause':
try:
self.device.__stopGeneration__()
except Exception as ex:
Event.setevent(
cmdEventName + '_REPLY',
'Cannot pause waveform generation : ' + str(ex))
elif jcmd["command"] == 'resume':
try:
self.device.configChannels(False)
self.device.__startGeneration__()
except Exception as ex:
Event.setevent(
cmdEventName + '_REPLY',
'Cannot resume waveform generation : ' + str(ex))
elif jcmd["command"] == 'update':
boardId = self.device.board_id.data()
boardType = self.device.board_type.data()
wavePoint = self.device.wave_point.data()
gain = self.device.gain.data()
chStateAr = np.asarray(jcmd['chState'])
chMaxAr = np.asarray(jcmd['chMax'])
chMinAr = np.asarray(jcmd['chMin'])
chTypeAr = np.asarray(jcmd['chType'])
chAOXAr = np.asarray(jcmd['chAOX'])
chAOYAr = np.asarray(jcmd['chAOY'])
chFreqAr = np.asarray(jcmd['chFreq'])
minFreq = 1e6
for ch in range(4):
if chStateAr[ch]:
if chFreqAr[ch] < minFreq:
minFreq = chFreqAr[ch]
numPeriod = (np.asarray(chFreqAr) / minFreq + 0.5).astype(int)
sampleRate = wavePoint * minFreq
periodDivisor = int(20000000 / sampleRate)
print('==update periodDivisor ', periodDivisor)
print('==update Num Period ', chFreqAr, numPeriod, minFreq)
try:
self.device.__stopGeneration__()
self.device.closeInfo()
if self.device.restoreInfo(True) != NI_WAVE_GEN.NO_ERROR:
Data.execute('DevLogErr($1,$2)', self.device.getNid(),
'Cannot open device')
raise mdsExceptions.DevINV_SETUP
self.device.saveInfo()
aoConfig = c_void_p(0)
NI_WAVE_GEN.niInterfaceLib.pxi6259_create_ao_conf_ptr(
byref(aoConfig))
# initialize AO configuration
self.device.__aoConfiguration__(
aoConfig, self.device.AO_DAC_POLARITY_BIPOLAR,
wavePoint, periodDivisor)
for ch in range(4):
self.device.configChannel(boardType, boardId, ch,
False, wavePoint,
chMaxAr[ch], chMinAr[ch],
chTypeAr[ch].strip(),
chAOXAr[ch], chAOXAr[ch],
numPeriod[ch])
self.device.__startGeneration__()
except Exception as ex:
Event.setevent(
cmdEventName + '_REPLY',
'Cannot update waveforms generation : ' + str(ex))
Event.setevent(cmdEventName + '_REPLY', msg)
return
def run(self):
def lcm(a, b):
from fractions import gcd
return (a * b / gcd(int(a), int(b)))
def lcma(arr):
ans = 1.
for e in arr:
ans = lcm(ans, e)
return int(ans)
def truncate(f, n):
return math.floor(f * 10**n) / 10**n
if self.dev.debug:
print("MDSWorker running")
event_name = self.dev.seg_event.data()
dt = 1. / self.dev.freq.data()
decimator = lcma(self.decim)
if self.seg_length % decimator:
self.seg_length = (self.seg_length // decimator +
1) * decimator
self.dims = []
for i in range(self.nchans):
self.dims.append(
Range(0., truncate((self.seg_length - 1) * dt, 3),
dt * self.decim[i]))
self.device_thread.start()
segment = 0
running = self.dev.running
max_segments = self.dev.max_segments.data()
while running.on and segment < max_segments:
try:
buf = self.full_buffers.get(block=True, timeout=1)
except Queue.Empty:
continue
buffer = np.frombuffer(buf, dtype='int16')
i = 0
for c in self.chans:
if c.on:
b = buffer[i::self.nchans * self.decim[i]]
c.makeSegment(self.dims[i].begin, self.dims[i].ending,
self.dims[i], b)
self.dims[i] = Range(
self.dims[i].begin +
truncate(self.seg_length * dt, 3),
self.dims[i].ending +
truncate(self.seg_length * dt, 3),
dt * self.decim[i])
i += 1
segment += 1
Event.setevent(event_name)
self.empty_buffers.put(buf)
self.dev.trig_time.record = self.device_thread.trig_time - (
(self.device_thread.io_buffer_size / np.int16(0).nbytes) * dt)
self.device_thread.stop()
