def set_source_flux(self, args):
""" inst.set_source_flux(flux_Jy) -> err_code
This accepts a single float representing the requested source flux density
in Jansky's and for right now always returns an error code of 0
meaning that the source flux was set successfully."""
self._source_flux = FLOAT.unpack(args[:4])[0]
self.logger.debug('set_source_flux(%.2f)' %self._source_flux)
return SBYTE.pack(0)
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)
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)
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)
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)
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)
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
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)
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)
