AD9959 DDS Sweeper

labscript_devices/AD9959DDSSweeper/blacs_tabs.py

@@ -13,12 +13,20 @@
 
 from blacs.device_base_class import DeviceTab
 
+
 class AD9959DDSSweeperTab(DeviceTab):
     def initialise_GUI(self):
+        device = self.settings['connection_table'].find_by_name(self.device_name)
+
+        ref_clk_freq = device.properties['ref_clock_frequency']
+        pll_mult = device.properties['pll_mult']
+        self.com_port = device.properties['com_port']
+
+        max_freq = 0.5 * (ref_clk_freq * pll_mult)
         # Capabilities
         self.base_units =    {'freq':'Hz',          'amp':'Arb',   'phase':'Degrees'}
         self.base_min =      {'freq':0.0,           'amp':0,       'phase':0}
-        self.base_max =      {'freq':250.0*10.0**6, 'amp':1,       'phase':360}
+        self.base_max =      {'freq':max_freq,      'amp':1,       'phase':360}
         self.base_step =     {'freq':10**6,         'amp':1/1023., 'phase':1}
         self.base_decimals = {'freq':1,             'amp':4,       'phase':3}
         self.num_DDS = 4
@@ -38,10 +46,6 @@ def initialise_GUI(self):
         dds_widgets, _, _ = self.auto_create_widgets()
         self.auto_place_widgets(('DDS Outputs', dds_widgets))
 
-        device = self.settings['connection_table'].find_by_name(self.device_name)
-
-        self.com_port = device.properties['com_port']
-
         self.supports_remote_value_check(False)
         self.supports_smart_programming(True)
 

labscript_devices/AD9959DDSSweeper/blacs_workers.py

@@ -296,7 +296,7 @@ def program_manual(self, values):
             values (dict): dictionary of dictionaries with keys of active DDS 
             channels, subkeys of ['freq', 'amp', 'phase']
         '''
-        # invalidate static cache
+        self.smart_cache = {'static_data' : None, 'dds_data' : None}
 
         for chan in values:
             chan_int = int(chan[8:])
@@ -368,19 +368,6 @@ def transition_to_buffered(self, device_name, h5file, initial_values, fresh):
                         'amp' : amp,
                         'phase' : phase,
                     }
-
-                else:
-                    self.logger.debug(f'Setting outputs using cache on chan: {chan}')
-                    self.intf.set_output(chan, cache_freq, cache_amp, cache_phase)
-                    self.final_values[f'channel {chan}'] = {
-                        'freq' : cache_freq * self.intf.tuning_words_to_SI['freq'],
-                        'amp' : cache_amp * self.intf.tuning_words_to_SI['amp'],
-                        'phase' : cache_phase * self.intf.tuning_words_to_SI['phase']
-                    }
-
-        if dds_data is None and stat_data is None:
-            self.logger.debug('No instructions to set')
-            return self.initial_values
 
         if dds_data is not None:
             self.logger.debug(f'Dynamic Data found')

labscript_devices/AD9959DDSSweeper/labscript_devices.py

@@ -54,7 +54,7 @@ class AD9959DDSSweeper(IntermediateDevice):
         }
     )
 
-    def __init__(self, name, parent_device, com_port,
+    def __init__(self, name, parent_device, com_port, dynamic_channels,
                  pico_board='pico1', sweep_mode=0,
                  ref_clock_external=0, ref_clock_frequency=125e6, pll_mult=4, **kwargs):
         '''Labscript device class for AD9959 eval board controlled by a Raspberry Pi Pico running the DDS Sweeper firmware (https://github.com/QTC-UMD/dds-sweeper).
@@ -67,6 +67,8 @@ def __init__(self, name, parent_device, com_port,
                 Pseudoclock clockline used to clock DDS parameter changes.
             com_port (str): COM port assigned to the AD9959DDSSweeper by the OS.
                 On Windows, takes the form of `COMd` where `d` is an integer.
+            dynamic_channels (int): number of dynamic DDS channels that will be added.
+                This must be specified in the constructor so that update rates can be calculated correctly.
             pico_board (str): The version of pico board used, pico1 or pico2.
             sweep_mode (int):
                 The DDS Sweeper firmware can set the DDS outputs in either fixed steps or sweeps of the amplitude, frequency, or phase.
@@ -75,7 +77,6 @@ def __init__(self, name, parent_device, com_port,
             ref_clock_frequency (float): Frequency of the reference clock. If ref_clock_external is 0, the Pi Pico system clock will be set to this frequency. If the PLL is used, ref_clock_frequency * pll_mult must be between 100 MHz and 500 MHz. If the PLL is not used, ref_clock_frequency must be less than 500 MHz.
             pll_mult: the AD9959 has a PLL to multiply the reference clock frequency. Allowed values are 1 or 4-20.
         '''
-        IntermediateDevice.__init__(self, name, parent_device, **kwargs)
         self.BLACS_connection = '%s' % com_port
 
         if pico_board in self.allowed_boards:
@@ -97,27 +98,55 @@ def __init__(self, name, parent_device, com_port,
         self.dds_clock = ref_clock_frequency * pll_mult
         self.clk_scale = 2**32 / self.dds_clock
 
+        # Store number of dynamic channels
+        if dynamic_channels > 4:
+            raise ValueError('AD9959DDSSweeper only supports up to 4 total channels, dynamic channels must be 4 or less.')
+        self.dynamic_channels = dynamic_channels
+
+        IntermediateDevice.__init__(self, name, parent_device, **kwargs)
+
     @property
     def clock_limit(self):
         '''Dynamically computs clock limit based off of number of dynamic 
         channels and reference clock frequency.'''
-        num_dyn_chans = sum(isinstance(child, DDS) for child in self.child_devices)
-        if num_dyn_chans == 0:
-            # Set to worst case 
-            # 4 channels, step mode, default 125 MHz pico ref clk
-            return 100000
+        if self.dynamic_channels == 0:
+            # No clock limit
+            return None
 
         if self.sweep_mode > 0:
             mode = 'sweeps'
         else:
             mode = 'steps'
         try:
-            cycles_per_instruction = self.cycles_per_instruction_map[mode][num_dyn_chans - 1]
+            cycles_per_instruction = self.cycles_per_instruction_map[mode][self.dynamic_channels - 1]
         except (KeyError, IndexError):
-            raise LabscriptError(f'Unsupported mode or number of channels: {mode}, {num_dyn_chans}')        
+            raise LabscriptError(f'Unsupported mode or number of channels: {mode}, {self.dynamic_channels}')
 
         return self.ref_clock_frequency / cycles_per_instruction
-
+
+    def add_device(self, device):
+        """Confirms channel specified is valid before adding
+
+        Validity checks include channel name and static/dynamic status.
+        Dynamic channels must be specified before static channels.
+        Args:
+            device(): Device to attach. Must be a DDS or a StaticDDS.
+                Allowed connections are a string of the form `channel X`.
+        """
+        conn = device.connection
+        chan = int(conn.split('channel ')[-1])
+
+        if isinstance(device, StaticDDS):
+            if chan < self.dynamic_channels:
+                raise LabscriptError(f'Channel {chan} configured as dynamic channel, can not create StaticDDS.')
+            elif chan >= 4:
+                raise LabscriptError('AD9959DDSSweeper only supports 4 channels')
+        elif isinstance(device, DDS):
+            if chan >= self.dynamic_channels:
+                raise LabscriptError(f'Channel {chan} not configured as dynamic channel, can not create DDS.')
+
+        super().add_device(device)
+
     def get_default_unit_conversion_classes(self, device):
         """Child devices call this during their __init__ (with themselves
         as the argument) to check if there are certain unit calibration