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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scietex.hal.vfd
-Version: 2.0.1
+Version: 2.0.2
 Summary: Scietex VFD HAL package
 Author-email: Anton Bondarenko <bond.anton@gmail.com>
 License: MIT License
@@ -86,7 +86,7 @@ A driver reaches a drive over one of two transports:
 
 | Field | Intek SPE-B | Vesper E5-8200 | Vesper E4-8400 |
 | --- | --- | --- | --- |
-| `frequency_hz` | yes | yes | yes |
+| `frequency_hz` | yes¹ | yes | yes |
 | `frequency_percent` | yes | yes | yes |
 | `output_current` | yes | yes | yes |
 | `output_voltage` | yes | yes | yes |
@@ -98,6 +98,12 @@ A driver reaches a drive over one of two transports:
 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 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
+connection stays usable and only the Hz field degrades. `set_frequency` is
+refused in that state, because no percentage can be computed.
+
 ## Installation
 
 Install the package via pip (assuming it's published to PyPI):

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

@@ -38,7 +38,7 @@ A driver reaches a drive over one of two transports:
 
 | Field | Intek SPE-B | Vesper E5-8200 | Vesper E4-8400 |
 | --- | --- | --- | --- |
-| `frequency_hz` | yes | yes | yes |
+| `frequency_hz` | yes¹ | yes | yes |
 | `frequency_percent` | yes | yes | yes |
 | `output_current` | yes | yes | yes |
 | `output_voltage` | yes | yes | yes |
@@ -50,6 +50,12 @@ A driver reaches a drive over one of two transports:
 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 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
+connection stays usable and only the Hz field degrades. `set_frequency` is
+refused in that state, because no percentage can be computed.
+
 ## Installation
 
 Install the package via pip (assuming it's published to PyPI):

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

@@ -44,7 +44,10 @@ class VFDParameters(msgspec.Struct, frozen=True):
     """Model for VFD operational parameters.
 
     Attributes:
-        frequency_hz: Output frequency in Hz.
+        frequency_hz: Output frequency in Hz, or ``None`` when the drive
+            reports the frequency only as a percentage and the maximum it is a
+            percentage of is unknown. ``None`` rather than 0.0 because the drive
+            has not reported a frequency of zero — it has reported nothing.
         frequency_percent: Output frequency as a percentage of the configured
             maximum, 0-100.
         output_current: Output current in Amps.
@@ -61,7 +64,7 @@ class VFDParameters(msgspec.Struct, frozen=True):
         state: Current VFD state.
     """
 
-    frequency_hz: float  # Current operating frequency in Hz
+    frequency_hz: float | None  # Current operating frequency in Hz
     frequency_percent: float  # Frequency as a percentage of max (0-100%)
     output_current: float = 0.0  # Output current in Amps
     output_voltage: float = 0.0  # Output voltage in Volts

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

@@ -103,11 +103,13 @@ class IntekSPEBModbusVFD(VFDProtocol):
         Open the TCP connection to the gateway and read the drive's scale factors.
 
         Raises:
-            ModbusOperationError: If the gateway is unreachable, or if P0.10
-                cannot be read. pymodbus reports a failed connect by returning
-                ``False`` rather than raising, so the result is checked here;
-                otherwise an unreachable drive would look connected and only
-                fail on the first read.
+            ModbusOperationError: If the gateway is unreachable. pymodbus
+                reports a failed connect by returning ``False`` rather than
+                raising, so the result is checked here; otherwise an
+                unreachable drive would look connected and only fail on the
+                first read. An unreadable P0.10 is not an error: the drive
+                still reports its measurements, only ``frequency_hz`` degrades
+                to ``None``.
         """
         if self._client is None:
             self._client = AsyncModbusTcpClient(self._host, port=self._port, timeout=self._timeout)
@@ -205,16 +207,25 @@ class IntekSPEBModbusVFD(VFDProtocol):
         """
         Read and cache the P0.10 maximum frequency and the Pd.06 resolution.
 
-        Raises:
-            ModbusOperationError: If P0.10 cannot be read, because every
-                frequency this client reports would then be a guess.
+        P0.10 is optional: a drive that refuses it still reports its operating
+        percentage, current, voltage and power, so the connection stays usable
+        and only ``frequency_hz`` degrades to ``None``. Raising here would make
+        the poll loop log a connect failure every cycle and publish nothing at
+        all, which is what an SPE-B that has not been configured for Modbus
+        (Pd.01/Pd.05) does — it answers the gateway with exception 11.
         """
-        raw = await self._read_registers(registers.PARAM_MAX_FREQUENCY_EEPROM, 1)
-        self._max_frequency_hz = raw[0] / registers.PARAMETER_FREQUENCY_RESOLUTION
-        if self._max_frequency_hz <= 0:
+        try:
+            raw = await self._read_registers(registers.PARAM_MAX_FREQUENCY_EEPROM, 1)
+        except ModbusOperationError as exc:
             self.logger.warning(
-                "%s: P0.10 reads %d, frequency is reported as 0 Hz.", self.label, raw[0]
+                "%s: P0.10 is unreadable (%s), frequency is reported as None.", self.label, exc
             )
+        else:
+            self._max_frequency_hz = raw[0] / registers.PARAMETER_FREQUENCY_RESOLUTION
+            if self._max_frequency_hz <= 0:
+                self.logger.warning(
+                    "%s: P0.10 reads %d, frequency is reported as None.", self.label, raw[0]
+                )
         # Pd.06 only refines the current reading, so a drive that refuses the
         # read keeps working with the factory resolution instead of failing
         # the connection: stop and fault reset must stay available.
@@ -229,7 +240,7 @@ class IntekSPEBModbusVFD(VFDProtocol):
             else registers.CURRENT_RESOLUTION_FINE
         )
 
-    def _percent_to_hz(self, percent: float) -> float:
+    def _percent_to_hz(self, percent: float) -> float | None:
         """
         Convert an operating frequency percentage into Hz.
 
@@ -237,10 +248,13 @@ class IntekSPEBModbusVFD(VFDProtocol):
             percent: Frequency as reported by the drive.
 
         Returns:
-            float: The frequency in Hz, or 0.0 while P0.10 is unknown.
+            float | None: The frequency in Hz, or ``None`` while P0.10 is
+                unknown. ``None`` rather than 0.0 because a drive that refuses
+                P0.10 has not reported a frequency of zero — it has reported
+                nothing, and a caller must be able to tell the two apart.
         """
         if self._max_frequency_hz <= 0:
-            return 0.0
+            return None
         return registers.percent_to_hz(percent, self._max_frequency_hz)
 
     async def read_parameters(self) -> VFDParameters:

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

@@ -53,12 +53,22 @@ class SPEvB(VFD):
         self._current_resolution = registers.CURRENT_RESOLUTION_FINE
 
     async def _read_scale_factors(self) -> None:
-        """Read P0.10 and Pd.06 from the drive once and cache them."""
-        raw = await self.read_register(registers.PARAM_MAX_FREQUENCY_EEPROM, holding=True)
+        """
+        Read P0.10 and Pd.06 from the drive once and cache them.
+
+        P0.10 is optional: a drive that refuses it still reports its operating
+        percentage, current, voltage and power, so only ``frequency_hz``
+        degrades to ``None``. Raising here would fail the whole snapshot.
+        """
+        raw = await self.read_register(
+            registers.PARAM_MAX_FREQUENCY_EEPROM,
+            holding=True,
+            raise_on_error=False,
+        )
         self._max_frequency_hz = (raw or 0) / registers.PARAMETER_FREQUENCY_RESOLUTION
         if self._max_frequency_hz <= 0:
             self.logger.warning(
-                "%s: P0.10 reads %s, frequency is reported as 0 Hz.", self.label, raw
+                "%s: P0.10 reads %s, frequency is reported as None.", self.label, raw
             )
         # Pd.06 only refines the current reading, so a drive that refuses the
         # read keeps working with the factory resolution.
@@ -114,7 +124,7 @@ class SPEvB(VFD):
         frequency_hz = (
             registers.percent_to_hz(percent, self._max_frequency_hz)
             if self._max_frequency_hz
-            else 0.0
+            else None
         )
         state = await self.read_state()
         return VFDParameters(

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scietex.hal.vfd
-Version: 2.0.1
+Version: 2.0.2
 Summary: Scietex VFD HAL package
 Author-email: Anton Bondarenko <bond.anton@gmail.com>
 License: MIT License
@@ -86,7 +86,7 @@ A driver reaches a drive over one of two transports:
 
 | Field | Intek SPE-B | Vesper E5-8200 | Vesper E4-8400 |
 | --- | --- | --- | --- |
-| `frequency_hz` | yes | yes | yes |
+| `frequency_hz` | yes¹ | yes | yes |
 | `frequency_percent` | yes | yes | yes |
 | `output_current` | yes | yes | yes |
 | `output_voltage` | yes | yes | yes |
@@ -98,6 +98,12 @@ A driver reaches a drive over one of two transports:
 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 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
+connection stays usable and only the Hz field degrades. `set_frequency` is
+refused in that state, because no percentage can be computed.
+
 ## Installation
 
 Install the package via pip (assuming it's published to PyPI):

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

@@ -159,12 +159,48 @@ def test_read_parameters_uses_the_coarse_current_resolution():
     assert asyncio.run(vfd.read_parameters()).output_current == pytest.approx(12.3)
 
 
-def test_read_parameters_reports_zero_hz_when_p010_is_zero():
-    """An unreadable maximum frequency keeps the percentage but cannot scale it."""
+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)
     parameters = asyncio.run(vfd.read_parameters())
     assert parameters.frequency_percent == pytest.approx(50.0)
-    assert parameters.frequency_hz == pytest.approx(0.0)
+    assert parameters.frequency_hz is None
+
+
+def test_connect_survives_a_refused_p010_and_still_reports_measurements():
+    """A drive that refuses P0.10 must not blank the whole snapshot.
+
+    An SPE-B that has not been configured for Modbus (Pd.01/Pd.05) answers the
+    gateway with exception 11 for every register. Raising from `connect()` made
+    the poll loop log a connect failure every cycle and publish nothing; the
+    percentage, current, voltage and power are still readable, so only
+    `frequency_hz` degrades to None.
+    """
+    stub = _StubClient(
+        [
+            ExceptionResponse(function_code=3),  # P0.10
+            _read([1]),  # Pd.06 = coarse, 0.1 A
+            _read([5000, 540, 380, 123, 45]),
+            _read([1]),  # status: running forward
+        ]
+    )
+    vfd = IntekSPEBModbusVFD("127.0.0.1")
+    vfd._client = stub
+    asyncio.run(vfd.connect())
+    parameters = asyncio.run(vfd.read_parameters())
+    assert parameters.frequency_percent == pytest.approx(50.0)
+    assert parameters.frequency_hz is None
+    assert parameters.output_current == pytest.approx(12.3)
+    assert parameters.output_voltage == pytest.approx(380.0)
+    assert parameters.dc_bus_voltage == pytest.approx(540.0)
+    assert parameters.state is VFDState.RUNNING_FORWARD
+
+
+def test_set_frequency_still_refuses_when_p010_is_unknown():
+    """Without P0.10 no percentage can be computed, so the write is rejected."""
+    vfd, _ = _connected([], max_frequency_raw=0)
+    with pytest.raises(ValueError, match="P0.10"):
+        asyncio.run(vfd.set_frequency(25.0))
 
 
 def test_read_parameters_survives_an_unreadable_status_register():