def main(): """ Go, go, go! """ def parse_args(): """Parse the command-line arguments""" parser = argparse.ArgumentParser(description='Update the CPLD image on the X4xx') parser.add_argument("--file", help="Filename of CPLD image", default="/lib/firmware/ni/cpld-x410.rpd") parser.add_argument("--updater", help="The image updater method to use, either \"legacy\" or \"flash\"", default="flash") parser.add_argument( '-v', '--verbose', help="Increase verbosity level", action="count", default=1 ) parser.add_argument( '-q', '--quiet', help="Decrease verbosity level", action="count", default=0 ) return parser.parse_args() args = parse_args() # We need to make a logger if we're running stand-alone from usrp_mpm.mpmlog import get_main_logger log = get_main_logger(log_default_delta=args.verbose-args.quiet) return do_update_cpld(args.file, args.updater)
def main(): """ Go, go, go! """ # We need to make a logger if we're running stand-alone from usrp_mpm.mpmlog import get_main_logger log = get_main_logger() # Do some setup def parse_args(): """Parse the command-line arguments""" parser = argparse.ArgumentParser( description='Update the CPLD image on NI Magnesium') parser.add_argument("--file", help="Filename of CPLD image", default="/lib/firmware/ni/cpld-magnesium-revc.svf") parser.add_argument("--dboards", help="Slot name to program", default="0,1") return parser.parse_args() args = parse_args() dboards = args.dboards.split(",") if any([x not in ('0', '1') for x in dboards]): log.error("Unsupported dboards requested: %s", dboards) return False return do_update_cpld(args.file, dboards)
def __init__(self, raw_data_buffer, max_size=None, alignment=None, log=None): assert isinstance(raw_data_buffer, bytes) self.max_size = len(raw_data_buffer) if max_size is None else max_size self.raw_data_buffer = raw_data_buffer[:self.max_size] self.alignment = alignment or DEFAULT_ALIGNMENT self.pad = b'\xFF' if log is None: from usrp_mpm import mpmlog self.log = mpmlog.get_main_logger().getChild("EEPROMFS") else: self.log = log header = self._parse_header(raw_data_buffer) self.log.trace("EEPROM-FS header has {} valid entries.".format( len(header.get('entries', [])))) self.entries = OrderedDict({ str(x['id'], encoding='ascii'): x for x in header.get('entries', []) }) self.buffer = self._trunc_buffer(raw_data_buffer, self.entries) self.log.trace("Truncated buffer to length %d", len(self.buffer)) # Start storing entries at 128 self.entries_base = 128 # We can only store so many entries before running out of TOC space self.max_entries = (128 - 16) // 20 # TODO -- these last two shouldn't be hard coded self.log.trace( "This BufferFS has {} max entries, starting at {}".format( self.max_entries, self.entries_base))
def _discovery_process(state, discovery_addr): """ The actual process for device discovery. Is spawned by spawn_discovery_process(). """ log = get_main_logger().getChild('discovery') def create_response_string(state): " Generate the string that gets sent back to the requester. " return RESPONSE_SEP.join( [RESPONSE_PREAMBLE] + \ [b"type="+state.dev_type.value] + \ [b"product="+state.dev_product.value] + \ [b"serial="+state.dev_serial.value] + \ [b"fpga="+state.dev_fpga_type.value] + \ [RESPONSE_CLAIMED_KEY+to_binary_str("={}".format(state.claim_status.value))] ) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # FIXME really, we should only bind to the subnet but I haven't gotten that # working yet sock.bind((("0.0.0.0", MPM_DISCOVERY_PORT))) send_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) send_sock.setsockopt(socket.IPPROTO_IP, IP_MTU_DISCOVER, IP_PMTUDISC_DO) # TODO yeah I know that's not how you do this discovery_addr_prefix = discovery_addr.replace('.255', '') if discovery_addr == '0.0.0.0': discovery_addr_prefix = '' try: while True: data, sender = sock.recvfrom(MAX_MTU) log.debug("Got poked by: %s", sender[0]) # TODO this is still part of the awful subnet identification if not sender[0].startswith(discovery_addr_prefix): continue if data.strip(b"\0") == b"MPM-DISC": log.debug("Sending discovery response to %s port: %d", sender[0], sender[1]) resp_str = create_response_string(state) send_data = resp_str log.trace("Return data: %s", send_data) send_sock.sendto(send_data, sender) elif data.strip(b"\0").startswith(b"MPM-ECHO"): log.debug("Received echo request from {sender}".format( sender=sender[0])) send_data = data try: send_sock.sendto(send_data, sender) except OSError as ex: log.warning("ECHO send error: %s", str(ex)) except Exception as err: log.error("Unexpected error: `%s' Type: `%s'", str(err), type(err)) sock.close() send_sock.close() exit(1)
def __init__(self): # Make a logger try: self.log = get_logger('GPSDIface') except AssertionError: from usrp_mpm.mpmlog import get_main_logger self.log = get_main_logger('GPSDIface') # Make a socket to connect to GPSD self.gpsd_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def main(): """ Go, go, go! """ def parse_args(): """Parse the command-line arguments""" parser = argparse.ArgumentParser(description='Update the CPLD image on the X4xx') default_image_names = get_default_cpld_image_names(get_mb_compat_rev()) default_image_path = "/lib/firmware/ni/" + default_image_names[0] parser.add_argument("--file", help="Filename of CPLD image", default=default_image_path) # There are two --updater options supported by the script: "legacy" and "flash". However, # the "legacy" mode requires a custom FPGA bitfile where the JTAG engine is compiled into. # This is not the case for the standard UHD bitfile and hence the legacy mode cannot be # used with it. --> Hide the command line argument to avoid false expectations parser.add_argument("--updater", help = argparse.SUPPRESS, default="flash") parser.add_argument("--force", help="Force installing the CPLD image specified by the --file " \ "argument if it does not match the name of the default CPLD image. " \ "Using the wrong CPLD image may brick your device.", action="store_true", default=False, required=False) parser.add_argument( '-v', '--verbose', help="Increase verbosity level", action="count", default=1 ) parser.add_argument( '-q', '--quiet', help="Decrease verbosity level", action="count", default=0 ) args = parser.parse_args() if (os.path.basename(args.file) not in default_image_names) and not args.force: parser.epilog = "\nERROR: Valid CPLD image names for X410 compat_rev {} are {}, " \ "but you selected {}. Using the wrong CPLD image may brick your device. " \ "Please use the --force option if you are really sure.".format( get_mb_compat_rev(), ' and '.join(default_image_names), args.file ) parser.print_help() parser.epilog = None sys.exit(1) return args args = parse_args() # We need to make a logger if we're running stand-alone from usrp_mpm.mpmlog import get_main_logger log = get_main_logger(log_default_delta=args.verbose-args.quiet) return do_update_cpld(args.file, args.updater)
def _discovery_process(state, discovery_addr): """ The actual process for device discovery. Is spawned by spawn_discovery_process(). """ log = get_main_logger().getChild('discovery') def create_response_string(state): " Generate the string that gets sent back to the requester. " return RESPONSE_SEP.join( [RESPONSE_PREAMBLE] + \ [b"type="+state.dev_type.value] + \ [b"product="+state.dev_product.value] + \ [b"serial="+state.dev_serial.value] + \ [RESPONSE_CLAIMED_KEY+to_binary_str("={}".format(state.claim_status.value))] ) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # FIXME really, we should only bind to the subnet but I haven't gotten that # working yet sock.bind((("0.0.0.0", MPM_DISCOVERY_PORT))) send_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) send_sock.setsockopt(socket.IPPROTO_IP, IP_MTU_DISCOVER, IP_PMTUDISC_DO) # TODO yeah I know that's not how you do this discovery_addr_prefix = discovery_addr.replace('.255', '') if discovery_addr == '0.0.0.0': discovery_addr_prefix = '' try: while True: data, sender = sock.recvfrom(MAX_MTU) log.debug("Got poked by: %s", sender[0]) # TODO this is still part of the awful subnet identification if not sender[0].startswith(discovery_addr_prefix): continue if data.strip(b"\0") == b"MPM-DISC": log.debug("Sending discovery response to %s port: %d", sender[0], sender[1]) resp_str = create_response_string(state) send_data = resp_str log.trace("Return data: %s", send_data) send_sock.sendto(send_data, sender) elif data.strip(b"\0").startswith(b"MPM-ECHO"): log.debug("Received echo request from {sender}" .format(sender=sender[0])) send_data = data try: send_sock.sendto(send_data, sender) except OSError as ex: log.warning("ECHO send error: %s", str(ex)) except Exception as err: log.error("Unexpected error: `%s' Type: `%s'", str(err), type(err)) sock.close() send_sock.close() exit(1)
def __init__(self, state, default_args): self.log = get_main_logger().getChild('RPCServer') self.log.trace("Launching RPC server with compat num %d.%d", MPM_COMPAT_NUM[0], MPM_COMPAT_NUM[1]) self._state = state self._timer = Greenlet() # Setting this to True will disable an unclaim on timeout. Use with # care, and make sure to set it to False again when finished. self._disable_timeouts = False self._timeout_interval = float( default_args.get("rpc_timeout_interval", TIMEOUT_INTERVAL)) self.session_id = None # Create the periph_manager for this device # This call will be forwarded to the device specific implementation # e.g. in periph_manager/n3xx.py # Which implementation is called will be determined during # configuration with cmake (-DMPM_DEVICE). # mgr is thus derived from PeriphManagerBase # (see periph_manager/base.py) from usrp_mpm.periph_manager import periph_manager self._mgr_generator = lambda: periph_manager(default_args) self.periph_manager = self._mgr_generator() device_info = self.periph_manager.get_device_info() self._state.dev_type.value = \ to_binary_str(device_info.get("type", "n/a")) self._state.dev_product.value = \ to_binary_str(device_info.get("product", "n/a")) self._state.dev_serial.value = \ to_binary_str(device_info.get("serial", "n/a")) self._state.dev_fpga_type.value = \ to_binary_str(device_info.get("fpga", "n/a")) self._db_methods = [] self._mb_methods = [] self.claimed_methods = copy.copy(self.default_claimed_methods) self._last_error = "" self._init_rpc_calls(self.periph_manager) # We call the server __init__ function here, and not earlier, because # first the commands need to be registered super(MPMServer, self).__init__( pack_params={'use_bin_type': True}, unpack_params={ 'max_buffer_size': 50000000, 'raw': False }, ) self._state.system_ready.value = True self.log.info("RPC server ready!") # Optionally spawn watchdog. Note: In order for us to be able to spawn # the task from this thread, the main process needs to hand control to # us using watchdog.transfer_control(). if watchdog.has_watchdog(): self.log.info("Spawning watchdog task...") watchdog.spawn_watchdog_task(self._state, self.log)
def __init__(self, state, default_args): self.log = get_main_logger().getChild('RPCServer') self.log.trace("Launching RPC server with compat num %d.%d", MPM_COMPAT_NUM[0], MPM_COMPAT_NUM[1]) self._state = state self._timer = Greenlet() # Setting this to True will disable an unclaim on timeout. Use with # care, and make sure to set it to False again when finished. self._disable_timeouts = False self._timeout_interval = float(default_args.get( "rpc_timeout_interval", TIMEOUT_INTERVAL )) self.session_id = None # Create the periph_manager for this device # This call will be forwarded to the device specific implementation # e.g. in periph_manager/n3xx.py # Which implementation is called will be determined during # configuration with cmake (-DMPM_DEVICE). # mgr is thus derived from PeriphManagerBase # (see periph_manager/base.py) from usrp_mpm.periph_manager import periph_manager self._mgr_generator = lambda: periph_manager(default_args) self.periph_manager = self._mgr_generator() device_info = self.periph_manager.get_device_info() self._state.dev_type.value = \ to_binary_str(device_info.get("type", "n/a")) self._state.dev_product.value = \ to_binary_str(device_info.get("product", "n/a")) self._state.dev_serial.value = \ to_binary_str(device_info.get("serial", "n/a")) self._db_methods = [] self._mb_methods = [] self.claimed_methods = copy.copy(self.default_claimed_methods) self._last_error = "" self._init_rpc_calls(self.periph_manager) # We call the server __init__ function here, and not earlier, because # first the commands need to be registered super(MPMServer, self).__init__( pack_params={'use_bin_type': True}, ) self._state.system_ready.value = True self.log.info("RPC server ready!") # Optionally spawn watchdog. Note: In order for us to be able to spawn # the task from this thread, the main process needs to hand control to # us using watchdog.transfer_control(). if watchdog.has_watchdog(): self.log.info("Spawning watchdog task...") watchdog.spawn_watchdog_task(self._state, self.log)
def main(): """ Main function """ db_id = get_dboard_id_from_eeprom(['rhodium']) if 'rhodium' not in db_id: exit() logger = get_main_logger() dtoverlay.apply_overlay_safe('n320') context = pyudev.Context() adapter = pyudev.Devices.from_sys_path(context, '/sys/class/i2c-adapter/i2c-9') lodist = FPGAtoLoDist(adapter) lodist.reset('P3_3V_RF_EN') lodist.reset('P6_5V_LDO_EN') lodist.reset('P6_8V_EN')
def get_log_buf(self, token): """ Return the contents of the log buffer as a list of str -> str dictionaries. """ if not self._check_token_valid(token): self.log.warning( "Attempt to read logs without valid claim from {}".format( self.client_host)) err_msg = "get_log_buf() called without valid claim." self._last_error = err_msg raise RuntimeError(err_msg) log_records = get_main_logger().get_log_buf() self.log.trace("Returning %d log records.", len(log_records)) return [{k: str(v) for k, v in iteritems(record)} for record in log_records]
def main(): """ Go, go, go! """ # Do some setup def parse_args(): """Parse the command-line arguments""" parser = argparse.ArgumentParser( description='Update the CPLD image on ZBX daughterboard') parser.add_argument("--file", help="Filename of CPLD image", default="/lib/firmware/ni/cpld-zbx.rpd") parser.add_argument("--dboards", help="Slot name to program", default="0,1") parser.add_argument("--updater", help="The image updater method to use, either " " 'legacy' (uses openocd) or 'flash'", default="flash") parser.add_argument('-v', '--verbose', help="Increase verbosity level", action="count", default=1) parser.add_argument('-q', '--quiet', help="Decrease verbosity level", action="count", default=0) return parser.parse_args() args = parse_args() # We need to make a logger if we're running stand-alone from usrp_mpm.mpmlog import get_main_logger log = get_main_logger(log_default_delta=args.verbose - args.quiet) dboards = args.dboards.split(",") if any([x not in ('0', '1') for x in dboards]): log.error("Unsupported dboards requested: %s", dboards) return False return do_update_cpld(args.file, dboards, args.updater)
def get_log_buf(self, token): """ Return the contents of the log buffer as a list of str -> str dictionaries. """ if not self._check_token_valid(token): self.log.warning( "Attempt to read logs without valid claim from {}".format( self.client_host ) ) err_msg = "get_log_buf() called without valid claim." self._last_error = err_msg raise RuntimeError(err_msg) log_records = get_main_logger().get_log_buf() self.log.trace("Returning %d log records.", len(log_records)) return [ {k: str(v) for k, v in iteritems(record)} for record in log_records ]
def __init__(self, state, default_args): self.log = get_main_logger().getChild('RPCServer') self._state = state self._timer = Greenlet() self.session_id = None # Create the periph_manager for this device # This call will be forwarded to the device specific implementation # e.g. in periph_manager/n310.py # Which implementation is called will be determined during # configuration with cmake (-DMPM_DEVICE). # mgr is thus derived from PeriphManagerBase # (see periph_manager/base.py) from usrp_mpm.periph_manager import periph_manager self._mgr_generator = lambda: periph_manager(default_args) self.periph_manager = self._mgr_generator() device_info = self.periph_manager.get_device_info() self._state.dev_type.value = \ to_binary_str(device_info.get("type", "n/a")) self._state.dev_product.value = \ to_binary_str(device_info.get("product", "n/a")) self._state.dev_serial.value = \ to_binary_str(device_info.get("serial", "n/a")) self._db_methods = [] self._mb_methods = [] self.claimed_methods = copy.copy(self.default_claimed_methods) self._last_error = "" self._init_rpc_calls(self.periph_manager) # We call the server __init__ function here, and not earlier, because # first the commands need to be registered super(MPMServer, self).__init__( pack_params={'use_bin_type': True}, ) self._state.system_ready.value = True self.log.info("RPC server ready!") # Optionally spawn watchdog. Note: In order for us to be able to spawn # the task from this thread, the main process needs to hand control to # us using watchdog.transfer_control(). if watchdog.has_watchdog(): self.log.info("Spawning watchdog task...") watchdog.spawn_watchdog_task(self._state, self.log)
def main(): """ Go, go, go! """ # We need to make a logger if we're running stand-alone from usrp_mpm.mpmlog import get_main_logger log = get_main_logger() # Do some setup def parse_args(): """Parse the command-line arguments""" parser = argparse.ArgumentParser(description='Update the CPLD image on NI Rhodium') parser.add_argument("--file", help="Filename of CPLD image", default="/lib/firmware/ni/cpld-rhodium-revb.svf") parser.add_argument("--dboards", help="Slot name to program", default="0,1") return parser.parse_args() args = parse_args() dboards = args.dboards.split(",") if any([x not in ('0', '1') for x in dboards]): log.error("Unsupported dboards requested: %s", dboards) return False return do_update_cpld(args.file, dboards)