def get(self):
"""
Get the TCT time string and parse it.
Returns a tuple containing:
* UnixTime stamp as an integer
* TCT status byte. 0 is good
* Offset between system time and TCT time in seconds as a float
"""
self.ser.flushInput()
txtime = 18*10/9600. #Amount of time to transmit 18 characters at 9600bps
r = self.ser.readline(eol='\r')
now = time.time()-txtime
if len(r) != 18:
corelog.warning("TCT did not transmit")
return None
# 012345678901234567
#Format is YYYYjjjHHMMSSrCCC\r
try:
Y = int(r[:4]) #year
doy = int(r[4:7]) #day of year
H = int(r[7:9]) #hour
M = int(r[9:11]) #min
S = int(r[11:13]) #sec
status = int(r[13],base=16)
checksum = int(r[14:17],16)
except Exception, e:
corelog.exception("Couldn't parse TCT output")
return None
def findTCT(devs):
"""
Identify the TCT by looking for the time stamp emitted at 1 second intervals
"""
for dev in devs:
try:
ser = serial.Serial(dev)
except Exception,e:
logger.warning("findTCT: Couldn't open serial port: %s... moving to next port" % dev)
continue
ser.setBaudrate(9600)
ser.setParity('O')
ser.setByteSize(7)
ser.setTimeout(2)
ser.flushInput()
tries = 0
while tries < 2:
r = ser.readline(eol='\r')
logger.debug('findTCT: Trying %s Trial # %d got %s' % (dev,tries,r))
if len(r) == 18:
break
tries += 1
if tries == 2:
logger.info('findTCT: failed to find TCT on port %s' % dev)
ser.setParity('N')
ser.setByteSize(8)
ser.close()
continue
else:
logger.info('findTCT: Found TCT on port %s' % dev)
ser.close()
return dev
def findPowerSupply(devs):
"""
Identify the Lambda Power supply which provdes +5 V to the SPSS equipment
"""
for dev in devs:
try:
ser = serial.Serial(dev)
except Exception,e:
logger.warning("findPowerSupply: Couldn't open serial port: %s... moving to next port" % dev)
continue
ser.setBaudrate(9600)
ser.setParity('N')
ser.setByteSize(8)
ser.setTimeout(1)
ser.flushInput()
tries = 0
while tries < 3:
ser.flushInput()
ser.write('adr 6\r')
r = ser.readline(eol='\r')
logger.debug('findPowerSupply: Trying %s Trial # %d got %s' % (dev,tries,r))
if r.find('OK') >= 0:
break
tries += 1
if tries == 3:
logger.info('findPowerSupply: failed to find on port %s' % dev)
ser.close()
continue
else:
logger.info('findPowerSupply: Found on port %s' % dev)
ser.close()
return dev
def findValon(devs):
"""
Identify the Valon synthesizer
"""
for dev in devs:
try:
ser = serial.Serial(dev)
except Exception,e:
logger.warning("findValon: Couldn't open serial port: %s... moving to next port" % dev)
continue
ser.setBaudrate(9600)
ser.setParity('N')
ser.setByteSize(8)
ser.setTimeout(1)
ser.flushInput()
tries = 0
while tries < 3:
ser.flushInput()
ser.write(struct.pack('>B',0x82))
r = ser.read(16)
logger.debug('findValon: Trying %s Trial # %d got %s' % (dev,tries,r))
if r.find('Synth') >= 0:
break
tries += 1
if tries == 3:
logger.info('findValon: failed to find on port %s' % dev)
ser.close()
continue
else:
logger.info('findValon: Found on port %s' % dev)
ser.close()
return dev
def prepare_for_writing(self, filename):
"""
prepares the real h5 (history) file to be written
"""
self.filename = filename
if os.path.isfile(filename):
corelog.warning("%s h5 filename %s already exists, overwriting..." % (self.name,filename))
with self.h5_lock:
# try to open the file for writing
try:
self.h5 = tables.openFile(self.filename,'w')
except Exception, e:
self.h5 = None
self.filename = None
corelog.exception("%s could not open new h5 file for writing: %s" % (self.name,self.filename))
return
self.comment_table = self.h5.createTable(self.h5.root, "comment_table",
self.comment_table_description())
# set up tables for each iBOB based on each iBOB's personality
personality = self.personality
iBOB_group = self.h5.root
self.h5.createTable(iBOB_group, "file_info", dict(personality=tables.StringCol(128,dflt=' ')))
iBOB_group.file_info.row['personality'] = self.personality.__class__.__name__
iBOB_group.file_info.row.append()
self.h5.flush()
self.iBOB_group = iBOB_group
self.measurements = {}
iBOB_meas = self.measurements
measurement_types = personality._measTypesDict
for measurement_type in measurement_types.keys():
iBOB_meas[measurement_type] = {}
meas_grp = self.h5.createGroup(iBOB_group,measurement_type)
iBOB_meas[measurement_type]['group'] = meas_grp
thistable = \
self.h5.createTable(meas_grp, 'table',
measurement_types[measurement_type]['table'],
expectedrows=2000)
iBOB_meas[measurement_type]['table'] = thistable
iBOB_meas[measurement_type]['arrays'] = {}
for name,shape in measurement_types[measurement_type]['arrays'].items():
fullshape = tuple([0]+list(shape))
thisarr = self.h5.createEArray(meas_grp, name,
tables.Float32Atom(),fullshape)
iBOB_meas[measurement_type]['arrays'][name] = thisarr
self.spec_info_table = self.h5.createTable(iBOB_group, "InfoTable",
personality._infoTable, expectedrows = 2000)
def setLevelB(self,level=-1):
try:
r = self.set_rf_level(SYNTH_B,level)
except:
corelog.exception("Couldn't set RF level %f" % level)
return False
if r:
corelog.info("Set level to %d",level)
else:
corelog.warning("Set level reply was NOACK")
return r
def setFreqB(self,freq,chan_spacing=1):
try:
r = self.set_frequency(SYNTH_B,freq,chan_spacing=chan_spacing)
except:
corelog.exception("Couldn't set frequency %f" % freq)
return False
if r:
corelog.info("Set frequency to %f",freq)
else:
corelog.warning("Set frequency reply was NOACK")
return r
def checkConnected(self):
try:
self.sock.getpeername()
except:
self._connected = False
self.addr = None
corelog.warning("Xant not connected")
return False
corelog.debug("Xant is connected")
self._connected = True
return True
def lockStatus(self):
"""
Get synthesizer lock status. Returns a boolean for each synthesizer
"""
s0,s1 = self.syn0.isLocked(),self.syn1.isLocked()
if not (s0 and s1):
corelog.warning("ADC Synthesizers are not locked: Syn0 %s Syn1 %s" % (s0,s1))
else:
corelog.info("ADC Synthesizers are in lock")
return s0,s1
def lockStatus(self):
try:
a = self.get_phase_lock(SYNTH_A)
b = self.get_phase_lock(SYNTH_B)
except:
corelog.exception("Couldn't get lock status")
if not (a and b):
corelog.warning("Valon not in lock - A: %s B: %s" %(str(a),str(b)))
else:
corelog.info("Valon synthesizer is in lock")
return (a,b)
def set_personality(self, personality,adcClock=1024.0):
"""
sets the personality of a specific iBOB
"""
if self.writing or self.personality:
corelog.warning("%s cannot set personality: it's already set" % self.name)
return
corelog.debug("%s Setting personality %s %s" % (self.name,str(personality), personalities.__file__))
self.personality = personality(adcClock=adcClock) # removed self as parent
try:
self._init_rtbuf()
except Exception,e:
corelog.exception("Could not init realtime buf for ibob %d %s"%(self.id,str(self.personality)))
def quit(self):
self.running = False
self.stop_writing()
with self.realtime_lock:
if self.realtime_h5:
self.realtime_h5.close()
self.realtime_h5 = None
self.realtime_filename = None
try:
ns = Pyro.naming.NameServerLocator().getNS()
ns.unregister(self.name)
except Exception, e:
corelog.warning("%s could not unregister from ns: %s" %(self.name,str(e)))
def _stopIbobServer(self,ib):
corelog.info("Stopping IBOB %d server" % ib)
ns = Pyro.naming.NameServerLocator().getNS()
thisiBOB = ns.resolve(':IBOB.%d'%ib).getProxy()
try:
thisiBOB.quit()
except:
corelog.warning("Couldn't quit iBOB %d server nicely, so terminating" % ib)
self.iBOBProcesses[ib].terminate()
if self.iBOBProcesses.has_key(ib):
del self.iBOBProcesses[ib]
if self.iBOBServers.has_key(ib):
del self.iBOBServers[ib]
def record_measurement(self, measurement):
"""
save data to realtime h5 file for recent access, save to history file if
necessary
spec_measurement is a tuple from the spectrometer personality,
[0] = name
[1] = arraydict
[2] = tabledict
"""
# print "start of record measurement",iBOB_id
personality = self.personality
if personality is None:
return
spec_measurement = personality._reconstructMeasurement(measurement)
measurement_type = spec_measurement[0]
arrays = spec_measurement[1]
table_data = spec_measurement[2]
# print measurement_type, len(table_data),table_data
if measurement_type == 'S':
acc = table_data['AccNumber']
if acc - self.acc != 1:
print "missed:",self.id,acc,self.acc
self.acc = acc
#self.publish('msr', spec_measurement)
self.number_of_measurements += 1
# always write to realtime h5 file
# table_string = "%s_%s" % (measurement_type, "table_description")
if not self.realtime_h5:
corelog.warning("%s no realtime_h5 file opened yet, record_measurement failed" % self.name)
return
with self.realtime_lock:
table = self.realtime_measurements[measurement_type]['table']
if len(table) >= MAX_REALTIME_ROWS:
# TODO: change this to not delete just one row
table.removeRows(0)
# TODO: hopefully pytables reassigns the indices of table.row, otherwise
# we have to adjust...
for key in table_data.keys():
try:
table.row[key] = table_data[key]
except Exception, e:
corelog.exception("%s could not insert data for key %s" %(self.name,str(key)))
#print "added data for ",key
try:
table.row.append()
except Exception, e:
corelog.exception("%s could not append row to realtime h5 file" % self.name)
def checkConnected(self):
"""
Check that connection is still available to RCT.
Returns bool
"""
print "checking connection"
try:
self.sock.getpeername()
except:
self._connected = False
self.addr = None
corelog.warning("RSS not connected")
return False
corelog.debug("RSS is connected")
self._connected = True
return True
tic = time.time()
try:
self._send(cmd)
except Exception,e:
corelog.exception("Couldn't send command to XANT")
return
tstart = time.time()
resp = ''
while (time.time()-tstart < timeout):
try:
resp = resp + self.sock.recv(1000)
if resp.find('completed') >= 0:
corelog.debug("Command %s accepted" % cmd)
break
elif resp.find('rejected') >= 0:
corelog.warning("Command %s rejected with response: %s" % (cmd,resp))
break
except:
corelog.exception("Problem waiting for response from XANT")
pass
corelog.debug("Xant response time: %.2f ms" %((time.time()-tic)*1000))
time.sleep(0.1) #sleep a moment
return resp
def runXantInterface():
import Pyro.naming
Pyro.core.initServer()
ns = Pyro.naming.NameServerLocator().getNS()
try:
# sends Measurement to personality to parse the raw BRAM data,
# then sends the parsed data to the data server for writing
try:
self.record_measurement(measurement)
# self.personality._reconstructMeasurement(measurement))
except Exception, e:
corelog.exception("%s Could not record measurement" % self.name)
# remove it from list of Measurements
self.measurements_list.remove(piece_key)
del self.measurements_dict[piece_key]
# Throttle: if the number of Measurements exceeds some value x, delete
# the first x/2 number of Measurements
if len(self.measurements_list) > MAX_MEASUREMENTS_IN_PROGRESS:
corelog.warning("%s too many incomplete measurements, dropping half" % self.name)
delete_this = self.measurements_list[:MAX_MEASUREMENTS_IN_PROGRESS / 2]
for m in delete_this:
del self.measurements_dict[m]
del self.measurements_list[:MAX_MEASUREMENTS_IN_PROGRESS / 2]
def get_measurements(self):
return self.measurements_dict
def _init_rtbuf(self):
self.realtime_filename = "/tmp/rt%d.h5" % self.id
corelog.info("Starting realtime data capture. Creating %s" %self.realtime_filename)
# try to open the realtime h5 file for writing
with self.realtime_lock:
try:
