def main():
args = get_argparser().parse_args()
init_logger(args)
port = None
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)
if args.simulation:
port = open(args.dump, "wb")
dev = PDQ(url=args.device, dev=port, num_boards=args.boards)
try:
if args.reset:
dev.write(b"") # flush etx
dev.set_config(reset=True)
time.sleep(.1)
dev.set_crc(0)
dev.checksum = 0
simple_server_loop({"pdq": dev}, bind_address_from_args(args),
args.port, description="device=" + str(args.device))
finally:
dev.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
dev = Client(args.server, args.port, "pdq2")
freq = dev.get_freq()
times = np.around(eval(args.times, globals(), {})*freq)
voltages = eval(args.voltages, globals(), dict(t=times/freq))
dt = np.diff(times.astype(np.int))
if args.order:
tck = interpolate.splrep(times, voltages, k=args.order, s=0)
u = interpolate.spalde(times, tck)
else:
u = voltages[:, None]
segment = []
for dti, ui in zip(dt, u):
segment.append({
"duration": int(dti),
"channel_data": [{
"bias": {
"amplitude": [float(uij) for uij in ui]
}
}]
})
program = [[] for i in range(args.frame)]
program.append(segment)
dev.park()
dev.program(program, [args.channel])
dev.unpark()
dev.cmd("TRIGGER", args.free)
def main():
args = get_argparser().parse_args()
init_logger(args)
dev = Client(args.server, args.port, "pdq2")
if args.reset:
dev.write(b"\x00\x00") # flush any escape
dev.cmd("RESET", True)
time.sleep(.1)
dev.cmd("START", False)
dev.cmd("ARM", False)
dev.cmd("DCM", args.dcm)
freq = 100e6 if args.dcm else 50e6
dev.set_freq(freq)
times = eval(args.times, globals(), {})
voltages = eval(args.voltages, globals(), dict(t=times))
if args.demo:
for ch, channel in enumerate(dev.channels):
entry = []
for fr in range(dev.channels[0].num_frames):
vi = .1*fr + ch + voltages
entry.append(channel.segment(times, vi, order=args.order,
end=False, aux=args.aux))
pi = 2*np.pi*(-.5 + .01*fr + .1*ch + 0*voltages)
fi = 10e6*times/times[-1]
channel.segment(2*times, voltages, pi, fi, trigger=False,
silence=True, aux=args.aux)
dev.write_channel(channel, entry)
elif args.bit:
v = [-1, 0, -1]
# for i in range(15):
# v.extend([(1 << i) - 1, 1 << i])
v = np.array(v)*dev.channels[0].max_out/dev.channels[0].max_val
t = np.arange(len(v))
for channel in dev.channels:
s = channel.segment(t, v, order=0, shift=15, stop=False,
trigger=False)
dev.write_channel(channel, [s for i in range(channel.num_frames)])
else:
c = dev.channels[args.channel]
map = [None] * c.num_frames
map[args.frame] = c.segment(times, voltages, order=args.order,
aux=args.aux)
dev.write_channel(c, map)
dev.cmd("START", True)
dev.cmd("ARM", not args.disarm)
dev.cmd("TRIGGER", args.free)
if args.plot:
from matplotlib import pyplot as plt
fig, ax = plt.subplots()
ax.plot(times, voltages, "xk", label="points")
if args.order > 0:
spline = interpolate.splrep(times, voltages, k=args.order)
ttimes = np.arange(0, times[-1], 1/freq)
vvoltages = interpolate.splev(ttimes, spline)
ax.plot(ttimes, vvoltages, ",b", label="interpolation")
fig.savefig(args.plot)
def main():
args = get_argparser().parse_args()
init_logger(args)
incoherent_channels = [False]*4
if args.disable_coherence:
for arg in args.disable_coherence:
ch = int(arg)
if ch < 0 or ch > 3:
raise ValueError("channel must be in 0-3")
incoherent_channels[ch] = True
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)
if args.simulation:
dev = CoherentDdsSim()
else:
dev = CoherentDds(addr=args.device, clockFreq=args.clockfreq,
internal_clock=args.internal_clock,
incoherent_channels=incoherent_channels)
simple_server_loop({"coherentDds": dev}, args.bind, args.port)
def main():
args = get_argparser().parse_args()
init_logger(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 main():
args = get_argparser().parse_args()
init_logger(args)
dev = Ddr05Driver(serial=args.serial)
simple_server_loop({"ddr05": dev}, args.bind, args.port)
def main():
args = get_argparser().parse_args()
init_logger(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)
filter = Filter(args.pattern_file)
rpc_server = Server({"influxdb_filter": filter}, builtin_terminate=True)
loop.run_until_complete(rpc_server.start(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)
loop.run_until_complete(rpc_server.wait_terminate())
def main():
args = get_argparser().parse_args()
init_logger(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)
if not args.simulation:
dev = PiezoController(args.device)
else:
dev = SimulationPiezoController()
# Q: Why not use try/finally for port closure?
# A: We don't want to try to close the serial if sys.exit() is called,
# and sys.exit() isn't caught by Exception
try:
simple_server_loop({"piezoController": dev}, args.bind, args.port)
except Exception:
dev.close()
else:
dev.close()
finally:
dev.save_setpoints()
def main():
args = get_argparser().parse_args()
init_logger(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))
try:
if args.read_dump:
with open(args.read_dump, "rb") as f:
dump = f.read()
else:
comm = device_mgr.get("comm")
dump = comm.get_analyzer_dump()
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)
if args.write_dump:
with open(args.write_dump, "wb") as f:
f.write(dump)
finally:
device_mgr.close_devices()
def main():
args = get_argparser().parse_args()
init_logger(args)
device_mgr = DeviceManager(DeviceDB(args.device_db))
try:
comm = device_mgr.get("comm")
comm.check_ident()
if args.action == "read":
value = comm.flash_storage_read(args.key)
if not value:
print("Key {} does not exist".format(args.key))
else:
print(value)
elif args.action == "write":
for key, value in args.string:
comm.flash_storage_write(key, value.encode("utf-8"))
for key, filename in args.file:
with open(filename, "rb") as fi:
comm.flash_storage_write(key, fi.read())
elif args.action == "delete":
for key in args.key:
comm.flash_storage_remove(key)
elif args.action == "erase":
comm.flash_storage_erase()
finally:
device_mgr.close_devices()
def main():
args = get_argparser().parse_args()
init_logger(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)
product = args.product.lower()
if args.simulation:
if product == "tdc001":
dev = TdcSim()
elif product == "tpz001":
dev = TpzSim()
else:
if product == "tdc001":
dev = Tdc(args.device)
elif product == "tpz001":
dev = Tpz(args.device)
try:
simple_server_loop({product: dev}, args.bind, args.port)
finally:
dev.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
if os.name == "nt":
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
atexit.register(lambda: loop.close())
ddb = FlatFileDB(args.ddb)
pdb = FlatFileDB(args.pdb)
rtr = Notifier(dict())
log = Log(1000)
if args.git:
repo_backend = GitBackend(args.repository)
else:
repo_backend = FilesystemBackend(args.repository)
repository = Repository(repo_backend, log.log)
atexit.register(repository.close)
repository.scan_async()
worker_handlers = {
"get_device": ddb.get,
"get_parameter": pdb.get,
"set_parameter": pdb.set,
"update_rt_results": lambda mod: process_mod(rtr, mod),
"log": log.log
}
scheduler = Scheduler(get_last_rid() + 1, worker_handlers, repo_backend)
worker_handlers["scheduler_submit"] = scheduler.submit
scheduler.start()
atexit.register(lambda: loop.run_until_complete(scheduler.stop()))
server_control = Server({
"master_ddb": ddb,
"master_pdb": pdb,
"master_schedule": scheduler,
"master_repository": repository
})
loop.run_until_complete(server_control.start(
args.bind, args.port_control))
atexit.register(lambda: loop.run_until_complete(server_control.stop()))
server_notify = Publisher({
"schedule": scheduler.notifier,
"devices": ddb.data,
"parameters": pdb.data,
"rt_results": rtr,
"explist": repository.explist,
"log": log.data
})
loop.run_until_complete(server_notify.start(
args.bind, args.port_notify))
atexit.register(lambda: loop.run_until_complete(server_notify.stop()))
loop.run_forever()
def main():
args = get_argparser().parse_args()
init_logger(args)
device_mgr = DeviceManager(DeviceDB(args.device_db))
try:
comm = device_mgr.get("comm")
comm.check_ident()
print(comm.get_log(), end="")
finally:
device_mgr.close_devices()
def main():
# initialize application
args = get_argparser().parse_args()
init_logger(args)
app = QtWidgets.QApplication([])
loop = QEventLoop(app)
asyncio.set_event_loop(loop)
atexit.register(loop.close)
smgr = state.StateManager(args.db_file)
datasets_sub = models.LocalModelManager(datasets.Model)
# initialize main window
main_window = MainWindow()
smgr.register(main_window)
status_bar = QtWidgets.QStatusBar()
main_window.setStatusBar(status_bar)
mdi_area = MdiArea()
mdi_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
mdi_area.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
main_window.setCentralWidget(mdi_area)
d_results = results.ResultsBrowser(datasets_sub)
smgr.register(d_results)
d_applets = applets.AppletsDock(main_window, datasets_sub)
atexit_register_coroutine(d_applets.stop)
smgr.register(d_applets)
d_datasets = datasets.DatasetsDock(datasets_sub)
smgr.register(d_datasets)
main_window.setCentralWidget(d_results)
main_window.addDockWidget(QtCore.Qt.BottomDockWidgetArea, d_applets)
main_window.addDockWidget(QtCore.Qt.RightDockWidgetArea, d_datasets)
# load/initialize state
if os.name == "nt":
# HACK: show the main window before creating applets.
# Otherwise, the windows of those applets that are in detached
# QDockWidgets fail to be embedded.
main_window.show()
smgr.load()
if args.PATH:
d_results.select(args.PATH)
smgr.start()
atexit_register_coroutine(smgr.stop)
# run
main_window.show()
loop.run_until_complete(main_window.exit_request.wait())
def main():
args = get_argparser().parse_args()
init_logger(args)
delay_gen = None
if not args.simulation:
delay_gen = Driver().init_single_pci_card()
delay_gen.set_clock_source(ClockSource.external_80_mhz)
timing = PulsePickerTiming(delay_gen, args.allow_long_pulses)
simple_server_loop({"timing": timing}, args.bind, args.port)
def main():
args = get_argparser().parse_args()
init_logger(args)
if args.simulation:
lda = Ldasim()
else:
lda = Lda(args.device, args.product)
try:
simple_server_loop({"lda": lda},
args.bind, args.port)
finally:
lda.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
if args.trapDacDevice is None or args.trapRFDevice is None:
print("You need to specify --trapDacDevice and --trapRFDevice"
"arguments. Use --help for more information.")
sys.exit(1)
dev = TrapDac(addr_dc_iface=args.trapDacDevice, addr_rf_iface=args.trapRFDevice)
simple_server_loop({"trapDac": dev}, args.bind, args.port)
def main():
args = get_argparser().parse_args()
init_logger(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)
dev = Novatech409B(args.device if not args.simulation else None)
try:
simple_server_loop(
{"novatech409b": dev}, args.bind, args.port)
finally:
dev.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
if args.ipaddr is None:
print("You need to specify a device IP address (-i/--ipaddr) "
"argument. Use --help for more information.")
sys.exit(1)
dev = N8241A(addr=args.ipaddr)
try:
simple_server_loop({"N8241A": dev}, args.bind, args.port)
finally:
dev.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
if not args.simulation and (args.trapDacDevice is None or args.trapRFDevice is None):
print("You need to specify either --simulation or --trapDacDevice and --trapRFDevice"
"arguments. Use --help for more information.")
sys.exit(1)
if args.simulation:
dev = TrapDacSim()
else:
dev = TrapDac(addrDCInterface=args.trapDacDevice, addrRFInterface=args.trapRFDevice)
simple_server_loop({"trapDac": dev}, args.bind, args.port)
def main():
args = get_argparser().parse_args()
init_logger(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)
if args.simulation:
dev = CoherentDdsSim()
else:
dev = CoherentDds(addr=args.device, clockFreq=args.clockfreq)
simple_server_loop({"coherentDds": dev}, args.bind, args.port)
def main():
args = get_argparser().parse_args()
init_logger(args)
if args.ipaddr is None:
print("You need to specify -i/--ipaddr"
"Use --help for more information.")
sys.exit(1)
dev = ScpiSynth(addr=args.ipaddr)
try:
simple_server_loop({"scpi_synth": dev}, args.bind, args.port)
finally:
dev.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
core_addr = DeviceDB(args.device_db).get("core")["arguments"]["host"]
mgmt = CommMgmt(core_addr)
try:
if args.action == "reboot":
mgmt.reboot()
elif args.action == "hotswap":
mgmt.hotswap(args.image.read())
else:
print("An action needs to be specified.", file=sys.stderr)
sys.exit(1)
finally:
mgmt.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
core_addr = DeviceDB(args.device_db).get("core")["arguments"]["host"]
mgmt = CommMgmt(core_addr)
try:
if args.action == "set_level":
mgmt.set_log_level(args.level)
elif args.action == "set_uart_level":
mgmt.set_uart_log_level(args.level)
elif args.action == "clear":
mgmt.clear_log()
else:
print(mgmt.get_log(), end="")
finally:
mgmt.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
port = None
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)
if args.simulation:
port = open(args.dump, "wb")
dev = Pdq2(url=args.device, dev=port)
try:
simple_server_loop({"pdq2": dev}, args.bind, args.port,
description="device=" + str(args.device))
finally:
dev.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
if not args.simulation and args.ipaddr is None:
print("You need to specify either --simulation or -i/--ipaddr "
"argument. Use --help for more information.")
sys.exit(1)
if args.simulation:
dev = RohdeSynthSim()
else:
dev = RohdeSynth(addr=args.ipaddr)
try:
simple_server_loop({"rohdeSynth": dev}, args.bind, args.port)
finally:
dev.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
if args.device is None:
print("You need to specify a -d/--device "
"argument. Use --help for more information.")
sys.exit(1)
dev = QL355(args.device)
# Q: Why not use try/finally for port closure?
# A: We don't want to try to close the serial if sys.exit() is called,
# and sys.exit() isn't caught by Exception
try:
simple_server_loop({"ql355": dev}, bind_address_from_args(args), args.port)
except Exception:
dev.close()
else:
dev.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
if not args.simulation and args.channels is None:
print("You need to specify either --simulation or -C/--channels "
"argument. Use --help for more information.")
sys.exit(1)
if args.simulation:
daq = DAQmxSim()
else:
daq = DAQmx(args.channels,
args.clock)
try:
simple_server_loop({"pxi6733": daq},
args.bind, args.port)
finally:
daq.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
client = SSHClient(args.host)
sftp = client.get_sftp()
tcpdump = client.spawn_command(
"/usr/sbin/tcpdump host {device} -w {tmp}/trace.pcap",
get_pty=True,
device=args.device)
try:
subprocess.check_call(args.command)
except subprocess.CalledProcessError:
logger.error("Command failed")
tcpdump.close()
sftp.get("{tmp}/trace.pcap".format(tmp=client.tmp), args.file + ".new")
os.rename(args.file + ".new", args.file)
logger.info("Pcap file {file} retrieved".format(file=args.file))
def main():
args = get_argparser().parse_args()
init_logger(args)
client = SSHClient(args.host)
sftp = client.get_sftp()
tcpdump = client.spawn_command(
"/usr/sbin/tcpdump host {device} -w {tmp}/trace.pcap", get_pty=True,
device=args.device)
try:
subprocess.check_call(args.command)
except subprocess.CalledProcessError:
logger.error("Command failed")
tcpdump.close()
sftp.get("{tmp}/trace.pcap".format(tmp=client.tmp),
args.file + ".new")
os.rename(args.file + ".new", args.file)
logger.info("Pcap file {file} retrieved".format(file=args.file))
def main():
args = get_argparser().parse_args()
init_logger(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)
dev = PiezoController(args.device if not args.simulation else None)
# Q: Why not use try/finally for port closure?
# A: We don't want to try to close the serial if sys.exit() is called,
# and sys.exit() isn't caught by Exception
try:
simple_server_loop({"piezoController": dev}, args.bind, args.port)
except Exception:
dev.close()
else:
dev.close()
finally:
dev.save_setpoints()
def main():
args = get_argparser().parse_args()
init_logger(args)
core_addr = DeviceDB(args.device_db).get("core")["arguments"]["host"]
mgmt = CommMgmt(core_addr)
try:
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,
not args.no_compression)
writer.header()
for addr, count in hits.items():
writer.hit(addr, count)
for (caller, callee), count in edges.items():
writer.edge(caller, callee, count)
finally:
mgmt.close()
def run_simple_rpc_server(port, setup_args, interface_name, setup_interface):
parser = ArgumentParser()
influxdb_args(parser)
simple_network_args(parser, port)
verbosity_args(parser)
if setup_args:
setup_args(parser)
args = parser.parse_args()
init_logger(args)
loop = asyncio.get_event_loop()
atexit.register(loop.close)
influx_pusher = influxdb_pusher_from_args(args)
if influx_pusher:
t = asyncio.ensure_future(influx_pusher.run())
def stop():
t.cancel()
try:
loop.run_until_complete(t)
except asyncio.CancelledError:
pass
atexit.register(stop)
interface = setup_interface(args, influx_pusher, loop)
# Provide a default ping() method, which ARTIQ calls regularly for
# heartbeating purposes.
if not hasattr(interface, "ping"):
setattr(interface, "ping", lambda: True)
rpc_server = Server({interface_name: interface}, builtin_terminate=True)
loop.run_until_complete(rpc_server.start(bind_address_from_args(args), args.port))
atexit_register_coroutine(rpc_server.stop)
loop.run_until_complete(rpc_server.wait_terminate())
def main():
args = get_argparser().parse_args()
init_logger(args)
loop = asyncio.get_event_loop()
atexit.register(lambda: loop.close())
writer = DBWriter(args.baseurl_db, args.user_db, args.password_db,
args.database, args.table)
writer.start()
atexit.register(lambda: loop.run_until_complete(writer.stop()))
filter = Filter(args.pattern_file)
rpc_server = Server({"influxdb_filter": filter}, builtin_terminate=True)
loop.run_until_complete(rpc_server.start(args.bind, args.bind_port))
atexit.register(lambda: loop.run_until_complete(rpc_server.stop()))
reader = MasterReader(args.server_master, args.port_master,
args.retry_master, filter._filter, writer)
reader.start()
atexit.register(lambda: loop.run_until_complete(reader.stop()))
loop.run_until_complete(rpc_server.wait_terminate())
def main():
args = get_argparser().parse_args()
init_logger(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)
if args.simulation:
if args.product == "TDC001":
dev = TdcSim()
elif args.product == "TPZ001":
dev = TpzSim()
else:
if args.product == "TDC001":
dev = Tdc(args.device)
elif args.product == "TPZ001":
dev = Tpz(args.device)
try:
simple_server_loop({args.product.lower(): dev}, args.bind, args.port)
finally:
dev.close()
def main():
args = get_argparser().parse_args()
init_logger(args)
if os.name == "nt":
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
atexit.register(lambda: loop.close())
ctlmgr = ControllerManager(args.server, args.port, args.retry_master)
ctlmgr.start()
atexit.register(lambda: loop.run_until_complete(ctlmgr.stop()))
class CtlMgrRPC:
retry_now = ctlmgr.retry_now
rpc_target = CtlMgrRPC()
rpc_server = Server({"ctlmgr": rpc_target}, builtin_terminate=True)
loop.run_until_complete(rpc_server.start(args.bind, args.bind_port))
atexit.register(lambda: loop.run_until_complete(rpc_server.stop()))
loop.run_until_complete(rpc_server.wait_terminate())
def main():
args = get_argparser().parse_args()
init_logger(args)
dev = DummyCamera()
run_server(dev, args)
def main():
args = get_argparser().parse_args()
init_logger(args)
dev = Client(args.server, args.port, "pdq2")
dev.init()
if args.reset:
dev.write(b"\x00\x00") # flush any escape
dev.cmd("RESET", True)
time.sleep(.1)
dev.cmd("START", False)
dev.cmd("ARM", False)
dev.cmd("DCM", args.dcm)
freq = 100e6 if args.dcm else 50e6
dev.set_freq(freq)
num_channels = dev.get_num_channels()
num_frames = dev.get_num_frames()
times = eval(args.times, globals(), {})
voltages = eval(args.voltages, globals(), dict(t=times))
if args.demo:
for ch, channel in enumerate(dev.channels):
entry = []
for fr in range(dev.channels[0].num_frames):
vi = .1 * fr + ch + voltages
entry.append(
channel.segment(times,
vi,
order=args.order,
end=False,
aux=args.aux))
pi = 2 * np.pi * (-.5 + .01 * fr + .1 * ch + 0 * voltages)
fi = 10e6 * times / times[-1]
channel.segment(2 * times,
voltages,
pi,
fi,
trigger=False,
silence=True,
aux=args.aux)
dev.write_channel(channel, entry)
elif args.bit:
v = [-1, 0, -1]
# for i in range(15):
# v.extend([(1 << i) - 1, 1 << i])
v = np.array(v) * dev.channels[0].max_out / dev.channels[0].max_val
t = np.arange(len(v))
for channel in dev.channels:
s = channel.segment(t,
v,
order=0,
shift=15,
stop=False,
trigger=False)
dev.write_channel(channel, [s for i in range(channel.num_frames)])
else:
c = dev.channels[args.channel]
map = [None] * c.num_frames
map[args.frame] = c.segment(times,
voltages,
order=args.order,
aux=args.aux)
dev.write_channel(c, map)
dev.cmd("START", True)
dev.cmd("ARM", not args.disarm)
dev.cmd("TRIGGER", args.free)
if args.plot:
from matplotlib import pyplot as plt
fig, ax = plt.subplots()
ax.plot(times, voltages, "xk", label="points")
if args.order > 0:
spline = interpolate.splrep(times, voltages, k=args.order)
ttimes = np.arange(0, times[-1], 1 / freq)
vvoltages = interpolate.splev(ttimes, spline)
ax.plot(ttimes, vvoltages, ",b", label="interpolation")
fig.savefig(args.plot)
def main():
args = get_argparser().parse_args()
init_logger(args)
dev = Client(args.server, args.port, "pdq2")
dev.init()
if args.reset:
dev.flush_escape()
dev.write_cmd("RESET_EN")
time.sleep(.1)
if args.dcm:
dev.write_cmd("DCM_EN")
dev.set_freq(100e6)
elif args.dcm == 0:
dev.write_cmd("DCM_DIS")
dev.set_freq(50e6)
dev.write_cmd("START_DIS")
num_channels = dev.get_num_channels()
num_frames = dev.get_num_frames()
times = eval(args.times, globals(), {})
voltages = eval(args.voltages, globals(), dict(t=times))
if args.demo:
# FIXME
channels = [args.channel] if args.channel < num_channels \
else range(num_channels)
frames = [args.frame] if args.frame < num_frames \
else range(num_frames)
for channel in channels:
f = []
for frame in frames:
vi = .1 * frame + channel + voltages
pi = 2 * np.pi * (.01 * frame + .1 * channel + 0 * voltages)
fi = 10e6 * times / times[-1]
f.append(b"".join([
dev.frame(times, vi, order=args.order, end=False),
dev.frame(2 * times, voltages, pi, fi, trigger=False),
# dev.frame(2*times, 0*vi+.1, 0*pi, 0*fi+1e6),
# dev.frame(times, 0*vi, order=args.order, silence=True),
]))
board, dac = divmod(channel, dev.num_dacs)
dev.write_data(dev.add_mem_header(board, dac, dev.map_frames(f)))
elif args.bit:
map = [0] * num_frames
t = np.arange(2 * 16) * 1.
v = [-1, 0, -1]
for i in range(15):
vi = 1 << i
v.extend([vi - 1, vi])
v = np.array(v) * dev.get_max_out() / (1 << 15)
t, v = t[:3], v[:3]
# print(t, v)
for channel in range(num_channels):
dev.multi_frame([(t, v)],
channel=channel,
order=0,
map=map,
shift=15,
stop=False,
trigger=False)
else:
tv = [(times, voltages)]
map = [None] * num_frames
map[args.frame] = 0
dev.multi_frame(tv, channel=args.channel, order=args.order, map=map)
dev.write_cmd("START_EN")
if not args.disarm:
dev.write_cmd("ARM_EN")
if args.free:
dev.write_cmd("TRIGGER_EN")
if args.plot:
from matplotlib import pyplot as plt
fig, ax0 = plt.subplots()
ax0.plot(times, voltages, "xk", label="points")
if args.order:
spline = interpolate.splrep(times, voltages, k=args.order)
ttimes = np.arange(0, times[-1], 1 / dev.get_freq())
vvoltages = interpolate.splev(ttimes, spline)
ax0.plot(ttimes, vvoltages, ",b", label="interpolation")
fig.savefig(args.plot)
def main():
args = get_argparser().parse_args()
init_logger(args)
if args.verbose == args.quiet == 0:
logging.getLogger().setLevel(logging.INFO)
def build_dir(*path, target=args.target):
return os.path.join("/tmp/", "artiq_" + target, *path)
if args.target == "kc705":
board_type, firmware = "kc705", "runtime"
variant = "nist_clock" if args.variant is None else args.variant
elif args.target == "sayma":
board_type, firmware = "sayma", "runtime"
variant = "standalone" if args.variant is None else args.variant
elif args.target == "kasli":
board_type, firmware = "kasli", "runtime"
variant = "tester" if args.variant is None else args.variant
else:
raise NotImplementedError("unknown target {}".format(args.target))
board = args.board.format(board_type=board_type)
board_file = args.board_file.format(board=board)
device = args.device.format(board=board, host=args.host)
serial = args.serial.format(board=board)
client = SSHClient(args.host, args.jump)
flock_acquired = False
flock_file = None # GC root
def lock():
nonlocal flock_acquired
nonlocal flock_file
if not flock_acquired:
fuser_args = ["fuser", "-u", board_file]
fuser = client.spawn_command(fuser_args)
fuser_file = fuser.makefile('r')
fuser_match = re.search(r"\((.+?)\)", fuser_file.readline())
if fuser_match and fuser_match.group(1) == os.getenv("USER"):
logger.info("Lock already acquired by {}".format(os.getenv("USER")))
flock_acquired = True
return
logger.info("Acquiring device lock")
flock_args = ["flock"]
if not args.wait:
flock_args.append("--nonblock")
flock_args += ["--verbose", board_file]
flock_args += ["sleep", "86400"]
flock = client.spawn_command(flock_args, get_pty=True)
flock_file = flock.makefile('r')
while not flock_acquired:
line = flock_file.readline()
if not line:
break
logger.debug(line.rstrip())
if line.startswith("flock: executing"):
flock_acquired = True
elif line.startswith("flock: failed"):
logger.error("Failed to get lock")
sys.exit(1)
def command(*args, on_failure="Command failed"):
logger.debug("Running {}".format(" ".join([shlex.quote(arg) for arg in args])))
try:
subprocess.check_call(args)
except subprocess.CalledProcessError:
logger.error(on_failure)
sys.exit(1)
def build(target, *extra_args, output_dir=build_dir(), variant=variant):
build_args = ["python3", "-m", "artiq.gateware.targets." + target, *extra_args]
if not args.gateware:
build_args.append("--no-compile-gateware")
if variant:
build_args += ["--variant", variant]
build_args += ["--output-dir", output_dir]
command(*build_args, on_failure="Build failed")
def flash(*steps):
lock()
flash_args = ["artiq_flash"]
for _ in range(args.verbose):
flash_args.append("-v")
flash_args += ["-H", args.host]
if args.jump:
flash_args += ["-J", args.jump]
flash_args += ["-t", board_type]
flash_args += ["-V", variant]
flash_args += ["-I", "source {}".format(board_file)]
flash_args += ["--srcbuild", build_dir()]
flash_args += steps
command(*flash_args, on_failure="Flashing failed")
for action in args.actions:
if action == "build":
logger.info("Building target")
if args.target == "sayma":
build("sayma_rtm", output_dir=build_dir("rtm_gateware"), variant=None)
build("sayma_amc", "--rtm-csr-csv", build_dir("rtm_gateware", "rtm_csr.csv"))
else:
build(args.target)
elif action == "clean":
logger.info("Cleaning build directory")
shutil.rmtree(build_dir(), ignore_errors=True)
elif action == "reset":
logger.info("Resetting device")
flash("start")
elif action == "flash":
gateware = ["gateware"] if args.gateware else []
logger.info("Flashing and booting")
flash(*gateware, "bootloader", "firmware", "start")
elif action == "flash+log":
gateware = ["gateware"] if args.gateware else []
logger.info("Flashing")
flash(*gateware, "bootloader", "firmware")
flterm = client.spawn_command(["flterm", serial, "--output-only"])
logger.info("Booting")
flash("start")
client.drain(flterm)
elif action == "load":
logger.info("Loading gateware")
flash("load")
elif action == "connect":
lock()
transport = client.get_transport()
transport.set_keepalive(30)
def forwarder(local_stream, remote_stream):
try:
while True:
r, _, _ = select.select([local_stream, remote_stream], [], [])
if local_stream in r:
data = local_stream.recv(65535)
if data == b"":
break
remote_stream.sendall(data)
if remote_stream in r:
data = remote_stream.recv(65535)
if data == b"":
break
local_stream.sendall(data)
except Exception as err:
logger.error("Cannot forward on port %s: %s", port, repr(err))
local_stream.close()
remote_stream.close()
def listener(port):
listener = socket.socket()
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(('localhost', port))
listener.listen(8)
while True:
local_stream, peer_addr = listener.accept()
logger.info("Accepting %s:%s and opening SSH channel to %s:%s",
*peer_addr, device, port)
try:
remote_stream = \
transport.open_channel('direct-tcpip', (device, port), peer_addr)
except Exception:
logger.exception("Cannot open channel on port %s", port)
continue
thread = threading.Thread(target=forwarder, args=(local_stream, remote_stream),
name="forward-{}".format(port), daemon=True)
thread.start()
ports = [1380, 1381, 1382, 1383]
for port in ports:
thread = threading.Thread(target=listener, args=(port,),
name="listen-{}".format(port), daemon=True)
thread.start()
logger.info("Forwarding ports {} to core device and logs from core device"
.format(", ".join(map(str, ports))))
client.run_command(["flterm", serial, "--output-only"])
elif action == "hotswap":
lock()
logger.info("Hotswapping firmware")
firmware = build_dir(variant, "software", firmware, firmware + ".bin")
mgmt = CommMgmt(device)
mgmt.open(ssh_transport=client.get_transport())
with open(firmware, "rb") as f:
mgmt.hotswap(f.read())
else:
logger.error("Unknown action {}".format(action))
sys.exit(1)
def main():
args = get_argparser().parse_args()
init_logger(args)
config = {
"kasli": {
"programmer":
partial(ProgrammerXC7,
board="kasli",
proxy="bscan_spi_xc7a100t.bit"),
"def_variant":
"opticlock",
"gateware": ("spi0", 0x000000),
"bootloader": ("spi0", 0x400000),
"storage": ("spi0", 0x440000),
"firmware": ("spi0", 0x450000),
},
"sayma": {
"programmer": ProgrammerSayma,
"def_variant": "standalone",
"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]
variant = args.variant
if variant is None:
variant = config["def_variant"]
bin_dir = args.dir
if bin_dir is None:
bin_name = args.target
if variant:
bin_name += "-" + variant
bin_dir = os.path.join(artiq_dir, "binaries", bin_name)
if args.host is None:
client = LocalClient()
else:
client = SSHClient(args.host, args.jump)
programmer = config["programmer"](client,
preinit_script=args.preinit_command)
def artifact_path(*path_filename):
if args.srcbuild is None:
*path, filename = path_filename
return os.path.join(bin_dir, filename)
else:
return os.path.join(args.srcbuild, *path_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, "gateware", "top.bit"))
programmer.write_binary(*config["gateware"], gateware_bin)
if args.target == "sayma" and args.variant != "master":
rtm_gateware_bin = convert_gateware(artifact_path(
"rtm_gateware", "rtm.bit"),
header=True)
programmer.write_binary(*config["rtm_gateware"],
rtm_gateware_bin)
elif action == "bootloader":
bootloader_bin = artifact_path(variant, "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 == "satellite":
firmware = "satman"
else:
firmware = "runtime"
firmware_fbi = artifact_path(variant, "software", firmware,
firmware + ".fbi")
programmer.write_binary(*config["firmware"], firmware_fbi)
elif action == "load":
if args.target == "sayma":
rtm_gateware_bit = artifact_path("rtm_gateware", "rtm.bit")
programmer.load(rtm_gateware_bit, 0)
gateware_bit = artifact_path(variant, "gateware", "top.bit")
programmer.load(gateware_bit, 1)
else:
gateware_bit = artifact_path(variant, "gateware", "top.bit")
programmer.load(gateware_bit, 0)
elif action == "start":
programmer.start()
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(args)
if args.target == "kc705_dds":
firmware = "runtime"
elif args.target == "kc705_drtio_satellite":
firmware = "satman"
else:
raise NotImplementedError("unknown target {}".format(args.target))
ssh = None
def get_ssh():
nonlocal ssh
if ssh is not None:
return ssh
ssh = paramiko.SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(args.host)
return ssh
sftp = None
def get_sftp():
nonlocal sftp
if sftp is not None:
return sftp
sftp = get_ssh().open_sftp()
return sftp
rng = Random()
tmp = "artiq" + "".join([rng.choice("ABCDEFGHIJKLMNOPQRSTUVWXYZ") for _ in range(6)])
env = "bash -c 'export PATH=$HOME/miniconda/bin:$PATH; exec $0 $*' "
def run_command(cmd, **kws):
logger.info("Executing {}".format(cmd))
chan = get_ssh().get_transport().open_session()
chan.set_combine_stderr(True)
chan.exec_command(cmd.format(tmp=tmp, env=env, serial=args.serial, ip=args.ip,
firmware=firmware, **kws))
return chan.makefile()
def drain(chan):
while True:
char = chan.read(1)
if char == b"":
break
sys.stderr.write(char.decode("utf-8", errors='replace'))
for action in args.actions:
if action == "build":
logger.info("Building firmware")
try:
subprocess.check_call(["python3",
"-m", "artiq.gateware.targets." + args.target,
"--no-compile-gateware",
"--output-dir",
"/tmp/{target}".format(target=args.target)])
except subprocess.CalledProcessError:
logger.error("Build failed")
sys.exit(1)
elif action == "boot" or action == "boot+log":
logger.info("Uploading firmware")
get_sftp().mkdir("/tmp/{tmp}".format(tmp=tmp))
get_sftp().put("/tmp/{target}/software/{firmware}/{firmware}.bin"
.format(target=args.target, firmware=firmware),
"/tmp/{tmp}/{firmware}.bin".format(tmp=tmp, firmware=firmware))
logger.info("Booting firmware")
flterm = run_command(
"{env} python3 flterm.py {serial} " +
"--kernel /tmp/{tmp}/{firmware}.bin " +
("--upload-only" if action == "boot" else "--output-only"))
artiq_flash = run_command(
"{env} artiq_flash start")
drain(flterm)
elif action == "connect":
def forwarder(port):
listener = socket.socket()
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(('localhost', port))
listener.listen(1)
while True:
local_stream, peer_addr = listener.accept()
logger.info("Accepting %s:%s and opening SSH channel to %s:%s",
*peer_addr, args.ip, port)
if get_ssh().get_transport() is None:
logger.error("Trying to open a channel before the transport is ready!")
continue
try:
remote_stream = get_ssh().get_transport() \
.open_channel('direct-tcpip', (args.ip, port), peer_addr)
except Exception as e:
logger.exception("Cannot open channel on port %s", port)
while True:
try:
r, w, x = select.select([local_stream, remote_stream], [], [])
if local_stream in r:
data = local_stream.recv(1024)
if data == b"":
break
remote_stream.send(data)
if remote_stream in r:
data = remote_stream.recv(1024)
if data == b"":
break
local_stream.send(data)
except Exception as e:
logger.exception("Forward error on port %s", port)
local_stream.close()
remote_stream.close()
for port in (1381, 1382):
thread = threading.Thread(target=forwarder, args=(port,),
name="port-{}".format(port), daemon=True)
thread.start()
logger.info("Connecting to device")
flterm = run_command(
"{env} python3 flterm.py {serial} --output-only")
drain(flterm)
else:
logger.error("Unknown action {}".format(action))
sys.exit(1)
def main():
args = get_argparser().parse_args()
init_logger(args)
app = QtGui.QApplication([])
loop = QEventLoop(app)
asyncio.set_event_loop(loop)
atexit.register(lambda: loop.close())
smgr = StateManager(args.db_file)
schedule_ctl = AsyncioClient()
loop.run_until_complete(
schedule_ctl.connect_rpc(args.server, args.port_control,
"master_schedule"))
atexit.register(lambda: schedule_ctl.close_rpc())
win = MainWindow(app, args.server)
area = dockarea.DockArea()
smgr.register(area)
smgr.register(win)
win.setCentralWidget(area)
status_bar = QtGui.QStatusBar()
status_bar.showMessage("Connected to {}".format(args.server))
win.setStatusBar(status_bar)
d_explorer = ExplorerDock(win, status_bar, schedule_ctl)
smgr.register(d_explorer)
loop.run_until_complete(
d_explorer.sub_connect(args.server, args.port_notify))
atexit.register(lambda: loop.run_until_complete(d_explorer.sub_close()))
d_datasets = DatasetsDock(win, area)
smgr.register(d_datasets)
loop.run_until_complete(
d_datasets.sub_connect(args.server, args.port_notify))
atexit.register(lambda: loop.run_until_complete(d_datasets.sub_close()))
if os.name != "nt":
d_ttl_dds = MonInj()
loop.run_until_complete(d_ttl_dds.start(args.server, args.port_notify))
atexit.register(lambda: loop.run_until_complete(d_ttl_dds.stop()))
if os.name != "nt":
area.addDock(d_ttl_dds.dds_dock, "top")
area.addDock(d_ttl_dds.ttl_dock, "above", d_ttl_dds.dds_dock)
area.addDock(d_datasets, "above", d_ttl_dds.ttl_dock)
else:
area.addDock(d_datasets, "top")
area.addDock(d_explorer, "above", d_datasets)
d_schedule = ScheduleDock(status_bar, schedule_ctl)
loop.run_until_complete(
d_schedule.sub_connect(args.server, args.port_notify))
atexit.register(lambda: loop.run_until_complete(d_schedule.sub_close()))
d_log = LogDock()
smgr.register(d_log)
loop.run_until_complete(d_log.sub_connect(args.server, args.port_notify))
atexit.register(lambda: loop.run_until_complete(d_log.sub_close()))
dataset_db = AsyncioClient()
loop.run_until_complete(
dataset_db.connect_rpc(args.server, args.port_control,
"master_dataset_db"))
atexit.register(lambda: dataset_db.close_rpc())
def _set_dataset(k, v):
asyncio.ensure_future(dataset_db.set(k, v))
def _del_dataset(k):
asyncio.ensure_future(dataset_db.delete(k))
d_console = ConsoleDock(d_datasets.get_dataset, _set_dataset, _del_dataset)
area.addDock(d_console, "bottom")
area.addDock(d_log, "above", d_console)
area.addDock(d_schedule, "above", d_log)
smgr.load()
smgr.start()
atexit.register(lambda: loop.run_until_complete(smgr.stop()))
win.show()
loop.run_until_complete(win.exit_request.wait())
def main():
args = get_argparser().parse_args()
init_logger(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": ProgrammerSayma,
"gateware": ("spi0", 0x000000),
"bootloader": ("spi1", 0x000000),
"storage": ("spi1", 0x040000),
"firmware": ("spi1", 0x050000),
"rtm_gateware": ("spi1", 0x200000),
},
"metlino": {
"programmer": ProgrammerMetlino,
"gateware": ("spi0", 0x000000),
"bootloader": ("spi1", 0x000000),
"storage": ("spi1", 0x040000),
"firmware": ("spi1", 0x050000),
},
"kc705": {
"programmer": partial(ProgrammerXC7, board="kc705", proxy="bscan_spi_xc7k325t.bit"),
"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 = any(action in args.action
for action in ["gateware", "bootloader", "firmware", "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_gateware")
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.host is None:
client = LocalClient()
else:
client = SSHClient(args.host, args.jump)
programmer = config["programmer"](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)
if args.target == "sayma" and variant != "master":
rtm_gateware_bin = convert_gateware(
artifact_path("rtm_gateware", "rtm.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":
rtm_gateware_bit = artifact_path("rtm_gateware", "rtm.bit")
programmer.load(rtm_gateware_bit, 0)
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 == "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 __init__(self):
self.args = args = get_argparser().parse_args()
init_logger(args)
self.config = load_config(args, "_server")
self.lasers = self.config["lasers"].keys()
for laser in self.lasers:
self.config["lasers"][laser]["lock_ready"] = False
# connect to hardware
self.wlm = WLM(args.simulation)
self.osas = OSAs(self.config["osas"], args.simulation)
self.exp_min = self.wlm.get_exposure_min()
self.exp_max = self.wlm.get_exposure_max()
self.num_ccds = self.wlm.get_num_ccds()
if self.config["switch"]["type"] == "internal":
self.switch = self.wlm.get_switch()
elif self.config["switch"]["type"] == "leoni":
self.switch = LeoniSwitch(
self.config["switch"]["ip"], args.simulation)
else:
raise ValueError("Unrecognised switch type: {}".format(
self.config["switch"]["type"]))
# measurement queue, processed by self.measurement_task
self.measurement_ids = task_id_generator()
self.measurements_queued = asyncio.Event()
self.queue = []
self.wake_locks = {laser: asyncio.Event() for laser in self.lasers}
# schedule initial frequency/osa readings all lasers
self.measurements_queued.set()
for laser in self.lasers:
self.queue.append({
"laser": laser,
"priority": 0,
"expiry": time.time(),
"id": next(self.measurement_ids),
"get_osa_trace": True,
"done": asyncio.Event()
})
# "notify" interface
self.laser_db = Notifier(self.config["lasers"])
self.freq_db = Notifier({laser: {
"freq": None,
"status": WLMMeasurementStatus.ERROR,
"timestamp": 0
} for laser in self.lasers})
self.osa_db = Notifier({laser: {
"trace": None,
"timestamp": 0
} for laser in self.lasers})
self.server_notify = Publisher({
"laser_db": self.laser_db, # laser settings
"freq_db": self.freq_db, # most recent frequency measurements
"osa_db": self.osa_db # most recent osa traces
})
# "control" interface
self.control_interface = ControlInterface(self)
self.server_control = RPCServer({"control": self.control_interface},
allow_parallel=True)
self.running = False
def main():
args = get_argparser().parse_args()
init_logger(args)
device_mgr = DeviceManager(DeviceDB(args.device_db))
try:
core_addr = DeviceDB(args.device_db).get("core")["arguments"]["host"]
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()
finally:
device_mgr.close_devices()
def main():
args = get_argparser().parse_args()
init_logger(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()
init_logger(args)
if args.target == "kc705_dds" or args.target == "kc705_drtio_master":
firmware = "runtime"
elif args.target == "kc705_drtio_satellite":
firmware = "satman"
else:
raise NotImplementedError("unknown target {}".format(args.target))
client = SSHClient(args.host)
substs = {
"env": "bash -c 'export PATH=$HOME/miniconda/bin:$PATH; exec $0 $*' ",
"serial": args.serial,
"firmware": firmware,
}
for action in args.actions:
if action == "build":
logger.info("Building firmware")
try:
subprocess.check_call([
"python3", "-m", "artiq.gateware.targets." + args.target,
"--no-compile-gateware", "--output-dir",
"/tmp/{target}".format(target=args.target)
])
except subprocess.CalledProcessError:
logger.error("Build failed")
sys.exit(1)
elif action == "clean":
logger.info("Cleaning build directory")
target_dir = "/tmp/{target}".format(target=args.target)
if os.path.isdir(target_dir):
shutil.rmtree(target_dir)
elif action == "reset":
logger.info("Resetting device")
client.run_command(
"{env} artiq_flash start" +
(" --target-file " + args.config if args.config else ""),
**substs)
elif action == "boot" or action == "boot+log":
logger.info("Uploading firmware")
client.get_sftp().put(
"/tmp/{target}/software/{firmware}/{firmware}.bin".format(
target=args.target, firmware=firmware),
"{tmp}/{firmware}.bin".format(tmp=client.tmp,
firmware=firmware))
logger.info("Booting firmware")
flterm = client.spawn_command(
"{env} python3 flterm.py {serial} " +
"--kernel {tmp}/{firmware}.bin " +
("--upload-only" if action == "boot" else "--output-only"),
**substs)
artiq_flash = client.spawn_command(
"{env} artiq_flash start" +
(" --target-file " + args.config if args.config else ""),
**substs)
client.drain(flterm)
elif action == "connect":
transport = client.get_transport()
def forwarder(local_stream, remote_stream):
try:
while True:
r, _, _ = select.select([local_stream, remote_stream],
[], [])
if local_stream in r:
data = local_stream.recv(65535)
if data == b"":
break
remote_stream.sendall(data)
if remote_stream in r:
data = remote_stream.recv(65535)
if data == b"":
break
local_stream.sendall(data)
except Exception as err:
logger.error("Cannot forward on port %s: %s", port,
repr(err))
local_stream.close()
remote_stream.close()
def listener(port):
listener = socket.socket()
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(('localhost', port))
listener.listen(8)
while True:
local_stream, peer_addr = listener.accept()
logger.info(
"Accepting %s:%s and opening SSH channel to %s:%s",
*peer_addr, args.device, port)
if client.get_transport() is None:
logger.error(
"Trying to open a channel before the transport is ready!"
)
continue
try:
remote_stream = \
transport.open_channel('direct-tcpip', (args.device, port), peer_addr)
except Exception:
logger.exception("Cannot open channel on port %s",
port)
continue
thread = threading.Thread(target=forwarder,
args=(local_stream,
remote_stream),
name="forward-{}".format(port),
daemon=True)
thread.start()
for port in (1380, 1381, 1382, 1383):
thread = threading.Thread(target=listener,
args=(port, ),
name="listen-{}".format(port),
daemon=True)
thread.start()
logger.info("Connecting to device")
client.run_command(
"{env} python3 flterm.py {serial} --output-only", **substs)
elif action == "hotswap":
logger.info("Hotswapping firmware")
try:
subprocess.check_call([
"python3", "-m", "artiq.frontend.artiq_coreboot",
"hotswap",
"/tmp/{target}/software/{firmware}/{firmware}.bin".format(
target=args.target, firmware=firmware)
])
except subprocess.CalledProcessError:
logger.error("Build failed")
sys.exit(1)
else:
logger.error("Unknown action {}".format(action))
sys.exit(1)
def main():
args = get_argparser().parse_args()
init_logger(args)
if args.verbose == args.quiet == 0:
logging.getLogger().setLevel(logging.INFO)
def build_dir(*path, target=args.target):
return os.path.join("/tmp/", "artiq_" + target, *path)
if args.target == "kc705":
board_type, firmware = "kc705", "runtime"
variant = "nist_clock" if args.variant is None else args.variant
elif args.target == "sayma":
board_type, firmware = "sayma", "runtime"
variant = "standalone" if args.variant is None else args.variant
elif args.target == "kasli":
board_type, firmware = "kasli", "runtime"
variant = "tester" if args.variant is None else args.variant
else:
raise NotImplementedError("unknown target {}".format(args.target))
board = args.board.format(board_type=board_type)
board_file = args.board_file.format(board=board)
device = args.device.format(board=board, host=args.host)
serial = args.serial.format(board=board)
client = SSHClient(args.host, args.jump)
flock_acquired = False
flock_file = None # GC root
def lock():
nonlocal flock_acquired
nonlocal flock_file
if not flock_acquired:
fuser_args = ["fuser", "-u", board_file]
fuser = client.spawn_command(fuser_args)
fuser_file = fuser.makefile('r')
fuser_match = re.search(r"\((.+?)\)", fuser_file.readline())
if fuser_match and fuser_match.group(1) == os.getenv("USER"):
logger.info("Lock already acquired by {}".format(
os.getenv("USER")))
flock_acquired = True
return
logger.info("Acquiring device lock")
flock_args = ["flock"]
if not args.wait:
flock_args.append("--nonblock")
flock_args += ["--verbose", board_file]
flock_args += ["sleep", "86400"]
flock = client.spawn_command(flock_args, get_pty=True)
flock_file = flock.makefile('r')
while not flock_acquired:
line = flock_file.readline()
if not line:
break
logger.debug(line.rstrip())
if line.startswith("flock: executing"):
flock_acquired = True
elif line.startswith("flock: failed"):
logger.error("Failed to get lock")
sys.exit(1)
def command(*args, on_failure="Command failed"):
logger.debug("Running {}".format(" ".join(
[shlex.quote(arg) for arg in args])))
try:
subprocess.check_call(args)
except subprocess.CalledProcessError:
logger.error(on_failure)
sys.exit(1)
def build(target, *extra_args, output_dir=build_dir(), variant=variant):
build_args = [
"python3", "-m", "artiq.gateware.targets." + target, *extra_args
]
if not args.gateware:
build_args.append("--no-compile-gateware")
if variant:
build_args += ["--variant", variant]
build_args += ["--output-dir", output_dir]
command(*build_args, on_failure="Build failed")
def flash(*steps):
lock()
flash_args = ["artiq_flash"]
for _ in range(args.verbose):
flash_args.append("-v")
flash_args += ["-H", args.host]
if args.jump:
flash_args += ["-J", args.jump]
flash_args += ["-t", board_type]
flash_args += ["-V", variant]
flash_args += ["-I", "source {}".format(board_file)]
flash_args += ["--srcbuild", build_dir()]
flash_args += steps
command(*flash_args, on_failure="Flashing failed")
for action in args.actions:
if action == "build":
logger.info("Building target")
if args.target == "sayma":
build("sayma_rtm",
output_dir=build_dir("rtm_gateware"),
variant=None)
build("sayma_amc", "--rtm-csr-csv",
build_dir("rtm_gateware", "rtm_csr.csv"))
else:
build(args.target)
elif action == "clean":
logger.info("Cleaning build directory")
shutil.rmtree(build_dir(), ignore_errors=True)
elif action == "reset":
logger.info("Resetting device")
flash("start")
elif action == "flash":
gateware = ["gateware"] if args.gateware else []
logger.info("Flashing and booting")
flash(*gateware, "bootloader", "firmware", "start")
elif action == "flash+log":
gateware = ["gateware"] if args.gateware else []
logger.info("Flashing")
flash(*gateware, "bootloader", "firmware")
flterm = client.spawn_command(["flterm", serial, "--output-only"])
logger.info("Booting")
flash("start")
client.drain(flterm)
elif action == "load":
logger.info("Loading gateware")
flash("load")
elif action == "connect":
lock()
transport = client.get_transport()
transport.set_keepalive(30)
def forwarder(local_stream, remote_stream):
try:
while True:
r, _, _ = select.select([local_stream, remote_stream],
[], [])
if local_stream in r:
data = local_stream.recv(65535)
if data == b"":
break
remote_stream.sendall(data)
if remote_stream in r:
data = remote_stream.recv(65535)
if data == b"":
break
local_stream.sendall(data)
except Exception as err:
logger.error("Cannot forward on port %s: %s", port,
repr(err))
local_stream.close()
remote_stream.close()
def listener(port):
listener = socket.socket()
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(('localhost', port))
listener.listen(8)
while True:
local_stream, peer_addr = listener.accept()
logger.info(
"Accepting %s:%s and opening SSH channel to %s:%s",
*peer_addr, device, port)
try:
remote_stream = \
transport.open_channel('direct-tcpip', (device, port), peer_addr)
except Exception:
logger.exception("Cannot open channel on port %s",
port)
continue
thread = threading.Thread(target=forwarder,
args=(local_stream,
remote_stream),
name="forward-{}".format(port),
daemon=True)
thread.start()
ports = [1380, 1381, 1382, 1383]
for port in ports:
thread = threading.Thread(target=listener,
args=(port, ),
name="listen-{}".format(port),
daemon=True)
thread.start()
logger.info(
"Forwarding ports {} to core device and logs from core device".
format(", ".join(map(str, ports))))
client.run_command(["flterm", serial, "--output-only"])
elif action == "hotswap":
lock()
logger.info("Hotswapping firmware")
firmware = build_dir(variant, "software", firmware,
firmware + ".bin")
mgmt = CommMgmt(device)
mgmt.open(ssh_transport=client.get_transport())
with open(firmware, "rb") as f:
mgmt.hotswap(f.read())
else:
logger.error("Unknown action {}".format(action))
sys.exit(1)
def main():
args = get_argparser().parse_args()
init_logger(args)
config = {
"kc705": {
"programmer":
partial(ProgrammerXC7,
board="kc705",
proxy="bscan_spi_xc7k325t.bit"),
"variants": ["nist_clock", "nist_qc2"],
"gateware": ("spi0", 0x000000),
"bootloader": ("spi0", 0xaf0000),
"storage": ("spi0", 0xb30000),
"firmware": ("spi0", 0xb40000),
},
"kasli": {
"programmer":
partial(ProgrammerXC7,
board="kasli",
proxy="bscan_spi_xc7a100t.bit"),
"variants": ["opticlock", "master", "satellite"],
"gateware": ("spi0", 0x000000),
"bootloader": ("spi0", 0x400000),
"storage": ("spi0", 0x440000),
"firmware": ("spi0", 0x450000),
},
"sayma": {
"programmer": ProgrammerSayma,
"variants": ["standalone", "master", "satellite"],
"gateware": ("spi0", 0x000000),
"bootloader": ("spi1", 0x000000),
"storage": ("spi1", 0x040000),
"firmware": ("spi1", 0x050000),
},
}[args.target]
variant = args.variant
if "variants" in config:
if variant is not None and variant not in config["variants"]:
raise SystemExit("Invalid variant for this board")
if variant is None:
variant = config["variants"][0]
bin_dir = args.dir
if bin_dir is None:
bin_name = args.target
if variant:
bin_name += "-" + variant
bin_dir = os.path.join(artiq_dir, "binaries", bin_name)
if args.host is None:
client = LocalClient()
else:
client = SSHClient(args.host)
programmer = config["programmer"](client,
preinit_script=args.preinit_command)
def artifact_path(*path_filename):
if args.srcbuild is None:
*path, filename = path_filename
return os.path.join(bin_dir, filename)
else:
return os.path.join(args.srcbuild, *path_filename)
try:
for action in args.action:
if action == "gateware":
gateware_bin = artifact_path("gateware", "top.bin")
if not os.access(gateware_bin, os.R_OK):
bin_handle, gateware_bin = tempfile.mkstemp()
gateware_bit = artifact_path("gateware", "top.bit")
with open(gateware_bit,
"rb") as bit_file, open(bin_handle,
"wb") as bin_file:
bit2bin(bit_file, bin_file)
atexit.register(lambda: os.unlink(gateware_bin))
programmer.write_binary(*config["gateware"], gateware_bin)
elif action == "bootloader":
bootloader_bin = artifact_path("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 == "satellite":
firmware = "satman"
else:
firmware = "runtime"
firmware_fbi = artifact_path("software", firmware,
firmware + ".fbi")
programmer.write_binary(*config["firmware"], firmware_fbi)
elif action == "load":
if args.target == "sayma":
rtm_gateware_bit = artifact_path("rtm_gateware", "rtm.bit")
programmer.load(rtm_gateware_bit, 0)
gateware_bit = artifact_path("gateware", "top.bit")
programmer.load(gateware_bit, 1)
else:
gateware_bit = artifact_path("gateware", "top.bit")
programmer.load(gateware_bit, 0)
elif action == "start":
programmer.start()
else:
raise ValueError("invalid action", action)
except FileNotFoundError as e:
raise SystemExit(e)
if args.dry_run:
print("\n".join(programmer.script()))
else:
programmer.run()