Added select box for lademodus and switch to turn on/off

Author: derolli1976

custom_components/enpal_webparser/__init__.py

@@ -24,7 +24,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     hass.data.setdefault(DOMAIN, {})
 
     use_wallbox_addon = entry.options.get("use_wallbox_addon", False)
-    platforms = ["sensor"] + (["button"] if use_wallbox_addon else [])
+    
+    platforms = ["sensor"]
+    if use_wallbox_addon:
+        platforms.extend(["button", "switch", "select"])
 
     hass.data[DOMAIN][entry.entry_id] = {
         "config": entry.data,

custom_components/enpal_webparser/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/derolli1976/enpal/issues",
   "requirements": [],
-  "version": "2.0.2"
+  "version": "2.1.0"
 }

custom_components/enpal_webparser/select.py

@@ -0,0 +1,93 @@
+import logging
+from homeassistant.components.select import SelectEntity
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+# Mapping: API → UI
+MODE_MAP = {
+    "eco": "Eco",
+    "fast": "Full",
+    "solar": "Solar",
+}
+
+# UI → API
+REVERSE_MODE_MAP = {v.lower(): k for k, v in MODE_MAP.items()}
+
+async def async_setup_entry(hass, config_entry, async_add_entities):
+    if not config_entry.options.get("use_wallbox_addon", False):
+        return
+
+    async_add_entities([EnpalWallboxModeSelect(hass)], True)
+
+class EnpalWallboxModeSelect(SelectEntity):
+    def __init__(self, hass):
+        self._hass = hass
+        self._attr_name = "Wallbox Mode"
+        self._attr_unique_id = "enpal_wallbox_mode_select"
+        self._attr_options = list(MODE_MAP.values())
+        self._current_option = None
+        self._pending_change = None
+        self._base_url = "http://localhost:36725/wallbox"
+
+    @property
+    def current_option(self):
+        return self._pending_change or self._current_option
+
+    @property
+    def device_info(self):
+        return {
+            "identifiers": {(DOMAIN, "enpal_device")},
+            "name": "Enpal Webgerät",
+            "manufacturer": "Enpal",
+            "model": "Webparser",
+        }
+
+    async def async_update(self):
+        mode_entity = self._hass.states.get("sensor.wallbox_lademodus")
+        if not mode_entity:
+            return
+
+        mode = mode_entity.state.lower()
+        new_option = MODE_MAP.get(mode)
+
+        if not new_option:
+            _LOGGER.warning("Unknown wallbox mode from sensor: %s", mode)
+            return
+
+        # Wenn gerade ein pending change aktiv ist, dann prüfen:
+        if self._pending_change:
+            if self._pending_change == new_option:
+                # Auswahl wurde bestätigt → Pending löschen
+                _LOGGER.debug("Pending wallbox mode %s confirmed by sensor.", new_option)
+                self._current_option = new_option
+                self._pending_change = None
+            else:
+                # Auswahl noch nicht bestätigt → Anzeige bleibt unverändert
+                _LOGGER.debug("Wallbox mode change pending: %s (sensor reports %s)", self._pending_change, new_option)
+        else:
+            self._current_option = new_option
+
+    async def async_select_option(self, option: str):
+        key = REVERSE_MODE_MAP.get(option.lower())
+        if key:
+            self._pending_change = option
+            self.async_write_ha_state()
+
+            await self._call_wallbox_api(f"/set_{key}")
+
+            # Im Erfolgsfall übernehmen wir nicht direkt — wir warten auf Bestätigung durch Sensor
+        else:
+            _LOGGER.warning("Unknown selected option: %s", option)
+
+    async def _call_wallbox_api(self, endpoint):
+        url = f"{self._base_url}{endpoint}"
+        try:
+            session = async_get_clientsession(self._hass)
+            async with session.post(url, timeout=5) as resp:
+                if resp.status != 200:
+                    _LOGGER.warning("Wallbox API call failed: %s", url)
+        except Exception as e:
+            _LOGGER.error("Error calling wallbox API endpoint %s: %s", endpoint, e)

custom_components/enpal_webparser/switch.py

@@ -0,0 +1,73 @@
+import logging
+from homeassistant.components.switch import SwitchEntity
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+async def async_setup_entry(hass, config_entry, async_add_entities):
+    if not config_entry.options.get("use_wallbox_addon", False):
+        return
+
+    async_add_entities([EnpalWallboxSwitch(hass)], True)
+
+class EnpalWallboxSwitch(SwitchEntity):
+    def __init__(self, hass):
+        self._hass = hass
+        self._attr_name = "Wallbox Charging"
+        self._attr_unique_id = "enpal_wallbox_charging_switch"
+        self._is_on = False
+        self._pending_state = None
+        self._base_url = "http://localhost:36725/wallbox"
+
+    @property
+    def is_on(self):
+        return self._pending_state if self._pending_state is not None else self._is_on
+    
+    @property
+    def device_info(self):
+        return {
+            "identifiers": {(DOMAIN, "enpal_device")},
+            "name": "Enpal Webgerät",
+            "manufacturer": "Enpal",
+            "model": "Webparser",
+        }
+
+    async def async_update(self):
+        status_entity = self._hass.states.get("sensor.wallbox_status")
+        if not status_entity:
+            return
+
+        status = status_entity.state.lower()
+        new_state = status == "loading"
+
+        if self._pending_state is not None:
+            if self._pending_state == new_state:
+                _LOGGER.debug("Wallbox switch state confirmed by sensor: %s", status)
+                self._is_on = new_state
+                self._pending_state = None
+            else:
+                _LOGGER.debug("Wallbox switch state pending: requested=%s, sensor=%s", self._pending_state, new_state)
+        else:
+            self._is_on = new_state
+
+    async def async_turn_on(self, **kwargs):
+        await self._call_wallbox_api("/start")
+        self._pending_state = True
+        self.async_write_ha_state()
+
+    async def async_turn_off(self, **kwargs):
+        await self._call_wallbox_api("/stop")
+        self._pending_state = False
+        self.async_write_ha_state()
+
+    async def _call_wallbox_api(self, endpoint):
+        url = f"{self._base_url}{endpoint}"
+        try:
+            session = async_get_clientsession(self._hass)
+            async with session.post(url, timeout=5) as resp:
+                if resp.status != 200:
+                    _LOGGER.warning("Wallbox API call failed: %s", url)
+        except Exception as e:
+            _LOGGER.error("Error calling wallbox API endpoint %s: %s", endpoint, e)