scietex.hal.vfd 2.0.2__tar.gz → 2.1.0__tar.gz

{scietex_hal_vfd-2.0.2/src/scietex.hal.vfd.egg-info → scietex_hal_vfd-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scietex.hal.vfd
-Version: 2.0.2
+Version: 2.1.0
 Summary: Scietex VFD HAL package
 Author-email: Anton Bondarenko <bond.anton@gmail.com>
 License: MIT License
@@ -71,8 +71,9 @@ A driver reaches a drive over one of two transports:
   unsupported command before dispatching it.
 - `VFDParameters`, which reports frequency in both Hz and percent of the
   configured maximum, plus output current, voltage and power, and the optional
-  DC bus voltage and temperatures a drive exposes. An optional field is `None`
-  when the drive does not report it, which is distinct from a reported `0.0`.
+  DC bus voltage, temperatures and run-time counters a drive exposes. An
+  optional field is `None` when the drive does not report it, which is distinct
+  from a reported `0.0`.
 - Implemented drive models, each with both transports:
   - `Intek SPE-B` — direct RS485 (`SPEvB`) and gateway (`IntekSPEBModbusVFD`).
   - `Vesper E5-8200` — direct RS485 (`VesperE58200`) and gateway
@@ -94,10 +95,21 @@ A driver reaches a drive over one of two transports:
 | `dc_bus_voltage` | yes | yes | yes |
 | `heatsink_temperature_c` | no (`None`) | no (`None`) | yes |
 | `motor_temperature_c` | no (`None`) | no (`None`) | no (`None`) |
+| `total_run_hours` | yes | no (`None`) | no (`None`) |
+| `total_power_on_hours` | yes | no (`None`) | no (`None`) |
 
 Only the E4-8400 exposes a live temperature reading (`004Dh`, U1-46). The other
 two report overheat only as a fault code, and a fault is not a temperature.
 
+The SPE-B keeps two run-time counters (`0x101A` power-on, `0x101B` run). The
+manual states no unit; the drive was measured incrementing the power-on counter
+by exactly one over sixty seconds, so both are minutes and are reported as
+hours. The E4-8400 defines U1-48 and U1-49 as "run time 1" and "run time 2"
+without stating a unit or which is cumulative, and no drive was available to
+measure them, so both hours fields stay `None` for that model. The E5-8200 has
+no counter at all. A caller that needs hours for either drive accumulates them
+itself.
+
 ¹ The SPE-B reports the operating frequency only as a percentage of `P0.10`, so
 `frequency_hz` is `None` until `P0.10` has been read. A drive that refuses
 `P0.10` still reports `frequency_percent`, current, voltage and power; the

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/README.md

@@ -23,8 +23,9 @@ A driver reaches a drive over one of two transports:
   unsupported command before dispatching it.
 - `VFDParameters`, which reports frequency in both Hz and percent of the
   configured maximum, plus output current, voltage and power, and the optional
-  DC bus voltage and temperatures a drive exposes. An optional field is `None`
-  when the drive does not report it, which is distinct from a reported `0.0`.
+  DC bus voltage, temperatures and run-time counters a drive exposes. An
+  optional field is `None` when the drive does not report it, which is distinct
+  from a reported `0.0`.
 - Implemented drive models, each with both transports:
   - `Intek SPE-B` — direct RS485 (`SPEvB`) and gateway (`IntekSPEBModbusVFD`).
   - `Vesper E5-8200` — direct RS485 (`VesperE58200`) and gateway
@@ -46,10 +47,21 @@ A driver reaches a drive over one of two transports:
 | `dc_bus_voltage` | yes | yes | yes |
 | `heatsink_temperature_c` | no (`None`) | no (`None`) | yes |
 | `motor_temperature_c` | no (`None`) | no (`None`) | no (`None`) |
+| `total_run_hours` | yes | no (`None`) | no (`None`) |
+| `total_power_on_hours` | yes | no (`None`) | no (`None`) |
 
 Only the E4-8400 exposes a live temperature reading (`004Dh`, U1-46). The other
 two report overheat only as a fault code, and a fault is not a temperature.
 
+The SPE-B keeps two run-time counters (`0x101A` power-on, `0x101B` run). The
+manual states no unit; the drive was measured incrementing the power-on counter
+by exactly one over sixty seconds, so both are minutes and are reported as
+hours. The E4-8400 defines U1-48 and U1-49 as "run time 1" and "run time 2"
+without stating a unit or which is cumulative, and no drive was available to
+measure them, so both hours fields stay `None` for that model. The E5-8200 has
+no counter at all. A caller that needs hours for either drive accumulates them
+itself.
+
 ¹ The SPE-B reports the operating frequency only as a percentage of `P0.10`, so
 `frequency_hz` is `None` until `P0.10` has been read. A drive that refuses
 `P0.10` still reports `frequency_percent`, current, voltage and power; the

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/base/data.py

@@ -62,6 +62,13 @@ class VFDParameters(msgspec.Struct, frozen=True):
         motor_temperature_c: Motor winding or PTC temperature in degrees
             Celsius, or ``None`` when the drive does not report it.
         state: Current VFD state.
+        total_run_hours: Cumulative motor run time in hours, or ``None`` when
+            the drive keeps no such counter. A drive that reports the counter
+            but refuses the read also yields ``None``: the caller cannot tell
+            "no counter" from "unreadable", and both mean the value must come
+            from somewhere else.
+        total_power_on_hours: Cumulative powered-on time in hours, or ``None``
+            when the drive keeps no such counter.
     """
 
     frequency_hz: float | None  # Current operating frequency in Hz
@@ -73,6 +80,8 @@ class VFDParameters(msgspec.Struct, frozen=True):
     heatsink_temperature_c: float | None = None  # Power-module temperature, deg C
     motor_temperature_c: float | None = None  # Motor temperature, deg C
     state: VFDState = VFDState.STOPPED  # Current VFD state
+    total_run_hours: float | None = None  # Cumulative run time, hours
+    total_power_on_hours: float | None = None  # Cumulative power-on time, hours
 
     def __str__(self) -> str:
         return (
@@ -84,7 +93,9 @@ class VFDParameters(msgspec.Struct, frozen=True):
             f"dc_bus={self.dc_bus_voltage} V, "
             f"heatsink={self.heatsink_temperature_c} C, "
             f"motor={self.motor_temperature_c} C, "
-            f"state={self.state})"
+            f"state={self.state}, "
+            f"run_hours={self.total_run_hours}, "
+            f"power_on_hours={self.total_power_on_hours})"
         )
 
 

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/intek/spe_b/client.py

@@ -270,6 +270,10 @@ class IntekSPEBModbusVFD(VFDProtocol):
         the status register still reports its measurements, so the state falls
         back to ``VFDState.UNKNOWN`` instead of failing the whole snapshot.
 
+        The two run-time counters are read as a second block and are optional
+        for the same reason: a drive that refuses them still reports its
+        measurements, and the hours fields stay ``None``.
+
         Returns:
             VFDParameters: The decoded parameters. Both temperature fields are
                 ``None``: SPE-B reports overheat as a fault code, not a reading.
@@ -287,6 +291,9 @@ class IntekSPEBModbusVFD(VFDProtocol):
             block[registers.REG_OUTPUT_CURRENT - registers.PARAMETERS_BLOCK_ADDRESS]
             * self._current_resolution
         )
+        run_time = await self._read_optional_registers(
+            registers.RUN_TIME_BLOCK_ADDRESS, registers.RUN_TIME_BLOCK_COUNT
+        )
         parameters = VFDParameters(
             frequency_hz=self._percent_to_hz(percent),
             frequency_percent=percent,
@@ -301,6 +308,12 @@ class IntekSPEBModbusVFD(VFDProtocol):
                 block[registers.REG_DC_BUS_VOLTAGE - registers.PARAMETERS_BLOCK_ADDRESS]
             ),
             state=await self.read_state(),
+            total_power_on_hours=(
+                registers.run_time_to_hours(run_time[0]) if run_time is not None else None
+            ),
+            total_run_hours=(
+                registers.run_time_to_hours(run_time[1]) if run_time is not None else None
+            ),
         )
         self.logger.debug("%s: %s", self.label, parameters)
         return parameters

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/intek/spe_b/registers.py

@@ -54,6 +54,16 @@ REG_AUX_FREQUENCY_Y = 0x1020  # Auxiliary frequency Y, raw
 PARAMETERS_BLOCK_ADDRESS = REG_OPERATING_FREQUENCY
 PARAMETERS_BLOCK_COUNT = 5
 
+# The two consecutive run-time counters, read as a second block because they sit
+# outside the measurement block. The manual calls them "raw" and states no unit;
+# the drive was measured incrementing 0x101A by one per minute, so both are
+# minutes. `0x1015` (remaining run time) is deliberately not read: it is the
+# countdown to a maintenance interval, not a total, and it reads 0 when no
+# interval is configured.
+RUN_TIME_BLOCK_ADDRESS = REG_TOTAL_POWER_ON_TIME
+RUN_TIME_BLOCK_COUNT = 2
+RUN_TIME_RESOLUTION = 60.0  # Counter units per hour
+
 # Control register, FC06 write only.
 REG_CONTROL = 0x2000
 CONTROL_FORWARD_RUN = 1
@@ -185,6 +195,23 @@ def raw_to_percent(raw: int) -> float:
     return raw / ANALOG_OUTPUT_MAX_RAW * 100.0
 
 
+def run_time_to_hours(raw: int) -> float:
+    """
+    Convert a run-time counter register into hours.
+
+    The manual states no unit for `REG_TOTAL_POWER_ON_TIME` and
+    `REG_TOTAL_RUN_TIME`. The drive was measured incrementing the power-on
+    counter by exactly one over sixty seconds, so the counters are minutes.
+
+    Args:
+        raw: The register value.
+
+    Returns:
+        float: The counter as hours.
+    """
+    return raw / RUN_TIME_RESOLUTION
+
+
 def status_to_state(status: int) -> VFDState:
     """
     Decode the status register into a `VFDState`.

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/intek/spe_b/rs485.py

@@ -127,6 +127,12 @@ class SPEvB(VFD):
             else None
         )
         state = await self.read_state()
+        run_time = await self.read_registers(
+            registers.RUN_TIME_BLOCK_ADDRESS,
+            registers.RUN_TIME_BLOCK_COUNT,
+            holding=True,
+            raise_on_error=False,
+        )
         return VFDParameters(
             frequency_hz=frequency_hz,
             frequency_percent=percent,
@@ -141,6 +147,12 @@ class SPEvB(VFD):
                 block[registers.REG_DC_BUS_VOLTAGE - registers.PARAMETERS_BLOCK_ADDRESS]
             ),
             state=state,
+            total_power_on_hours=(
+                registers.run_time_to_hours(run_time[0]) if run_time is not None else None
+            ),
+            total_run_hours=(
+                registers.run_time_to_hours(run_time[1]) if run_time is not None else None
+            ),
         )
 
     async def read_state(self) -> VFDState:

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/version.py

@@ -5,4 +5,4 @@ Attributes:
     __version__ (str): The current version of the package.
 """
 
-__version__ = "2.0.2"
+__version__ = "2.1.0"

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/vesper/e4_8400/client.py

@@ -254,7 +254,9 @@ class VesperE48400ModbusVFD(VFDProtocol):
         Returns:
             VFDParameters: The decoded parameters. ``heatsink_temperature_c`` is
                 populated from U1-46; ``motor_temperature_c`` stays ``None``
-                because the drive reports motor overheat only as a fault.
+                because the drive reports motor overheat only as a fault. Both
+                hours fields stay ``None``: U1-48 and U1-49 are undocumented as
+                to unit and meaning, so the caller accumulates the hours.
 
         Raises:
             ModbusOperationError: If the measurement block or E1-04 cannot be

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/vesper/e4_8400/registers.py

@@ -109,6 +109,11 @@ REG_COUNTER = 0x004E  # U1-47, counter value
 REG_RUN_TIME_1 = 0x004F  # U1-48, run time 1
 REG_RUN_TIME_2 = 0x0050  # U1-49, run time 2
 
+# U1-48 and U1-49 are not read: the manual names them "run time 1" and "run time
+# 2" without stating a unit or which one is cumulative, and no drive was
+# available to measure them. `VFDParameters.total_run_hours` therefore stays
+# ``None`` for this model and the caller accumulates the hours itself.
+
 # Fault snapshot, read only. The values are captured when the last fault
 # occurred and are not updated while the drive runs.
 REG_FAULT_OUTPUT_FREQUENCY = 0x0083  # U2-04, output frequency at fault

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/vesper/e4_8400/rs485.py

@@ -206,7 +206,9 @@ class VesperE48400(VFD):
         Returns:
             VFDParameters: The decoded parameters. ``heatsink_temperature_c`` is
                 populated from U1-46; ``motor_temperature_c`` stays ``None``
-                because the drive reports motor overheat only as a fault.
+                because the drive reports motor overheat only as a fault. Both
+                hours fields stay ``None``: U1-48 and U1-49 are undocumented as
+                to unit and meaning, so the caller accumulates the hours.
 
         Raises:
             ModbusOperationError: If the measurement block or E1-04 cannot be

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/vesper/e5_8200/client.py

@@ -228,7 +228,9 @@ class VesperE58200ModbusVFD(VFDProtocol):
         back to ``VFDState.UNKNOWN`` instead of failing the whole snapshot.
 
         Returns:
-            VFDParameters: The decoded parameters.
+            VFDParameters: The decoded parameters. Both hours fields stay
+                ``None``: the drive exposes no run-time counter, so the caller
+                accumulates the hours.
 
         Raises:
             ModbusOperationError: If the measurement block cannot be read.

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/src/scietex/hal/vfd/vesper/e5_8200/rs485.py

@@ -138,7 +138,9 @@ class VesperE58200(VFD):
         back to ``VFDState.UNKNOWN`` instead of failing the whole snapshot.
 
         Returns:
-            VFDParameters: The decoded parameters.
+            VFDParameters: The decoded parameters. Both hours fields stay
+                ``None``: the drive exposes no run-time counter, so the caller
+                accumulates the hours.
 
         Raises:
             ModbusOperationError: If the measurement block cannot be read.

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0/src/scietex.hal.vfd.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scietex.hal.vfd
-Version: 2.0.2
+Version: 2.1.0
 Summary: Scietex VFD HAL package
 Author-email: Anton Bondarenko <bond.anton@gmail.com>
 License: MIT License
@@ -71,8 +71,9 @@ A driver reaches a drive over one of two transports:
   unsupported command before dispatching it.
 - `VFDParameters`, which reports frequency in both Hz and percent of the
   configured maximum, plus output current, voltage and power, and the optional
-  DC bus voltage and temperatures a drive exposes. An optional field is `None`
-  when the drive does not report it, which is distinct from a reported `0.0`.
+  DC bus voltage, temperatures and run-time counters a drive exposes. An
+  optional field is `None` when the drive does not report it, which is distinct
+  from a reported `0.0`.
 - Implemented drive models, each with both transports:
   - `Intek SPE-B` — direct RS485 (`SPEvB`) and gateway (`IntekSPEBModbusVFD`).
   - `Vesper E5-8200` — direct RS485 (`VesperE58200`) and gateway
@@ -94,10 +95,21 @@ A driver reaches a drive over one of two transports:
 | `dc_bus_voltage` | yes | yes | yes |
 | `heatsink_temperature_c` | no (`None`) | no (`None`) | yes |
 | `motor_temperature_c` | no (`None`) | no (`None`) | no (`None`) |
+| `total_run_hours` | yes | no (`None`) | no (`None`) |
+| `total_power_on_hours` | yes | no (`None`) | no (`None`) |
 
 Only the E4-8400 exposes a live temperature reading (`004Dh`, U1-46). The other
 two report overheat only as a fault code, and a fault is not a temperature.
 
+The SPE-B keeps two run-time counters (`0x101A` power-on, `0x101B` run). The
+manual states no unit; the drive was measured incrementing the power-on counter
+by exactly one over sixty seconds, so both are minutes and are reported as
+hours. The E4-8400 defines U1-48 and U1-49 as "run time 1" and "run time 2"
+without stating a unit or which is cumulative, and no drive was available to
+measure them, so both hours fields stay `None` for that model. The E5-8200 has
+no counter at all. A caller that needs hours for either drive accumulates them
+itself.
+
 ¹ The SPE-B reports the operating frequency only as a percentage of `P0.10`, so
 `frequency_hz` is `None` until `P0.10` has been read. A drive that refuses
 `P0.10` still reports `frequency_percent`, current, voltage and power; the

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/tests/test_modbus_client.py

@@ -132,8 +132,8 @@ def test_read_before_connect_raises():
 
 
 def test_read_parameters_scales_percent_current_and_reads_state():
-    """One block read at 0x1001, then the status register."""
-    vfd, stub = _connected([_read([5000, 540, 380, 123, 45]), _read([1])])
+    """One block read at 0x1001, the run-time block, then the status register."""
+    vfd, stub = _connected([_read([5000, 540, 380, 123, 45]), _read([3231, 120]), _read([1])])
     parameters = asyncio.run(vfd.read_parameters())
 
     assert stub.calls == [
@@ -143,6 +143,7 @@ def test_read_parameters_scales_percent_current_and_reads_state():
             registers.PARAMETERS_BLOCK_COUNT,
             1,
         ),
+        ("read", registers.RUN_TIME_BLOCK_ADDRESS, registers.RUN_TIME_BLOCK_COUNT, 1),
         ("read", registers.REG_STATUS, 1, 1),
     ]
     assert parameters.frequency_percent == pytest.approx(50.0)
@@ -151,22 +152,36 @@ def test_read_parameters_scales_percent_current_and_reads_state():
     assert parameters.output_voltage == pytest.approx(380.0)
     assert parameters.output_power == pytest.approx(45.0)
     assert parameters.state is VFDState.RUNNING_FORWARD
+    assert parameters.total_power_on_hours == pytest.approx(53.85)
+    assert parameters.total_run_hours == pytest.approx(2.0)
 
 
 def test_read_parameters_uses_the_coarse_current_resolution():
     """Pd.06 = 1 means 0.1 A per count."""
-    vfd, _ = _connected([_read([0, 0, 0, 123, 0]), _read([3])], current_raw=1)
+    vfd, _ = _connected([_read([0, 0, 0, 123, 0]), _read([0, 0]), _read([3])], current_raw=1)
     assert asyncio.run(vfd.read_parameters()).output_current == pytest.approx(12.3)
 
 
 def test_read_parameters_reports_no_hz_when_p010_is_zero():
     """An unusable maximum frequency keeps the percentage but cannot scale it."""
-    vfd, _ = _connected([_read([5000, 0, 0, 0, 0]), _read([3])], max_frequency_raw=0)
+    vfd, _ = _connected([_read([5000, 0, 0, 0, 0]), _read([0, 0]), _read([3])], max_frequency_raw=0)
     parameters = asyncio.run(vfd.read_parameters())
     assert parameters.frequency_percent == pytest.approx(50.0)
     assert parameters.frequency_hz is None
 
 
+def test_read_parameters_survives_an_unreadable_run_time_block():
+    """A refused run-time block leaves the hours unknown, not the snapshot empty."""
+    vfd, _ = _connected(
+        [_read([5000, 540, 380, 123, 45]), ExceptionResponse(function_code=3), _read([1])]
+    )
+    parameters = asyncio.run(vfd.read_parameters())
+    assert parameters.frequency_hz == pytest.approx(25.0)
+    assert parameters.total_run_hours is None
+    assert parameters.total_power_on_hours is None
+    assert parameters.state is VFDState.RUNNING_FORWARD
+
+
 def test_connect_survives_a_refused_p010_and_still_reports_measurements():
     """A drive that refuses P0.10 must not blank the whole snapshot.
 
@@ -181,6 +196,7 @@ def test_connect_survives_a_refused_p010_and_still_reports_measurements():
             ExceptionResponse(function_code=3),  # P0.10
             _read([1]),  # Pd.06 = coarse, 0.1 A
             _read([5000, 540, 380, 123, 45]),
+            _read([3231, 120]),  # run-time block
             _read([1]),  # status: running forward
         ]
     )
@@ -194,6 +210,7 @@ def test_connect_survives_a_refused_p010_and_still_reports_measurements():
     assert parameters.output_voltage == pytest.approx(380.0)
     assert parameters.dc_bus_voltage == pytest.approx(540.0)
     assert parameters.state is VFDState.RUNNING_FORWARD
+    assert parameters.total_run_hours == pytest.approx(2.0)
 
 
 def test_set_frequency_still_refuses_when_p010_is_unknown():
@@ -210,12 +227,19 @@ def test_read_parameters_survives_an_unreadable_status_register():
     would mean a drive that refuses one diagnostic register never reports its
     frequency, current or voltage at all.
     """
-    vfd, _ = _connected([_read([5000, 540, 380, 123, 45]), ExceptionResponse(function_code=3)])
+    vfd, _ = _connected(
+        [
+            _read([5000, 540, 380, 123, 45]),
+            _read([3231, 120]),
+            ExceptionResponse(function_code=3),
+        ]
+    )
     parameters = asyncio.run(vfd.read_parameters())
     assert parameters.frequency_hz == pytest.approx(25.0)
     assert parameters.output_current == pytest.approx(1.23)
     assert parameters.output_voltage == pytest.approx(380.0)
     assert parameters.state is VFDState.UNKNOWN
+    assert parameters.total_run_hours == pytest.approx(2.0)
 
 
 def test_read_parameters_still_raises_when_the_measurement_block_fails():
@@ -332,7 +356,7 @@ def test_write_raises_on_an_exception_response():
 
 def test_read_data_returns_the_parameter_fields():
     """`read_data` flattens `VFDParameters` into a plain mapping."""
-    vfd, _ = _connected([_read([5000, 0, 380, 100, 10]), _read([2])])
+    vfd, _ = _connected([_read([5000, 0, 380, 100, 10]), _read([3231, 120]), _read([2])])
     data = asyncio.run(vfd.read_data())
     assert data == {
         "frequency_hz": pytest.approx(25.0),
@@ -344,4 +368,6 @@ def test_read_data_returns_the_parameter_fields():
         "heatsink_temperature_c": None,
         "motor_temperature_c": None,
         "state": VFDState.RUNNING_BACKWARD,
+        "total_run_hours": pytest.approx(2.0),
+        "total_power_on_hours": pytest.approx(53.85),
     }

{scietex_hal_vfd-2.0.2 → scietex_hal_vfd-2.1.0}/tests/test_registers.py

@@ -39,6 +39,19 @@ def test_parameters_block_starts_at_the_operating_frequency():
     )
 
 
+def test_run_time_block_spans_the_two_counters():
+    """Power-on time is 0x101A and run time 0x101B, so one read covers both."""
+    assert registers.RUN_TIME_BLOCK_ADDRESS == 0x101A
+    assert registers.RUN_TIME_BLOCK_COUNT == 2
+    assert registers.RUN_TIME_BLOCK_ADDRESS + registers.RUN_TIME_BLOCK_COUNT - 1 == 0x101B
+
+
+@pytest.mark.parametrize("raw, expected_hours", [(0, 0.0), (60, 1.0), (3231, 53.85)])
+def test_run_time_to_hours(raw, expected_hours):
+    """The counters are minutes: the drive was measured incrementing by one per minute."""
+    assert registers.run_time_to_hours(raw) == pytest.approx(expected_hours)
+
+
 @pytest.mark.parametrize(
     "percent, expected_hz",
     [(100.0, 50.0), (50.0, 25.0), (0.0, 0.0), (-100.0, -50.0), (200.0, 100.0)],