예제 #1
0
 def __init__(self, address, handler=BasicRequestHandler,
              correlator=BEE2CorrelationProvider, reference=6,
              fstop=0.256, antennas=[6, 1, 2, 3, 4, 5, 7, 8],
              correlator_lags=16, include_baselines='*-*', initial_int_time=16, 
              analog_bandwidth=512000000.0, antenna_diameter=3,
              bee2_host='b02.ata.pvt', bee2_port=7147,
              correlator_bitstream='bee2_calib_corr.bof',
              ipa_hosts=('169.254.128.3', '169.254.128.2'),
              dbe_host='169.254.128.0', dds_host='128.171.116.189',
              correlator_client_port=8332, phase_tracker_port=9453):
     """ SubmillimeterArrayTCPServer(address, handler, correlator, lags, baselines)
     This subclasses the BasicTCPServer and adds some methods needed for
     controlling and reading data from the BEE2CorrelationProvider. Please see 
     the BasicTCPServer documentation for more detailed information."""
     BasicTCPServer.__init__(self, address, handler=handler, 
                             correlator=correlator, correlator_lags=correlator_lags, 
                             antennas=antennas, initial_int_time=initial_int_time,
                             antenna_diameter=antenna_diameter, analog_bandwidth=analog_bandwidth, 
                             include_baselines=include_baselines)
     self._correlator = correlator(self, self._include_baselines, bee2_host, bee2_port, 
                                   lags=correlator_lags, bof=correlator_bitstream)
     self._correlator_client = BEE2CorrelatorClient('0.0.0.0', correlator_client_port)
     self.bee2_host, self.bee2_port, self.bee2_bitstream = bee2_host, bee2_port, correlator_bitstream
     self._delay_tracker_thread = Thread(target=self._delay_tracker)
     self._delay_tracker_stopevent = Event()
     self._checks_thread = Thread(target=self._checks_loop)
     self._checks_stopevent = Event()
     self._bee2 = BEE2Client(bee2_host, port=bee2_port)
     self._bee2._connected.wait()
     self._dds = DDSClient(dds_host)
     self._ipa0 = IBOBClient(ipa_hosts[0], port=23)
     self._ipa1 = IBOBClient(ipa_hosts[1], port=23)
     self._dbe = IBOBClient(dbe_host, port=23)
     self._reference_antenna = reference
     self._phase_tracker_port = phase_tracker_port
     self._fstop = fstop # GHz, fringe stopping
     self._ipas = {'ipa0': self._ipa0, 'ipa1': self._ipa1}
     self._ibobs = {'ipa0': self._ipa0, 'ipa1': self._ipa1, 'dbe': self._dbe}
     self._boards = {'ipa0': self._ipa0, 'ipa1': self._ipa1, 'dbe': self._dbe, 'bee2': self._bee2}
     self._mapping = dict((a, i) for i, a in enumerate(self._antennas))#{6:0, 1:1, 2:2, 3:3, 4:4, 5:5, 7:6, 8:7}
     self._input_ibob_map = {0: [self._ipa0, 0], 1: [self._ipa0, 1],
                             2: [self._ipa0, 2], 3: [self._ipa0, 3],
                             4: [self._ipa1, 0], 5: [self._ipa1, 1],
                             6: [self._ipa1, 2], 7: [self._ipa1, 3]}
     self._param_handlers = {'_thresholds' : self._thresh_handler,
                             '_phases': self._phase_handler,
                             '_phase_offsets': self._phase_offset_handler,
                             '_delays': self._delay_handler,
                             '_delay_offsets': self._delay_offset_handler,
                             '_gains': self._gain_handler}
     self._command_set.update({2 : self.get_mapping,
                               3 : self.set_mapping,
                               5 : self.load_walsh_table,
                               6 : self.clear_walsh_table,
                               7 : self.delay_tracker,
                               12 : self.reset_xaui,
                               13 : self.arm_sync,
                               14 : self.noise_mode,
                               15 : self._board,
                               16 : self.get_reference,
                               17 : self.setup_fstopping,
                               18 : self.start_fstopping,
                               19 : self.stop_fstopping,
                               36 : self.get_delays,
                               37 : self.set_delays,
                               38 : self.get_phases,
                               39 : self.set_phases,
                               40 : self.get_gains,
                               41 : self.set_gains,
                               42 : self.get_thresholds,
                               43 : self.set_thresholds,
                               64 : self.get_dbe_gains,
                               65 : self.set_dbe_gains,
                               96 : self.operations_log,
                               128 : self.get_correlation})
     self.setup()
     #self.sync_all()
     self.start_checks_loop(30.0)
     #self.start_delay_tracker(4.0)
     self.start_phase_tracker(1)
예제 #2
0
class SubmillimeterArrayTCPServer(BasicTCPServer):

    def __init__(self, address, handler=BasicRequestHandler,
                 correlator=BEE2CorrelationProvider, reference=6,
                 fstop=0.256, antennas=[6, 1, 2, 3, 4, 5, 7, 8],
                 correlator_lags=16, include_baselines='*-*', initial_int_time=16, 
                 analog_bandwidth=512000000.0, antenna_diameter=3,
                 bee2_host='b02.ata.pvt', bee2_port=7147,
                 correlator_bitstream='bee2_calib_corr.bof',
                 ipa_hosts=('169.254.128.3', '169.254.128.2'),
                 dbe_host='169.254.128.0', dds_host='128.171.116.189',
                 correlator_client_port=8332, phase_tracker_port=9453):
        """ SubmillimeterArrayTCPServer(address, handler, correlator, lags, baselines)
        This subclasses the BasicTCPServer and adds some methods needed for
        controlling and reading data from the BEE2CorrelationProvider. Please see 
        the BasicTCPServer documentation for more detailed information."""
        BasicTCPServer.__init__(self, address, handler=handler, 
                                correlator=correlator, correlator_lags=correlator_lags, 
                                antennas=antennas, initial_int_time=initial_int_time,
                                antenna_diameter=antenna_diameter, analog_bandwidth=analog_bandwidth, 
                                include_baselines=include_baselines)
        self._correlator = correlator(self, self._include_baselines, bee2_host, bee2_port, 
                                      lags=correlator_lags, bof=correlator_bitstream)
        self._correlator_client = BEE2CorrelatorClient('0.0.0.0', correlator_client_port)
        self.bee2_host, self.bee2_port, self.bee2_bitstream = bee2_host, bee2_port, correlator_bitstream
        self._delay_tracker_thread = Thread(target=self._delay_tracker)
        self._delay_tracker_stopevent = Event()
        self._checks_thread = Thread(target=self._checks_loop)
        self._checks_stopevent = Event()
        self._bee2 = BEE2Client(bee2_host, port=bee2_port)
        self._bee2._connected.wait()
        self._dds = DDSClient(dds_host)
        self._ipa0 = IBOBClient(ipa_hosts[0], port=23)
        self._ipa1 = IBOBClient(ipa_hosts[1], port=23)
        self._dbe = IBOBClient(dbe_host, port=23)
        self._reference_antenna = reference
        self._phase_tracker_port = phase_tracker_port
        self._fstop = fstop # GHz, fringe stopping
        self._ipas = {'ipa0': self._ipa0, 'ipa1': self._ipa1}
        self._ibobs = {'ipa0': self._ipa0, 'ipa1': self._ipa1, 'dbe': self._dbe}
        self._boards = {'ipa0': self._ipa0, 'ipa1': self._ipa1, 'dbe': self._dbe, 'bee2': self._bee2}
        self._mapping = dict((a, i) for i, a in enumerate(self._antennas))#{6:0, 1:1, 2:2, 3:3, 4:4, 5:5, 7:6, 8:7}
        self._input_ibob_map = {0: [self._ipa0, 0], 1: [self._ipa0, 1],
                                2: [self._ipa0, 2], 3: [self._ipa0, 3],
                                4: [self._ipa1, 0], 5: [self._ipa1, 1],
                                6: [self._ipa1, 2], 7: [self._ipa1, 3]}
        self._param_handlers = {'_thresholds' : self._thresh_handler,
                                '_phases': self._phase_handler,
                                '_phase_offsets': self._phase_offset_handler,
                                '_delays': self._delay_handler,
                                '_delay_offsets': self._delay_offset_handler,
                                '_gains': self._gain_handler}
        self._command_set.update({2 : self.get_mapping,
                                  3 : self.set_mapping,
                                  5 : self.load_walsh_table,
                                  6 : self.clear_walsh_table,
                                  7 : self.delay_tracker,
                                  12 : self.reset_xaui,
                                  13 : self.arm_sync,
                                  14 : self.noise_mode,
                                  15 : self._board,
                                  16 : self.get_reference,
                                  17 : self.setup_fstopping,
                                  18 : self.start_fstopping,
                                  19 : self.stop_fstopping,
                                  36 : self.get_delays,
                                  37 : self.set_delays,
                                  38 : self.get_phases,
                                  39 : self.set_phases,
                                  40 : self.get_gains,
                                  41 : self.set_gains,
                                  42 : self.get_thresholds,
                                  43 : self.set_thresholds,
                                  64 : self.get_dbe_gains,
                                  65 : self.set_dbe_gains,
                                  96 : self.operations_log,
                                  128 : self.get_correlation})
        self.setup()
        #self.sync_all()
        self.start_checks_loop(30.0)
        #self.start_delay_tracker(4.0)
        self.start_phase_tracker(1)

    def shutdown(self, args):
        self.stop_checks_loop()
        self.stop_delay_tracker()
        self.stop_phase_tracker()
        return BasicTCPServer.shutdown(self, args)

    @info
    def reset_xaui(self, args):
        lev = BYTE.unpack(args[0])[0]
        for board in [self._dbe, self._bee2]:
            board.regwrite('xaui_rst', lev)
            board.logger.info('xaui_rst=%d' % board.regread('xaui_rst'))
            board.regwrite('xaui_rst', 0)
            board.logger.info('xaui_rst=%d' % board.regread('xaui_rst'))
        return BYTE.pack(0)

    @info
    def arm_sync(self, args):
        self.sync_all()
        return BYTE.pack(0)

    @debug
    def _setup_IPA(self, ipanum):
        ipa = self._ibobs['ipa%d'%ipanum]
        ipa.regwrite('insel', 0)
        ipa.regwrite('smasel', 0)
        ipa.regwrite('monsel', 2)
        ipa.regwrite('walsh/colsel', 31 | 30*2**8 | 29*2**16 | 28*2**24)
        ipa.regwrite('walsh/syncsel', 1)
        ipa.regwrite('walsh/sign90', 1)
        #ipa.regwrite('start_xaui', 1)

    @debug
    def _setup_DBE(self):
        self._dbe.regwrite('insel', 0)

    @debug
    def _setup_BEE2(self):
        #self._bee2.progdev('bee2_complex_corr.bof')
        self._bee2.regwrite('refant', self._mapping[self._reference_antenna])
        self._bee2.regwrite('syncsel', 2)

    @info
    def _setup_fringe_stopping(self):
        with RLock():
            queues = {}
            self._dds.query_dds(None)
            query = self._dds.query.copy()
            for name, ibob in self._ipas.iteritems():
                sync_time = time() + 1 # second from now
                H = self._dds.get_hour_angle(query['rA'],
                                             query['refLong'],
                                             sync_time)
                h_cmd = 'sync_hour_angle {} 0'.format(int(H*10**5))
                while time()<sync_time:
                    pass
                ibob.tinysh(h_cmd)
                ibob.logger.info(h_cmd)
                fstop_cmd = 'set_fstop {} 0'.format(int(self._fstop*10**5))
                ibob.tinysh(fstop_cmd)
                ibob.logger.info(fstop_cmd)
            for ant in self._antennas:
                B = -query['b'][ant] * 10**9
                C = -query['c'][ant] * 10**9
                A = 4000.0 - query['a'][ant] * 10**9
                ibob, ibob_input = self._input_ibob_map[self._mapping[ant]]
                cmd = 'set_delay_triplet {input} {A} {B} {C}'.format(
                    input=ibob_input, A=int(A*10**5), B=int(B*10**5), C=int(C*10**5)
                    )
                queue = ibob.tinysh(cmd)
                queue.get()
                ibob.logger.info(cmd)
                
    @debug
    def _sync_1pps(self):
        with RLock():
            queues = {}
            for name, ibob in self._ibobs.iteritems():
                queues[ibob] = ibob.tinysh('arm1pps')
            for ibob, queue in queues.iteritems():
                last_line = queue.get().splitlines()[-2]
                # should check if they were actually sync'ed
                # here instead of just logging about it
                ibob.logger.info(last_line)

    @debug
    def _sync_sowf(self):
        with RLock():
            queues = {}
            for name, ibob in self._ipas.iteritems():
                queues[ibob] = ibob.tinysh('armsowf')
            for ibob, queue in queues.iteritems():
                last_line = queue.get().splitlines()[-2]
                # should check if they were actually sync'ed
                # here instead of just logging about it
                ibob.logger.info(last_line)

    @debug
    def _check_XAUI(self):
        boards = {'DBE': (self._dbe, '/'),
                  'BEE': (self._bee2, '_')}
        for board_name, info in boards.iteritems():
            board, regsep = info
            msg = "{board}/{0}: (period {1})(syncs {2})(errors: {3})(linkdowns: {4})"
            for xaui in ['xaui0', 'xaui1']:
                prefix = xaui+regsep
                with RLock():
                    linkdown = board.regread(prefix+'rx_linkdown')
                    period = board.regread(prefix+'period')
                    sync_cnt = board.regread(prefix+'sync_cnt')
                    period_err_cnt = board.regread(prefix+'period_err_cnt')
                    linkdown_cnt = board.regread(prefix+'linkdown_cnt')
                if linkdown:
                    self.logger.error('{board} {0} link is down!'.format(xaui, board=board_name))
                board.logger.info(msg.format(xaui, period, sync_cnt, period_err_cnt,
                                            linkdown_cnt, board=board_name))

    @info
    def setup(self):
        self._setup_IPA(0)
        self._setup_IPA(1)
        self._setup_DBE()
        self._setup_BEE2()

    @debug
    def sync_all(self):
        self._sync_1pps()
        self._sync_sowf()

    @info
    def run_checks(self):
        self._check_XAUI()

    @debug
    def run_delay_tracker(self, delays):
        for a in self._antennas:
            self.set_value('_delays', a, delays[a])

    @debug
    def run_fringe_stopper(self, phases):
        for a in self._antennas:
            self.set_value('_phases', a, phases[a])

    @debug
    def _checks_loop(self):
        while not self._checks_stopevent.isSet():
            with RLock():
                checks_period = self._checks_period
            self.run_checks()
            self._checks_stopevent.wait(checks_period)

    @debug
    def _delay_tracker(self):
        count = 0
        logger = logging.getLogger("DelayTracker")
        while not self._delay_tracker_stopevent.isSet():
            start = time()
            if count%20 == 0:
                try:
                    self._dds.reconnect()
                    self._dds.query_dds(None)
                except:
                    logger.error("Problem communicating with the DDS!")
                    self._delay_tracker_stopevent.wait(20)
                    continue
            with RLock():
                fstop = self._fstop
                period = self._delay_tracker_period
                delays = self._dds.get_delays(start+period)
            phases = dict((a, sign(fstop)*(360*d*abs(fstop) % 360)) for a, d in delays.iteritems())
            count += 1
            while time() < start+period:
                self._delay_tracker_stopevent.wait(period/10.)
            with RLock():
                self.run_delay_tracker(delays)
                self.run_fringe_stopper(phases)
            logger.info('|'.join('%d:%.2f'%(a, d) for a, d in delays.iteritems() if a in self._antennas))
            #logger.info('|'.join('%d:%.2f'%(a, p) for a, p in phases.iteritems() if a in self._antennas))
            
    @debug
    def start_checks_loop(self, period):
        self.logger.info('starting check loop at %s (period %.2f)' % (asctime(), period))
        self._checks_period = period
        self._checks_thread.start()

    @debug
    def start_delay_tracker(self, period):
        self.logger.info('starting delay tracker at %s (period %.2f)' % (asctime(), period))
        self._delay_tracker_thread = Thread(target=self._delay_tracker)
        self._delay_tracker_stopevent.clear()
        self._delay_tracker_period = period
        self._delay_tracker_thread.start()

    @debug
    def start_phase_tracker(self, period):
        self.logger.info('starting phase tracker at %s (period %.2f)' % (asctime(), period))
        self._phase_tracker = PhaseTracker(self, '0.0.0.0', self._phase_tracker_port)
        self._correlator.add_subscriber(('0.0.0.0', self._phase_tracker_port))
        self._phase_tracker.start(period)

    @debug
    def stop_checks_loop(self):
        self._checks_stopevent.set()
        self._checks_thread.join()

    @debug
    def stop_delay_tracker(self):
        self._delay_tracker_stopevent.set()
        if self._delay_tracker_thread.isAlive():
            self._delay_tracker_thread.join()

    @debug
    def stop_phase_tracker(self):
        self._phase_tracker.stop()
        self._correlator.remove_subscriber(('0.0.0.0', self._phase_tracker_port))

    @info
    def delay_tracker(self, args):
        """ inst.noise_mode(bool)
        If bool=True, selects internally generated noise.
        If bool=False, selects external ADC data (normal)."""
        on = unpack('!B', args[0])[0]
        if self._delay_tracker_thread.isAlive():
            if on:
                self.logger.warning("delay tracker already started!")
                return SBYTE.pack(-1)
            else:
                self.stop_delay_tracker()
                self.logger.info("delay tracker stopped")
        else:
            if not on:
                self.logger.warning("delay tracker has not been started!")
                return SBYTE.pack(-2)
            else:
                self.start_delay_tracker(1)
                self.logger.info("delay tracker started")
        return SBYTE.pack(0)

    @info
    def clear_walsh_table(self, args):
        for name, ibob in self._ipas.iteritems():
            for step in range(64):
                ibob.bramwrite('walsh/table/90', 0, location=step)
                ibob.bramwrite('walsh/table/180', 0, location=step)
        return SBYTE.pack(0)

    @info
    def load_walsh_table(self, args):
        try:
            walsh_table = self._dds.get_walsh_pattern()
        except:
            self.logger.error("problem communicating with the DDS!")
            return SBYTE.pack(-1)
        for step in range(64):
            cur90 = dict.fromkeys(self._ipas.values(), 0)
            cur180 = dict.fromkeys(self._ipas.values(), 0)
            for antenna, steps in walsh_table.items():
                try:
                    ibob, col = self._input_ibob_map[self._mapping[antenna]]
                except KeyError:
                    self.logger.warning("antenna %d not in array" % antenna)
                    walsh_table.pop(antenna)
                    continue
                bit90 = steps[step] & 1 # extract bottom bit
                bit180 = (steps[step] >> 1) & 1 # extract top bit
                cur90[ibob] = cur90[ibob] | (bit90 << col)
                cur180[ibob] = cur180[ibob] | (bit180 << col)
            for ibob in self._ipas.values():
                ibob.bramwrite('walsh/table/90', cur90[ibob], location=step)
                ibob.bramwrite('walsh/table/180', cur180[ibob], location=step)
        return SBYTE.pack(0)

    @debug
    def _delay_handler(self, mode, antenna, ibob, ibob_input, value=None):
        adc_per_ns = 1.024
        regname = 'delay%d' % ibob_input
        if mode=='get':
            regvalue = ibob.regread(regname)
            if regvalue < 64:
                regvalue += 2**17
            return ((regvalue-64)/(16*adc_per_ns)) % (2**17)
        elif mode=='set':
            total = value + self._delay_offsets[antenna]
            regvalue = (round(16*adc_per_ns*total)+64) % (2**17)
            ibob.regwrite(regname, int(regvalue))
            return self._delay_handler('get', antenna, ibob, ibob_input)

    @debug
    def _delay_offset_handler(self, mode, antenna, ibob, ibob_input, value=None):
        if mode=='get':
            return ibob.get_delay_offset(ibob_input)
        elif mode=='set':
            ibob.set_delay_offset(ibob_input, value)
            return self._delay_offset_handler('get', antenna, ibob, ibob_input)

    @debug
    def _phase_handler(self, mode, antenna, ibob, ibob_input, value=None):
        deg_per_step = 360./2**12
        regname = 'phase%d' % ibob_input
        if mode=='get':
            regvalue = ibob.regread(regname)
            return regvalue * deg_per_step
        elif mode=='set':
            total = value + self._phase_offsets[antenna]
            regvalue = round(total/deg_per_step)
            ibob.regwrite(regname, int(regvalue))
            return self._phase_handler('get', antenna, ibob, ibob_input)

    @debug
    def _phase_offset_handler(self, mode, antenna, ibob, ibob_input, value=None):
        if mode=='get':
            return ibob.get_phase_offset(ibob_input)
        elif mode=='set':
            ibob.set_phase_offset(ibob_input, value)
            return self._phase_offset_handler('get', antenna, ibob, ibob_input)

    @debug
    def _gain_handler(self, mode, antenna, ibob, ibob_input, value=None):
        regname = 'gain%d' % ibob_input
        if mode=='get':
            regvalue = ibob.regread(regname)
            return (regvalue % 256) * 2**-7
        elif mode=='set':
            regvalue = round(value * 2**7) % 256
            ibob.regwrite(regname, int(regvalue))
            return self._gain_handler('get', antenna, ibob, ibob_input)

    @debug
    def _thresh_handler(self, mode, antenna, ibob, ibob_input, value=None):
        regname = 'quant/thresh%d' % ibob_input
        if mode=='get':
            return ibob.regread(regname)
        elif mode=='set':
            ibob.regwrite(regname, value)
            return self._thresh_handler('get', antenna, ibob, ibob_input)

    def get_value(self, param, antenna):
        try:
            ibob, ibob_input = self._input_ibob_map[self._mapping[antenna]]
            return self._param_handlers[param]('get', antenna, ibob, ibob_input)
        except KeyError:
            return BasicTCPServer.get_value(self, param, antenna)

    def set_value(self, param, antenna, value):
        ibob, ibob_input = self._input_ibob_map[self._mapping[antenna]]
        try:
            return self._param_handlers[param]('set', antenna, ibob, ibob_input, value)
        except KeyError:
            return BasicTCPServer.set_value(self, param, antenna, value)

    @info
    def get_delays(self, args):
        """ inst.get_delays(ant=[1,2,3,4,...]) -> values=[100.0, 100.0, 100.0,...]
        Get the current delays (with delay offsets included). """
        return self.get_values('delays', args, type='f')

    @info
    def set_delays(self, args):
        """ inst.set_delays(ant_val=[1,1.0,2,1.0,3,1.0,...]) -> values=[0,1,2,...]
        Set the delays, this may be overriden by the delay tracking loop.
        If you're looking to just add a delay offset use set_delay_offsets instead
        and wait for the delay loop to iterate."""
        return self.set_values('delays', args, type='f')

    @info
    def get_phases(self, args):
        """ inst.get_phases(ant=[1,2,3,4,...]) -> values=[100.0, 100.0, 100.0,...]
        Get the current delays (with delay offsets included). """
        return self.get_values('phases', args, type='f')

    @info
    def set_phases(self, args):
        """ inst.set_phases(ant_val=[1,1.0,2,1.0,3,1.0,...]) -> values=[0,1,2,...]
        Set the phases, this may be overriden by the delay tracking loop.
        If you're looking to just add a phase offset use set_phase_offsets instead
        and wait for the delay loop to iterate."""
        return self.set_values('phases', args, type='f')

    @info
    def get_mapping(self, args):
        """ inst.get_mapping(ant=[1,2,3,4,...]) -> values=[4,5,6,7,...]
        Get mapping of antennas to input numbers. """
        return self.get_values('mapping', args, type='B')

    @info
    def set_mapping(self, args):
        """ inst.set_delay_offsets(ant_val=[1,0,2,1,3,2,...]) -> values=[0,1,2,...]
        Set the mapping of antennas to input numbers. """
        return self.set_values('mapping', args, type='B')

    @info
    def get_gains(self, args):
        """ inst.get_gains(ant=[1,2,3,4,...]) -> values=[1.0, 1.0, 1.0,...]
        Get the pre-sum gains. """
        return self.get_values('gains', args, type='f')

    @info
    def set_gains(self, args):
        """ inst.set_gains(ant_val=[1,1.0,2,1.0,3,1.0,...]) -> values=[0,1,2,...]
        Set the pre-sum gains. """
        return self.set_values('gains', args, type='f')

    @info
    def get_dbe_gains(self, args):
        """ inst.get_dbe_gains(ant=[0,1,2,3,4,...,15]) -> values=[1.0, 1.0, 1.0,...]
        Get the DBE channelizer gains. """
        gainctrl0 = self._dbe.bramdump('pol0/gainctrl0', 8)
        gainctrl1 = self._dbe.bramdump('pol0/gainctrl1', 8)
        changains = [None] * 16
        changains[::2] = gainctrl0
        changains[1::2] = gainctrl1
        return pack('!B16I', 0, *changains)

    @info
    def set_dbe_gains(self, args):
        """ inst.set_dbe_gains(ant_val=[0,1.0,1,1.0,2,1.0,...]) -> values=[0,1,2,...]
        Set the DBE channelizer gains. """
        changains = unpack('!16I', args)
        for chan, gain in enumerate(changains):
            self._dbe.bramwrite('pol0/gainctrl%d' %(chan%2), gain, int(chan/2.))
        return self.get_dbe_gains('')

    @debug
    def get_correlation(self, args):
        """ inst.get_correlation() -> single_udp_packet
        Gets the next correlation from the correlator client, returns -1 if there is no
        correlation ready. Note: it is preferable to use a direcy UDP client instead of
        this function but it is provided to enable secure remote operations."""
        try:
            pkt = self._correlator_client._request('')
            return pack('!B%ds' % len(pkt), 0, pkt)
        except NoCorrelations:
            return SBYTE.pack(-1)

    @info
    def get_thresholds(self, args):
        """ inst.get_thresholds(ant=[1,2,3,4,...]) -> values=[16, 16, 16,...]
        Get the threshold values used by the 2-bit quantizers. """
        return self.get_values('thresholds', args, type='B')

    @info
    def set_thresholds(self, args):
        """ inst.set_thresholds(ant_val=[1,16,2,16,3,16,...]) -> values=[0,1,2,...]
        Set the 2-bit quantization thresholds. """
        return self.set_values('thresholds', args, type='B')

    @info
    def noise_mode(self, args):
        """ inst.noise_mode(bool)
        If bool=True, selects internally generated noise.
        If bool=False, selects external ADC data (normal)."""
        insel = unpack('!B', args[0])[0]
        seed = (randint(0, 2**16-1) << 16) + randint(0, 2**16-1)
        for name, ibob in self._ipas.iteritems():
            ibob.regwrite('noise/seed/0', seed)
            ibob.regwrite('noise/seed/1', seed)
            ibob.regwrite('noise/seed/2', seed)
            ibob.regwrite('noise/seed/3', seed)
        for name, ibob in self._ipas.iteritems():
            ibob.regwrite('noise/arm', 0)
        for name, ibob in self._ipas.iteritems():
            ibob.regwrite('noise/arm', 0x1111)
        for name, ibob in self._ipas.iteritems():
            ibob.regwrite('insel', insel*0x55555555)
        return SBYTE.pack(0)

    @debug
    def _board(self, args):
        """ inst._board(board, cmd)
        This allows the client to send commands and receive
        responses from the server's underlying iBOBs. Note: this
        should be used cautiously, if you find yourself using this often
        you should just write a server command."""
        queues = {}
        board_re, sep, cmd = args.partition(' ')
        for name, board in self._boards.iteritems():
            if re.match(board_re, name):
                queues[name] = board.tinysh(cmd)
        response = ''
        for name, queue in queues.iteritems():
            response += queue.get(20)
            response += "\r### {0} {1} @({2})\n\r".format(name, cmd, asctime()) 
        return SBYTE.pack(0) + response

    @debug
    def get_reference(self, args):
        """ inst.get_reference() -> err_code
        Returns the current reference antenna. """
        return pack('!bB', 0, self._reference_antenna)

    @debug
    def setup_fstopping(self, args):
        """ inst.setup_fstopping() -> err_code
        Setup the IPA iBOBs to perform fringe stopping.
        The only argument is the fringe stopping rate in GHz."""
        self._fstop = unpack('!f', args)[0]
        try:
            self._setup_fringe_stopping()
            return pack('!b', 0)
        except:
            self.logger.error('Error setting up fringe stopping!')
            return pack('!b', -1)

    @debug
    def start_fstopping(self, args):
        """ inst.start_fstopping() -> err_code
        Enable fringe stopping in the IPA iBOBs."""
        for name, ibob in self._ipas.iteritems():
            fstop_cmd = 'set_fstop {} 1'.format(int(self._fstop*10**5))
            ibob.tinysh(fstop_cmd)
            ibob.logger.info(fstop_cmd)
        return pack('!b', 0)

    @debug
    def stop_fstopping(self, args):
        """ inst.stop_fstopping() -> err_code
        Disable fringe stopping in the IPA iBOBs."""
        for name, ibob in self._ipas.iteritems():
            fstop_cmd = 'set_fstop {} 0'.format(int(self._fstop*10**5))
            ibob.tinysh(fstop_cmd)
            ibob.logger.info(fstop_cmd)
        return pack('!b', 0)

    def get_integration_time(self, args):
        """ inst.get_integration_time() -> err_code
        Overloaded method to get integration time on the BEE2."""
        itime = self._bee2.regread('integ_time')
        PERIOD = PERIOD_SYNCSEL[self._bee2.regread('syncsel')]
        self._integration_time = itime * PERIOD
        return pack('!bf', 0, self._integration_time)

    def set_integration_time(self, args):
        """ inst.set_integration_time(time) -> err_code
        Overloaded method to set the integration time on the BEE2."""
        itime = unpack('!f', args)[0]
        PERIOD = PERIOD_SYNCSEL[self._bee2.regread('syncsel')]
        integ_time = round(itime / PERIOD)
        self._bee2.regwrite('integ_time', integ_time)
        self._integration_time = integ_time
        return SBYTE.pack(0)

    @debug
    def operations_log(self, args):
        """ inst.operations_log(level, logger_name, msg)
        This allows any client to send log messages to the
        given logger at any level. """
        level, logger_msg = unpack('!B%ds' %(len(args)-1), args)
        logger_name, msg = logger_msg.split('\r')
        logger = logging.getLogger(logger_name)
        logger.log(level, msg)
        return SBYTE.pack(0)