spirack 0.2.18__tar.gz → 0.2.20__tar.gz

{spirack-0.2.18 → spirack-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spirack
-Version: 0.2.18
+Version: 0.2.20
 Summary: Drivers for the QuTech SPI-rack
 Home-page: https://github.com/qutechdev/SPI-rack
 Author: QuTech Electronics Team

{spirack-0.2.18 → spirack-0.2.20}/spirack/D5a_module.py

@@ -44,8 +44,8 @@ class D5a_module(object):
 
     # DAC software span constants
     range_4V_uni = 0
-    range_4V_bi = 2
     range_8V_uni = 1
+    range_4V_bi = 2
     range_8V_bi = 3
     range_2V_bi = 4
 
@@ -67,7 +67,7 @@ class D5a_module(object):
         self.spi_rack = spi_rack
         self.module = module
         self._num_dacs = num_dacs
-        self.span = [np.nan]*self._num_dacs
+        self.spans = [np.nan]*self._num_dacs
         self.voltages = [np.nan]*self._num_dacs
 
         for i in range(self._num_dacs):
@@ -108,7 +108,7 @@ class D5a_module(object):
         if DAC not in range(self._num_dacs):
             raise ValueError('D5a module {} [change_span_update]: DAC {} does not exist.'.format(self.module, DAC))
 
-        self.span[DAC] = span
+        self.spans[DAC] = span
 
         # Determine which DAC in IC by checking even/uneven
         address = (DAC%2)<<1
@@ -130,7 +130,7 @@ class D5a_module(object):
         # The change of span will also cause a change in the actual output voltage
         # Make update to the voltages array to reflect that change
         new_settings = self.get_settings(DAC)       # read from actual hardware
-        self.span[DAC] = new_settings[0]            # update to the cached variables
+        self.voltages[DAC] = new_settings[0]        # update to the cached variables
 
     def change_span(self, DAC, span):
         """Changes the software span of selected DAC without update
@@ -148,7 +148,7 @@ class D5a_module(object):
         if DAC not in range(self._num_dacs):
             raise ValueError('D5a module {} [change_span]: DAC {} does not exist.'.format(self.module, DAC))
 
-        self.span[DAC] = span
+        self.spans[DAC] = span
 
         # Determine which DAC in IC by checking even/uneven
         address = (DAC%2)<<1
@@ -272,27 +272,27 @@ class D5a_module(object):
 
         step = self.get_stepsize(DAC)
 
-        if self.span[DAC] == D5a_module.range_4V_uni:
+        if self.spans[DAC] == D5a_module.range_4V_uni:
             bit_value = int(round(voltage / step))
             self.voltages[DAC] = bit_value * step
             maxV = 4.0
             minV = 0.0
-        elif self.span[DAC] == D5a_module.range_4V_bi:
+        elif self.spans[DAC] == D5a_module.range_4V_bi:
             bit_value = int(round((voltage + 4.0) / step))
             self.voltages[DAC] = (bit_value * step) - 4.0
             maxV = 4.0
             minV = -4.0
-        if self.span[DAC] == D5a_module.range_8V_uni:
+        if self.spans[DAC] == D5a_module.range_8V_uni:
             bit_value = int(round(voltage / step))
             self.voltages[DAC] = bit_value * step
             maxV = 8.0
             minV = 0.0
-        elif self.span[DAC] == D5a_module.range_8V_bi:
+        elif self.spans[DAC] == D5a_module.range_8V_bi:
             bit_value = int(round((voltage + 8.0) / step))
             self.voltages[DAC] = (bit_value * step) - 8.0
             maxV = 8.0
             minV = -8.0
-        elif self.span[DAC] == D5a_module.range_2V_bi:
+        elif self.spans[DAC] == D5a_module.range_2V_bi:
             bit_value = int(round((voltage + 2.0) / step))
             self.voltages[DAC] = (bit_value * step) - 2.0
             maxV = 2.0
@@ -331,16 +331,16 @@ class D5a_module(object):
         if DAC not in range(self._num_dacs):
             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)
-        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)
+        if self.spans[DAC] == D5a_module.range_4V_uni:
+            return 4.0/(2**18)
+        elif (self.spans[DAC] == D5a_module.range_4V_bi or self.spans[DAC] == D5a_module.range_8V_uni):
+            return 8.0/(2**18)
+        elif self.spans[DAC] == D5a_module.range_8V_bi:
+            return 16.0/(2**18)
+        elif self.spans[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]}.")
+            raise ValueError("Span for DAC ",DAC," is not a valid value. The span is currently set to ".self.span[DAC],".")
 
     def get_settings(self, DAC):
         """Reads current DAC settings
@@ -362,14 +362,14 @@ class D5a_module(object):
         DAC_ic = DAC//2
 
         # Read code command
-        command = 0b1101
+        command = 0b1101                                       # 0xd
         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
+        command = 0b1100                                       # 0xc
         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)
@@ -389,8 +389,8 @@ class D5a_module(object):
             raise ValueError("Span {} should not be used. Accepted values are: {}".format(span, [0, 1, 2, 3, 4]))
 
         self.voltages[DAC] = voltage
-        self.span[DAC] = span
-
+        self.spans[DAC] = span
+        
         return [voltage, span]
 
     def is_D5a_communicating(self):
@@ -429,4 +429,4 @@ class D5a_module(object):
         if (test_value != new_value):
             return 0
         else:
-            return 1
+            return 1

{spirack-0.2.18 → spirack-0.2.20}/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.20/spirack/version.py

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

{spirack-0.2.18 → spirack-0.2.20}/spirack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spirack
-Version: 0.2.18
+Version: 0.2.20
 Summary: Drivers for the QuTech SPI-rack
 Home-page: https://github.com/qutechdev/SPI-rack
 Author: QuTech Electronics Team

spirack-0.2.18/spirack/version.py

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