m-labs · Jul 21, 2015 · Jul 21, 2015 · Jul 21, 2015 · Jul 21, 2015 · Jul 21, 2015
diff --git a/artiq/frontend/artiq_client.py b/artiq/frontend/artiq_client.py
@@ -12,7 +12,6 @@
 from artiq.protocols.pc_rpc import Client
 from artiq.protocols.sync_struct import Subscriber
 from artiq.protocols import pyon
-from artiq.tools import format_arguments
 
 
 def clear_screen():
@@ -149,7 +148,7 @@ def _show_schedule(schedule):
                                   x[1]["due_date"] or 0,
                                   x[0]))
         table = PrettyTable(["RID", "Pipeline", "    Status    ", "Prio",
-                             "Due date", "File", "Class name", "Arguments"])
+                             "Due date", "File", "Class name"])
         for rid, v in l:
             row = [rid, v["pipeline"], v["status"], v["priority"]]
             if v["due_date"] is None:
@@ -162,7 +161,6 @@ def _show_schedule(schedule):
                 row.append("")
             else:
                 row.append(v["expid"]["class_name"])
-            row.append(format_arguments(v["expid"]["arguments"]))
             table.add_row(row)
         print(table)
     else:

diff --git a/artiq/frontend/artiq_gui.py b/artiq/frontend/artiq_gui.py
@@ -87,23 +87,27 @@ def main():
     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()))
-    area.addDock(d_ttl_dds.dds_dock, "top")
-    area.addDock(d_ttl_dds.ttl_dock, "above", d_ttl_dds.dds_dock)
-    area.addDock(d_results, "above", d_ttl_dds.ttl_dock)
-    area.addDock(d_explorer, "above", d_results)
 
     d_params = ParametersDock()
-    area.addDock(d_params, "right", d_explorer)
     loop.run_until_complete(d_params.sub_connect(
         args.server, args.port_notify))
     atexit.register(lambda: loop.run_until_complete(d_params.sub_close()))
 
+    area.addDock(d_ttl_dds.dds_dock, "top")
+    area.addDock(d_ttl_dds.ttl_dock, "above", d_ttl_dds.dds_dock)
+    area.addDock(d_results, "above", d_ttl_dds.ttl_dock)
+    area.addDock(d_params, "above", d_results)
+    area.addDock(d_explorer, "above", d_params)
+
     d_schedule = ScheduleDock(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()
+    loop.run_until_complete(d_log.sub_connect(
+        args.server, args.port_notify))
+    atexit.register(lambda: loop.run_until_complete(d_log.sub_close()))
 
     area.addDock(d_log, "bottom")
     area.addDock(d_schedule, "above", d_log)

diff --git a/artiq/frontend/artiq_master.py b/artiq/frontend/artiq_master.py
@@ -30,26 +30,39 @@ def get_argparser():
     return parser
 
 
+class Log:
+    def __init__(self, depth):
+        self.depth = depth
+        self.data = Notifier([])
+
+    def log(self, rid, message):
+        if len(self.data.read) >= self.depth:
+            del self.data[0]
+        self.data.append((rid, message))
+    log.worker_pass_rid = True
+
+
 def main():
     args = get_argparser().parse_args()
-
     init_logger(args)
-    ddb = FlatFileDB("ddb.pyon")
-    pdb = FlatFileDB("pdb.pyon")
-    rtr = Notifier(dict())
-
     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("ddb.pyon")
+    pdb = FlatFileDB("pdb.pyon")
+    rtr = Notifier(dict())
+    log = Log(1000)
+
     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)
     worker_handlers["scheduler_submit"] = scheduler.submit
@@ -74,7 +87,8 @@ def main():
         "devices": ddb.data,
         "parameters": pdb.data,
         "rt_results": rtr,
-        "explist": repository.explist
+        "explist": repository.explist,
+        "log": log.data
     })
     loop.run_until_complete(server_notify.start(
         args.bind, args.port_notify))

diff --git a/artiq/gui/explorer.py b/artiq/gui/explorer.py
@@ -8,6 +8,7 @@
 from artiq.protocols.sync_struct import Subscriber
 from artiq.protocols import pyon
 from artiq.gui.tools import DictSyncModel
+from artiq.gui.scan import ScanController
 
 
 class _ExplistModel(DictSyncModel):
@@ -93,7 +94,8 @@ def get_argument_value(self):
     "BooleanValue": _BooleanEntry,
     "EnumerationValue": _EnumerationEntry,
     "NumberValue": _NumberEntry,
-    "StringValue": _StringEntry
+    "StringValue": _StringEntry,
+    "Scannable": ScanController
 }
 
 

diff --git a/artiq/gui/log.py b/artiq/gui/log.py
@@ -1,7 +1,40 @@
+import asyncio
+
 from quamash import QtGui
 from pyqtgraph import dockarea
 
+from artiq.protocols.sync_struct import Subscriber
+from artiq.gui.tools import ListSyncModel
+
+
+class _LogModel(ListSyncModel):
+    def __init__(self, parent, init):
+        ListSyncModel.__init__(self,
+            ["RID", "Message"],
+            parent, init)
+
+    def convert(self, v, column):
+        return v[column]
+
 
 class LogDock(dockarea.Dock):
     def __init__(self):
         dockarea.Dock.__init__(self, "Log", size=(1000, 300))
+
+        self.log = QtGui.QTableView()
+        self.log.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
+        self.addWidget(self.log)
+
+    @asyncio.coroutine
+    def sub_connect(self, host, port):
+        self.subscriber = Subscriber("log", self.init_log_model)
+        yield from self.subscriber.connect(host, port)
+
+    @asyncio.coroutine
+    def sub_close(self):
+        yield from self.subscriber.close()
+
+    def init_log_model(self, init):
+        table_model = _LogModel(self.log, init)
+        self.log.setModel(table_model)
+        return table_model
diff --git a/artiq/gui/parameters.py b/artiq/gui/parameters.py
@@ -5,7 +5,7 @@
 from pyqtgraph import LayoutWidget
 
 from artiq.protocols.sync_struct import Subscriber
-from artiq.gui.tools import DictSyncModel
+from artiq.gui.tools import DictSyncModel, short_format
 
 
 class ParametersModel(DictSyncModel):
@@ -20,7 +20,7 @@ def convert(self, k, v, column):
         if column == 0:
             return k
         elif column == 1:
-            return str(v)
+            return short_format(v)
         else:
            raise ValueError
 

diff --git a/artiq/gui/results.py b/artiq/gui/results.py
@@ -7,21 +7,13 @@
 from pyqtgraph import LayoutWidget
 
 from artiq.protocols.sync_struct import Subscriber
-from artiq.gui.tools import DictSyncModel
+from artiq.gui.tools import DictSyncModel, short_format
 from artiq.gui.displays import *
 
 
-def _fmt_type(v):
-    t = type(v)
-    r = t.__name__
-    if t is list or t is dict or t is set:
-        r += " ({})".format(len(v))
-    return r
-
-
 class ResultsModel(DictSyncModel):
     def __init__(self, parent, init):
-        DictSyncModel.__init__(self, ["Result", "Type"],
+        DictSyncModel.__init__(self, ["Result", "Value"],
                                parent, init)
 
     def sort_key(self, k, v):
@@ -31,7 +23,7 @@ def convert(self, k, v, column):
         if column == 0:
             return k
         elif column == 1:
-            return _fmt_type(v)
+            return short_format(v)
         else:
            raise ValueError
 

diff --git a/artiq/gui/scan.py b/artiq/gui/scan.py
@@ -0,0 +1,137 @@
+from quamash import QtGui
+from pyqtgraph import LayoutWidget
+
+
+class _Range(LayoutWidget):
+    def __init__(self, global_min, global_max, global_step, unit):
+        LayoutWidget.__init__(self)
+
+        def apply_properties(spinbox):
+            if global_min is not None:
+                spinbox.setMinimum(global_min)
+            if global_max is not None:
+                spinbox.setMaximum(global_max)
+            if global_step is not None:
+                spinbox.setSingleStep(global_step)
+            if unit:
+                spinbox.setSuffix(" " + unit)
+
+        self.addWidget(QtGui.QLabel("Min:"), 0, 0)
+        self.min = QtGui.QDoubleSpinBox()
+        apply_properties(self.min)
+        self.addWidget(self.min, 0, 1)
+
+        self.addWidget(QtGui.QLabel("Max:"), 0, 2)
+        self.max = QtGui.QDoubleSpinBox()
+        apply_properties(self.max)
+        self.addWidget(self.max, 0, 3)
+
+        self.addWidget(QtGui.QLabel("#Points:"), 0, 4)
+        self.npoints = QtGui.QSpinBox()
+        self.npoints.setMinimum(2)
+        self.npoints.setValue(10)
+        self.addWidget(self.npoints, 0, 5)
+
+    def set_values(self, min, max, npoints):
+        self.min.setValue(min)
+        self.max.setValue(max)
+        self.npoints.setValue(npoints)
+
+    def get_values(self):
+        return {
+            "min": self.min.value(),
+            "max": self.max.value(),
+            "npoints": self.npoints.value()
+        }
+
+
+class ScanController(LayoutWidget):
+    def __init__(self, procdesc):
+        LayoutWidget.__init__(self)
+
+        self.stack = QtGui.QStackedWidget()
+        self.addWidget(self.stack, 1, 0, colspan=4)
+
+        gmin, gmax = procdesc["global_min"], procdesc["global_max"]
+        gstep = procdesc["global_step"]
+        unit = procdesc["unit"]
+
+        self.v_noscan = QtGui.QDoubleSpinBox()
+        if gmin is not None:
+            self.v_noscan.setMinimum(gmin)
+        if gmax is not None:
+            self.v_noscan.setMaximum(gmax)
+        if gstep is not None:
+            self.v_noscan.setSingleStep(gstep)
+        if unit:
+            self.v_noscan.setSuffix(" " + unit)
+        self.v_noscan_gr = LayoutWidget()
+        self.v_noscan_gr.addWidget(QtGui.QLabel("Value:"), 0, 0)
+        self.v_noscan_gr.addWidget(self.v_noscan, 0, 1)
+        self.stack.addWidget(self.v_noscan_gr)
+
+        self.v_linear = _Range(gmin, gmax, gstep, unit)
+        self.stack.addWidget(self.v_linear)
+
+        self.v_random = _Range(gmin, gmax, gstep, unit)
+        self.stack.addWidget(self.v_random)
+
+        self.v_explicit = QtGui.QLineEdit()
+        self.v_explicit_gr = LayoutWidget()
+        self.v_explicit_gr.addWidget(QtGui.QLabel("Sequence:"), 0, 0)
+        self.v_explicit_gr.addWidget(self.v_explicit, 0, 1)
+        self.stack.addWidget(self.v_explicit_gr)
+
+        self.noscan = QtGui.QRadioButton("No scan")
+        self.linear = QtGui.QRadioButton("Linear")
+        self.random = QtGui.QRadioButton("Random")
+        self.explicit = QtGui.QRadioButton("Explicit")
+        radiobuttons = QtGui.QButtonGroup()
+        for n, b in enumerate([self.noscan, self.linear,
+                               self.random, self.explicit]):
+            self.addWidget(b, 0, n)
+            radiobuttons.addButton(b)
+            b.toggled.connect(self.select_page)
+
+        if "default" in procdesc:
+            d = procdesc["default"]
+            if d["ty"] == "NoScan":
+                self.noscan.setChecked(True)
+                self.v_noscan.setValue(d["value"])
+            elif d["ty"] == "LinearScan":
+                self.linear.setChecked(True)
+                self.v_linear.set_values(d["min"], d["max"], d["step"])
+            elif d["ty"] == "RandomScan":
+                self.random.setChecked(True)
+                self.v_random.set_values(d["min"], d["max"], d["step"])
+            elif d["ty"] == "ExplicitScan":
+                self.explicit.setChecked(True)
+                self.v_explicit.insert(" ".join(
+                    [str(x) for x in d["sequence"]]))
+        else:
+            self.noscan.setChecked(True)
+
+    def select_page(self):
+        if self.noscan.isChecked():
+            self.stack.setCurrentWidget(self.v_noscan_gr)
+        elif self.linear.isChecked():
+            self.stack.setCurrentWidget(self.v_linear)
+        elif self.random.isChecked():
+            self.stack.setCurrentWidget(self.v_random)
+        elif self.explicit.isChecked():
+            self.stack.setCurrentWidget(self.v_explicit_gr)
+
+    def get_argument_value(self):
+        if self.noscan.isChecked():
+            return {"ty": "NoScan", "value": self.v_noscan.value()}
+        elif self.linear.isChecked():
+            d = {"ty": "LinearScan"}
+            d.update(self.v_linear.get_values())
+            return d
+        elif self.random.isChecked():
+            d = {"ty": "RandomScan"}
+            d.update(self.v_random.get_values())
+            return d
+        elif self.explicit.isChecked():
+            sequence = [float(x) for x in self.v_explicit.text().split()]
+            return {"ty": "ExplicitScan", "sequence": sequence}
diff --git a/artiq/gui/schedule.py b/artiq/gui/schedule.py
@@ -6,14 +6,13 @@
 
 from artiq.protocols.sync_struct import Subscriber
 from artiq.gui.tools import DictSyncModel
-from artiq.tools import format_arguments
 
 
 class _ScheduleModel(DictSyncModel):
     def __init__(self, parent, init):
         DictSyncModel.__init__(self,
             ["RID", "Pipeline", "Status", "Prio", "Due date",
-             "File", "Class name", "Arguments"],
+             "File", "Class name"],
             parent, init)
 
     def sort_key(self, k, v):
@@ -42,8 +41,6 @@ def convert(self, k, v, column):
                 return ""
             else:
                 return v["expid"]["class_name"]
-        elif column == 7:
-            return format_arguments(v["expid"]["arguments"])
         else:
             raise ValueError