Homevolt 0.2.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

homevolt/homevolt.py

@@ -3,10 +3,24 @@
 from __future__ import annotations
 
 import logging
+from typing import Any
 
 import aiohttp
 
-from .device import Device
+from .const import (
+    DEVICE_MAP,
+    ENDPOINT_CONSOLE,
+    ENDPOINT_EMS,
+    ENDPOINT_PARAMS,
+    ENDPOINT_SCHEDULE,
+    SCHEDULE_TYPE,
+)
+from .exceptions import (
+    HomevoltAuthenticationError,
+    HomevoltConnectionError,
+    HomevoltDataError,
+)
+from .models import DeviceMetadata, Sensor
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -33,34 +47,18 @@ class Homevolt:
         self._password = password
         self._websession = websession
         self._own_session = websession is None
+        self._auth = aiohttp.BasicAuth("admin", password) if password else None
 
-        self._device: Device | None = None
+        self.unique_id: str | None = None
+        self.sensors: dict[str, Sensor] = {}
+        self.device_metadata: dict[str, DeviceMetadata] = {}
+        self.current_schedule: dict[str, Any] | None = None
 
     async def update_info(self) -> None:
-        """Fetch and update device information."""
-        if self._device is None:
-            await self._ensure_session()
-            assert self._websession is not None
-            self._device = Device(
-                base_url=self.base_url,
-                password=self._password,
-                websession=self._websession,
-            )
-
-        await self._device.update_info()
-
-    def get_device(self) -> Device:
-        """Get the device object.
-
-        Returns:
-            The Device object for this Homevolt connection
-
-        Raises:
-            RuntimeError: If device information hasn't been fetched yet
-        """
-        if self._device is None:
-            raise RuntimeError("Device information not yet fetched. Call update_info() first.")
-        return self._device
+        """Fetch and update all device information."""
+        await self._ensure_session()
+        await self.fetch_ems_data()
+        await self.fetch_schedule_data()
 
     async def close_connection(self) -> None:
         """Close the connection and clean up resources."""
@@ -82,3 +80,718 @@ class Homevolt:
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         """Async context manager exit."""
         await self.close_connection()
+
+    async def fetch_ems_data(self) -> None:
+        """Fetch EMS data from the device."""
+        await self._ensure_session()
+        assert self._websession is not None
+        url = f"{self.base_url}{ENDPOINT_EMS}"
+        try:
+            async with self._websession.get(url, auth=self._auth) as response:
+                if response.status == 401:
+                    raise HomevoltAuthenticationError("Authentication failed")
+                response.raise_for_status()
+                ems_data = await response.json()
+        except aiohttp.ClientError as err:
+            raise HomevoltConnectionError(f"Failed to connect to device: {err}") from err
+        except Exception as err:
+            raise HomevoltDataError(f"Failed to parse EMS data: {err}") from err
+        _LOGGER.debug("EMS Data: %s", ems_data)
+        self._parse_ems_data(ems_data)
+
+    async def fetch_schedule_data(self) -> None:
+        """Fetch schedule data from the device."""
+        await self._ensure_session()
+        assert self._websession is not None
+        url = f"{self.base_url}{ENDPOINT_SCHEDULE}"
+        try:
+            async with self._websession.get(url, auth=self._auth) as response:
+                if response.status == 401:
+                    raise HomevoltAuthenticationError("Authentication failed")
+                response.raise_for_status()
+                schedule_data = await response.json()
+        except aiohttp.ClientError as err:
+            raise HomevoltConnectionError(f"Failed to connect to device: {err}") from err
+        except Exception as err:
+            raise HomevoltDataError(f"Failed to parse schedule data: {err}") from err
+
+        _LOGGER.debug("Schedule Data: %s", schedule_data)
+        self._parse_schedule_data(schedule_data)
+
+    def _parse_ems_data(self, ems_data: dict[str, Any]) -> None:
+        """Parse EMS JSON response."""
+        if not ems_data.get("ems") or not ems_data["ems"]:
+            raise HomevoltDataError("No EMS data found in response")
+
+        device_id = str(ems_data["ems"][0]["ecu_id"])
+        self.unique_id = device_id
+        ems_device_id = f"ems_{device_id}"
+
+        # Initialize device metadata
+        self.device_metadata = {
+            ems_device_id: DeviceMetadata(name=f"Homevolt EMS {device_id}", model="EMS"),
+            "grid": DeviceMetadata(name="Homevolt Grid Sensor", model="Grid Sensor"),
+            "solar": DeviceMetadata(name="Homevolt Solar Sensor", model="Solar Sensor"),
+            "load": DeviceMetadata(name="Homevolt Load Sensor", model="Load Sensor"),
+        }
+
+        # Initialize sensors dictionary
+        self.sensors = {}
+
+        # EMS device sensors - all main EMS data
+        ems = ems_data["ems"][0]
+        self.sensors.update(
+            {
+                "L1 Voltage": Sensor(
+                    value=ems["ems_voltage"]["l1"] / 10,
+                    key="l1_voltage",
+                    device_identifier=ems_device_id,
+                ),
+                "L2 Voltage": Sensor(
+                    value=ems["ems_voltage"]["l2"] / 10,
+                    key="l2_voltage",
+                    device_identifier=ems_device_id,
+                ),
+                "L3 Voltage": Sensor(
+                    value=ems["ems_voltage"]["l3"] / 10,
+                    key="l3_voltage",
+                    device_identifier=ems_device_id,
+                ),
+                "L1_L2 Voltage": Sensor(
+                    value=ems["ems_voltage"]["l1_l2"] / 10,
+                    key="l1_l2_voltage",
+                    device_identifier=ems_device_id,
+                ),
+                "L2_L3 Voltage": Sensor(
+                    value=ems["ems_voltage"]["l2_l3"] / 10,
+                    key="l2_l3_voltage",
+                    device_identifier=ems_device_id,
+                ),
+                "L3_L1 Voltage": Sensor(
+                    value=ems["ems_voltage"]["l3_l1"] / 10,
+                    key="l3_l1_voltage",
+                    device_identifier=ems_device_id,
+                ),
+                "L1 Current": Sensor(
+                    value=ems["ems_current"]["l1"],
+                    key="l1_current",
+                    device_identifier=ems_device_id,
+                ),
+                "L2 Current": Sensor(
+                    value=ems["ems_current"]["l2"],
+                    key="l2_current",
+                    device_identifier=ems_device_id,
+                ),
+                "L3 Current": Sensor(
+                    value=ems["ems_current"]["l3"],
+                    key="l3_current",
+                    device_identifier=ems_device_id,
+                ),
+                "System Temperature": Sensor(
+                    value=ems["ems_data"]["sys_temp"] / 10.0,
+                    key="system_temperature",
+                    device_identifier=ems_device_id,
+                ),
+                "Imported Energy": Sensor(
+                    value=ems["ems_aggregate"]["imported_kwh"],
+                    key="imported_energy",
+                    device_identifier=ems_device_id,
+                ),
+                "Exported Energy": Sensor(
+                    value=ems["ems_aggregate"]["exported_kwh"],
+                    key="exported_energy",
+                    device_identifier=ems_device_id,
+                ),
+                "Available Charging Power": Sensor(
+                    value=ems["ems_prediction"]["avail_ch_pwr"],
+                    key="available_charging_power",
+                    device_identifier=ems_device_id,
+                ),
+                "Available Discharge Power": Sensor(
+                    value=ems["ems_prediction"]["avail_di_pwr"],
+                    key="available_discharge_power",
+                    device_identifier=ems_device_id,
+                ),
+                "Available Charging Energy": Sensor(
+                    value=ems["ems_prediction"]["avail_ch_energy"],
+                    key="available_charging_energy",
+                    device_identifier=ems_device_id,
+                ),
+                "Available Discharge Energy": Sensor(
+                    value=ems["ems_prediction"]["avail_di_energy"],
+                    key="available_discharge_energy",
+                    device_identifier=ems_device_id,
+                ),
+                "Power": Sensor(
+                    value=ems["ems_data"]["power"],
+                    key="power",
+                    device_identifier=ems_device_id,
+                ),
+                "Frequency": Sensor(
+                    value=ems["ems_data"]["frequency"],
+                    key="frequency",
+                    device_identifier=ems_device_id,
+                ),
+                "Battery State of Charge": Sensor(
+                    value=ems["ems_data"]["soc_avg"] / 100,
+                    key="battery_state_of_charge",
+                    device_identifier=ems_device_id,
+                ),
+            }
+        )
+
+        # Battery sensors
+        for bat_id, battery in enumerate(ems.get("bms_data", [])):
+            battery_device_id = f"battery_{bat_id}"
+            self.device_metadata[battery_device_id] = DeviceMetadata(
+                name=f"Homevolt Battery {bat_id}",
+                model="Battery blade",
+            )
+            if "soc" in battery:
+                self.sensors[f"Homevolt battery {bat_id}"] = Sensor(
+                    value=battery["soc"] / 100,
+                    key="state_of_charge",
+                    device_identifier=battery_device_id,
+                )
+            if "tmin" in battery:
+                self.sensors[f"Homevolt battery {bat_id} tmin"] = Sensor(
+                    value=battery["tmin"] / 10,
+                    key="tmin",
+                    device_identifier=battery_device_id,
+                )
+            if "tmax" in battery:
+                self.sensors[f"Homevolt battery {bat_id} tmax"] = Sensor(
+                    value=battery["tmax"] / 10,
+                    key="tmax",
+                    device_identifier=battery_device_id,
+                )
+            if "cycle_count" in battery:
+                self.sensors[f"Homevolt battery {bat_id} charge cycles"] = Sensor(
+                    value=battery["cycle_count"],
+                    key="charge_cycles",
+                    device_identifier=battery_device_id,
+                )
+            if "voltage" in battery:
+                self.sensors[f"Homevolt battery {bat_id} voltage"] = Sensor(
+                    value=battery["voltage"] / 100,
+                    key="voltage",
+                    device_identifier=battery_device_id,
+                )
+            if "current" in battery:
+                self.sensors[f"Homevolt battery {bat_id} current"] = Sensor(
+                    value=battery["current"],
+                    key="current",
+                    device_identifier=battery_device_id,
+                )
+            if "power" in battery:
+                self.sensors[f"Homevolt battery {bat_id} power"] = Sensor(
+                    value=battery["power"],
+                    key="power",
+                    device_identifier=battery_device_id,
+                )
+            if "soh" in battery:
+                self.sensors[f"Homevolt battery {bat_id} soh"] = Sensor(
+                    value=battery["soh"] / 100,
+                    key="soh",
+                    device_identifier=battery_device_id,
+                )
+
+        # External sensors (grid, solar, load)
+        for sensor in ems_data.get("sensors", []):
+            if not sensor.get("available"):
+                continue
+
+            sensor_type = sensor["type"]
+            sensor_device_id = DEVICE_MAP.get(sensor_type)
+
+            if not sensor_device_id:
+                continue
+
+            # Calculate total power from all phases
+            total_power = sum(phase["power"] for phase in sensor.get("phase", []))
+
+            self.sensors[f"Power {sensor_type}"] = Sensor(
+                value=total_power,
+                key=f"power_{sensor_type}",
+                device_identifier=sensor_device_id,
+            )
+            self.sensors[f"Energy imported {sensor_type}"] = Sensor(
+                value=sensor.get("energy_imported", 0),
+                key=f"energy_imported_{sensor_type}",
+                device_identifier=sensor_device_id,
+            )
+            self.sensors[f"Energy exported {sensor_type}"] = Sensor(
+                value=sensor.get("energy_exported", 0),
+                key=f"energy_exported_{sensor_type}",
+                device_identifier=sensor_device_id,
+            )
+            self.sensors[f"RSSI {sensor_type}"] = Sensor(
+                value=sensor.get("rssi"),
+                key=f"rssi_{sensor_type}",
+                device_identifier=sensor_device_id,
+            )
+            self.sensors[f"Average RSSI {sensor_type}"] = Sensor(
+                value=sensor.get("average_rssi"),
+                key=f"average_rssi_{sensor_type}",
+                device_identifier=sensor_device_id,
+            )
+
+            # Phase-specific sensors
+            for phase_name, phase in zip(["L1", "L2", "L3"], sensor.get("phase", [])):
+                phase_lower = phase_name.lower()
+                self.sensors[f"{phase_name} Voltage {sensor_type}"] = Sensor(
+                    value=phase.get("voltage"),
+                    key=f"{phase_lower}_voltage_{sensor_type}",
+                    device_identifier=sensor_device_id,
+                )
+                self.sensors[f"{phase_name} Current {sensor_type}"] = Sensor(
+                    value=phase.get("amp"),
+                    key=f"{phase_lower}_current_{sensor_type}",
+                    device_identifier=sensor_device_id,
+                )
+                self.sensors[f"{phase_name} Power {sensor_type}"] = Sensor(
+                    value=phase.get("power"),
+                    key=f"{phase_lower}_power_{sensor_type}",
+                    device_identifier=sensor_device_id,
+                )
+
+    def _parse_schedule_data(self, schedule_data: dict[str, Any]) -> None:
+        """Parse schedule JSON response."""
+        self.current_schedule = schedule_data
+
+        if not self.unique_id:
+            return
+
+        ems_device_id = f"ems_{self.unique_id}"
+
+        self.sensors["Schedule id"] = Sensor(
+            value=schedule_data.get("schedule_id"),
+            key="schedule_id",
+            device_identifier=ems_device_id,
+        )
+
+        schedule = (
+            schedule_data.get("schedule", [{}])[0]
+            if schedule_data.get("schedule")
+            else {"type": -1, "params": {}}
+        )
+
+        self.sensors["Schedule Type"] = Sensor(
+            value=SCHEDULE_TYPE.get(schedule.get("type", -1)),
+            key="schedule_type",
+            device_identifier=ems_device_id,
+        )
+        self.sensors["Schedule Power Setpoint"] = Sensor(
+            value=schedule.get("params", {}).get("setpoint"),
+            key="schedule_power_setpoint",
+            device_identifier=ems_device_id,
+        )
+        self.sensors["Schedule Max Power"] = Sensor(
+            value=schedule.get("max_charge"),
+            key="schedule_max_power",
+            device_identifier=ems_device_id,
+        )
+        self.sensors["Schedule Max Discharge"] = Sensor(
+            value=schedule.get("max_discharge"),
+            key="schedule_max_discharge",
+            device_identifier=ems_device_id,
+        )
+
+    async def _execute_console_command(self, command: str) -> dict[str, Any]:
+        """Execute a console command via the HTTP API.
+
+        Args:
+            command: The console command to execute
+
+        Returns:
+            The JSON response from the console endpoint
+
+        Raises:
+            HomevoltConnectionError: If connection fails
+            HomevoltAuthenticationError: If authentication fails
+            HomevoltDataError: If response parsing fails
+        """
+        await self._ensure_session()
+        assert self._websession is not None
+        try:
+            url = f"{self.base_url}{ENDPOINT_CONSOLE}"
+            async with self._websession.post(
+                url,
+                auth=self._auth,
+                json={"cmd": command},
+            ) as response:
+                if response.status == 401:
+                    raise HomevoltAuthenticationError("Authentication failed")
+                response.raise_for_status()
+                return await response.json()
+        except aiohttp.ClientError as err:
+            raise HomevoltConnectionError(f"Failed to execute command: {err}") from err
+        except Exception as err:
+            raise HomevoltDataError(f"Failed to parse command response: {err}") from err
+
+    async def set_battery_mode(
+        self,
+        mode: int,
+        *,
+        setpoint: int | None = None,
+        max_charge: int | None = None,
+        max_discharge: int | None = None,
+        min_soc: int | None = None,
+        max_soc: int | None = None,
+        offline: bool = False,
+    ) -> dict[str, Any]:
+        """Set immediate battery control mode.
+
+        Args:
+            mode: Schedule type (0=Idle, 1=Inverter Charge, 2=Inverter Discharge,
+                3=Grid Charge, 4=Grid Discharge, 5=Grid Charge/Discharge,
+                6=Frequency Reserve, 7=Solar Charge, 8=Solar Charge/Discharge,
+                9=Full Solar Export)
+            setpoint: Power setpoint in Watts (for grid modes)
+            max_charge: Maximum charge power in Watts
+            max_discharge: Maximum discharge power in Watts
+            min_soc: Minimum state of charge percentage
+            max_soc: Maximum state of charge percentage
+            offline: Take inverter offline during idle mode
+
+        Returns:
+            Response from the console command
+
+        Raises:
+            HomevoltConnectionError: If connection fails
+            HomevoltAuthenticationError: If authentication fails
+            HomevoltDataError: If command execution fails
+        """
+        if mode not in SCHEDULE_TYPE:
+            raise ValueError(f"Invalid mode: {mode}. Must be 0-9")
+
+        cmd_parts = [f"sched_set {mode}"]
+
+        if setpoint is not None:
+            cmd_parts.append(f"-s {setpoint}")
+        if max_charge is not None:
+            cmd_parts.append(f"-c {max_charge}")
+        if max_discharge is not None:
+            cmd_parts.append(f"-d {max_discharge}")
+        if min_soc is not None:
+            cmd_parts.append(f"--min {min_soc}")
+        if max_soc is not None:
+            cmd_parts.append(f"--max {max_soc}")
+        if offline:
+            cmd_parts.append("-o")
+
+        command = " ".join(cmd_parts)
+        return await self._execute_console_command(command)
+
+    async def add_schedule(
+        self,
+        mode: int,
+        *,
+        from_time: str | None = None,
+        to_time: str | None = None,
+        setpoint: int | None = None,
+        max_charge: int | None = None,
+        max_discharge: int | None = None,
+        min_soc: int | None = None,
+        max_soc: int | None = None,
+        offline: bool = False,
+    ) -> dict[str, Any]:
+        """Add a scheduled battery control entry.
+
+        Args:
+            mode: Schedule type (0=Idle, 1=Inverter Charge, 2=Inverter Discharge,
+                3=Grid Charge, 4=Grid Discharge, 5=Grid Charge/Discharge,
+                6=Frequency Reserve, 7=Solar Charge, 8=Solar Charge/Discharge,
+                9=Full Solar Export)
+            from_time: Start time in ISO format (YYYY-MM-DDTHH:mm:ss)
+            to_time: End time in ISO format (YYYY-MM-DDTHH:mm:ss)
+            setpoint: Power setpoint in Watts (for grid modes)
+            max_charge: Maximum charge power in Watts
+            max_discharge: Maximum discharge power in Watts
+            min_soc: Minimum state of charge percentage
+            max_soc: Maximum state of charge percentage
+            offline: Take inverter offline during idle mode
+
+        Returns:
+            Response from the console command
+
+        Raises:
+            HomevoltConnectionError: If connection fails
+            HomevoltAuthenticationError: If authentication fails
+            HomevoltDataError: If command execution fails
+        """
+        if mode not in SCHEDULE_TYPE:
+            raise ValueError(f"Invalid mode: {mode}. Must be 0-9")
+
+        cmd_parts = [f"sched_add {mode}"]
+
+        if from_time:
+            cmd_parts.append(f"--from {from_time}")
+        if to_time:
+            cmd_parts.append(f"--to {to_time}")
+        if setpoint is not None:
+            cmd_parts.append(f"-s {setpoint}")
+        if max_charge is not None:
+            cmd_parts.append(f"-c {max_charge}")
+        if max_discharge is not None:
+            cmd_parts.append(f"-d {max_discharge}")
+        if min_soc is not None:
+            cmd_parts.append(f"--min {min_soc}")
+        if max_soc is not None:
+            cmd_parts.append(f"--max {max_soc}")
+        if offline:
+            cmd_parts.append("-o")
+
+        command = " ".join(cmd_parts)
+        return await self._execute_console_command(command)
+
+    async def delete_schedule(self, schedule_id: int) -> dict[str, Any]:
+        """Delete a schedule by ID.
+
+        Args:
+            schedule_id: The ID of the schedule to delete
+
+        Returns:
+            Response from the console command
+
+        Raises:
+            HomevoltConnectionError: If connection fails
+            HomevoltAuthenticationError: If authentication fails
+            HomevoltDataError: If command execution fails
+        """
+        return await self._execute_console_command(f"sched_del {schedule_id}")
+
+    async def clear_all_schedules(self) -> dict[str, Any]:
+        """Clear all schedules.
+
+        Returns:
+            Response from the console command
+
+        Raises:
+            HomevoltConnectionError: If connection fails
+            HomevoltAuthenticationError: If authentication fails
+            HomevoltDataError: If command execution fails
+        """
+        return await self._execute_console_command("sched_clear")
+
+    async def enable_local_mode(self) -> dict[str, Any]:
+        """Enable local mode to prevent remote schedule overrides.
+
+        When enabled, remote schedules from Tibber/partners via MQTT will be blocked,
+        and only local schedules will be used.
+
+        Returns:
+            Response from the params endpoint
+
+        Raises:
+            HomevoltConnectionError: If connection fails
+            HomevoltAuthenticationError: If authentication fails
+            HomevoltDataError: If parameter setting fails
+        """
+        return await self.set_parameter("settings_local", 1)
+
+    async def disable_local_mode(self) -> dict[str, Any]:
+        """Disable local mode to allow remote schedule overrides.
+
+        When disabled, remote schedules from Tibber/partners via MQTT will replace
+        local schedules.
+
+        Returns:
+            Response from the params endpoint
+
+        Raises:
+            HomevoltConnectionError: If connection fails
+            HomevoltAuthenticationError: If authentication fails
+            HomevoltDataError: If parameter setting fails
+        """
+        return await self.set_parameter("settings_local", 0)
+
+    async def set_parameter(self, key: str, value: Any) -> dict[str, Any]:
+        """Set a device parameter.
+
+        Args:
+            key: Parameter name
+            value: Parameter value
+
+        Returns:
+            Response from the params endpoint
+
+        Raises:
+            HomevoltConnectionError: If connection fails
+            HomevoltAuthenticationError: If authentication fails
+            HomevoltDataError: If parameter setting fails
+        """
+        await self._ensure_session()
+        assert self._websession is not None
+        try:
+            url = f"{self.base_url}{ENDPOINT_PARAMS}"
+            async with self._websession.post(
+                url,
+                auth=self._auth,
+                json={key: value},
+            ) as response:
+                if response.status == 401:
+                    raise HomevoltAuthenticationError("Authentication failed")
+                response.raise_for_status()
+                return await response.json()
+        except aiohttp.ClientError as err:
+            raise HomevoltConnectionError(f"Failed to set parameter: {err}") from err
+        except Exception as err:
+            raise HomevoltDataError(f"Failed to parse parameter response: {err}") from err
+
+    async def get_parameter(self, key: str) -> Any:
+        """Get a device parameter value.
+
+        Args:
+            key: Parameter name
+
+        Returns:
+            Parameter value
+
+        Raises:
+            HomevoltConnectionError: If connection fails
+            HomevoltAuthenticationError: If authentication fails
+            HomevoltDataError: If parameter retrieval fails
+        """
+        await self._ensure_session()
+        assert self._websession is not None
+        try:
+            url = f"{self.base_url}{ENDPOINT_PARAMS}"
+            async with self._websession.get(url, auth=self._auth) as response:
+                if response.status == 401:
+                    raise HomevoltAuthenticationError("Authentication failed")
+                response.raise_for_status()
+                params = await response.json()
+                return params.get(key)
+        except aiohttp.ClientError as err:
+            raise HomevoltConnectionError(f"Failed to get parameter: {err}") from err
+        except Exception as err:
+            raise HomevoltDataError(f"Failed to parse parameter response: {err}") from err
+
+    async def charge_battery(
+        self,
+        *,
+        max_power: int | None = None,
+        max_soc: int | None = None,
+        min_soc: int | None = None,
+    ) -> dict[str, Any]:
+        """Charge battery using inverter (immediate).
+
+        Args:
+            max_power: Maximum charge power in Watts
+            max_soc: Maximum state of charge percentage (stops at this level)
+            min_soc: Minimum state of charge percentage (only charges if below this)
+
+        Returns:
+            Response from the console command
+        """
+        return await self.set_battery_mode(
+            1,  # Inverter Charge
+            max_charge=max_power,
+            max_soc=max_soc,
+            min_soc=min_soc,
+        )
+
+    async def discharge_battery(
+        self,
+        *,
+        max_power: int | None = None,
+        min_soc: int | None = None,
+        max_soc: int | None = None,
+    ) -> dict[str, Any]:
+        """Discharge battery using inverter (immediate).
+
+        Args:
+            max_power: Maximum discharge power in Watts
+            min_soc: Minimum state of charge percentage (stops at this level)
+            max_soc: Maximum state of charge percentage (only discharges if above this)
+
+        Returns:
+            Response from the console command
+        """
+        return await self.set_battery_mode(
+            2,  # Inverter Discharge
+            max_discharge=max_power,
+            min_soc=min_soc,
+            max_soc=max_soc,
+        )
+
+    async def set_battery_idle(self, *, offline: bool = False) -> dict[str, Any]:
+        """Set battery to idle mode (immediate).
+
+        Args:
+            offline: If True, take inverter offline during idle
+
+        Returns:
+            Response from the console command
+        """
+        return await self.set_battery_mode(0, offline=offline)
+
+    async def charge_from_grid(
+        self,
+        *,
+        setpoint: int,
+        max_power: int | None = None,
+        max_soc: int | None = None,
+    ) -> dict[str, Any]:
+        """Charge battery from grid with power setpoint (immediate).
+
+        Args:
+            setpoint: Power setpoint in Watts
+            max_power: Maximum charge power in Watts
+            max_soc: Maximum state of charge percentage
+
+        Returns:
+            Response from the console command
+        """
+        return await self.set_battery_mode(
+            3,  # Grid Charge
+            setpoint=setpoint,
+            max_charge=max_power,
+            max_soc=max_soc,
+        )
+
+    async def discharge_to_grid(
+        self,
+        *,
+        setpoint: int,
+        max_power: int | None = None,
+        min_soc: int | None = None,
+    ) -> dict[str, Any]:
+        """Discharge battery to grid with power setpoint (immediate).
+
+        Args:
+            setpoint: Power setpoint in Watts
+            max_power: Maximum discharge power in Watts
+            min_soc: Minimum state of charge percentage
+
+        Returns:
+            Response from the console command
+        """
+        return await self.set_battery_mode(
+            4,  # Grid Discharge
+            setpoint=setpoint,
+            max_discharge=max_power,
+            min_soc=min_soc,
+        )
+
+    async def charge_from_solar(
+        self,
+        *,
+        max_power: int | None = None,
+        max_soc: int | None = None,
+    ) -> dict[str, Any]:
+        """Charge battery from solar only (immediate).
+
+        Args:
+            max_power: Maximum charge power in Watts
+            max_soc: Maximum state of charge percentage
+
+        Returns:
+            Response from the console command
+        """
+        return await self.set_battery_mode(
+            7,  # Solar Charge
+            max_charge=max_power,
+            max_soc=max_soc,
+        )