def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
loop = asyncio.get_event_loop()
atexit.register(loop.close)
writer = DBWriter(args.baseurl_db, args.user_db, args.password_db,
args.database, args.table)
writer.start()
atexit_register_coroutine(writer.stop)
log = Log(writer)
server = Logger()
rpc_server = Server({"schedule_logger": server}, builtin_terminate=True)
loop.run_until_complete(
rpc_server.start(common_args.bind_address_from_args(args),
args.port_control))
atexit_register_coroutine(rpc_server.stop)
reader = MasterReader(args.server_master, args.port_master,
args.retry_master, log)
reader.start()
atexit_register_coroutine(reader.stop)
loop.run_until_complete(rpc_server.wait_terminate())
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if os.name == "nt":
asyncio.set_event_loop(asyncio.ProactorEventLoop())
loop = asyncio.get_event_loop()
if args.simulation:
from .sim import NewFocus8742Sim
dev = loop.run_until_complete(NewFocus8742Sim.connect())
elif args.tcp:
from .tcp import NewFocus8742TCP
dev = loop.run_until_complete(NewFocus8742TCP.connect(args.tcp))
else:
from .usb import NewFocus8742USB
dev = loop.run_until_complete(NewFocus8742USB.connect())
try:
simple_server_loop({"newfocus8742": dev},
common_args.bind_address_from_args(args), args.port)
except KeyboardInterrupt:
pass
finally:
dev.close()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
signal_handler = SignalHandler()
signal_handler.setup()
try:
get_logs_task = asyncio.ensure_future(
get_logs_sim(args.core_addr) if args.simulation else get_logs(args.core_addr))
try:
server = Server({"corelog": PingTarget()}, None, True)
loop.run_until_complete(server.start(common_args.bind_address_from_args(args), args.port))
try:
_, pending = loop.run_until_complete(asyncio.wait(
[signal_handler.wait_terminate(),
server.wait_terminate(),
get_logs_task],
return_when=asyncio.FIRST_COMPLETED))
for task in pending:
task.cancel()
finally:
loop.run_until_complete(server.stop())
finally:
pass
finally:
signal_handler.teardown()
finally:
loop.close()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if (not args.print_decoded and args.write_vcd is None
and args.write_dump is None):
print("No action selected, use -p, -w and/or -d. See -h for help.")
sys.exit(1)
device_mgr = DeviceManager(DeviceDB(args.device_db))
if args.read_dump:
with open(args.read_dump, "rb") as f:
dump = f.read()
else:
core_addr = device_mgr.get_desc("core")["arguments"]["host"]
dump = get_analyzer_dump(core_addr)
decoded_dump = decode_dump(dump)
if args.print_decoded:
print("Log channel:", decoded_dump.log_channel)
print("DDS one-hot:", decoded_dump.dds_onehot_sel)
for message in decoded_dump.messages:
print(message)
if args.write_vcd:
with open(args.write_vcd, "w") as f:
decoded_dump_to_vcd(f,
device_mgr.get_device_db(),
decoded_dump,
uniform_interval=args.vcd_uniform_interval)
if args.write_dump:
with open(args.write_dump, "wb") as f:
f.write(dump)
def run(with_file=False):
args = get_argparser(with_file).parse_args()
common_args.init_logger_from_args(args)
device_mgr = DeviceManager(DeviceDB(args.device_db),
virtual_devices={
"scheduler": DummyScheduler(),
"ccb": DummyCCB()
})
dataset_db = DatasetDB(args.dataset_db)
dataset_mgr = DatasetManager(dataset_db)
try:
exp_inst = _build_experiment(device_mgr, dataset_mgr, args)
exp_inst.prepare()
exp_inst.run()
exp_inst.analyze()
except CompileError as error:
return
except Exception as exn:
if hasattr(exn, "artiq_core_exception"):
print(exn.artiq_core_exception, file=sys.stderr)
raise exn
finally:
device_mgr.close_devices()
if args.hdf5 is not None:
with h5py.File(args.hdf5, "w") as f:
dataset_mgr.write_hdf5(f)
else:
for k, v in sorted(dataset_mgr.local.items(), key=itemgetter(0)):
print("{}: {}".format(k, v))
dataset_db.save()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
atexit.register(loop.close)
signal_handler = SignalHandler()
signal_handler.setup()
atexit.register(signal_handler.teardown)
writer = DBWriter(args.baseurl_db,
args.user_db, args.password_db,
args.database, args.table)
writer.start()
atexit_register_coroutine(writer.stop)
filter = Filter(args.pattern_file)
rpc_server = Server({"influxdb_filter": filter}, builtin_terminate=True)
loop.run_until_complete(rpc_server.start(common_args.bind_address_from_args(args),
args.port_control))
atexit_register_coroutine(rpc_server.stop)
reader = MasterReader(args.server_master, args.port_master,
args.retry_master, filter._filter, writer)
reader.start()
atexit_register_coroutine(reader.stop)
_, pending = loop.run_until_complete(asyncio.wait(
[signal_handler.wait_terminate(), rpc_server.wait_terminate()],
return_when=asyncio.FIRST_COMPLETED))
for task in pending:
task.cancel()
def main():
args = get_argparser().parse_args()
init_logger_from_args(args)
try:
channel = "ch{}".format(int(args.channel))
except ValueError:
if args.channel in ["T", "p"]:
channel = args.channel
else:
raise Exception("Invalid channel: {}".format(args.channel))
rpc_host = args.server if args.rpc_host == "" else args.rpc_host
plot_symbol = args.plot_symbol if args.plot_symbol != "" else None
wcm = WavemeterChannelMonitor(host=args.server, channel=channel, port=args.port, rpc_host=rpc_host,
rpc_port=args.rpc_port, rpc_target=args.rpc_target, title=args.title,
window_width=args.width, window_x=args.x, window_y=args.y,
enable_stripchart=not args.no_plot, stripchart_height=args.plot_height,
stripchart_num_points=args.plot_numpoints, plot_freq=not args.plot_wl,
plot_offset=args.plot_offset,
plot_pen=pyqtgraph.mkPen(color=args.plot_color, width=args.plot_width),
plot_symbol=plot_symbol, plot_bgr=args.plot_bgr,
enable_lcd=not args.no_lcd, lcd_height=args.number_height,
lcd_ndigits=args.number_digits, lcd_freq=args.lcd_freq,
enable_interferograms=args.interferograms,
interferogram_update_interval=args.iplot_interval,
show_interferogram_update_control=args.if_update_control,
if0_pen=pyqtgraph.mkPen(color=args.iplot_color, width=args.iplot_width),
if1_pen=pyqtgraph.mkPen(color=args.iplot_color2, width=args.iplot_width2),
interferogram_bgr=args.iplot_bgr, interferogram_height=args.iplot_height,
interferogram_exposure_control=args.if_exp_control)
wcm.run()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if args.device is None:
print("You need to supply a -d/--device "
"argument. Use --help for more information.")
sys.exit(1)
async def run():
async with RPCClient(NetworkConnection(args.device, loop=loop)) as dev:
server = Server({"laser": dev}, None, True)
await server.start(common_args.bind_address_from_args(args), args.port)
try:
await server.wait_terminate()
finally:
await server.stop()
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(run())
except KeyboardInterrupt:
pass
finally:
loop.close()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if args.device is None:
print("You need to supply a -d/--device "
"argument. Use --help for more information.")
sys.exit(1)
loop = asyncio.get_event_loop()
async def run():
with await Wavemeter.connect(args.device,
port=args.device_port,
loop=loop) as dev:
# only wavemeter
# logger.debug("connected, version %s", await dev.get_version())
server = Server({"wavemeter": dev}, None, True)
await server.start(common_args.bind_address_from_args(args),
args.port)
try:
await server.wait_terminate()
finally:
await server.stop()
try:
loop.run_until_complete(run())
except KeyboardInterrupt:
pass
finally:
loop.close()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
loop = asyncio.get_event_loop()
try:
get_logs_task = asyncio.ensure_future(
get_logs_sim(args.core_addr) if args.
simulation else get_logs(args.core_addr))
try:
server = Server({"corelog": PingTarget()}, None, True)
loop.run_until_complete(
server.start(common_args.bind_address_from_args(args),
args.port))
try:
loop.run_until_complete(server.wait_terminate())
finally:
loop.run_until_complete(server.stop())
finally:
get_logs_task.cancel()
try:
loop.run_until_complete(get_logs_task)
except asyncio.CancelledError:
pass
finally:
loop.close()
def main():
args = get_argparser().parse_args()
init_logger_from_args(args)
next_poll_time = time.monotonic()
while True:
time.sleep(max(0, next_poll_time - time.monotonic()))
next_poll_time += args.poll_time
measurements = []
for server in args.server:
try:
client = RPCClient(server, 3251, timeout=args.timeout)
lasers = client.get_laser_db()
for laser in lasers:
meas = client.get_freq(laser,
age=args.poll_time,
priority=3,
get_osa_trace=False,
blocking=True,
mute=False,
offset_mode=False)
status, freq, _ = meas
if status != WLMMeasurementStatus.OKAY:
logger.info("{}: measurement error")
continue
f_ref = lasers[laser]["f_ref"]
delta = freq - lasers[laser]["f_ref"]
measurements.append({
"measurement": laser,
"fields": {
"freq": freq,
"f_ref": f_ref,
"detuning": delta
}
})
logger.info("{}: freq {} THz, f_ref {} THz, "
"detuning {} MHz".format(
laser, freq, f_ref, delta))
except OSError:
logger.warning("Error querying server {}".format(server))
finally:
client.close_rpc()
if not measurements:
continue
try:
influx = influxdb.InfluxDBClient(host=args.host_db,
database=args.database,
username=args.user_db,
password=args.password_db)
influx.write_points(measurements)
finally:
influx.close()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if args.simulation:
lda = Ldasim()
else:
lda = Lda(args.device, args.product)
try:
simple_server_loop({"lda": lda},
common_args.bind_address_from_args(args), args.port)
finally:
lda.close()
def __init__(self):
self.args = args = get_argparser().parse_args()
init_logger_from_args(args)
if args.log_to_file:
log_file = pkg_resources.resource_filename("wand", "log.txt")
fh = logging.FileHandler(log_file, mode="wt")
fh.setLevel(logger.getEffectiveLevel())
logger.addHandler(fh)
logging.getLogger("qasync").addHandler(fh)
sys.excepthook = lambda exc_type, exc_value, exc_traceback: \
logger.exception("".join(
traceback.format_exception(exc_type,
exc_value,
exc_traceback)))
self.config = load_config(args, "_gui")
self.laser_db = {}
self.freq_db = {}
self.osa_db = {}
self.subscribers = {}
self.qapp = QtWidgets.QApplication(["WAnD"])
self.loop = QEventLoop(self.qapp)
asyncio.set_event_loop(self.loop)
atexit.register(self.loop.close)
# set program icon
icon = QtGui.QIcon()
icon.addFile(pkg_resources.resource_filename("wand", "wand.svg"))
self.qapp.setWindowIcon(icon)
# create main window
self.win = MainWindow()
self.area = dock.DockArea()
self.win.setCentralWidget(self.area)
self.win.setWindowTitle("Super-duper Python Wavemeter Viewer!")
# populate GUI
self.laser_displays = {}
for row in self.config["layout"]:
prev = None
pos = 'bottom'
for display_name in row:
display = LaserDisplay(display_name, self)
self.laser_displays.update({display.laser: display})
self.area.addDock(display.dock, position=pos, relativeTo=prev)
pos = 'right'
prev = display.dock
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
cam = Cam(args.device)
if args.exposure:
cam.set_exposure(float(args.exposure))
try:
logger.info("Camera open. Serving...")
simple_server_loop({"camera": cam},
common_args.bind_address_from_args(args), args.port)
finally:
cam.close()
def main():
args = get_argparser().parse_args()
init_logger_from_args(args)
channels = []
for ch in args.channel:
try:
channels.append(int(ch))
except ValueError:
if ch in ["T", "p"]:
channels.append(ch)
wau = WavemeterArtiqUpdater(channels=channels, host_artiq=args.artiq_server, port_artiq=args.artiq_port,
host_wavemeter_pub=args.wavemeter_server, port_wavemeter_pub=args.wavemeter_port,
dataset_name_prefix=args.dataset)
wau.run()
def __init__(self, args):
self.args = args
common_args.init_logger_from_args(args)
# TODO: Consider exposing Context in Root.
context = Context(self.set_dataset)
super().__init__(SubscriberRoot(args.prefix, context), context)
# Try ensuring a sensible window size on startup (i.e. large enough to show a
# plot in.
# FIXME: This doesn't seem to work when used with ARTIQ applet embedding. See if
# call_later() works around that, or whether this needs to be fixed in ARTIQ.
self.resize(600, 600)
self.setWindowTitle("ndscan plot")
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if not args.serialPort:
print("You need to specify -s")
sys.exit(1)
psu = PSU(args.serialPort)
try:
logger.info("DP700 open. Serving...")
simple_server_loop({"DP700": psu},
common_args.bind_address_from_args(args), args.port)
finally:
psu.close()
def main():
args = get_argparser().parse_args()
init_logger_from_args(args)
if args.lock_current:
client = WavemeterPIClientTopticaEthernetCurrent(
host=args.server,
port=args.port,
channel=args.channel,
dlc_address=args.dlc_address,
laser_id=args.laser,
output_offset=args.current_center,
output_span=args.current_span,
setpoint=args.setpoint,
cp=args.cp,
ci=args.ci,
integrator_timeout=args.integrator_timeout,
integrator_cutoff=args.integrator_cutoff,
output_sensitivity=args.output_sensitivity,
startup_locked=args.startup_locked)
else:
client = WavemeterPIClientTopticaEthernetPZT(
host=args.server,
port=args.port,
channel=args.channel,
dlc_address=args.dlc_address,
laser_id=args.laser,
output_offset=args.pzt_center,
output_span=args.pzt_span,
setpoint=args.setpoint,
cp=args.cp,
ci=args.ci,
integrator_timeout=args.integrator_timeout,
integrator_cutoff=args.integrator_cutoff,
output_sensitivity=args.output_sensitivity,
current_center=args.current_center,
current_span=args.current_span,
startup_locked=args.startup_locked)
pub = Publisher(
{"lock_client_{}".format(args.channel): client.status_notifier})
asyncio.get_event_loop().run_until_complete(
pub.start(bind_address_from_args(args), args.port_pub))
simple_server_loop({"lock_client_{}".format(args.channel): client},
bind_address_from_args(args), args.port_rpc)
client.close_subscriber()
client.close_dlc_connection()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if args.device is None:
ddb = DeviceDB(args.device_db)
core_addr = ddb.get("core", resolve_alias=True)["arguments"]["host"]
else:
core_addr = args.device
mgmt = CommMgmt(core_addr)
if args.tool == "log":
if args.action == "set_level":
mgmt.set_log_level(args.level)
if args.action == "set_uart_level":
mgmt.set_uart_log_level(args.level)
if args.action == "clear":
mgmt.clear_log()
if args.action == None:
print(mgmt.get_log(), end="")
if args.tool == "config":
if args.action == "read":
value = mgmt.config_read(args.key)
if not value:
print("Key {} does not exist".format(args.key))
else:
print(value)
if args.action == "write":
for key, value in args.string:
mgmt.config_write(key, value.encode("utf-8"))
for key, filename in args.file:
with open(filename, "rb") as fi:
mgmt.config_write(key, fi.read())
if args.action == "remove":
for key in args.key:
mgmt.config_remove(key)
if args.action == "erase":
mgmt.config_erase()
if args.tool == "reboot":
mgmt.reboot()
if args.tool == "debug":
if args.action == "allocator":
mgmt.debug_allocator()
def main():
args = get_argparser().parse_args()
init_logger_from_args(args)
wlr = WavemeterRemote(host=args.server,
rpc_target=args.rpc_target,
rpc_port=args.rpc_port,
notifier_port=args.pub_port,
title=args.title,
window_x=args.x,
window_y=args.y,
cal_channel=args.cal_channel,
cal_wl=args.cal_wl,
cal_threshold=args.cal_threshold,
cal_interval=args.cal_interval,
cal_retry_interval=args.cal_retry_interval,
start_autocal=args.start_autocal)
wlr.run()
def main():
args = get_argparser().parse_args()
init_logger_from_args(args)
if args.aux_output:
client = WavemeterPIClientRedLabPlusAuxOut(
host=args.server,
port=args.port,
channel=args.channel,
board_num=args.board,
channel_id=args.id,
board_num_aux=args.board2,
channel_id_aux=args.id2,
setpoint=args.setpoint,
cp=args.cp,
ci=args.ci,
integrator_timeout=args.integrator_timeout,
integrator_cutoff=args.integrator_cutoff,
output_sensitivity=args.output_sensitivity,
output_offset=args.output_offset,
startup_locked=args.startup_locked)
else:
client = WavemeterPIClientRedLab(
host=args.server,
port=args.port,
channel=args.channel,
board_num=args.board,
channel_id=args.id,
setpoint=args.setpoint,
cp=args.cp,
ci=args.ci,
integrator_timeout=args.integrator_timeout,
integrator_cutoff=args.integrator_cutoff,
output_sensitivity=args.output_sensitivity,
output_offset=args.output_offset,
startup_locked=args.startup_locked)
pub = Publisher(
{"lock_client_{}".format(args.channel): client.status_notifier})
asyncio.get_event_loop().run_until_complete(
pub.start(bind_address_from_args(args), args.port_pub))
simple_server_loop({"lock_client_{}".format(args.channel): client},
bind_address_from_args(args), args.port_rpc)
client.close_subscriber()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if os.name == "nt":
asyncio.set_event_loop(asyncio.ProactorEventLoop())
if not args.simulation and args.device is None:
print("You need to specify either --simulation or -d/--device "
"argument. Use --help for more information.")
sys.exit(1)
dev = Novatech409B(args.device if not args.simulation else None)
asyncio.get_event_loop().run_until_complete(dev.setup())
try:
simple_server_loop(
{"novatech409b": dev}, common_args.bind_address_from_args(args), args.port)
finally:
dev.close()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
bind_address = common_args.bind_address_from_args(args)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
signal_handler = SignalHandler()
signal_handler.setup()
try:
monitor_mux = MonitorMux()
comm_moninj = CommMonInj(monitor_mux.monitor_cb,
monitor_mux.injection_status_cb,
monitor_mux.disconnect_cb)
monitor_mux.comm_moninj = comm_moninj
loop.run_until_complete(comm_moninj.connect(args.core_addr))
try:
proxy_server = ProxyServer(monitor_mux)
loop.run_until_complete(proxy_server.start(bind_address, args.port_proxy))
try:
server = Server({"moninj_proxy": PingTarget()}, None, True)
loop.run_until_complete(server.start(bind_address, args.port_control))
try:
_, pending = loop.run_until_complete(asyncio.wait(
[signal_handler.wait_terminate(),
server.wait_terminate(),
comm_moninj.wait_terminate()],
return_when=asyncio.FIRST_COMPLETED))
for task in pending:
task.cancel()
finally:
loop.run_until_complete(server.stop())
finally:
loop.run_until_complete(proxy_server.stop())
finally:
loop.run_until_complete(comm_moninj.close())
finally:
signal_handler.teardown()
finally:
loop.close()
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if not args.simulation and args.device is None:
print("You need to specify either --simulation or -d/--device "
"argument. Use --help for more information.")
sys.exit(1)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
product = args.product.lower()
if args.simulation:
if product == "tdc001":
dev = TdcSim()
elif product == "tpz001":
dev = TpzSim()
else:
print("Invalid product string (-P/--product), "
"choose from tdc001 or tpz001")
sys.exit(1)
else:
if product == "tdc001":
dev = Tdc(args.device)
elif product == "tpz001":
dev = Tpz(args.device)
loop.run_until_complete(dev.get_tpz_io_settings())
else:
print("Invalid product string (-P/--product), "
"choose from tdc001 or tpz001")
sys.exit(1)
try:
simple_server_loop({product: dev},
common_args.bind_address_from_args(args), args.port,
loop=loop)
finally:
dev.close()
finally:
loop.close()
def main():
args = get_argparser().parse_args()
init_logger_from_args(args)
if args.file == "":
if GUI_available:
wlcg = WavemeterLoggingClientGUI(host=args.server, port=args.port)
wlcg.run()
else:
logger.error("No filename specified and no GUI available - exiting")
return
else:
wlc = WavemeterLoggingClient(host=args.server, port=args.port)
channels = []
for ch in args.channel:
try:
channels.append(int(ch))
except ValueError:
if ch in ["T", "p"]:
channels.append(ch)
wlc.log(channels, float(args.interval), args.file, args.append)
wlc.wm_server.close_rpc()
def main():
args = get_argparser().parse_args()
channels = []
for ch in args.channel:
try:
channels.append(int(ch))
except ValueError:
pass
init_logger_from_args(args)
simple_server_loop(
{
"wavemeter_server":
WavemeterServer(channels=channels,
num_hw_channels=args.nchannels,
get_temperature=args.T,
get_pressure=args.p,
skip_threshold_nm=args.skip_thr,
install_callback=args.callback,
start_publisher=args.start_pub,
publisher_host=bind_address_from_args(args),
publisher_port=args.port_pub)
}, bind_address_from_args(args), args.port_rpc)
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
device_mgr = DeviceManager(DeviceDB(args.device_db))
dataset_mgr = DatasetManager(DatasetDB(args.dataset_db))
try:
module = file_import(args.file, prefix="artiq_run_")
exp = get_experiment(module, args.class_name)
arguments = parse_arguments(args.arguments)
argument_mgr = ProcessArgumentManager(arguments)
exp_inst = exp((device_mgr, dataset_mgr, argument_mgr, {}))
if not hasattr(exp.run, "artiq_embedded"):
raise ValueError("Experiment entry point must be a kernel")
core_name = exp.run.artiq_embedded.core_name
core = getattr(exp_inst, core_name)
object_map, kernel_library, _, _ = \
core.compile(exp.run, [exp_inst], {},
attribute_writeback=False, print_as_rpc=False)
except CompileError as error:
return
finally:
device_mgr.close_devices()
if object_map.has_rpc():
raise ValueError("Experiment must not use RPC")
output = args.output
if output is None:
basename, ext = os.path.splitext(args.file)
output = "{}.elf".format(basename)
with open(output, "wb") as f:
f.write(kernel_library)
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
config = {
"kasli": {
"programmer":
partial(ProgrammerXC7,
board="kasli",
proxy="bscan_spi_xc7a100t.bit"),
"gateware": ("spi0", 0x000000),
"bootloader": ("spi0", 0x400000),
"storage": ("spi0", 0x440000),
"firmware": ("spi0", 0x450000),
},
"sayma": {
"programmer": ProgrammerAMCRTM,
"gateware": ("spi0", 0x000000),
"bootloader": ("spi1", 0x000000),
"storage": ("spi1", 0x040000),
"firmware": ("spi1", 0x050000),
"rtm_gateware": ("spi1", 0x200000),
},
"kc705": {
"programmer":
partial(ProgrammerXC7,
board="kc705",
proxy="bscan_spi_xc7k325t.bit"),
"def_variant":
"nist_clock",
"gateware": ("spi0", 0x000000),
"bootloader": ("spi0", 0xaf0000),
"storage": ("spi0", 0xb30000),
"firmware": ("spi0", 0xb40000),
},
}[args.target]
bin_dir = args.dir
if bin_dir is None:
bin_dir = os.path.join(artiq_dir, "board-support")
needs_artifacts = not args.action or any(
action in args.action for action in [
"gateware", "rtm_gateware", "bootloader", "firmware", "load",
"rtm_load"
])
variant = args.variant
if needs_artifacts and variant is None:
variants = []
if args.srcbuild:
for entry in os.scandir(bin_dir):
if entry.is_dir():
variants.append(entry.name)
else:
prefix = args.target + "-"
for entry in os.scandir(bin_dir):
if entry.is_dir() and entry.name.startswith(prefix):
variants.append(entry.name[len(prefix):])
if args.target == "sayma":
try:
variants.remove("rtm")
except ValueError:
pass
if len(variants) == 0:
raise FileNotFoundError(
"no variants found, did you install a board binary package?")
elif len(variants) == 1:
variant = variants[0]
else:
raise ValueError(
"more than one variant found for selected board, specify -V. "
"Found variants: {}".format(" ".join(sorted(variants))))
if needs_artifacts:
if args.srcbuild:
variant_dir = variant
else:
variant_dir = args.target + "-" + variant
if args.target == "sayma":
if args.srcbuild:
rtm_variant_dir = "rtm"
else:
rtm_variant_dir = "sayma-rtm"
if not args.action:
if args.target == "sayma" and variant != "simplesatellite" and variant != "master":
args.action = "gateware rtm_gateware bootloader firmware start".split(
)
else:
args.action = "gateware bootloader firmware start".split()
if args.host is None:
client = LocalClient()
else:
client = SSHClient(args.host, args.jump)
if args.target == "sayma" and args.no_rtm_jtag:
programmer_cls = ProgrammerAMC
else:
programmer_cls = config["programmer"]
programmer = programmer_cls(client, preinit_script=args.preinit_command)
def artifact_path(this_variant_dir, *path_filename):
if args.srcbuild:
# source tree - use path elements to locate file
return os.path.join(bin_dir, this_variant_dir, *path_filename)
else:
# flat tree - all files in the same directory, discard path elements
*_, filename = path_filename
return os.path.join(bin_dir, this_variant_dir, filename)
def convert_gateware(bit_filename, header=False):
bin_handle, bin_filename = tempfile.mkstemp(
prefix="artiq_", suffix="_" + os.path.basename(bit_filename))
with open(bit_filename, "rb") as bit_file, \
open(bin_handle, "wb") as bin_file:
if header:
bin_file.write(b"\x00" * 8)
bit2bin(bit_file, bin_file)
if header:
magic = 0x5352544d # "SRTM", see sayma_rtm target
length = bin_file.tell() - 8
bin_file.seek(0)
bin_file.write(magic.to_bytes(4, byteorder="big"))
bin_file.write(length.to_bytes(4, byteorder="big"))
atexit.register(lambda: os.unlink(bin_filename))
return bin_filename
for action in args.action:
if action == "gateware":
gateware_bin = convert_gateware(
artifact_path(variant_dir, "gateware", "top.bit"))
programmer.write_binary(*config["gateware"], gateware_bin)
elif action == "rtm_gateware":
rtm_gateware_bin = convert_gateware(artifact_path(
rtm_variant_dir, "gateware", "top.bit"),
header=True)
programmer.write_binary(*config["rtm_gateware"], rtm_gateware_bin)
elif action == "bootloader":
bootloader_bin = artifact_path(variant_dir, "software",
"bootloader", "bootloader.bin")
programmer.write_binary(*config["bootloader"], bootloader_bin)
elif action == "storage":
storage_img = args.storage
programmer.write_binary(*config["storage"], storage_img)
elif action == "firmware":
if variant.endswith("satellite"):
firmware = "satman"
else:
firmware = "runtime"
firmware_fbi = artifact_path(variant_dir, "software", firmware,
firmware + ".fbi")
programmer.write_binary(*config["firmware"], firmware_fbi)
elif action == "load":
if args.target == "sayma":
gateware_bit = artifact_path(variant_dir, "gateware",
"top.bit")
programmer.load(gateware_bit, 1)
else:
gateware_bit = artifact_path(variant_dir, "gateware",
"top.bit")
programmer.load(gateware_bit, 0)
elif action == "rtm_load":
rtm_gateware_bit = artifact_path(rtm_variant_dir, "gateware",
"top.bit")
programmer.load(rtm_gateware_bit, 0)
elif action == "start":
programmer.start()
elif action == "erase":
if args.target == "sayma" or args.target == "metlino":
programmer.erase_flash("spi0")
programmer.erase_flash("spi1")
else:
programmer.erase_flash("spi0")
else:
raise ValueError("invalid action", action)
if args.dry_run:
print("\n".join(programmer.script()))
else:
programmer.run()
def main():
args = get_argparser().parse_args()
init_logger_from_args(args)
servers = {
idx: {
"host": ip,
"notify": 3250,
"control": 3251
}
for idx, ip in enumerate(args.server)}
while True:
measurements = []
for _, server in servers.items():
try:
client = RPCClient(server["host"], server["control"])
lasers = client.get_laser_db()
for laser in lasers:
meas = client.get_freq(laser,
age=args.poll_time,
priority=3,
get_osa_trace=False,
blocking=True,
mute=False,
offset_mode=False)
status, freq, _ = meas
if status != WLMMeasurementStatus.OKAY:
logger.info("{}: measurement error")
continue
f_ref = lasers[laser]["f_ref"]
delta = freq - lasers[laser]["f_ref"]
measurements.append({
"measurement": laser,
"fields": {
"freq": freq,
"f_ref": f_ref,
"detuning": delta
}
})
logger.info("{}: freq {} THz, f_ref {} THz, "
"detuning {} MHz".format(laser,
freq,
f_ref,
delta))
except OSError:
logger.warning("Error querying server {}".format(server))
finally:
client.close_rpc()
if measurements == []:
time.sleep(args.poll_time)
continue
try:
influx = influxdb.InfluxDBClient(
host="10.255.6.4",
database=args.database,
username="******",
password="******")
influx.write_points(measurements)
finally:
influx.close()
time.sleep(args.poll_time)
def main():
args = get_argparser().parse_args()
common_args.init_logger_from_args(args)
if args.device is None:
ddb = DeviceDB(args.device_db)
core_addr = ddb.get("core", resolve_alias=True)["arguments"]["host"]
else:
core_addr = args.device
mgmt = CommMgmt(core_addr)
if args.tool == "log":
if args.action == "set_level":
mgmt.set_log_level(args.level)
if args.action == "set_uart_level":
mgmt.set_uart_log_level(args.level)
if args.action == "clear":
mgmt.clear_log()
if args.action == None:
print(mgmt.get_log(), end="")
if args.tool == "config":
if args.action == "read":
value = mgmt.config_read(args.key)
if not value:
print("Key {} does not exist".format(args.key))
else:
print(value)
if args.action == "write":
for key, value in args.string:
mgmt.config_write(key, value.encode("utf-8"))
for key, filename in args.file:
with open(filename, "rb") as fi:
mgmt.config_write(key, fi.read())
if args.action == "remove":
for key in args.key:
mgmt.config_remove(key)
if args.action == "erase":
mgmt.config_erase()
if args.tool == "reboot":
mgmt.reboot()
if args.tool == "hotswap":
mgmt.hotswap(args.image.read())
if args.tool == "profile":
if args.action == "start":
mgmt.start_profiler(args.interval, args.hits_size, args.edges_size)
elif args.action == "stop":
mgmt.stop_profiler()
elif args.action == "save":
hits, edges = mgmt.get_profile()
writer = CallgrindWriter(args.output, args.firmware, "or1k-linux",
args.compression, args.demangle)
writer.header()
for addr, count in hits.items():
writer.hit(addr, count)
for (caller, callee), count in edges.items():
writer.edge(caller, callee, count)
if args.tool == "debug":
if args.action == "allocator":
mgmt.debug_allocator()
