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 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 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 fromList(self, config=default_config): """ Initialize synthesizer from list of register values """ for r in config: self.WriteReg(r[0], r[1]) self.WriteReg(0x232, 1) corelog.info("Initialized ADC Synthesizer")
def loop(self,interval=3600): while True: corelog.info("Getting UPS data and inserting in database...") try: self.getData() self.insertData() except: corelog.exception("Failed to get UPS data and insert to database") corelog.debug("UPSLogger sleeping for %d seconds" % interval) time.sleep(interval)
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: self.realtime_h5 = tables.openFile(self.realtime_filename, "w") except Exception, e: corelog.exception("could not open new realtime h5 file for writing: %s" % self.realtime_filename) self.realtime_h5 = None self.realtime_filename = None return # if no iBOBs are registered, error and quit personality = self.personality iBOB_group = self.realtime_h5.root self.realtime_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() iBOB_group.file_info.flush() corelog.debug("set personality: %s" % str(iBOB_group.file_info[:])) self.realtime_iBOB_group = iBOB_group self.realtime_measurements = {} iBOB_meas = self.realtime_measurements measurement_types = personality._measTypesDict for measurement_type in measurement_types.keys(): corelog.debug("adding measurement type: %s" % measurement_type) iBOB_meas[measurement_type] = {} meas_grp = self.realtime_h5.createGroup(iBOB_group,measurement_type) iBOB_meas[measurement_type]['group'] = meas_grp thistable = \ self.realtime_h5.createTable(meas_grp, 'table', measurement_types[measurement_type]['table'], expectedrows=2000) iBOB_meas[measurement_type]['table'] = thistable iBOB_meas[measurement_type]['arrays'] = {} iBOB_meas[measurement_type]['index'] = self.realtime_h5.createArray(meas_grp, 'index', np.zeros((1,),dtype='uint32')) for name,shape in measurement_types[measurement_type]['arrays'].items(): if (name.lower().find('adc') >= 0): fullshape = tuple([16]+list(shape)) # kludge to reduce wasted space on lots of adc snapshots elif shape[0] > 1024: fullshape = tuple([2**20/shape[0]]+list(shape)) #keep size = 1Mpoint else: fullshape = tuple([MAX_REALTIME_ROWS]+list(shape)) thisarr = self.realtime_h5.createArray(meas_grp, name, np.zeros(fullshape,dtype='float32')) iBOB_meas[measurement_type]['arrays'][name] = thisarr self.realtime_infotable = \ self.realtime_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 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 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 _startRecord(self,ibobids,datapath): corelog.info("Got request to record from ibobs: %s In path: %s" % (str(ibobids),datapath)) try: os.mkdir(datapath) os.chmod(datapath,stat.S_IRWXO | stat.S_IRWXG | stat.S_IRWXU) except: corelog.exception("Couldn't create data path %s" % datapath) for id,ibob in self.iBOBProxies.items(): if id in ibobids: ibob.start_writing(os.path.join(datapath,'ibob%d.h5' % id))
def calcPLL(self, f): """ Calculate the PLL parameters """ if f > 1125: corelog.error("Attempting to set frequency higher than 1125 MHz. Value was: %f MHz" % f) return None finaldiv = 1 while f * finaldiv < 291: finaldiv *= 2 if finaldiv > 32: corelog.error( "IBOB ADC clock synthesizer cannot reach that frequency. would require a final divider of %d > 32" % finaldiv ) return None forig = f f = f * finaldiv if f >= 875 and f <= 1125: VCOdiv = 2 elif f >= 583 and f <= 750: VCOdiv = 3 elif f >= 438 and f <= 562: if finaldiv < 32: f *= 2 finaldiv *= 2 VCOdiv = 2 else: VCOdiv = 4 elif f >= 350 and f <= 450: VCOdiv = 5 elif f >= 291 and f <= 375: if finaldiv < 32: finaldiv *= 2 f *= 2 VCOdiv = 3 else: VCOdiv = 6 else: corelog.error( "IBOB ADC clock synthesizer cannot reach that frequency. forig: %f f: %f finaldiv: %d" % (forig, f, finaldiv) ) return None (b, a) = divmod(f * VCOdiv, 8) output = (b * 8 + a) / VCOdiv / finaldiv corelog.info( "Found PLL settings: forig: %f, f: %f, finaldiv: %d, VCOdiv: %d, b: %d, a: %d, VCO: %f expected output: %f", (forig, f, finaldiv, VCOdiv, b, a, f * VCOdiv, output), ) return dict(VCOdiv=VCOdiv, b=b, a=a, finaldiv=finaldiv, VCO=f, output=output)
def __init__(self): Pyro.core.ObjBase.__init__(self) self._connected = False self.addr = None self.source = {} corelog.info("Connecting to GavrtDB") self.gdb = GavrtDB(rw=True) rec = self.gdb.get("SELECT * FROM antenna_cmd ORDER BY ID DESC LIMIT 1") if rec: self.source = dict(name=rec['Name'][0],RA=rec['RA'][0],Dec=rec['Dec'][0],id=int(rec['SourceID'][0])) corelog.info("Got most recent source: %s" % (rec['Name'][0])) else: corelog.error("Could not find a most recent sournce in the antenna_cmd table.")
def __init__(self,sql = True): Pyro.core.ObjBase.__init__(self) if sql: self.sql = True corelog.info("Connecting to GavrtDB") self.gdb = gavrtdb.GavrtDB(rw=True) else: self.sql = False self.gdb = None self.iBOBProcesses = {} self.iBOBServers = {} self.iBOBProxies = {}
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 getData(self,passwd=SPSS_UPS.passwd): """ Retrieve data via FTP from UPS """ if passwd is None: print "Enter password for root on UPS: ", passwd = raw_input() corelog.info("Retrieving data from UPS") try: self.ftp = FTP(self.addr) self.ftp.login(user=SPSS_UPS.user,passwd=passwd) except Exception, e: corelog.exception("Couldn't connect to UPS by FTP at address %s with user root and password %s" % (self.addr,passwd))
def setSynths(self,freq,force=False): """ Set synthesizers to given frequency Arguments: *freq* : float Frequency in MHz *force* : bool (optional) if freq is same as current frequency of synthesizer, will not change the frequency unless *force* is True """ if self.syn0.freq != freq or force: corelog.info("Setting syn0 to %f" % freq) s0 = self.setSynth(freq, 0) else: corelog.info("Syn0 was already at %f" % freq) s0 = None if self.syn1.freq != freq or force: corelog.info("Setting syn1 to %f" % freq) s1 = self.setSynth(freq, 1) else: corelog.info("Syn1 was already at %f" % freq) s1 = None status = self.lockStatus() if not (status[0] and status[1]): raise Exception("At least one synthesizer is out of lock! %s" % str((s0,s1,status))) return (s0,s1,status)
def __init__(self,port=None): if port is None: try: port =config.serialPortMap['TCT'] except: corelog.exception("TCT entry not found in serialPortMap. Manually searching for port") port = self.findport() corelog.info("Using port %s",port) self.ser = serial.Serial(port) self.ser.setBaudrate(9600) self.ser.setParity('O') self.ser.setByteSize(7) self.ser.setTimeout(2) self.ser.flushInput() self.running = True self.gdb = gavrtdb.GavrtDB(rw=True)
def insertData(self): if self.data is None: print "no data!" return corelog.info("Inserting UPS data: %d values" % (self.data.shape[0])) ut = [calendar.timegm(x.timetuple()) for x in self.data['time']] data = self.data try: c = self.gdb.cursor() for k in range(len(ut)): data = self.data[k] c.execute("INSERT IGNORE INTO spss_ups (UnixTime,Vmin,Vmax,Vout,Wout,Freq,Capacity,Vbat,Temperature) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)", (ut[k],data['vmin'],data['vmax'],data['vout'],data['wout'],data['freq'],data['cap'],data['vbat'],data['tupsc'])) self.gdb.commit() except Exception, e: corelog.exception("Couldn't write UPS data to database") try: self.gdb = gavrtdb.GavrtDB(rw=True) except Exception, e: corelog.exception("Couldn't reconnect to database")
def programIBOBs(self,ibobs,ipfid=None,ipffile=None,force=False): """ Program a list of iBOBs with a given configuration file. The configuration file can be explicitly provided or an index to the database of designs can be given Arguments: *ibobs* : list of ints Which ibobs to program *ipfid* : int Record ID of row in dss28_spec.ibob_designs that indicates the desired configuration *ipffile* : str (advanced use only) Instead of a design in the database, use this IPF explicitly *force* : bool Program the ibob even if we think it may already be programmed with same design. """ if self.sql: if ipfid: try: resd = self.gdb.getIPF(ipfid) ipf = resd['IPF'] ipfdir = resd['Directory'] ipffile = os.path.join(ipfdir,ipf) except Exception, e: corelog.exception("Could not resolve programming file from database") raise e corelog.debug("Found ipfID: %d correspoing to %s" % (ipfid, ipffile)) else: ipfid = 1 #we are connected to database, but programming an arbitrary file, so # tell the database that the design is default if force == False: droplist = [] stat = self.gdb.getSPSSStatus() for ii in ibobs: if stat["iBOBDesignID%d" % ii] == ipfid: droplist.append(ii) corelog.info("iBOB%d is already programmed with this ipf, skipping" % ii) for k in droplist: ibobs.remove(k)
def connect(self): """ Connect to server running Xant, usually dss28-eac """ self.sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind(('',9013)) for addr in XANT_ADDRS: tries = 0 maxtries = 2 corelog.debug("Trying to connect to xant at %s" % (str(addr))) while tries < maxtries: tries += 1 try: self.sock.connect(addr) break except Exception, e: corelog.debug("Failed on %d try\n%s" % (tries,str(e))) if tries < maxtries: corelog.info("Succeeded in connecting to Xant at %s after %d tries" % (str(addr),tries)) self.sock.setblocking(False) self._connected = True self.addr = addr return addr
def connect(self): """ Open a TCP connection to the RCT """ self.sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind(('',9002)) for addr in RCT_ADDRS: tries = 0 while tries < 1: try: self.sock.connect(addr) corelog.info("RCT Connected at %s" % (str(addr))) break except Exception, e: corelog.info("Could not connect to RCT on %s" % (str(addr))) tries += 1 if tries <1: self.sock.setblocking(False) self._connected = True return else: corelog.error("Could not connect to RCT on %s" % (str(addr))) self._connected = False
def _startIbobServers(self,ibs): ns = Pyro.naming.NameServerLocator().getNS() for ib in ibs: if self.iBOBProcesses.has_key(ib): self._stopIbobServer(ib) thisServer = IbobServer(ib) self.iBOBServers[ib] = thisServer thisProcess = Process(target = thisServer.run, args = ()) self.iBOBProcesses[ib] = thisProcess thisProcess.start() corelog.info("Started server for iBOB %d" % ib) corelog.info("Sleeping for 5 seconds while iBOB processes initialize...") time.sleep(5) corelog.debug("Done sleeping, starting to resolve ibobs") for ib in ibs: thisiBOB = ns.resolve(':IBOB.%d'%ib).getProxy() tupd,pers,clk = self.gdb.getPersonality(ib) corelog.info("Database entry at %s indicates iBOB %d, personality: %s clock rate %f MHz" % (time.ctime(tupd),ib,pers,clk)) thisiBOB.set_personality(getattr(personalities,pers)) self.iBOBProxies[ib] = thisiBOB corelog.info("Set personality for ibob %d" % ib)
def __init__(self,sql = True): """ *sql* argument is largely a relic, no longer used without database """ Pyro.core.ObjBase.__init__(self) Pyro.config.PYRO_MULTITHREADED = 0 # do not use multiple threads, because we want to ensure programming finishes if sql: self.sql = True corelog.debug("Connecting to GavrtDB") self.gdb = gavrtdb.GavrtDB(rw = True) else: self.sql = False self.gdb = None self.iBOBProcesses = {} self.iBOBServers = {} self.serialPorts = [None,None] self.lj0 = None self.lj1 = None self.ljs = [None,None] self.syns = [None,None] self.syn0 = None self.syn1 = None self.jtagcables = ['usb21','usb22'] corelog.debug("Identifying JTAG programmers from list: %s" % str(self.jtagcables)) try: self.identifyCables() except: corelog.exception("Could not identify JTAG programmers!") corelog.info("JTAG cables identified") corelog.debug("Opening LabJacks") try: self.openLabJacks() except: corelog.exception("Could not open LabJacks!") # Check if synthesizers are already initialized before clobbering them. if not self.synsInitialized(): corelog.info("found synthesizers uninitialized, so initializing to 1024 MHz") self.initialize() self.setSynths(1024.0) corelog.info("Started")
return float(x) except: return 0.0 names = ['date','time','vmin','vmax','vout','wout','freq','cap','vbat','tupsc'] convd = {} for k in names: convd[k] = myfloat dp = dateutil.parser.parse convd['date'] = dp convd['time'] = dp try: res = mlab.csv2rec(fname,skiprows=6,names=names,converterd = convd,delimiter='\t') except Exception,e: corelog.exception("Could not parse UPS data file") self.data = res corelog.info("Retrieved %d UPS data values" % (self.data.shape[0])) try: self.convTime() except Exception,e: corelog.exception("Failed to convert UPS time data") def insertData(self): if self.data is None: print "no data!" return corelog.info("Inserting UPS data: %d values" % (self.data.shape[0])) ut = [calendar.timegm(x.timetuple()) for x in self.data['time']] data = self.data try: c = self.gdb.cursor()
except: corelog.exception("Couldn't create data path %s" % datapath) for id,ibob in self.iBOBProxies.items(): if id in ibobids: ibob.start_writing(os.path.join(datapath,'ibob%d.h5' % id)) if __name__=="__main__": import Pyro import ifconfig for k in range(4): cfg = ifconfig.ifconfig('eth%d'%k) if cfg['addr'].startswith('192.168'): myip = cfg['addr'] break print "My IP is:",myip Pyro.config.PYRO_HOST = myip corelog.info("Starting iBOBProcessServer on %s" % myip) Pyro.core.initServer() Pyro.config.PYRO_MULTITHREADED = 0 ns = Pyro.naming.NameServerLocator().getNS() try: ns.unregister('ProcessServer') except: pass daemon = Pyro.core.Daemon() daemon.useNameServer(ns) daemon.connect(iBOBProcessServer(),"ProcessServer") daemon.requestLoop()
except Exception, e: corelog.exception("Couldn't write to database") try: self.gdb = gavrtdb.GavrtDB(rw=True) except Exception, e: corelog.exception("Couldn't reconnect to database") if __name__=="__main__": import select Pyro4.config.SERVERTYPE = "multiplex" ns = Pyro4.locateNS() try: old = ns.lookup('TCTServer') old.quit() corelog.info("Quit existing TCTServer") time.sleep(1) except: pass try: ns.unregister('TCTServer') except: pass daemon = Pyro4.Daemon() tct = TCTServer() uri = daemon.register(tct) ns.register('TCTServer',uri) while tct.running: tct.update() while True:
keystr = '' valstr = '' values = [] for k,v in data.items(): keystr = keystr + k + ', ' valstr = valstr + '%s, ' values.append(v) keystr = keystr + 'UnixTime' valstr = valstr + '%s' values.append(time.time()) try: c = self.pdb.cursor() c.executemany( "INSERT INTO forx_mon (" + keystr + ") VALUES (" + valstr + ");", [tuple(values)]) print "INSERT INTO forx_mon (" + keystr + ") VALUES (" + valstr + ");",tuple(values) self.pdb.commit() except Exception, e: corelog.exception("Could not log to GavrtDB, will try reconnecting") try: self.pdb = gavrtdb.GavrtDB(rw=True) except Exception, e: corelog.exception("Could not reconnect to GavrtDB") time.sleep(60) if __name__ == "__main__": forx = FORXDBWriter() corelog.info("Fiber RX Monitor started") forx.loop()
def run(self): self.writing = False self.running = True self.personality = None self.realtime_lock = Lock() self.h5_lock = Lock() name = ':IBOB.'+str(self.id) self.name=name self.iBOB_addr = IBOB_NETWORK + str(self.id+16) self.control_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.control_sock.setblocking(False) self.control_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 7 is the port on which the iBOB listens for commands self.control_sock.connect((self.iBOB_addr, 7)) self.measurements_dict = {} self.measurements_list = [] self.spec_info_table = None self.realtime_infotable = None self.packets_received = 0 self.data_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.data_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.data_sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, RCV_BUFFER_SIZE) self.data_sock.bind(("", IBOB_BASE_PORT+self.id+16)) self.acc = 0 self.number_of_measurements = 0 self.h5 = None self.realtime_h5 = None self.ns = Pyro.naming.NameServerLocator().getNS() try: self.ns.createGroup(':IBOB') #Ensure IBOB group exists except NamingError: pass try: uri = self.ns.resolve(name) try: uri.getProxy().quit() corelog.debug("successfully quit existing daemon for ibob %d" % self.id) time.sleep(2) except: pass try: self.ns.unregister(name) corelog.debug("found stale name in ns, and unregistered for ibob %d" % self.id) except NamingError: pass except NamingError: corelog.debug("No existing daemon registered, good ibob %d" % self.id) self.pd = Pyro.core.Daemon() self.pd.useNameServer(self.ns) self.pd.connect(self, name) corelog.info("Starting %s server" % self.name) self.data_sock.setblocking(False) # crucial to avoid deadlock in loop while self.running: self.pd.handleRequests(1, [self.data_sock], self.processData) self.data_sock.close() corelog.info("%s server done running" % self.name)