Beispiel #1
0
 def getStatus(self):
     """
     Read the voltages and temperature of the LabJack.
     
     Returns a dictionary of monitor points and values
     """
     stats = {}
 
     channels = channelmap.keys()
     channels.sort()
     ains = [u3.AIN(x,31,True) for x in channels]
     tic = time.time()
     meas = self.lj.getFeedback(ains)
     corelog.debug("got FORX measurements in: %.2f ms" % ((time.time()-tic)*1000))
     for n,ch in enumerate(channels):
         if ch < 4:
             volts = self.lj.binaryToCalibratedAnalogVoltage(meas[n],isLowVoltage = False, isSingleEnded = True)
         else:
             volts = self.lj.binaryToCalibratedAnalogVoltage(meas[n],isLowVoltage = True, isSingleEnded = True)
         stats[ch] = volts*2
         
     fields = {}
     for k,v in stats.items():
         fields[channelmap[k]] = v
     
     fields['RackTemp'] = self.lj.getTemperature() - 273.15 # convert K to C
     return fields
Beispiel #2
0
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
Beispiel #3
0
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
Beispiel #4
0
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
Beispiel #5
0
 def clear_personality(self):
     corelog.debug("%s Clearing personality" % self.name)
     self.personality = None
     with self.realtime_lock:
         if self.realtime_h5:
             self.realtime_h5.close()
             self.realtime_h5 = None
             corelog.debug("%s Closing realtime h5" % self.name)
Beispiel #6
0
 def setFreq(self, f):
     """
     Set output frequency in MHz
     """
     corelog.debug("Setting frequency to %f" % f)
     settings = self.calcPLL(f)
     self.setPLL(settings)
     self.freq = f
     return settings
Beispiel #7
0
Datei: ups.py Projekt: gitj/gavrt
 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)
Beispiel #8
0
 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)
Beispiel #9
0
 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
Beispiel #10
0
 def selectIBOB(self,ibob):
     """
     Select a given ibob with multiplexer circuits
     """
     if ibob < 4:
         self.syn0.seliBOB(ibob)
         corelog.debug("bank 0, selected ibob %d" %ibob)
     else:
         ibobsel = ibob - 4
         self.syn1.seliBOB(ibobsel)
         corelog.debug("bank 1, selected ibob %d (sel: %d)" %(ibob,ibobsel))
Beispiel #11
0
 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)))
Beispiel #12
0
 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
Beispiel #13
0
Datei: ups.py Projekt: gitj/gavrt
 def parseData(self,fname):
     from matplotlib import mlab
     corelog.debug("Parsing UPS data file: %s",fname)
     def myfloat(x):
         try:
             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")
Beispiel #14
0
 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)
Beispiel #15
0
 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
Beispiel #16
0
    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)
Beispiel #17
0
 def send_cmd(self,cmd,timeout=5):
     """
     Main function for sending a commaand string to the RCT and receiving a response.
     """
     try:
         self.sock.getpeername()
     except:
         corelog.warn("Trying to send command but found not connected, so trying to connect")
         self.connect()
     
     while True:
         try:
             self.sock.recv(10000)
         except:
             break
     
     tic = time.time()
     try:
         self.send(cmd)
         corelog.debug("Sent command %s" % cmd)
     except Exception,e:
         corelog.exception("Could not send command %s" % cmd)
         return
Beispiel #18
0
 def sendget_robust(self,message):
     """
     Send and receive control commands to iBOB using robust UDP protocol
     """
     header_fmt = '>IHBB'
     self.control_flush()
     
     
     tstart = time.time()
     while time.time() - tstart < 1.0:
         msgid = (0xFF<<24)+self.msgid
         self.msgid += 1
         if self.msgid > 0xFFFF00:
             self.msgid = 0
         hdr = struct.pack(header_fmt,msgid,0,0,0)
         msg = hdr + message
         self.control_send_msg(msg)
         tsend = time.time()
         resp = ''
         nextseq = 0
         while time.time() - tsend < 0.2:
             r = self.readone()
             if len(r) >= 8:
                 #print "waiting for seq:",nextseq,("msgid:%08X" %msgid)
                 rxid,seq,type,blah = struct.unpack(header_fmt,r[:8])
                 #print ("\nrxid:%08X"%rxid),"seq",seq,"type",type
                 if rxid == msgid:
                     if seq == nextseq:
                         resp += r[8:]
                         if type == 2:
                             corelog.debug("%s cmd '%s' response in %.2f ms: '%s'" %(self.name,msg,(time.time()-tstart)*1000,resp))
                             return resp
                         else:
                             nextseq += 1
                             continue
                     else:
                         corelog.debug("%s ibob sequence error: expected seq: %d got %d" % (self.name,nextseq,seq,r))
                 else:
                     corelog.debug("%s expected msgid %08X but got %08X" % (self.name,msgid,rxid))
             elif len(r):
                 corelog.debug("%s received: %s" % (self.name,r))
Beispiel #19
0
 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")
Beispiel #20
0
                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)
                    
        corelog.debug("Finished realtime data capture init %s" % self.name)

    def start_writing(self,filename):
        self.prepare_for_writing(filename)
        self.writing = True
    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:
Beispiel #21
0
            except:
                break
        
        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
    
Beispiel #22
0
                try:
                    r = prog_ipf(ipffile,cable=self.jtagcables[1],display=True)
                except Exception, e:
                    corelog.exception("Failure programming ibob %d with ipffile %s" % (ibob, ipffile))
                    raise e
                results.append(r)
                if r[0] == 0:
                    corelog.info("Programming ibob %d was successful.  Impact returned: %d Status info:\n\n %s \n\n" % (ibob,r[0],r[1]))
                else:
                    corelog.error("Programming ibob %d Failed! Impact returned: %d Status info:\n\n %s \n\n" % (ibob,r[0],r[1]))
            if results[-1][0] ==0:
                vald["iBOBDesignID%d" % ibob] = ipfid
            else:
                vald["iBOBDesignID%d" % ibob] = 1 # design 1 means unknown state
        
        corelog.debug("Updating status in db")
        vald['UnixTime'] = time.time()
        if self.sql:
            self.gdb.updateValues(vald, 'spss_config')
        return results
    
    
if __name__=="__main__":
    import Pyro.naming
    
    Pyro.core.initServer()
    ns = Pyro.naming.NameServerLocator().getNS()
    try:
        ns.unregister('UtilServer')
    except:
        pass
Beispiel #23
0
    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)
Beispiel #24
0
                break
        
        tic = time.time()
        try:
            self.send(cmd)
            corelog.debug("Sent command %s" % cmd)
        except Exception,e:
            corelog.exception("Could not send command %s" % cmd)
            return
        tstart = time.time()
        resp = ''
        while (time.time()-tstart < timeout):
            try:
                resp = resp + self.sock.recv(1000)
                if resp.find('COMPLETED:') >= 0:
                    corelog.debug("RSS successfully executed command %s in %.2f ms" % (cmd,(time.time()-tic)*1000))
                    time.sleep(0.1) #sleep a moment to ensure receiver is setup
                    return resp
        
            except:
                pass
        return resp
    
if __name__=="__main__":
    import Pyro.naming
    
    Pyro.core.initServer()
    ns = Pyro.naming.NameServerLocator().getNS()
    try:
        ns.unregister('RSSInterface')
    except:
Beispiel #25
0
 def setPLL(self, d):
     if d is None:
         return
     corelog.debug("Setting prescaler = 8/9")
     self.WriteReg(0x16, 0x04)
     corelog.debug("Setting r = 100 (100MHz ref)")
     self.WriteReg(0x11, 100)
     corelog.debug("Setting a: %d" % d["a"])
     self.WriteReg(0x13, d["a"])
     (h, l) = divmod(d["b"], 256)
     corelog.debug("Setting b: %d=%d*256+%d" % (d["b"], h, l))
     self.WriteReg(0x14, l)
     self.WriteReg(0x15, h)
     VCOdivVal = d["VCOdiv"] - 2
     if VCOdivVal < 0 or VCOdivVal > 4:
         corelog.error("Got bad VCOdivider: %d Original valud %d. Proceeding using 2" % (VCOdivVal, d["VCOdiv"]))
         VCOdivVal = 0
     corelog.debug("Setting VCOdiv: %d, reg: %d" % (d["VCOdiv"], VCOdivVal))
     self.WriteReg(0x1E0, VCOdivVal)
     finaldiv = d["finaldiv"]
     if finaldiv == 1:
         corelog.debug("Bypassing final divider")
         self.WriteReg(0x197, 0x80)
         self.WriteReg(0x191, 0x80)
     else:
         cycles = finaldiv / 2 - 1
         corelog.debug("cycles= %d cyclereg: 0x%02x" % (cycles, cycles * 16 + cycles))
         self.WriteReg(0x197, 0x00)
         self.WriteReg(0x191, 0x00)
         self.WriteReg(0x196, cycles * 16 + cycles)
         self.WriteReg(0x190, cycles * 16 + cycles)
     self.WriteReg(0x232, 1)
     corelog.debug("Calibrating VCO")
     self.WriteReg(0x18, 0x06)
     self.WriteReg(0x232, 1)
     self.WriteReg(0x18, 0x07)
     self.WriteReg(0x232, 1)