feat: add BatteryReserve and AllowGridCharging switches

Author: mkuthan

README.md

@@ -72,8 +72,8 @@ All Solis inverters should be supported, although the integration has been teste
 The integration provides a user-friendly interface to control your inverter settings. It allows you to:
 
 * ⚡ Control storage modes: "Self-Use", "Feed-In Priority" and "Off-Grid" (hybrid inverters only)
-* 🛠️ Access "Battery Reserve" and "Allow Grid Charging" options as Storage Mode attributes (hybrid inverters only)
 * ⏱️ Schedule charge and discharge slots (hybrid inverters only)
+* 🛠️ "Battery Reserve" and "Allow Grid Charging" switches (hybrid inverters only)
 * ⚖️ Set maximum export power
 * 🔌 Switch the inverter on or off
 

custom_components/solis_cloud_control/select.py

@@ -72,38 +72,26 @@ def current_option(self) -> str | None:
 
         return None
 
-    @property
-    def extra_state_attributes(self) -> dict[str, str]:
-        value_str = self.coordinator.data.get(self.storage_mode.cid)
-        value = safe_get_int_value(value_str)
-
-        attributes = {}
-        if value is not None:
-            battery_reserve = "ON" if value & (1 << self.storage_mode.bit_backup_mode) else "OFF"
-            allow_grid_charging = "ON" if value & (1 << self.storage_mode.bit_grid_charging) else "OFF"
-
-            attributes["battery_reserve"] = battery_reserve
-            attributes["allow_grid_charging"] = allow_grid_charging
-
-        return attributes
-
     async def async_select_option(self, option: str) -> None:
         value_str = self.coordinator.data.get(self.storage_mode.cid)
         value = safe_get_int_value(value_str)
         if value is None:
             return
 
-        value &= ~(1 << self.storage_mode.bit_self_use)
-        value &= ~(1 << self.storage_mode.bit_feed_in_priority)
-        value &= ~(1 << self.storage_mode.bit_off_grid)
+        # clear the bits for the storage mode options
+        new_value = value & ~(
+            (1 << self.storage_mode.bit_self_use)
+            | (1 << self.storage_mode.bit_feed_in_priority)
+            | (1 << self.storage_mode.bit_off_grid)
+        )
 
         if option == self.storage_mode.mode_self_use:
-            value |= 1 << self.storage_mode.bit_self_use
+            new_value |= 1 << self.storage_mode.bit_self_use
         elif option == self.storage_mode.mode_feed_in_priority:
-            value |= 1 << self.storage_mode.bit_feed_in_priority
+            new_value |= 1 << self.storage_mode.bit_feed_in_priority
         elif option == self.storage_mode.mode_off_grid:
-            value |= 1 << self.storage_mode.bit_off_grid
+            new_value |= 1 << self.storage_mode.bit_off_grid
 
-        _LOGGER.info("Setting storage mode to %s (value: %s)", option, value)
+        _LOGGER.info("Setting storage mode to %s (value: %s)", option, new_value)
 
-        await self.coordinator.control(self.storage_mode.cid, str(value))
+        await self.coordinator.control(self.storage_mode.cid, str(new_value))

custom_components/solis_cloud_control/switch.py

@@ -9,7 +9,9 @@
     InverterChargeDischargeSlot,
     InverterChargeDischargeSlots,
     InverterOnOff,
+    InverterStorageMode,  # Added import
 )
+from custom_components.solis_cloud_control.utils.safe_converters import safe_get_int_value  # Added import
 
 from .coordinator import SolisCloudControlCoordinator
 from .entity import SolisCloudControlEntity
@@ -69,6 +71,30 @@ async def async_setup_entry(
                 )
             )
 
+    if inverter.storage_mode is not None:
+        entities.append(
+            BatteryReserveSwitch(
+                coordinator=coordinator,
+                entity_description=SwitchEntityDescription(
+                    key="battery_reserve",
+                    name="Battery Reserve",
+                    icon="mdi:battery-heart-outline",
+                ),
+                storage_mode=inverter.storage_mode,
+            )
+        )
+        entities.append(
+            AllowGridChargingSwitch(
+                coordinator=coordinator,
+                entity_description=SwitchEntityDescription(
+                    key="allow_grid_charging",
+                    name="Allow Grid Charging",
+                    icon="mdi:battery-charging-outline",
+                ),
+                storage_mode=inverter.storage_mode,
+            )
+        )
+
     async_add_entities(entities)
 
 
@@ -148,3 +174,83 @@ def _calculate_old_value(self) -> str:
                 value |= 1 << bit_position
 
         return str(value)
+
+
+class BatteryReserveSwitch(SolisCloudControlEntity, SwitchEntity):
+    def __init__(
+        self,
+        coordinator: SolisCloudControlCoordinator,
+        entity_description: SwitchEntityDescription,
+        storage_mode: InverterStorageMode,
+    ) -> None:
+        super().__init__(coordinator, entity_description, storage_mode.cid)
+        self.storage_mode = storage_mode
+
+    @property
+    def is_on(self) -> bool | None:
+        value_str = self.coordinator.data.get(self.storage_mode.cid)
+        value = safe_get_int_value(value_str)
+        if value is None:
+            return None
+
+        return bool(value & (1 << self.storage_mode.bit_backup_mode))
+
+    async def async_turn_on(self, **kwargs: any) -> None:  # noqa: ARG002
+        await self._async_set_bit(True)
+
+    async def async_turn_off(self, **kwargs: any) -> None:  # noqa: ARG002
+        await self._async_set_bit(False)
+
+    async def _async_set_bit(self, state: bool) -> None:
+        value_str = self.coordinator.data.get(self.storage_mode.cid)
+        value = safe_get_int_value(value_str)
+        if value is None:
+            return
+
+        if state:
+            value |= 1 << self.storage_mode.bit_backup_mode
+        else:
+            value &= ~(1 << self.storage_mode.bit_backup_mode)
+
+        _LOGGER.info("Setting battery reserve to %s (value: %s)", state, value)
+        await self.coordinator.control(self.storage_mode.cid, str(value))
+
+
+class AllowGridChargingSwitch(SolisCloudControlEntity, SwitchEntity):
+    def __init__(
+        self,
+        coordinator: SolisCloudControlCoordinator,
+        entity_description: SwitchEntityDescription,
+        storage_mode: InverterStorageMode,
+    ) -> None:
+        super().__init__(coordinator, entity_description, storage_mode.cid)
+        self.storage_mode = storage_mode
+
+    @property
+    def is_on(self) -> bool | None:
+        value_str = self.coordinator.data.get(self.storage_mode.cid)
+        value = safe_get_int_value(value_str)
+        if value is None:
+            return None
+
+        return bool(value & (1 << self.storage_mode.bit_grid_charging))
+
+    async def async_turn_on(self, **kwargs: any) -> None:  # noqa: ARG002
+        await self._async_set_bit(True)
+
+    async def async_turn_off(self, **kwargs: any) -> None:  # noqa: ARG002
+        await self._async_set_bit(False)
+
+    async def _async_set_bit(self, state: bool) -> None:
+        value_str = self.coordinator.data.get(self.storage_mode.cid)
+        value = safe_get_int_value(value_str)
+        if value is None:
+            return
+
+        if state:
+            value |= 1 << self.storage_mode.bit_grid_charging
+        else:
+            value &= ~(1 << self.storage_mode.bit_grid_charging)
+
+        _LOGGER.info("Setting allow grid charging to %s (value: %s)", state, value)
+        await self.coordinator.control(self.storage_mode.cid, str(value))

tests/test_init.py

@@ -62,7 +62,7 @@ async def test_async_setup_entry(hass, mock_api_client, mock_config_entry, any_i
     assert platform_counts[Platform.NUMBER] == 26
     assert platform_counts[Platform.SELECT] == 1
     assert platform_counts[Platform.SENSOR] == 7
-    assert platform_counts[Platform.SWITCH] == 13
+    assert platform_counts[Platform.SWITCH] == 15
     assert platform_counts[Platform.TEXT] == 13
 
 

tests/test_select.py

@@ -42,24 +42,6 @@ async def test_current_option(self, storage_mode_entity, value, expected_mode):
         storage_mode_entity.coordinator.data = {storage_mode_entity.storage_mode.cid: value}
         assert storage_mode_entity.current_option == expected_mode
 
-    async def test_extra_state_attributes_on(self, storage_mode_entity):
-        value = (1 << InverterStorageMode.bit_backup_mode) | (1 << InverterStorageMode.bit_grid_charging)
-        storage_mode_entity.coordinator.data = {storage_mode_entity.storage_mode.cid: str(value)}
-
-        assert storage_mode_entity.extra_state_attributes == {
-            "battery_reserve": "ON",
-            "allow_grid_charging": "ON",
-        }
-
-    async def test_extra_state_attributes_off(self, storage_mode_entity):
-        value = 0
-        storage_mode_entity.coordinator.data = {storage_mode_entity.storage_mode.cid: str(value)}
-
-        assert storage_mode_entity.extra_state_attributes == {
-            "battery_reserve": "OFF",
-            "allow_grid_charging": "OFF",
-        }
-
     @pytest.mark.parametrize(
         ("option", "expected_value"),
         [
@@ -75,6 +57,32 @@ async def test_async_select_option(self, storage_mode_entity, option, expected_v
             storage_mode_entity.storage_mode.cid, expected_value
         )
 
+    @pytest.mark.parametrize(
+        "mode,bit",
+        [
+            (InverterStorageMode.mode_self_use, InverterStorageMode.bit_self_use),
+            (InverterStorageMode.mode_feed_in_priority, InverterStorageMode.bit_feed_in_priority),
+            (InverterStorageMode.mode_off_grid, InverterStorageMode.bit_off_grid),
+        ],
+    )
+    async def test_async_select_option_preserves_other_bits(self, storage_mode_entity, mode, bit):
+        other_bits = 0b10111010
+
+        # set initial value with storage mode bits cleared
+        initial_value = other_bits & ~(
+            (1 << InverterStorageMode.bit_self_use)
+            | (1 << InverterStorageMode.bit_feed_in_priority)
+            | (1 << InverterStorageMode.bit_off_grid)
+        )
+        storage_mode_entity.coordinator.data = {storage_mode_entity.storage_mode.cid: initial_value}
+
+        await storage_mode_entity.async_select_option(mode)
+
+        expected_value = initial_value | (1 << bit)
+        storage_mode_entity.coordinator.control.assert_awaited_once_with(
+            storage_mode_entity.storage_mode.cid, str(expected_value)
+        )
+
     @pytest.mark.parametrize(
         "initial_value",
         [

tests/test_switch.py

@@ -1,7 +1,12 @@
 import pytest
 from homeassistant.components.switch import SwitchEntityDescription
 
-from custom_components.solis_cloud_control.switch import OnOffSwitch, SlotSwitch
+from custom_components.solis_cloud_control.switch import (
+    AllowGridChargingSwitch,
+    BatteryReserveSwitch,
+    OnOffSwitch,
+    SlotSwitch,
+)
 
 
 @pytest.fixture
@@ -82,3 +87,117 @@ async def test_turn_off(self, slot_switch):
         slot_switch.coordinator.data = {slot_switch.charge_discharge_slot.switch_cid: "1"}
         await slot_switch.async_turn_off()
         slot_switch.coordinator.control.assert_awaited_once_with(slot_switch.charge_discharge_slot.switch_cid, "0", "1")
+
+
+@pytest.fixture
+def battery_reserve_switch(mock_coordinator, any_inverter):
+    return BatteryReserveSwitch(
+        coordinator=mock_coordinator,
+        entity_description=SwitchEntityDescription(
+            key="battery_reserve",
+            name="Battery Reserve",
+            icon="mdi:battery-heart-outline",
+        ),
+        storage_mode=any_inverter.storage_mode,
+    )
+
+
+class TestBatteryReserveSwitch:
+    def test_is_on_when_none(self, battery_reserve_switch):
+        battery_reserve_switch.coordinator.data = {battery_reserve_switch.storage_mode.cid: None}
+        assert battery_reserve_switch.is_on is None
+
+    def test_is_on_when_on(self, battery_reserve_switch):
+        bit = battery_reserve_switch.storage_mode.bit_backup_mode
+        battery_reserve_switch.coordinator.data = {battery_reserve_switch.storage_mode.cid: str(1 << bit)}
+        assert battery_reserve_switch.is_on is True
+
+    def test_is_on_when_off(self, battery_reserve_switch):
+        battery_reserve_switch.coordinator.data = {battery_reserve_switch.storage_mode.cid: str(0)}
+        assert battery_reserve_switch.is_on is False
+
+    async def test_turn_on(self, battery_reserve_switch):
+        bit = battery_reserve_switch.storage_mode.bit_backup_mode
+        battery_reserve_switch.coordinator.data = {battery_reserve_switch.storage_mode.cid: str(0)}
+        await battery_reserve_switch.async_turn_on()
+        battery_reserve_switch.coordinator.control.assert_awaited_once_with(
+            battery_reserve_switch.storage_mode.cid, str(1 << bit)
+        )
+
+    async def test_turn_off(self, battery_reserve_switch):
+        bit = battery_reserve_switch.storage_mode.bit_backup_mode
+        battery_reserve_switch.coordinator.data = {battery_reserve_switch.storage_mode.cid: str(1 << bit)}
+        await battery_reserve_switch.async_turn_off()
+        battery_reserve_switch.coordinator.control.assert_awaited_once_with(
+            battery_reserve_switch.storage_mode.cid, str(0)
+        )
+
+    @pytest.mark.parametrize(
+        "initial_value",
+        [
+            "not a number",
+            None,
+        ],
+    )
+    async def test_async_turn_on_off_invalid_initial(self, battery_reserve_switch, initial_value):
+        battery_reserve_switch.coordinator.data = {battery_reserve_switch.storage_mode.cid: initial_value}
+        await battery_reserve_switch.async_turn_on()
+        await battery_reserve_switch.async_turn_off()
+        battery_reserve_switch.coordinator.control.assert_not_awaited()
+
+
+@pytest.fixture
+def allow_grid_charging_switch(mock_coordinator, any_inverter):
+    return AllowGridChargingSwitch(
+        coordinator=mock_coordinator,
+        entity_description=SwitchEntityDescription(
+            key="allow_grid_charging",
+            name="Allow Grid Charging",
+            icon="mdi:battery-charging-outline",
+        ),
+        storage_mode=any_inverter.storage_mode,
+    )
+
+
+class TestAllowGridChargingSwitch:
+    def test_is_on_when_none(self, allow_grid_charging_switch):
+        allow_grid_charging_switch.coordinator.data = {allow_grid_charging_switch.storage_mode.cid: None}
+        assert allow_grid_charging_switch.is_on is None
+
+    def test_is_on_when_on(self, allow_grid_charging_switch):
+        bit = allow_grid_charging_switch.storage_mode.bit_grid_charging
+        allow_grid_charging_switch.coordinator.data = {allow_grid_charging_switch.storage_mode.cid: str(1 << bit)}
+        assert allow_grid_charging_switch.is_on is True
+
+    def test_is_on_when_off(self, allow_grid_charging_switch):
+        allow_grid_charging_switch.coordinator.data = {allow_grid_charging_switch.storage_mode.cid: str(0)}
+        assert allow_grid_charging_switch.is_on is False
+
+    async def test_turn_on(self, allow_grid_charging_switch):
+        bit = allow_grid_charging_switch.storage_mode.bit_grid_charging
+        allow_grid_charging_switch.coordinator.data = {allow_grid_charging_switch.storage_mode.cid: str(0)}
+        await allow_grid_charging_switch.async_turn_on()
+        allow_grid_charging_switch.coordinator.control.assert_awaited_once_with(
+            allow_grid_charging_switch.storage_mode.cid, str(1 << bit)
+        )
+
+    async def test_turn_off(self, allow_grid_charging_switch):
+        bit = allow_grid_charging_switch.storage_mode.bit_grid_charging
+        allow_grid_charging_switch.coordinator.data = {allow_grid_charging_switch.storage_mode.cid: str(1 << bit)}
+        await allow_grid_charging_switch.async_turn_off()
+        allow_grid_charging_switch.coordinator.control.assert_awaited_once_with(
+            allow_grid_charging_switch.storage_mode.cid, str(0)
+        )
+
+    @pytest.mark.parametrize(
+        "initial_value",
+        [
+            "not a number",
+            None,
+        ],
+    )
+    async def test_async_turn_on_off_invalid_initial(self, allow_grid_charging_switch, initial_value):
+        allow_grid_charging_switch.coordinator.data = {allow_grid_charging_switch.storage_mode.cid: initial_value}
+        await allow_grid_charging_switch.async_turn_on()
+        await allow_grid_charging_switch.async_turn_off()
+        allow_grid_charging_switch.coordinator.control.assert_not_awaited()