ohmpi.py

@@ -260,7 +260,7 @@ class OhmPi(object):
                 w.writeheader()
                 w.writerow(last_measurement)
 
-    def _compute_tx_volt(self, best_tx_injtime=0.1, strategy='vmax', tx_volt=5):
+    def _compute_tx_volt(self, best_tx_injtime=0.1, strategy='vmax', tx_volt=5, autogain=True):
         """Estimates best Tx voltage based on different strategies.
         At first a half-cycle is made for a short duration with a fixed
         known voltage. This gives us Iab and Rab. We also measure Vmn.
@@ -325,15 +325,16 @@ class OhmPi(object):
             self.DPS.write_register(0x0000, volt, 2)
             self.DPS.write_register(0x09, 1)  # DPS5005 on
             time.sleep(best_tx_injtime)  # inject for given tx time
-            # autogain
             self.ads_current = ads.ADS1115(self.i2c, gain=2 / 3, data_rate=860, address=self.ads_current_address)
             self.ads_voltage = ads.ADS1115(self.i2c, gain=2 / 3, data_rate=860, address=self.ads_voltage_address)
-            gain_current = self._gain_auto(AnalogIn(self.ads_current, ads.P0))
-            gain_voltage0 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P0))
-            gain_voltage2 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P2))
-            gain_voltage = np.min([gain_voltage0, gain_voltage2])  # TODO: separate gain for P0 and P2
-            self.ads_current = ads.ADS1115(self.i2c, gain=gain_current, data_rate=860, address=self.ads_current_address)
-            self.ads_voltage = ads.ADS1115(self.i2c, gain=gain_voltage, data_rate=860, address=self.ads_voltage_address)
+            # autogain
+            if autogain:
+                gain_current = self._gain_auto(AnalogIn(self.ads_current, ads.P0))
+                gain_voltage0 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P0))
+                gain_voltage2 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P2))
+                gain_voltage = np.min([gain_voltage0, gain_voltage2])  # TODO: separate gain for P0 and P2
+                self.ads_current = ads.ADS1115(self.i2c, gain=gain_current, data_rate=860, address=self.ads_current_address)
+                self.ads_voltage = ads.ADS1115(self.i2c, gain=gain_voltage, data_rate=860, address=self.ads_voltage_address)
             # we measure the voltage on both A0 and A2 to guess the polarity
             I = AnalogIn(self.ads_current, ads.P0).voltage * 1000. / 50 / self.r_shunt  # noqa measure current
             U0 = AnalogIn(self.ads_voltage, ads.P0).voltage * 1000.  # noqa measure voltage
@@ -366,15 +367,16 @@ class OhmPi(object):
                     self.DPS.write_register(0x09, 1)  # DPS5005 on
                     time.sleep(best_tx_injtime)  # inject for given tx time
                 self.DPS.write_register(0x0000, volt, 2)
-                # autogain
                 self.ads_current = ads.ADS1115(self.i2c, gain=2 / 3, data_rate=860, address=self.ads_current_address)
                 self.ads_voltage = ads.ADS1115(self.i2c, gain=2 / 3, data_rate=860, address=self.ads_voltage_address)
-                gain_current = self._gain_auto(AnalogIn(self.ads_current, ads.P0))
-                gain_voltage0 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P0))
-                gain_voltage2 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P2))
-                gain_voltage = np.min([gain_voltage0, gain_voltage2])  #TODO: separate gain for P0 and P2
-                self.ads_current = ads.ADS1115(self.i2c, gain=gain_current, data_rate=860, address=self.ads_current_address)
-                self.ads_voltage = ads.ADS1115(self.i2c, gain=gain_voltage, data_rate=860, address=self.ads_voltage_address)
+                # autogain
+                if autogain:
+                    gain_current = self._gain_auto(AnalogIn(self.ads_current, ads.P0))
+                    gain_voltage0 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P0))
+                    gain_voltage2 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P2))
+                    gain_voltage = np.min([gain_voltage0, gain_voltage2])  #TODO: separate gain for P0 and P2
+                    self.ads_current = ads.ADS1115(self.i2c, gain=gain_current, data_rate=860, address=self.ads_current_address)
+                    self.ads_voltage = ads.ADS1115(self.i2c, gain=gain_voltage, data_rate=860, address=self.ads_voltage_address)
                 # we measure the voltage on both A0 and A2 to guess the polarity
                 for i in range(10):
                     I = AnalogIn(self.ads_current, ads.P0).voltage * 1000. / 50 / self.r_shunt  # noqa measure current
@@ -437,16 +439,16 @@ class OhmPi(object):
                 if count==1:
                     self.DPS.write_register(0x09, 1)  # DPS5005 on
                 time.sleep(best_tx_injtime)  # inject for given tx time
-
-                # autogain
                 self.ads_current = ads.ADS1115(self.i2c, gain=2 / 3, data_rate=860, address=self.ads_current_address)
                 self.ads_voltage = ads.ADS1115(self.i2c, gain=2 / 3, data_rate=860, address=self.ads_voltage_address)
-                gain_current = self._gain_auto(AnalogIn(self.ads_current, ads.P0))
-                gain_voltage0 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P0))
-                gain_voltage2 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P2))
-                gain_voltage = np.min([gain_voltage0, gain_voltage2])  #TODO: separate gain for P0 and P2
-                self.ads_current = ads.ADS1115(self.i2c, gain=gain_current, data_rate=860, address=self.ads_current_address)
-                self.ads_voltage = ads.ADS1115(self.i2c, gain=gain_voltage, data_rate=860, address=self.ads_voltage_address)
+                # autogain
+                if autogain:
+                    gain_current = self._gain_auto(AnalogIn(self.ads_current, ads.P0))
+                    gain_voltage0 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P0))
+                    gain_voltage2 = self._gain_auto(AnalogIn(self.ads_voltage, ads.P2))
+                    gain_voltage = np.min([gain_voltage0, gain_voltage2])  #TODO: separate gain for P0 and P2
+                    self.ads_current = ads.ADS1115(self.i2c, gain=gain_current, data_rate=860, address=self.ads_current_address)
+                    self.ads_voltage = ads.ADS1115(self.i2c, gain=gain_voltage, data_rate=860, address=self.ads_voltage_address)
                 # we measure the voltage on both A0 and A2 to guess the polarity
                 I = AnalogIn(self.ads_current, ads.P0).voltage * 1000. / 50 / self.r_shunt  # noqa measure current
                 U0 = AnalogIn(self.ads_voltage, ads.P0).voltage * 1000.  # noqa measure voltage
@@ -783,7 +785,7 @@ class OhmPi(object):
             self.exec_logger.warning('Not on Raspberry Pi, skipping reboot...')
 
     def run_measurement(self, quad=None, nb_stack=None, injection_duration=None,
-                        autogain=True, strategy='constant', tx_volt=5, best_tx_injtime=0.1,
+                        autogain=True, strategy='constant', tx_volt=5, best_tx_injtime=0.1, duty_cycle=0.5,
                         cmd_id=None):
         """Measures on a quadrupole and returns transfer resistance.
 
@@ -810,6 +812,10 @@ class OhmPi(object):
             measurement will be taken and values will be NaN.
         best_tx_injtime : float, optional
             (V3.0 only) Injection time in seconds used for finding the best voltage.
+        duty_cycle : float, optional, default: 0.5
+            Ratio of time between injection duration and no injection duration during a half-cycle
+            It should be comprised between 0.5 (no injection duration same as injection duration) and 1 (no injection
+            duration equal to 0)
         cmd_id : str, optional
             Unique command identifier
         """
@@ -874,7 +880,7 @@ class OhmPi(object):
             # get best voltage to inject AND polarity
             if self.idps:
                 tx_volt, polarity, Rab = self._compute_tx_volt(
-                    best_tx_injtime=best_tx_injtime, strategy=strategy, tx_volt=tx_volt)
+                    best_tx_injtime=best_tx_injtime, strategy=strategy, tx_volt=tx_volt,autogain=autogain)
                 self.exec_logger.debug(f'Best vab found is {tx_volt:.3f}V')
             else:
                 polarity = 1
@@ -1007,17 +1013,15 @@ class OhmPi(object):
                     # stop current injection
                     self.pin0.value = False
                     self.pin1.value = False
-#                     if autogain: # select gain computed on first half cycle
-#                             self.ads_voltage = ads.ADS1115(self.i2c, gain=gain_voltage[2],data_rate=860,
-#                                                            address=self.ads_voltage_address, mode=0)
-                    self.pin6.value = False# IHM current injection led on
+                    if self.board_version == 'mb.2023.0.0':
+                        self.pin6.value = False# IHM current injection led on
                     end_delay = time.time()
 
                     # truncate the meas array if we didn't fill the last samples  #TODO: check why
                     meas = meas[:k + 1]
 
                     # measurement of current i and voltage u during off time
-                    measpp = np.zeros((meas.shape[0], 3)) * np.nan
+                    measpp = np.zeros((int(meas.shape[0]*(1/duty_cycle-1)), 3)) * np.nan
                     start_delay = time.time()  # stating measurement time
                     dt = 0
                     for k in range(0, measpp.shape[0]):