Moved comments to top of variable instead of being on the same line

Author: Tjoms99

.github/workflows/ruff.yaml

@@ -6,4 +6,5 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: astral-sh/ruff-action@v2
+      - uses: astral-sh/ruff-action@v2
+      

example.py

@@ -22,10 +22,13 @@
 ppk2_test.get_modifiers()
 ppk2_test.set_source_voltage(3300)
 
-ppk2_test.use_source_meter()  # set source meter mode
-ppk2_test.toggle_DUT_power("ON")  # enable DUT power
+# set source meter mode
+ppk2_test.use_source_meter()
+# enable DUT power
+ppk2_test.toggle_DUT_power("ON")
+# start measuring
+ppk2_test.start_measuring()
 
-ppk2_test.start_measuring()  # start measuring
 # measurements are a constant stream of bytes
 # the number of measurements in one sampling period depends on the wait between serial reads
 # it appears the maximum number of bytes received is 1024
@@ -46,9 +49,10 @@
         print()
     time.sleep(0.01)
 
-ppk2_test.toggle_DUT_power("OFF")  # disable DUT power
-
-ppk2_test.use_ampere_meter()  # set ampere meter mode
+# disable DUT power
+ppk2_test.toggle_DUT_power("OFF")
+# set ampere meter mode
+ppk2_test.use_ampere_meter()
 
 ppk2_test.start_measuring()
 for i in range(0, 1000):
@@ -65,8 +69,8 @@
             # Print last 10 values of each channel
             print(ch[-10:])
         print()
-    time.sleep(
-        0.01
-    )  # lower time between sampling -> less samples read in one sampling period
+
+    # lower time between sampling -> less samples read in one sampling period
+    time.sleep(0.01)
 
 ppk2_test.stop_measuring()

example_mp.py

@@ -32,10 +32,13 @@
 """
 Source mode example
 """
-ppk2_test.use_source_meter()  # set source meter mode
-ppk2_test.toggle_DUT_power("ON")  # enable DUT power
+# set source meter mode
+ppk2_test.use_source_meter()
+# enable DUT power
+ppk2_test.toggle_DUT_power("ON")
+# start measuring
+ppk2_test.start_measuring()
 
-ppk2_test.start_measuring()  # start measuring
 # measurements are a constant stream of bytes
 # the number of measurements in one sampling period depends on the wait between serial reads
 # it appears the maximum number of bytes received is 1024
@@ -57,13 +60,16 @@
 
     time.sleep(0.001)
 
-ppk2_test.toggle_DUT_power("OFF")  # disable DUT power
+
+# disable DUT power
+ppk2_test.toggle_DUT_power("OFF")
 ppk2_test.stop_measuring()
 
 """
 Ampere mode example
 """
-ppk2_test.use_ampere_meter()  # set ampere meter mode
+# set ampere meter mode
+ppk2_test.use_ampere_meter()
 
 ppk2_test.start_measuring()
 while True:
@@ -80,8 +86,8 @@
             # Print last 10 values of each channel
             print(ch[-10:])
         print()
-    time.sleep(
-        0.001
-    )  # lower time between sampling -> less samples read in one sampling period
+
+    # lower time between sampling -> less samples read in one sampling period
+    time.sleep(0.001)
 
 ppk2_test.stop_measuring()

src/power_profiler.py

@@ -28,9 +28,8 @@ def __init__(self, serial_port=None, source_voltage_mV=3300, filename=None):
                 self.ppk2 = PPK2_API(serial_port)
 
         try:
-            ret = (
-                self.ppk2.get_modifiers()
-            )  # try to read modifiers, if it fails serial port is probably not correct
+            # try to read modifiers, if it fails serial port is probably not correct
+            ret = self.ppk2.get_modifiers()
             print(f"Initialized ppk2 api: {ret}")
         except Exception as e:
             print(f"Error initializing power profiler: {e}")
@@ -47,7 +46,8 @@ def __init__(self, serial_port=None, source_voltage_mV=3300, filename=None):
 
             self.source_voltage_mV = source_voltage_mV
 
-            self.ppk2.set_source_voltage(self.source_voltage_mV)  # set to 3.3V
+            # set to 3.3V
+            self.ppk2.set_source_voltage(self.source_voltage_mV)
 
             print(f"Set power profiler source voltage: {self.source_voltage_mV}")
 
@@ -130,14 +130,15 @@ def disable_power(self):
     def measurement_loop(self):
         """Endless measurement loop will run in a thread"""
         while True and not self.stop:
-            if self.measuring:  # read data if currently measuring
+            # read data if currently measuring
+            if self.measuring:
                 read_data = self.ppk2.get_data()
                 if read_data != b"":
                     samples = self.ppk2.get_samples(read_data)
-                    self.current_measurements += (
-                        samples  # can easily sum lists, will append individual data
-                    )
-            time.sleep(0.001)  # TODO figure out correct sleep duration
+                    # can easily sum lists, will append individual data
+                    self.current_measurements += samples
+            # TODO figure out correct sleep duration
+            time.sleep(0.001)
 
     def _average_samples(self, list, window_size):
         """Average samples based on window size"""
@@ -152,17 +153,22 @@ def _average_samples(self, list, window_size):
 
     def start_measuring(self):
         """Start measuring"""
-        if not self.measuring:  # toggle measuring flag only if currently not measuring
-            self.current_measurements = []  # reset current measurements
-            self.measuring = True  # set internal flag
-            self.ppk2.start_measuring()  # send command to ppk2
+        # toggle measuring flag only if currently not measuring
+        if not self.measuring:
+            # reset current measurements
+            self.current_measurements = []
+            # set internal flag
+            self.measuring = True
+            # send command to ppk2
+            self.ppk2.start_measuring()
             self.measurement_start_time = time.time()
 
     def stop_measuring(self):
         """Stop measuring and return average of period"""
         self.measurement_stop_time = time.time()
         self.measuring = False
-        self.ppk2.stop_measuring()  # send command to ppk2
+        # send command to ppk2
+        self.ppk2.stop_measuring()
 
         # samples_average = self._average_samples(self.current_measurements, 1000)
         if self.filename is not None:
@@ -182,32 +188,33 @@ def get_average_current_mA(self):
         if len(self.current_measurements) == 0:
             return 0
 
+        # measurements are in microamperes, divide by 1000
         average_current_mA = (
             sum(self.current_measurements) / len(self.current_measurements)
-        ) / 1000  # measurements are in microamperes, divide by 1000
+        ) / 1000
         return average_current_mA
 
     def get_average_power_consumption_mWh(self):
         """Return average power consumption of last measurement in mWh"""
         average_current_mA = self.get_average_current_mA()
-        average_power_mW = (
-            (self.source_voltage_mV / 1000) * average_current_mA
-        )  # divide by 1000 as source voltage is in millivolts - this gives us milliwatts
-        measurement_duration_h = (
-            self.get_measurement_duration_s() / 3600
-        )  # duration in seconds, divide by 3600 to get hours
+        # divide by 1000 as source voltage is in millivolts - this gives us milliwatts
+        average_power_mW = (self.source_voltage_mV / 1000) * average_current_mA
+        # duration in seconds, divide by 3600 to get hours
+        measurement_duration_h = self.get_measurement_duration_s() / 3600
         average_consumption_mWh = average_power_mW * measurement_duration_h
         return average_consumption_mWh
 
     def get_average_charge_mC(self):
         """Returns average charge in milli coulomb"""
         average_current_mA = self.get_average_current_mA()
-        measurement_duration_s = self.get_measurement_duration_s()  # in seconds
+        # in seconds
+        measurement_duration_s = self.get_measurement_duration_s()
         return average_current_mA * measurement_duration_s
 
     def get_measurement_duration_s(self):
         """Returns duration of measurement"""
+        # measurement duration in seconds
         measurement_duration_s = (
             self.measurement_stop_time - self.measurement_start_time
-        )  # measurement duration in seconds
+        )
         return measurement_duration_s

src/ppk2_api/ppk2_api.py

@@ -124,7 +124,8 @@ def _write_serial(self, cmd_tuple):
     def _twos_comp(self, val):
         """Compute the 2's complement of int32 value"""
         if (val & (1 << (32 - 1))) != 0:
-            val = val - (1 << 32)  # compute negative value
+            # compute negative value
+            val = val - (1 << 32)
         return val
 
     def _convert_source_voltage(self, mV):
@@ -141,11 +142,13 @@ def _convert_source_voltage(self, mV):
         # get difference to baseline (the baseline is 800mV but the initial offset is 32)
         diff_to_baseline = mV - self.vdd_low + offset
         base_b_1 = 3
-        base_b_2 = 0  # is actually 32 - compensated with above offset
+        # is actually 32 - compensated with above offset
+        base_b_2 = 0
 
         # get the number of times we have to increase the first byte of the command
         ratio = int(diff_to_baseline / 256)
-        remainder = diff_to_baseline % 256  # get the remainder for byte 2
+        # get the remainder for byte 2
+        remainder = diff_to_baseline % 256
 
         set_b_1 = base_b_1 + ratio
         set_b_2 = base_b_2 + remainder
@@ -201,9 +204,10 @@ def _get_masked_value(self, value, meas, is_bits=False):
     def _handle_raw_data(self, adc_value):
         """Convert raw value to analog value"""
         try:
+            # 5 is the number of parameters
             current_measurement_range = min(
                 self._get_masked_value(adc_value, self.MEAS_RANGE), 4
-            )  # 5 is the number of parameters
+            )
             adc_result = self._get_masked_value(adc_value, self.MEAS_ADC) * 4
             bits = self._get_masked_value(adc_value, self.MEAS_LOGIC)
             analog_value = (
@@ -273,28 +277,26 @@ def set_source_voltage(self, mV):
     def toggle_DUT_power(self, state):
         """Toggle DUT power based on parameter"""
         if state == "ON":
+            # 12,1
             self._write_serial(
                 (PPK2_Command.DEVICE_RUNNING_SET, PPK2_Command.TRIGGER_SET)
-            )  # 12,1
+            )
 
         if state == "OFF":
-            self._write_serial(
-                (PPK2_Command.DEVICE_RUNNING_SET, PPK2_Command.NO_OP)
-            )  # 12,0
+            # 12,0
+            self._write_serial((PPK2_Command.DEVICE_RUNNING_SET, PPK2_Command.NO_OP))
 
     def use_ampere_meter(self):
         """Configure device to use ampere meter"""
         self.mode = PPK2_Modes.AMPERE_MODE
-        self._write_serial(
-            (PPK2_Command.SET_POWER_MODE, PPK2_Command.TRIGGER_SET)
-        )  # 17,1
+        # 17,1
+        self._write_serial((PPK2_Command.SET_POWER_MODE, PPK2_Command.TRIGGER_SET))
 
     def use_source_meter(self):
         """Configure device to use source meter"""
         self.mode = PPK2_Modes.SOURCE_MODE
-        self._write_serial(
-            (PPK2_Command.SET_POWER_MODE, PPK2_Command.AVG_NUM_SET)
-        )  # 17,2
+        # 17,2
+        self._write_serial((PPK2_Command.SET_POWER_MODE, PPK2_Command.AVG_NUM_SET))
 
     def get_adc_result(self, current_range, adc_value):
         """Get result of adc conversion"""
@@ -359,9 +361,8 @@ def get_adc_result(self, current_range, adc_value):
 
     def _digital_to_analog(self, adc_value):
         """Convert discrete value to analog value"""
-        return int.from_bytes(
-            adc_value, byteorder="little", signed=False
-        )  # convert reading to analog value
+        # convert reading to analog value
+        return int.from_bytes(adc_value, byteorder="little", signed=False)
 
     def digital_channels(self, bits):
         """
@@ -390,8 +391,8 @@ def get_samples(self, buf):
         Manipulation of samples is left to the user.
         See example for more info.
         """
-
-        sample_size = 4  # one analog value is 4 bytes in size
+        # one analog value is 4 bytes in size
+        sample_size = 4
         offset = self.remainder["len"]
         samples = []
         raw_digital_output = []
@@ -438,12 +439,10 @@ def __init__(self, ppk2, quit_evt, buffer_len_s=10, buffer_chunk_s=0.5):
         self._stats = (None, None)
         self._last_timestamp = 0
 
-        self._buffer_max_len = int(
-            buffer_len_s * 100000 * 4
-        )  # 100k 4-byte samples per second
-        self._buffer_chunk = int(
-            buffer_chunk_s * 100000 * 4
-        )  # put in the queue in chunks of 0.5s
+        # 100k 4-byte samples per second
+        self._buffer_max_len = int(buffer_len_s * 100000 * 4)
+        # put in the queue in chunks of 0.5s
+        self._buffer_chunk = int(buffer_chunk_s * 100000 * 4)
 
         # round buffers to a whole sample
         if self._buffer_max_len % 4 != 0:
@@ -495,9 +494,8 @@ def get_data(self):
         count = 0
         while True:
             try:
-                ret += self._buffer_q.get(
-                    timeout=0.001
-                )  # get_nowait sometimes skips a chunk for some reason
+                # get_nowait sometimes skips a chunk for some reason
+                ret += self._buffer_q.get(timeout=0.001)
                 count += 1
             except queue.Empty:
                 break