spirack 0.2.17__tar.gz → 0.2.19__tar.gz

{spirack-0.2.17 → spirack-0.2.19}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: spirack
-Version: 0.2.17
+Version: 0.2.19
 Summary: Drivers for the QuTech SPI-rack
-Home-page: https://github.com/mtiggelman/SPI-rack
-Author: Marijn Tiggelman
+Home-page: https://github.com/qutechdev/SPI-rack
+Author: QuTech Electronics Team
 Author-email: qutechdev@gmail.com
 License: MIT
 Keywords: SPI,Qcodes,SPI-rack,QuTech,TU Delft,SPI

{spirack-0.2.17 → spirack-0.2.19}/setup.py

@@ -30,8 +30,8 @@ setup(name='spirack',
       description='Drivers for the QuTech SPI-rack',
       long_description=long_description,
       long_description_content_type="text/markdown",
-      url='https://github.com/mtiggelman/SPI-rack',
-      author='Marijn Tiggelman',
+      url='https://github.com/qutechdev/SPI-rack',
+      author='QuTech Electronics Team',
       author_email='qutechdev@gmail.com',
       license='MIT',
       packages=['spirack'],

{spirack-0.2.17 → spirack-0.2.19}/spirack/D5a_module.py

@@ -44,8 +44,8 @@ class D5a_module(object):
 
     # DAC software span constants
     range_4V_uni = 0
-    range_8V_uni = 1
     range_4V_bi = 2
+    range_8V_uni = 1
     range_8V_bi = 3
     range_2V_bi = 4
 
@@ -254,34 +254,6 @@ class D5a_module(object):
         # send data via controller
         self.spi_rack.write_data(self.module, DAC_ic, LTC2758_MODE, LTC2758_SPEED, data)
 
-    def update_multiple_this_is_a_test(self, DAC1, DAC2):
-        """Updates the output of the DAC to the written value
-
-        Updates the output of the DAC when called. Neccessary after using
-        change_value or change_span when wanting to update the DAC.
-
-        Args:
-            DAC (int: 0-15): DAC inside the module of which to update
-        """
-        if DAC not in range(self._num_dacs):
-            raise ValueError('D5a module {} [update]: DAC {} does not exist.'.format(self.module, DAC))
-
-        # Determine which DAC in IC by checking even/uneven
-        address = (DAC%2)<<1
-
-        # Update DAC to given span/value
-        command = 0b0100
-        b1 = (command<<4) | address
-        b2 = 0
-        b3 = 0
-        b4 = 0
-        data = bytearray([b1, b2, b3, b4])
-
-        # Determine in which IC the DAC is, for SPI chip select
-        DAC_ic = DAC//2
-        # send data via controller
-        self.spi_rack.write_data(self.module, DAC_ic, LTC2758_MODE, LTC2758_SPEED, data)
-
     def set_voltage(self, DAC, voltage):
         """Sets the DAC output voltage and updates the DAC output
 
@@ -346,7 +318,7 @@ class D5a_module(object):
     def get_stepsize(self, DAC):
         """Returns the smallest voltage step for a given DAC
 
-        Calculates and returns the smalles voltage step of the DAC for the
+        Calculates and returns the smallest voltage step of the DAC for the
         set span. Voltage steps smaller than this will not change the DAC value.
         Recommended to only step the DAC in multiples of this value, as otherwise
         steps might not behave as expected.
@@ -360,13 +332,15 @@ class D5a_module(object):
             raise ValueError('D5a module {} [get_stepsize]: DAC {} does not exist.'.format(self.module, DAC))
 
         if self.span[DAC] == D5a_module.range_4V_uni:
-            return 4.0/(2**18)
-        if self.span[DAC] == (D5a_module.range_4V_bi or D5a_module.range_8V_uni):
-            return 8.0/(2**18)
-        if self.span[DAC] == D5a_module.range_8V_bi:
-            return 16.0/(2**18)
-        if self.span[DAC] == D5a_module.range_2V_bi:
-            return 4.0/(2**18)
+            return 4.0 / (2 ** 18)
+        elif self.span[DAC] == D5a_module.range_4V_bi or self.span[DAC] == D5a_module.range_8V_uni:
+            return 8.0 / (2 ** 18)
+        elif self.span[DAC] == D5a_module.range_8V_bi:
+            return 16.0 / (2 ** 18)
+        elif self.span[DAC] == D5a_module.range_2V_bi:
+            return 4.0 / (2 ** 18)
+        else:
+            raise ValueError(f"Span for DAC {DAC} not set to valid value. Span currently set to {self.span[DAC]}.")
 
     def get_settings(self, DAC):
         """Reads current DAC settings
@@ -388,14 +362,14 @@ class D5a_module(object):
         DAC_ic = DAC//2
 
         # Read code command
-        command = 0b1101                                       # 0xd
+        command = 0b1101
         data = bytearray([(command<<4) | address, 0, 0, 0])
 
         code_data = self.spi_rack.read_data(self.module, DAC_ic, LTC2758_MODE, LTC2758_RD_SPEED, data)
         code = (code_data[1]<<10) | (code_data[2]<<2) | (code_data[3]>>6)
 
         # Read span command
-        command = 0b1100                                       # 0xc
+        command = 0b1100
         data = bytearray([(command<<4) | address, 0, 0, 0])
 
         span_data = self.spi_rack.read_data(self.module, DAC_ic, LTC2758_MODE, LTC2758_RD_SPEED, data)
@@ -416,5 +390,43 @@ class D5a_module(object):
 
         self.voltages[DAC] = voltage
         self.span[DAC] = span
-        
+
         return [voltage, span]
+
+    def is_D5a_communicating(self):
+        """Checks proper communication with the D5a.
+        """
+        DAC = 0   # DAC 0 is expected available for any D5a version (any number of DACs)
+
+        # Determine which DAC in IC by checking even/uneven
+        address = (DAC%2)<<1
+        # Determine in which IC the DAC is, for SPI chip select
+        DAC_ic = DAC//2
+
+        # Read initial value of input code resgiter.
+        # Any value could be legal and user-given
+    
+        # Command to read input code register
+        command = 0b1011
+        data = bytearray([(command<<4) | address, 0, 0, 0])
+        orig_data_rd = self.spi_rack.read_data(self.module, DAC_ic, LTC2758_MODE, LTC2758_RD_SPEED, data)
+        orig_value = (orig_data_rd[1]<<10) | (orig_data_rd[2]<<2) | (orig_data_rd[3]>>6)
+
+        # Write a new value and read back to check
+        # First write to the input code register
+        test_value = 177033                           # Arbitrary, 0b10 1011 0011 1000 1001
+        self.change_value(DAC, test_value)
+        # Now read back the updated value
+        command = 0b1011
+        data = bytearray([(command<<4) | address, 0, 0, 0])
+        new_data_rd = self.spi_rack.read_data(self.module, DAC_ic, LTC2758_MODE, LTC2758_RD_SPEED, data)
+        new_value = (new_data_rd[1]<<10) | (new_data_rd[2]<<2) | (new_data_rd[3]>>6)
+    
+        # Write again the original value
+        self.change_value(DAC, orig_value)
+    
+        # Check and return the result
+        if (test_value != new_value):
+            return 0
+        else:
+            return 1

{spirack-0.2.17 → spirack-0.2.19}/spirack/M2p_module.py

@@ -1,10 +1,6 @@
 import numpy as np
-from spi_rack import *
-from chip_mode import BICPINS_MODE, BICPINS_SPEED
-from time import sleep
+from .chip_mode import BICPINS_MODE, BICPINS_SPEED
 
-#global values
-gainlist = [1,10,100,1000,10000]
 
 class M2p_module(object):
     """M2p module interface class
@@ -22,9 +18,20 @@ class M2p_module(object):
         remote_settings: contains a byte with the remote settigns (IQ gain and filter)
     """
 
+    #allowed gain values
+    gainlist = [1,10,100,1000,10000]
+
+
     def __init__(self, spi_rack, module):
         self.module = module
         self.spi_rack = spi_rack
+        
+        # Upon start-up copy the existing local settings 
+        # and set module to local operation
+        initial_gain = self.get_gain_local()
+        initial_coupling = self.get_coupling_local()
+        self.remote_set_gain_and_coupling(gain = initial_gain, coupling = initial_coupling)
+        self.set_local()
 
     def set_remote(self):
         """
@@ -35,29 +42,33 @@ class M2p_module(object):
         # check if module is already in remote mode, if so do nothing
         set_mode = self.get_operating_mode()
         if (set_mode == 1):
-            print("Already in remotemode, no mode change made" )
+            print("Already in remote mode. No mode change made" )
             return #exit do nothing
        
-        # Get gainswitch and coupleswitcht setting
-        gain = self.get_gainswitch()
-        couple = self.get_couple_switchsetting()
-        self.set_gain(gain,couple)
+        # Get the local gain and coupling settings (from the front panel) ... 
+        gain = self.get_gain_local()
+        couple = self.get_coupling_local()
+        # ... and use them initially when switching to remote mode
+        self.remote_set_gain_and_coupling(gain,couple)
         
         dummy_data = bytearray([0,0])
         r_data = bytearray([0,0])
         r_data = self.spi_rack.read_data(self.module, 6, BICPINS_MODE, BICPINS_SPEED, dummy_data)
         
-        #set remote bit keep the others
-        commandlow  = r_data[0]|0b10000000
-        commandhigh = r_data[1]|0b10000000
-        s_data = bytearray([commandhigh, commandlow,])
-        self.spi_rack.write_data(self.module, 5, BICPINS_MODE, BICPINS_SPEED, s_data)
-        self.set_gain(gain,couple)
+        #set remote bit to 1 (keeping other setings)
+        high_byte  = r_data[0]|0b10000000
+        #low_byte = r_data[1]|0b10000000
+        low_byte = r_data[1]
+        
+        #write new settings (with high remote bit)
+        w_data = bytearray([high_byte,low_byte])
+        self.spi_rack.write_data(self.module, 5, BICPINS_MODE, BICPINS_SPEED, w_data)
+        self.remote_set_gain_and_coupling(gain,couple)
          
     def set_local(self):
         """
-        Set the module to local mode. The gain- and coupling settings reverts to the frontpanel switch setting.
-        If the remotely set gain is different from the front panel setting there migh be a jump in output due to a differnce in gain.
+        Set the module to local mode. The gain- and coupling settings revert to the front-panel switch setting.
+        If the remotely set gain is different from the front panel setting there might be a jump in output due to a differnce in gain.
         """
 
         # read last high and low byte setting
@@ -65,209 +76,222 @@ class M2p_module(object):
         r_data = bytearray([0,0])
         r_data = self.spi_rack.read_data(self.module, 6, BICPINS_MODE, BICPINS_SPEED, dummy_data)
         
-        #reset remote bit keep the others
-        commandlow  = r_data[0] & 0b01111111
-        commandhigh = r_data[1] & 0b01111111  
+        #reset remote bit to 0 (keeping other setings)
+        high_byte  = r_data[0] & 0b01111111
+        #low_byte = r_data[1] & 0b01111111
+        low_byte = r_data[1]
 
-        #write settings with reset remote bit
-        s_data = bytearray([commandlow,commandhigh])
-        self.spi_rack.write_data(self.module, 5, BICPINS_MODE, BICPINS_SPEED, s_data)
+        #write new settings (with 0-set remote bit)
+        w_data = bytearray([high_byte,low_byte])
+        self.spi_rack.write_data(self.module, 5, BICPINS_MODE, BICPINS_SPEED, w_data)
 
-    def set_gain(self, gainlevel, couplemode):
+    def remote_set_gain_and_coupling(self, gain, coupling):
         """
         Set gain and coupling mode 
         Posible gain settings : 1, 10, 100, 1000, 10.000
-        Coupling DC=0 AC=1
+        Coupling 'DC'=1 'AC'=0
+        
         gainlevel and couplemode parameters are checked for valid values.
         When one of the parameters is out of range or otherwise invalid no change in settings will be made
-        The remote/local setting will not ne changed, so if current setting is local NO CHANGE in gain or coupling will happen.
+        
+        The remote/local selection is maintained, so under a 'local' setting NO CHANGE in gain or coupling will happen.
         But the last written values can be readback
         """
         
-        # check for valid gain and couple values       
-        if self.gainvalid(gainlevel) == False or self.couplemodevalid(couplemode) == False:
-            print("Invalid gain or couplemode, no settings changed" )
+        # check for valid gain and coupling values       
+        if self._is_gain_valid(gain) == False or self._is_couplemode_valid(coupling) == False:
+            print("Invalid gain or coupling, no settings changed" )
             return
         
-        # read high byte for remote bit and couple bit  
+        # read to preserve the value of the high byte for the upcoming 'write'
         dummy_data = bytearray([0,0])
         r_data = bytearray([0,0])
         r_data = self.spi_rack.read_data(self.module, 6, BICPINS_MODE, BICPINS_SPEED, dummy_data)
-        commandhigh = r_data[1]
+        high_byte = r_data[0]
        
-        #commandhigh = 0b10000001
-        # set gain bits
-        if gainlevel == 1:
-            commandlow  = 0b10010000
-        if gainlevel == 10:
-            commandlow  = 0b10010001
-        if gainlevel == 100:
-            commandlow  = 0b10010010
-        if gainlevel == 1000:
-            commandlow  = 0b10010110
-        if gainlevel == 10000:
-            commandlow  = 0b10011010
+        # config gain bits
+        if gain == 1:
+            low_byte  = 0b10010000
+        elif gain == 10:
+            low_byte  = 0b10010001
+        elif gain == 100:
+            low_byte  = 0b10010010
+        elif gain == 1000:
+            low_byte  = 0b10010110
+        else:
+            # gain == 10000:
+            low_byte  = 0b10011010
        
-        # (re)setcouple bit while keeping remote bit setting
-        if couplemode == 0:
-            commandlow = commandlow | 0b00010000  # DC
+        # config coupling bit (while keeping other settings)
+        if coupling == 'DC':
+            low_byte = low_byte | 0b00010000  # For DC, set control bit to 1
         else:
-            commandlow = commandlow & 0b11101111  # AC
+            low_byte = low_byte & 0b11101111  # For AC, set control bit to 0
 
-        s_data = bytearray([commandhigh,commandlow])
-        self.spi_rack.write_data(self.module, 5, BICPINS_MODE, BICPINS_SPEED, s_data)
+        w_data = bytearray([high_byte,low_byte])
+        self.spi_rack.write_data(self.module, 5, BICPINS_MODE, BICPINS_SPEED, w_data)
         
-    def gainvalid(self, gain):
+    def _is_gain_valid(self, gain):
         # Check gain parameter for valid values
         # return True (valid) or False (invalid)
-        if gain in gainlist:
+        if gain in self.gainlist:
             return True
         else:
             return False
             
-    def couplemodevalid(self, couplemode):
+    def _is_couplemode_valid(self, couplemode):
         # Check couple parameter for valid values
         # return True (valid) or False (invalid)
-        if couplemode <0 or couplemode>1:
-            return False
-        else:
+        if couplemode in ['AC','DC']:
             return True
+        else:
+            return False
     
     def get_operating_mode(self):
         """
         read the operating status of the module.
-        Either 1 = Remote mode or 0 = local mode
+        Modes can be 'remote' or 'local'
         """
     
-        mode = 0
+        mode = ''
         dummy_data = bytearray([0,0])
         r_data = bytearray([0,0])
         r_data = self.spi_rack.read_data(self.module, 6, BICPINS_MODE, BICPINS_SPEED, dummy_data)
        
         if r_data[0] & 0b10000000:
-            mode = 1
+            mode = 'remote'
         else:
-            mode = 0
+            mode = 'local'
       
         return(mode)
 
-    def get_lastgainset(self):
+    def get_gain_setting(self):
         """
         Get lastgain switch setting command.
         This in NOT the same as the gain settings of the switch panel!
         This is the last gain set in remote mode.
-        posible results: 1, 10, 100, 1000, 10000
+        Posible results: 1, 10, 100, 1000, 10000
         """
-        commandhigh = 0b00000000
-        commandlow = 0b00000000
-        s_data = bytearray([commandhigh, commandlow])
+        if self.get_operating_mode()=='local':
+            return self.get_gain_local()
+        else:
+            return self.get_gain_remote()
+
+    def get_gain_remote(self):
+        s_data = bytearray([0, 0])
         r_data = self.spi_rack.read_data(self.module, 6, BICPINS_MODE, BICPINS_SPEED, s_data)
         gain = -1
         if r_data[1] & 0b00001111 == 0:
             gain = 1
-        if r_data[1] & 0b00000001 == 0b00000001:
+        if r_data[1] & 0b00001111 == 0b00000001:
             gain = 10
-        if r_data[1] & 0b00000010 == 0b00000010 :
+        if r_data[1] & 0b00001111 == 0b00000010:
             gain = 100
-        if r_data[1] & 0b00000110 == 0b00000110:
+        if r_data[1] & 0b00001111 == 0b00000110:
             gain = 1000
-        if r_data[1] & 0b00001010 == 0b00001010:
+        if r_data[1] & 0b00001111 == 0b00001010:
             gain = 10000
         return (gain)
 
 
-    def get_gainswitch(self):
+    def get_gain_local(self):
         """
-        Get the frontpanel gain switch setting.
-        posible results: 1, 10, 100, 1000, 10000
+        Get the front-panel gain switch setting.
+        Posible results: 1, 10, 100, 1000, 10000
         """
-        commandhigh = 0b00000000
-        commandlow = 0b00000000
-        s_data = bytearray([commandhigh, commandlow])
+        s_data = bytearray([0,0])
         r_data = self.spi_rack.read_data(self.module, 4, BICPINS_MODE, BICPINS_SPEED, s_data)
 
         gain = -1
         if r_data[1] & 0b00001111 == 0:
             gain = 1
-        if r_data[1] & 0b00000001 == 0b00000001:
+        elif r_data[1] & 0b00001111 == 0b00000001:
             gain = 10
-        if r_data[1] & 0b00000010 == 0b00000010 :
+        elif r_data[1] & 0b00001111 == 0b00000010:
             gain = 100
-        if r_data[1] & 0b00000110 == 0b00000110:
+        elif r_data[1] & 0b00001111 == 0b00000110:
             gain = 1000
-        if r_data[1] & 0b00001010 == 0b00001010:
+        elif r_data[1] & 0b00001111 == 0b00001010:
             gain = 10000
 
         return (gain)
 
-    def get_lastcouple_switchsetting(self):
+    def get_coupling_setting(self):
         """
          Get the last frontpanel couple mode (AC/DC) switch setting command.
          This in NOT the same as the couple mode settings on the front panel!
-         posible results: 0 = DC 1=AC
+         posible results: 'DC'=1 AC='0'
         """
+        if self.get_operating_mode()=='local':
+            return self.get_coupling_local()
+        else:
+            return self.get_coupling_remote()
+        
+    def get_coupling_remote(self):
         dummy_data = bytearray([0,0])
         r_data = self.spi_rack.read_data(self.module, 6, BICPINS_MODE, BICPINS_SPEED, dummy_data)
         mode = -1
         if r_data[1] & 0b00010000:
-            mode = 1
+            mode = 'DC'
         else:
-            mode = 0
+            mode = 'AC'
         return (mode)
         
-    def get_couple_switchsetting(self):
+    def get_coupling_local(self):
         """
          Get the frontpanel couple mode (AC/DC) switch setting.
-         posible results: 0 = DC 1=AC
+         posible results: 'DC'=1 AC='0'
         """
         dummy_data = bytearray([0,0])
         r_data = self.spi_rack.read_data(self.module, 4, BICPINS_MODE, BICPINS_SPEED, dummy_data)
         mode = -1
         if r_data[1] & 0b00010000:
-            mode = 1
+            mode = 'DC'
         else:
-            mode = 0
+            mode = 'AC'
         return (mode)
-       
-    def get_clipped_latched(self):
-        # Return:
-        # 0 if none clipped
-        # 1 if pos clipped
-        # 2 if neg clipped
-        # 3 if pos and neg clipped (is posible when clipped is latched)
-        clipped = -1
-        dummy_data = bytearray([0,0])
-        r_data = self.spi_rack.read_data(self.module, 7, BICPINS_MODE, BICPINS_SPEED, dummy_data)
- 
-        if (((r_data[0] & 0b01000000) == 0) & ((r_data[0] & 0b10000000) == 0)):
-                clipped = 0
-        elif (r_data[0] & 0b11000000 == 0b11000000):
-                clipped = 3
-        elif (r_data[0] & 0b01000000):
-                clipped = 2
-        elif (r_data[0] & 0b10000000):
-                clipped = 1
-
-        return (clipped)
 
     def get_clipped_unlatched(self):
+        # Inverted polarity
         # Return:
         # 0 if none clipped
         # 1 if pos clipped
         # 2 if neg clipped
         # 3 if pos and neg clipped (is posible when clipped is latched)
         
-        clipped = -1
+        clipped = ''
         dummy_data = bytearray([0,0])
-        r_data = self.spi_rack.read_data(self.module, 7, BICPINS_MODE, BICPINS_SPEED, dummy_data)
+        r_data = self.spi_rack.read_data(self.module, 3, BICPINS_MODE, BICPINS_SPEED, dummy_data)
 
         if (r_data[0] & 0b00110000) == 0b00110000:
-            clipped = 0
+            clipped = 'not clipped'
         elif (((r_data[0] & 0b00010000) == 0) & ((r_data[0] & 0b00100000) == 0)):
-            clipped = 3
+            clipped = 'pos and neg clipped'
         elif (r_data[0] & 0b00010000) == 0:
-            clipped = 1
+            clipped = 'pos clipped'
         elif (r_data[0] & 0b00100000) == 0:
-            clipped = 2                
+            clipped = 'neg clipped'
+
+        return (clipped)
+       
+    def get_clipped_latched(self):
+        # Regular polarity (non-inverted)
+        # Return:
+        # 0 if none clipped
+        # 1 if pos clipped
+        # 2 if neg clipped
+        # 3 if pos and neg clipped (is posible when clipped is latched)
+        clipped = ''
+        dummy_data = bytearray([0,0])
+        r_data = self.spi_rack.read_data(self.module, 4, BICPINS_MODE, BICPINS_SPEED, dummy_data)
+ 
+        if (((r_data[0] & 0b01000000) == 0) & ((r_data[0] & 0b10000000) == 0)):
+                clipped = 'not clipped'
+        elif (r_data[0] & 0b11000000 == 0b11000000):
+                clipped = 'pos and neg clipped'
+        elif (r_data[0] & 0b01000000):
+                clipped = 'neg clipped'
+        elif (r_data[0] & 0b10000000):
+                clipped = 'pos clipped'
 
         return (clipped)

{spirack-0.2.17 → spirack-0.2.19}/spirack/spi_rack.py

@@ -381,3 +381,11 @@ class SPI_rack(serial.Serial):
 
             version = self.readline().decode('utf-8')
             return version[:-1]
+
+    def is_C1b_communicating(self):
+        """
+        """
+        if (self.get_battery()==[0.0,0.0]) and (self.get_temperature()==0.0):
+            if (self.get_battery()==[0.0,0.0]) and (self.get_temperature()==0.0):
+                return 0
+        return 1

spirack-0.2.19/spirack/version.py

@@ -0,0 +1 @@
+__version__ = '0.2.19'

{spirack-0.2.17 → spirack-0.2.19}/spirack.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: spirack
-Version: 0.2.17
+Version: 0.2.19
 Summary: Drivers for the QuTech SPI-rack
-Home-page: https://github.com/mtiggelman/SPI-rack
-Author: Marijn Tiggelman
+Home-page: https://github.com/qutechdev/SPI-rack
+Author: QuTech Electronics Team
 Author-email: qutechdev@gmail.com
 License: MIT
 Keywords: SPI,Qcodes,SPI-rack,QuTech,TU Delft,SPI

spirack-0.2.17/spirack/version.py

@@ -1 +0,0 @@
-__version__ = '0.2.17'