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: