Add frequency reference control and general cleanup and docs.

Author: dihm

Diff for: docs/source/devices.rst

@@ -59,6 +59,7 @@ These devices cover various frequency sources that provide either hardware-timed
 
    devices/novatechDDS9m
    devices/phasematrixquicksyn
+   devices/windfreak
 
 
 Miscellaneous

Diff for: docs/source/devices/windfreak.rst

@@ -0,0 +1,120 @@
+Windfreak Synth
+===============
+
+This labscript device controls the Windfreak SynthHD and SynthHD Pro signal generators.
+
+At present only static frequencies and DDS gating is supported.
+This driver also supports external referencing.
+
+
+Installation
+~~~~~~~~~~~~
+
+This driver requires the `windfreak` package available on pip.
+If using a version of Windows older than 10,
+you will need to install the usb driver available from windfreak.
+
+Usage
+~~~~~
+
+Below is a basic script using the driver.
+
+.. code-block:: python
+
+    from labscript import *
+
+    from labscript_devices.PrawnBlaster.labscript_devices import PrawnBlaster
+    from labscript_devices.Windfreak.labscript_devices import WindfreakSynthHDPro
+
+    PrawnBlaster(name='prawn', com_port='COM6', num_pseudoclocks=1)
+
+    WindfreakSynthHDPro(name='WF', com_port="COM7")
+
+    StaticDDS('WF_A', WF, 'channel 0')
+
+    if __name__ == '__main__':
+
+        WF.enable_output(0) # enables channel A (0)
+        WF_A.setfreq(10, units = 'GHz')
+        WF_A.setamp(-24) # in dBm
+        WF_A.setphase(45) # in deg
+
+        start(0)
+        stop(1)
+
+This driver supports the DDS Gate feature which can provide dynamic TTL control of the outputs.
+This is done by enabling the `rf_enable` triggering mode on the synth,
+as well as setting the correct `digital_gate` on the output.
+Note that both outputs will be toggled on/off when using `rf_enable` modulation.
+
+It also supports external referencing of the device.
+The below script uses external clocking and gating features.
+
+.. code-block:: python
+
+   from labscript import *
+
+   from labscript_devices.PrawnBlaster.labscript_devices import PrawnBlaster
+   from labscript_devices.Windfreak.labscript_devices import WindfreakSynthHDPro
+   from labscript_devices.NI_DAQmx.Models.NI_USB_6343 import NI_USB_6343
+
+   PrawnBlaster(name='prawn', com_port='COM6', num_pseudoclocks=1)
+
+   NI_USB_6343(name='ni_6343', parent_device=prawn.clocklines[0],
+               clock_terminal='/ni_usb_6343/PFI0',
+               MAX_name='ni_usb_6343',
+               )
+
+   WindfreakSynthHDPro(name='WF', com_port="COM7",
+                       trigger_mode='rf enable',
+                       reference_mode='external',
+                       reference_frequency=10e6)
+
+   StaticDDS('WF_A', WF, 'channel 0',
+             digital_gate={'device':ni_6343, 'connection':'port0/line0'})
+
+   if __name__ == '__main__':
+
+      WF.enable_output(0) # enables channel A (0)
+      WF_A.setfreq(10, units = 'GHz')
+      WF_A.setamp(-24) # in dBm
+      WF_A.setphase(45) # in deg
+
+      t = 0
+      start(t)
+
+      # enable rf via digital gate for 1 ms at 10 ms
+      t = 10e-3
+      WF_A.enable(t)
+      t += 1e-3
+      WF_A.disable(t)
+
+      stop(t+1e-3)
+
+
+Detailed Documentation
+~~~~~~~~~~~~~~~~~~~~~~
+
+.. automodule:: labscript_devices.Windfreak
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
+
+.. automodule:: labscript_devices.Windfreak.labscript_devices
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
+
+.. automodule:: labscript_devices.Windfreak.blacs_tabs
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
+
+.. automodule:: labscript_devices.Windfreak.blacs_workers
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:

Diff for: labscript_devices/Windfreak/blacs_tabs.py

@@ -14,11 +14,11 @@
 from blacs.device_base_class import DeviceTab
 
 
-class WindfreakSynthTab(DeviceTab):
+class WindfreakSynthHDTab(DeviceTab):
 
     def __init__(self, *args, **kwargs):
         if not hasattr(self,'device_worker_class'):
-            self.device_worker_class = 'labscript_devices.Windfreak.blacs_workers.WindfreakSynthWorker'
+            self.device_worker_class = 'labscript_devices.Windfreak.blacs_workers.WindfreakSynthHDWorker'
         DeviceTab.__init__(self, *args, **kwargs)
 
     def initialise_GUI(self):
@@ -69,9 +69,13 @@ def initialise_workers(self):
         conn_obj = self.settings['connection_table'].find_by_name(self.device_name).properties
         self.com_port = conn_obj.get('com_port',None)
         self.trigger_mode = conn_obj.get('trigger_mode','disabled')
+        self.reference_mode = conn_obj['reference_mode']
+        self.reference_frequency = conn_obj['reference_frequency']
 
         self.create_worker('main_worker',self.device_worker_class,{'com_port':self.com_port,
                                                                    'allowed_chans':self.allowed_chans,
-                                                                   'trigger_mode':self.trigger_mode})
+                                                                   'trigger_mode':self.trigger_mode,
+                                                                   'reference_mode':self.reference_mode,
+                                                                   'reference_frequency':self.reference_frequency})
 
         self.primary_worker = 'main_worker'

Diff for: labscript_devices/Windfreak/blacs_workers.py

@@ -16,7 +16,7 @@
 import numpy as np
 
 
-class WindfreakSynthWorker(Worker):
+class WindfreakSynthHDWorker(Worker):
 
     def init(self):
         # hide import of 3rd-party library in here so docs don't need it
@@ -32,12 +32,41 @@ def init(self):
         # connect to synth
         self.synth = windfreak.SynthHD(self.com_port)
         self.valid_modes = self.synth.trigger_modes
+        self.valid_ref_modes = self.synth.reference_modes
+        # set reference mode
+        self.set_reference_mode(self.reference_mode, self.reference_frequency)
         # set trigger mode from connection_table_properties
         self.set_trigger_mode(self.trigger_mode)
 
         # populate smart chache
         self.smart_cache['STATIC_DATA'] = self.check_remote_values()
 
+    def set_reference_mode(self, mode, ext_freq):
+        """Sets the synth reference mode.
+        
+        Provides basic error checking that setting is valid.
+
+        Args:
+            mode (str): Valid reference modes are `external`, `internal 27mhz`
+                and `internal 10mhz`. If mode is external, ext_freq must be provided.
+            ext_freq (float): Frequency of external reference.
+                If using internal reference, pass `None`.
+
+        Raises:
+            ValueError: if `mode` is not a valid setting or `ext_ref` not provided
+                when using an external reference.
+        """
+
+        if mode == 'external' and ext_freq is None:
+            raise ValueError('Must specify external reference frequency')
+
+        if mode in self.valid_ref_modes:
+            self.synth.reference_mode = mode
+            if mode == 'external':
+                self.synth.reference_frequency = ext_freq
+        else:
+            raise ValueError(f'{mode} not in {self.valid_ref_modes}')
+
     def set_trigger_mode(self,mode):
         """Sets the synth trigger mode.
 
@@ -81,6 +110,16 @@ def program_manual(self, front_panel_values):
         return self.check_remote_values()
 
     def check_remote_value(self,channel,typ):
+        """Checks the remote value of a parameter for a channel.
+        
+        Args:
+            channel (int): Which channel to check. Must be 0 or 1.
+            typ (str): Which parameter to get. Must be `freq`, `amp`, `phase`
+                or `gate`.
+
+        Raises:
+            ValueError: If `typ` is not a valid parameter type for the channel.
+        """
 
         if typ == 'freq':
             return self.synth[channel].frequency
@@ -91,9 +130,21 @@ def check_remote_value(self,channel,typ):
         elif typ == 'gate':
             return self.synth[channel].rf_enable and self.synth[channel].pll_enable
         else:
-            raise ValueError(type)
+            raise ValueError(typ)
 
     def program_static_value(self,channel,typ,value):
+        """Program a value for the specified parameter of the channel.
+        
+        Args:
+            channel (int): Channel to program. Must be 0 or 1.
+            typ (str): Parameter to program. Must be `freq`, `amp`, `phase`,
+                or `gate`.
+            value (float or bool): Value to program. `gate` takes a boolean type,
+                all others take a float.
+
+        Raises:
+            ValueError: If requested parameter type is not valid.
+        """
 
         if typ == 'freq':
             self.synth[channel].frequency = value
@@ -104,11 +155,12 @@ def program_static_value(self,channel,typ,value):
         elif typ == 'gate':
             # windfreak API does not like np.bool_
             # convert to native python bool
-            if isinstance(value, np.bool_): value = value.item()
+            if isinstance(value, np.bool_):
+                value = value.item()
             self.synth[channel].rf_enable = value
             self.synth[channel].pll_enable = value
         else:
-            raise ValueError(type)
+            raise ValueError(typ)
 
     def transition_to_buffered(self, device_name, h5file, initial_values, fresh):
 
@@ -122,21 +174,20 @@ def transition_to_buffered(self, device_name, h5file, initial_values, fresh):
                 static_data = group['STATIC_DATA'][:][0]
 
         if static_data is not None:
-            data = static_data
-            if fresh or data != self.smart_cache['STATIC_DATA']:
-
-                # need to infer which channels are programming
-                num_chan = len(data)//len(self.subchnls)
-                channels = [int(name[-1]) for name in data.dtype.names[0:num_chan]]
-
-                for i in channels:
-                    for sub in self.subchnls:
-                        if initial_values[f'channel {i:d}'][sub] != data[sub+str(i)]:
-                            self.program_static_value(i,sub,data[sub+str(i)])
-                            # update smart cache to reflect programmed values
-                            self.smart_cache['STATIC_DATA'][f'channel {i:d}'][sub] = data[sub+str(i)]
-                            # update final values to reflect programmed values
-                            self.final_values[f'channel {i:d}'][sub] = data[sub+str(i)]
+
+            # need to infer which channels are programming
+            num_chan = len(static_data)//len(self.subchnls)
+            channels = [int(name[-1]) for name in static_data.dtype.names[0:num_chan]]
+
+            for i in channels:
+                for sub in self.subchnls:
+                    desired_value = static_data[sub+str(i)]
+                    if self.smart_cache['STATIC_DATA'][f'channel {i:d}'][sub] != desired_value or fresh:
+                        self.program_static_value(i,sub,desired_value)
+                        # update smart cache to reflect programmed values
+                        self.smart_cache['STATIC_DATA'][f'channel {i:d}'][sub] = desired_value
+                        # update final values to reflect programmed values
+                        self.final_values[f'channel {i:d}'][sub] = desired_value
 
         return self.final_values
 
@@ -161,5 +212,5 @@ def transition_to_manual(self,abort = False):
             # If we're aborting the run, reset to original value
             self.program_manual(self.initial_values)
         # If we're not aborting the run, stick with buffered value. Nothing to do really!
-        # return the current values in the device
+
         return True

Diff for: labscript_devices/Windfreak/labscript_devices.py

@@ -11,22 +11,22 @@
 #                                                                   #
 #####################################################################
 
-from labscript import LabscriptError, set_passed_properties, config, StaticDDS, IntermediateDevice, Device
+from labscript import LabscriptError, set_passed_properties, config, StaticDDS, Device
 from labscript_utils import dedent
 from labscript_utils.unitconversions.generic_frequency import FreqConversion
 
 import numpy as np
 
 
-class WindfreakSynth(Device):
-    description = 'Windfreak HDPro Synthesizer'
+class WindfreakSynthHD(Device):
+    description = 'Windfreak HD Synthesizer'
     allowed_children = [StaticDDS]
     # note, box labels 'A', 'B' map to programming channels 0, 1
     allowed_chans = [0, 1]
     enabled_chans = []
 
     # define output limitations for the SynthHDPro
-    freq_limits = (10e6, 24e9)  # set in Hz
+    freq_limits = (10e6, 15e9)  # set in Hz
     freq_res = 1  # number of sig digits after decimal
     amp_limits = (-40.0, 20.0)  # set in dBm
     amp_res = 2
@@ -44,27 +44,39 @@ class WindfreakSynth(Device):
             'phase_limits',
             'phase_res',
             'trigger_mode',
+            'reference_mode',
+            'reference_frequency',
         ]
     })
-    def __init__(self, name, com_port="", trigger_mode='disabled', **kwargs):
+    def __init__(self, name, com_port="", trigger_mode='disabled',
+                 reference_mode='internal 27mhz',
+                 reference_frequency=None, **kwargs):
         """Creates a Windfreak HDPro Synthesizer
 
         Args:
             name (str): python variable name to assign the device to.
             com_port (str): COM port connection string.
                 Must take the form of 'COM d', where d is an integer.
             trigger_mode (str): Trigger mode for the device to use.
-                Currently, labscript only directly programs 'rf enable',
+                Currently, labscript only directly supports `'rf enable'`,
                 via setting DDS gates.
                 labscript could correctly program other modes with some effort.
                 Other modes can be correctly programmed externally,
                 with the settings saved to EEPROM.
-                **kwargs: Keyword arguments passed to :obj:`labscript:labscript.Device.__init__`.
+            reference_mode (str): Frequency reference mode to use.
+                Valid options are 'external', 'internal 27mhz', and 'internal 10mhz'.
+                Default is 'internal 27mhz'.
+            reference_frequency (float): Reference frequency (in Hz)
+                when using an external frequency.
+                Valid values are between 10 and 100 MHz.
+            **kwargs: Keyword arguments passed to :obj:`labscript:labscript.Device.__init__`.
         """
 
         Device.__init__(self, name, None, com_port, **kwargs)
         self.BLACS_connection = com_port
         self.trigger_mode = trigger_mode
+        self.reference_mode = reference_mode
+        self.reference_frequency = reference_frequency
 
     def add_device(self, device):
         Device.add_device(self, device)
@@ -157,3 +169,15 @@ def enable_output(self, channel):
                 self.enabled_chans.append(channel)
         else:
             raise LabscriptError(f'Channel {channel} is not a valid option for {self.device.name}.')
+
+
+class WindfreakSynthHDPro(WindfreakSynthHD):
+    description = 'Windfreak HDPro Synthesizer'
+
+    # define output limitations for the SynthHDPro
+    freq_limits = (10e6, 24e9)  # set in Hz
+    freq_res = 1  # number of sig digits after decimal
+    amp_limits = (-40.0, 20.0)  # set in dBm
+    amp_res = 2
+    phase_limits = (0.0, 360.0)  # in deg
+    phase_res = 2