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 __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 __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 _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():
"""
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 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)
