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)
