m-labs · Oct 4, 2015 · Oct 4, 2015 · Oct 4, 2015 · Oct 4, 2015
diff --git a/artiq/frontend/artiq_master.py b/artiq/frontend/artiq_master.py
@@ -74,11 +74,12 @@ def main():
         repo_backend = GitBackend(args.repository)
     else:
         repo_backend = FilesystemBackend(args.repository)
-    repository = Repository(repo_backend, log.log)
+    repository = Repository(repo_backend, ddb.get_ddb, log.log)
     atexit.register(repository.close)
     repository.scan_async()
 
     worker_handlers = {
+        "get_ddb": ddb.get_ddb,
         "get_device": ddb.get,
         "get_parameter": pdb.get,
         "set_parameter": pdb.set,

diff --git a/artiq/frontend/artiq_run.py b/artiq/frontend/artiq_run.py
@@ -13,6 +13,7 @@
 
 from artiq.language.environment import EnvExperiment
 from artiq.protocols.file_db import FlatFileDB
+from artiq.master.ddb import DDB
 from artiq.master.worker_db import DeviceManager, ResultDB
 from artiq.tools import *
 
@@ -111,7 +112,7 @@ def run(with_file=False):
     args = get_argparser(with_file).parse_args()
     init_logger(args)
 
-    dmgr = DeviceManager(FlatFileDB(args.ddb),
+    dmgr = DeviceManager(DDB(args.ddb),
                          virtual_devices={"scheduler": DummyScheduler()})
     pdb = FlatFileDB(args.pdb)
     pdb.hooks.append(SimpleParamLogger())

diff --git a/artiq/gui/moninj.py b/artiq/gui/moninj.py
@@ -23,9 +23,9 @@
 
 
 class _TTLWidget(QtGui.QFrame):
-    def __init__(self, send_to_device, channel, force_out, title):
-        self.send_to_device = send_to_device
+    def __init__(self, channel, send_to_device, force_out, title):
         self.channel = channel
+        self.send_to_device = send_to_device
         self.force_out = force_out
 
         QtGui.QFrame.__init__(self)
@@ -119,7 +119,8 @@ def set_value(self, value, oe, override):
 
 
 class _DDSWidget(QtGui.QFrame):
-    def __init__(self, sysclk, title):
+    def __init__(self, channel, sysclk, title):
+        self.channel = channel
         self.sysclk = sysclk
 
         QtGui.QFrame.__init__(self)
@@ -163,9 +164,11 @@ def __init__(self, send_to_device, init):
             self[k] = v
 
     def __setitem__(self, k, v):
-        self.ddb[k] = v
         if k in self.ttl_widgets:
             del self[k]
+        if k in self.dds_widgets:
+            del self[k]
+        self.ddb[k] = v
         if not isinstance(v, dict):
             return
         try:
@@ -176,23 +179,29 @@ def __setitem__(self, k, v):
                 if v["module"] == "artiq.coredevice.ttl":
                     channel = v["arguments"]["channel"]
                     force_out = v["class"] == "TTLOut"
-                    self.ttl_widgets[channel] = _TTLWidget(
-                        self.send_to_device, channel, force_out, title)
+                    self.ttl_widgets[k] = _TTLWidget(
+                        channel, self.send_to_device, force_out, title)
                     self.ttl_cb()
                 if (v["module"] == "artiq.coredevice.dds"
                         and v["class"] in {"AD9858", "AD9914"}):
                     channel = v["arguments"]["channel"]
                     sysclk = v["arguments"]["sysclk"]
-                    self.dds_widgets[channel] = _DDSWidget(sysclk, title)
+                    self.dds_widgets[channel] = _DDSWidget(
+                        channel, sysclk, title)
                     self.dds_cb()
         except KeyError:
             pass
 
     def __delitem__(self, k):
         del self.ddb[k]
         if k in self.ttl_widgets:
+            self.ttl_widgets[k].deleteLater()
             del self.ttl_widgets[k]
             self.ttl_cb()
+        if k in self.dds_widgets:
+            self.dds_widgets[k].deleteLater()
+            del self.dds_widgets[k]
+            self.dds_cb()
 
     def get_core_addr(self):
         try:
@@ -261,16 +270,17 @@ def datagram_received(self, data, addr):
         try:
             ttl_levels, ttl_oes, ttl_overrides = \
                 struct.unpack(">QQQ", data[:8*3])
-            for channel, w in self.dm.ttl_widgets.items():
+            for w in self.dm.ttl_widgets.values():
+                channel = w.channel
                 w.set_value(ttl_levels & (1 << channel),
                             ttl_oes & (1 << channel),
                             ttl_overrides & (1 << channel))
             dds_data = data[8*3:]
             ndds = len(dds_data)//4
             ftws = struct.unpack(">" + "I"*ndds, dds_data)
-            for channel, w in self.dm.dds_widgets.items():
+            for w in self.dm.dds_widgets.values():
                 try:
-                    ftw = ftws[channel]
+                    ftw = ftws[w.channel]
                 except KeyError:
                     pass
                 else:

diff --git a/artiq/language/environment.py b/artiq/language/environment.py
@@ -182,6 +182,12 @@ def setattr_argument(self, key, processor=None, group=None):
         attribute are the same."""
         setattr(self, key, self.get_argument(key, processor, group))
 
+    def get_ddb(self):
+        """Returns the full contents of the device database."""
+        if self.__parent is not None:
+            return self.__parent.get_ddb()
+        return self.__dmgr.get_ddb()
+
     def get_device(self, key):
         """Creates and returns a device driver."""
         if self.__parent is not None:

diff --git a/artiq/master/ddb.py b/artiq/master/ddb.py
@@ -17,5 +17,8 @@ def scan(self):
             if k not in self.data.read or self.data.read[k] != new_data[k]:
                 self.data[k] = new_data[k]
 
+    def get_ddb(self):
+        return self.data.read
+
     def get(self, key):
         return self.data.read[key]
diff --git a/artiq/master/repository.py b/artiq/master/repository.py
@@ -12,12 +12,15 @@
 logger = logging.getLogger(__name__)
 
 
-async def _scan_experiments(wd, log):
+async def _scan_experiments(wd, get_ddb, log):
     r = dict()
     for f in os.listdir(wd):
         if f.endswith(".py"):
             try:
-                worker = Worker({"log": lambda message: log("scan", message)})
+                worker = Worker({
+                    "get_ddb": get_ddb,
+                    "log": lambda message: log("scan", message)
+                })
                 try:
                     description = await worker.examine(os.path.join(wd, f))
                 finally:
@@ -53,8 +56,9 @@ def _sync_explist(target, source):
 
 
 class Repository:
-    def __init__(self, backend, log_fn):
+    def __init__(self, backend, get_ddb_fn, log_fn):
         self.backend = backend
+        self.get_ddb_fn = get_ddb_fn
         self.log_fn = log_fn
 
         self.cur_rev = self.backend.get_head_rev()
@@ -77,7 +81,7 @@ async def scan(self, new_cur_rev=None):
             wd, _ = self.backend.request_rev(new_cur_rev)
             self.backend.release_rev(self.cur_rev)
             self.cur_rev = new_cur_rev
-            new_explist = await _scan_experiments(wd, self.log_fn)
+            new_explist = await _scan_experiments(wd, self.get_ddb_fn, self.log_fn)
 
             _sync_explist(self.explist, new_explist)
         finally:

diff --git a/artiq/master/worker.py b/artiq/master/worker.py
@@ -244,7 +244,7 @@ async def examine(self, file, timeout=20.0):
         def register(class_name, name, arguments):
             r[class_name] = {"name": name, "arguments": arguments}
         self.register_experiment = register
-        await self._worker_action({"action": "examine",
-                                        "file": file}, timeout)
+        await self._worker_action({"action": "examine", "file": file},
+                                  timeout)
         del self.register_experiment
         return r
diff --git a/artiq/master/worker_db.py b/artiq/master/worker_db.py
@@ -136,6 +136,10 @@ def __init__(self, ddb, virtual_devices=dict()):
         self.virtual_devices = virtual_devices
         self.active_devices = OrderedDict()
 
+    def get_ddb(self):
+        """Returns the full contents of the device database."""
+        return self.ddb.get_ddb()
+
     def get(self, name):
         """Get the device driver or controller client corresponding to a
         device database entry."""

diff --git a/artiq/master/worker_impl.py b/artiq/master/worker_impl.py
@@ -63,12 +63,13 @@ def flush(self):
 
 
 class ParentDDB:
-    get = make_parent_action("get_device", "name", KeyError)
+    get_ddb = make_parent_action("get_ddb", "")
+    get = make_parent_action("get_device", "key", KeyError)
 
 
 class ParentPDB:
-    get = make_parent_action("get_parameter", "name", KeyError)
-    set = make_parent_action("set_parameter", "name value")
+    get = make_parent_action("get_parameter", "key", KeyError)
+    set = make_parent_action("set_parameter", "key value")
 
 
 update_rt_results = make_parent_action("update_rt_results", "mod")
@@ -121,7 +122,9 @@ def get_exp(file, class_name):
                                          "class_name name arguments")
 
 
-class DummyDMGR:
+class ExamineDMGR:
+    get_ddb = make_parent_action("get_ddb", "")
+
     def get(self, name):
         return None
 
@@ -207,7 +210,7 @@ def main():
                     f.close()
                 put_object({"action": "completed"})
             elif action == "examine":
-                examine(DummyDMGR(), DummyPDB(), ResultDB(), obj["file"])
+                examine(ExamineDMGR(), DummyPDB(), ResultDB(), obj["file"])
                 put_object({"action": "completed"})
             elif action == "terminate":
                 break

diff --git a/artiq/protocols/file_db.py b/artiq/protocols/file_db.py
@@ -13,19 +13,19 @@ def __init__(self, filename):
     def save(self):
         pyon.store_file(self.filename, self.data.read)
 
-    def get(self, name):
-        return self.data.read[name]
+    def get(self, key):
+        return self.data.read[key]
 
-    def set(self, name, value):
-        self.data[name] = value
+    def set(self, key, value):
+        self.data[key] = value
         self.save()
         timestamp = time()
         for hook in self.hooks:
-            hook.set(timestamp, name, value)
+            hook.set(timestamp, key, value)
 
-    def delete(self, name):
-        del self.data[name]
+    def delete(self, key):
+        del self.data[key]
         self.save()
         timestamp = time()
         for hook in self.hooks:
-            hook.delete(timestamp, name)
+            hook.delete(timestamp, key)
diff --git a/examples/master/repository/dds_setter.py b/examples/master/repository/dds_setter.py
@@ -0,0 +1,25 @@
+from operator import itemgetter
+
+from artiq import *
+
+
+class DDSSetter(EnvExperiment):
+    """DDS Setter"""
+    def build(self):
+        self.dds = dict()
+
+        ddb = self.get_ddb()
+        for k, v in sorted(ddb.items(), key=itemgetter(0)):
+            if (isinstance(v, dict)
+                    and v["type"] == "local"
+                    and v["module"] == "artiq.coredevice.dds"
+                    and v["class"] in {"AD9858", "AD9914"}):
+                self.dds[k] = {
+                    "driver": self.get_device(k),
+                    "frequency": self.get_argument("{}_frequency".format(k),
+                                                   NumberValue())
+                }
+
+    def run(self):
+        for k, v in self.dds.items():
+            v["driver"].set(v["frequency"])