python-qube-heatpump 1.10.0__tar.gz → 1.11.1__tar.gz

{python_qube_heatpump-1.10.0 → python_qube_heatpump-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-qube-heatpump
-Version: 1.10.0
+Version: 1.11.1
 Summary: Async Modbus client for Qube Heat Pumps
 Project-URL: Homepage, https://github.com/MattieGit/python-qube-heatpump
 Project-URL: Bug Tracker, https://github.com/MattieGit/python-qube-heatpump/issues

{python_qube_heatpump-1.10.0 → python_qube_heatpump-1.11.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-qube-heatpump"
-version = "1.10.0"
+version = "1.11.1"
 authors = [
   { name="MattieGit", email="6250046+MattieGit@users.noreply.github.com" },
 ]

{python_qube_heatpump-1.10.0 → python_qube_heatpump-1.11.1}/src/python_qube_heatpump/client.py

@@ -192,7 +192,7 @@ class QubeClient:
             Version as string (e.g., "2.15"), or None on error.
         """
         value = await self.read_value(const.SOFTWARE_VERSION)
-        if value is None:
+        if value is None or value == 0.0:
             return None
         return str(round(value, 2))
 
@@ -512,6 +512,47 @@ class QubeClient:
             _LOGGER.error("Exception writing switch %s: %s", key, e)
             return False
 
+    # SG Ready mode API
+    SG_READY_MODES = ("off", "block", "plus", "max")
+    _SGREADY_MODE_TO_BITS: dict[str, tuple[bool, bool]] = {
+        "off": (False, False),
+        "block": (True, False),
+        "plus": (False, True),
+        "max": (True, True),
+    }
+    _SGREADY_BITS_TO_MODE: dict[tuple[bool, bool], str] = {
+        v: k for k, v in _SGREADY_MODE_TO_BITS.items()
+    }
+
+    async def get_sg_ready_mode(self) -> str | None:
+        """Read the current SG Ready mode.
+
+        Returns:
+            Mode string ("off", "block", "plus", "max"), or None on error.
+        """
+        bit_a = await self.read_switch("bms_sgready_a")
+        bit_b = await self.read_switch("bms_sgready_b")
+        if bit_a is None or bit_b is None:
+            return None
+        return self._SGREADY_BITS_TO_MODE.get((bool(bit_a), bool(bit_b)))
+
+    async def set_sg_ready_mode(self, mode: str) -> bool:
+        """Set the SG Ready mode.
+
+        Args:
+            mode: One of "off", "block", "plus", "max".
+
+        Returns:
+            True if both writes succeeded, False otherwise.
+        """
+        bits = self._SGREADY_MODE_TO_BITS.get(mode)
+        if bits is None:
+            _LOGGER.warning("Unknown SG Ready mode: %s", mode)
+            return False
+        success_a = await self.write_switch("bms_sgready_a", bits[0])
+        success_b = await self.write_switch("bms_sgready_b", bits[1])
+        return success_a and success_b
+
     async def write_setpoint(self, key: str, value: float) -> bool:
         """Write a setpoint value by key.
 

{python_qube_heatpump-1.10.0 → python_qube_heatpump-1.11.1}/tests/test_client.py

@@ -435,3 +435,97 @@ async def test_get_all_data_applies_clamping(mock_modbus_client):
     # Energy values stored in cache
     assert client.monotonic_cache.get("energy_total_electric") == 0.0
     assert client.monotonic_cache.get("energy_total_thermic") == 0.0
+
+
+@pytest.mark.asyncio
+async def test_get_sg_ready_mode(mock_modbus_client):
+    """Test reading SG Ready mode from coil bits."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    client._client = mock_instance
+
+    # Mock coil reads: A=False, B=True -> "plus"
+    mock_resp_a = MagicMock()
+    mock_resp_a.isError.return_value = False
+    mock_resp_a.bits = [False]
+
+    mock_resp_b = MagicMock()
+    mock_resp_b.isError.return_value = False
+    mock_resp_b.bits = [True]
+
+    mock_instance.read_coils = AsyncMock(side_effect=[mock_resp_a, mock_resp_b])
+
+    result = await client.get_sg_ready_mode()
+    assert result == "plus"
+
+
+@pytest.mark.asyncio
+async def test_get_sg_ready_mode_all_modes(mock_modbus_client):
+    """Test all SG Ready mode combinations."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    client._client = mock_instance
+
+    cases = [
+        ((False, False), "off"),
+        ((True, False), "block"),
+        ((False, True), "plus"),
+        ((True, True), "max"),
+    ]
+    for (bit_a, bit_b), expected_mode in cases:
+        resp_a = MagicMock()
+        resp_a.isError.return_value = False
+        resp_a.bits = [bit_a]
+        resp_b = MagicMock()
+        resp_b.isError.return_value = False
+        resp_b.bits = [bit_b]
+        mock_instance.read_coils = AsyncMock(side_effect=[resp_a, resp_b])
+
+        result = await client.get_sg_ready_mode()
+        assert result == expected_mode, (
+            f"Expected {expected_mode} for bits ({bit_a}, {bit_b})"
+        )
+
+
+@pytest.mark.asyncio
+async def test_get_sg_ready_mode_read_error(mock_modbus_client):
+    """Test SG Ready mode returns None on read error."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    client._client = mock_instance
+
+    mock_resp = MagicMock()
+    mock_resp.isError.return_value = True
+    mock_instance.read_coils = AsyncMock(return_value=mock_resp)
+
+    result = await client.get_sg_ready_mode()
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_set_sg_ready_mode(mock_modbus_client):
+    """Test setting SG Ready mode writes both coils."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    client._client = mock_instance
+
+    mock_resp = MagicMock()
+    mock_resp.isError.return_value = False
+    mock_instance.write_coil = AsyncMock(return_value=mock_resp)
+
+    result = await client.set_sg_ready_mode("plus")
+    assert result is True
+
+    # "plus" = (False, True) -> A=False, B=True
+    calls = mock_instance.write_coil.call_args_list
+    assert len(calls) == 2
+    assert calls[0].args == (65, False)  # bms_sgready_a address
+    assert calls[1].args == (66, True)  # bms_sgready_b address
+
+
+@pytest.mark.asyncio
+async def test_set_sg_ready_mode_unknown(mock_modbus_client):
+    """Test setting unknown SG Ready mode returns False."""
+    client = QubeClient("1.2.3.4", 502)
+    result = await client.set_sg_ready_mode("turbo")
+    assert result is False