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())
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 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 stopMarte(self):
marteName = self.getNode('name').data()
self.suspendMarte()
time.sleep(2)
Event.seteventRaw(marteName, np.frombuffer(b'EXIT', dtype=np.uint8))
time.sleep(2)
Event.seteventRaw(marteName, np.frombuffer(b'EXIT', dtype=np.uint8))
return 1
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 publishEvent(eventname, eventbody=None):
"""
eventname -- name convention for this event. Tag to listen for.
eventbody -- should be text presently as we do not implement
deserialization of arbitrary types.
events are broadcast by Event over UDP
"""
try:
from MDSplus import Event
from numpy import uint8
if apidebug:
print("APIDEBUG: publishEvent", eventname, eventbody)
print("APIDEBUG: publishEvent", str(type(eventbody)))
Event.seteventRaw(eventname, uint8(bytearray(eventbody)))
except Exception as e:
import sys, os
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("ERROR, events not supported. Tried to " +
"send event %s, with message %s.") % (eventname, eventbody)
print(exc_type, fname, exc_tb.tb_lineno)
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 publishEvent(eventname, eventbody=None):
"""
eventname -- name convention for this event. Tag to listen for.
eventbody -- should be text presently as we do not implement
deserialization of arbitrary types.
events are broadcast by Event over UDP
"""
try:
from MDSplus import Event
from numpy import uint8
if apidebug:
print("APIDEBUG: publishEvent",eventname,eventbody)
print("APIDEBUG: publishEvent",str(type(eventbody)))
Event.seteventRaw(eventname,uint8(bytearray(eventbody)))
except Exception as e:
import sys,os
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("ERROR, events not supported. Tried to "+
"send event %s, with message %s.")%(eventname,eventbody)
print(exc_type, fname, exc_tb.tb_lineno)
def stopMarte(self):
marteName = self.getNode('name').data()
self.suspendMarte()
time.sleep(2)
Event.seteventRaw(marteName, np.frombuffer(b'EXIT', dtype=np.uint8))
time.sleep(2)
Event.seteventRaw(marteName, np.frombuffer(b'EXIT', dtype=np.uint8))
# KILL MARTe process
import subprocess
import os
command = 'ps -Af | grep %s_marte_configuration.cfg | grep MARTeApp.ex | grep -v grep | awk \'{print $2}\'' % (
marteName)
pid, error = subprocess.Popen("{cmd}".format(cmd=command),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE).communicate()
if len(pid) == 0:
if len(error) != 0:
print('INFO : %s' % (error))
else:
for p in pid.split():
os.kill(int(p), 9)
print('MARTe Process PID : %s Killed\n' % (p))
return 1
def suspendMarte(self):
marteName = self.getNode('name').data()
eventString1 = marteName + ':StopCurrentStateExecution:XX'
eventString2 = marteName + ':' + 'PrepareNextState:IDLE'
eventString3 = marteName + ':StartNextStateExecution:XX'
Event.seteventRaw(marteName,
np.frombuffer(eventString1.encode(), dtype=np.uint8))
time.sleep(0.1)
Event.seteventRaw(marteName,
np.frombuffer(eventString2.encode(), dtype=np.uint8))
time.sleep(0.1)
Event.seteventRaw(marteName,
np.frombuffer(eventString3.encode(), dtype=np.uint8))
def doState(self, state):
marteName = self.getNode('name').data()
stateName = getattr(self, 'state_%d_name' % (state)).data()
eventString1 = marteName + ':StopCurrentStateExecution:XX'
eventString2 = marteName + ':' + 'PrepareNextState:' + stateName
eventString3 = marteName + ':StartNextStateExecution:XX'
Event.seteventRaw(marteName,
np.frombuffer(eventString1.encode(), dtype=np.uint8))
time.sleep(.1)
Event.seteventRaw(marteName,
np.frombuffer(eventString2.encode(), dtype=np.uint8))
time.sleep(.1)
Event.seteventRaw(marteName,
np.frombuffer(eventString3.encode(), dtype=np.uint8))
def gotoidle(self):
marteName = self.getNode('name').data()
eventString1 = 'StateMachine:GOTOIDLE'
Event.seteventRaw(marteName,
np.frombuffer(eventString1.encode(), dtype=np.uint8))
#!/usr/bin/python
"""
Created on Fri Jul 10 05:29:47 2015
updateTime
@author: Cloud
"""
from archive import TimeInterval, setTIME
from MDSplus import Tree, Event
from time import sleep
from sys import argv
timer = 10
if len(argv) > 1:
timer = int(argv[1])
try:
tree = Tree('archive', 7)
except:
tree = Tree('archive', -1).createPulse(7)
setTIME(TimeInterval(-1800., 0, -1))
while True:
Event.seteventRaw('archive7')
sleep(timer)
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 cacca(self):
eventStr = "COLLECTION_COMPLETE"
Event.setevent(self.getEventName(), eventStr)
return
def abort(self):
eventStr = "ABORT"
Event.setevent(self.getEventName(), eventStr)
return
def __init__(self, evName, device):
Event.__init__(self, evName)
self.device = device
def collection_complete(self):
eventStr = "COLLECTION_COMPLETE"
Event.setevent(self.getEventName(), eventStr)
return
def post_req(self):
eventStr = "POST_REQ"
Event.setevent(self.getEventName(), eventStr)
return
def pulse_req(self):
eventStr = "PULSE_REQ"
Event.setevent(self.getEventName(), eventStr)
return
def pre_req(self):
eventStr = "PRE_REQ " + str(self.id.data())
Event.setevent(self.getEventName(), eventStr)
return
def trigger(self):
eventStr = "TRIGGER " + str(self.id.data())
Event.setevent(self.getEventName(), eventStr)
return
def stopMarte(self):
marteName = self.getNode('name').data()
Event.seteventRaw(marteName, np.frombuffer(b'EXIT', dtype=np.uint8))
return 1
#!/usr/bin/python
"""
Created on Fri Jul 10 05:29:47 2015
updateTime
@author: Cloud
"""
from archive import TimeInterval,setTIME
from MDSplus import Tree, Event
from time import sleep
from sys import argv
timer = 10
if len(argv)>1:
timer = int(argv[1])
try:
tree=Tree('archive',7)
except:
tree=Tree('archive',-1).createPulse(7)
setTIME(TimeInterval(-1800.,0,-1))
while True:
Event.seteventRaw('archive7')
sleep(timer)
def load(self):
eventStr = "LOAD"
Event.setevent(self.getEventName(), eventStr)
return 1
