Homevolt 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

homevolt/__init__.py

@@ -5,7 +5,7 @@ from .exceptions import (
     HomevoltAuthenticationError,
     HomevoltConnectionError,
     HomevoltDataError,
-    HomevoltException,
+    HomevoltError,
 )
 from .homevolt import Homevolt
 from .models import DeviceMetadata, Sensor, SensorType
@@ -17,8 +17,7 @@ __all__ = [
     "HomevoltAuthenticationError",
     "HomevoltConnectionError",
     "HomevoltDataError",
-    "HomevoltException",
+    "HomevoltError",
     "Sensor",
     "SensorType",
 ]
-

homevolt/const.py

@@ -3,14 +3,20 @@
 # API endpoints
 ENDPOINT_EMS = "/ems.json"
 ENDPOINT_SCHEDULE = "/schedule.json"
+ENDPOINT_CONSOLE = "/console.json"
+ENDPOINT_PARAMS = "/params.json"
 
 SCHEDULE_TYPE = {
     0: "Idle",
-    1: "Charge Setpoint",
-    2: "Discharge Setpoint",
-    3: "Charge Grid Setpoint",
-    4: "Discharge Grid Setpoint",
-    5: "Charge/Discharge Grid Setpoint",
+    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",
 }
 
 # Device type mappings for sensors
@@ -20,4 +26,3 @@ DEVICE_MAP = {
     "load": "load",
     "house": "load",
 }
-

homevolt/device.py

@@ -7,7 +7,14 @@ from typing import Any
 
 import aiohttp
 
-from .const import DEVICE_MAP, ENDPOINT_EMS, ENDPOINT_SCHEDULE, SCHEDULE_TYPE
+from .const import (
+    DEVICE_MAP,
+    ENDPOINT_CONSOLE,
+    ENDPOINT_EMS,
+    ENDPOINT_PARAMS,
+    ENDPOINT_SCHEDULE,
+    SCHEDULE_TYPE,
+)
 from .exceptions import (
     HomevoltAuthenticationError,
     HomevoltConnectionError,
@@ -210,26 +217,54 @@ class Device:
                 name=f"Homevolt Battery {bat_id}",
                 model="Homevolt Battery",
             )
-            self.sensors[f"Homevolt battery {bat_id}"] = Sensor(
-                value=battery["soc"] / 100,
-                type=SensorType.PERCENTAGE,
-                device_identifier=battery_device_id,
-            )
-            self.sensors[f"Homevolt battery {bat_id} tmin"] = Sensor(
-                value=battery["tmin"] / 10,
-                type=SensorType.TEMPERATURE,
-                device_identifier=battery_device_id,
-            )
-            self.sensors[f"Homevolt battery {bat_id} tmax"] = Sensor(
-                value=battery["tmax"] / 10,
-                type=SensorType.TEMPERATURE,
-                device_identifier=battery_device_id,
-            )
-            self.sensors[f"Homevolt battery {bat_id} charge cycles"] = Sensor(
-                value=battery["cycle_count"],
-                type=SensorType.COUNT,
-                device_identifier=battery_device_id,
-            )
+            if "soc" in battery:
+                self.sensors[f"Homevolt battery {bat_id}"] = Sensor(
+                    value=battery["soc"] / 100,
+                    type=SensorType.PERCENTAGE,
+                    device_identifier=battery_device_id,
+                )
+            if "tmin" in battery:
+                self.sensors[f"Homevolt battery {bat_id} tmin"] = Sensor(
+                    value=battery["tmin"] / 10,
+                    type=SensorType.TEMPERATURE,
+                    device_identifier=battery_device_id,
+                )
+            if "tmax" in battery:
+                self.sensors[f"Homevolt battery {bat_id} tmax"] = Sensor(
+                    value=battery["tmax"] / 10,
+                    type=SensorType.TEMPERATURE,
+                    device_identifier=battery_device_id,
+                )
+            if "cycle_count" in battery:
+                self.sensors[f"Homevolt battery {bat_id} charge cycles"] = Sensor(
+                    value=battery["cycle_count"],
+                    type=SensorType.COUNT,
+                    device_identifier=battery_device_id,
+                )
+            if "voltage" in battery:
+                self.sensors[f"Homevolt battery {bat_id} voltage"] = Sensor(
+                    value=battery["voltage"] / 100,
+                    type=SensorType.VOLTAGE,
+                    device_identifier=battery_device_id,
+                )
+            if "current" in battery:
+                self.sensors[f"Homevolt battery {bat_id} current"] = Sensor(
+                    value=battery["current"],
+                    type=SensorType.CURRENT,
+                    device_identifier=battery_device_id,
+                )
+            if "power" in battery:
+                self.sensors[f"Homevolt battery {bat_id} power"] = Sensor(
+                    value=battery["power"],
+                    type=SensorType.POWER,
+                    device_identifier=battery_device_id,
+                )
+            if "soh" in battery:
+                self.sensors[f"Homevolt battery {bat_id} soh"] = Sensor(
+                    value=battery["soh"] / 100,
+                    type=SensorType.PERCENTAGE,
+                    device_identifier=battery_device_id,
+                )
 
         # External sensors (grid, solar, load)
         for sensor in ems_data.get("sensors", []):
@@ -304,7 +339,11 @@ class Device:
             device_identifier=ems_device_id,
         )
 
-        schedule = schedule_data.get("schedule", [{}])[0] if schedule_data.get("schedule") else {"type": -1, "params": {}}
+        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)),
@@ -327,3 +366,395 @@ class Device:
             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
+        """
+        try:
+            url = f"http://{self._ip_address}{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
+        """
+        try:
+            url = f"http://{self._ip_address}{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
+        """
+        try:
+            url = f"http://{self._ip_address}{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,
+        )

homevolt/exceptions.py

@@ -1,26 +1,25 @@
 """Custom exceptions for the Homevolt library."""
 
 
-class HomevoltException(Exception):
+class HomevoltError(Exception):
     """Base exception for all Homevolt errors."""
 
     pass
 
 
-class HomevoltConnectionError(HomevoltException):
+class HomevoltConnectionError(HomevoltError):
     """Raised when there's a connection or network error."""
 
     pass
 
 
-class HomevoltAuthenticationError(HomevoltException):
+class HomevoltAuthenticationError(HomevoltError):
     """Raised when authentication fails."""
 
     pass
 
 
-class HomevoltDataError(HomevoltException):
+class HomevoltDataError(HomevoltError):
     """Raised when there's an error parsing or processing data."""
 
     pass
-

homevolt/homevolt.py

@@ -38,6 +38,7 @@ class Homevolt:
         """Fetch and update device information."""
         if self._device is None:
             await self._ensure_session()
+            assert self._websession is not None
             self._device = Device(
                 ip_address=self._ip_address,
                 password=self._password,
@@ -79,4 +80,3 @@ class Homevolt:
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         """Async context manager exit."""
         await self.close_connection()
-

homevolt/models.py

@@ -40,4 +40,3 @@ class Sensor:
     value: float | str | None
     type: SensorType
     device_identifier: str = "main"  # Device identifier for grouping sensors into devices
-

{homevolt-0.1.0.dist-info → homevolt-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Homevolt
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python library for Homevolt EMS devices
 Author-email: Your Name <your.email@example.com>
 License: GPL-3.0
@@ -24,6 +24,12 @@ Get real-time data from your Homevolt Energy Management System, including:
 - Grid, solar, and load sensor data
 - Schedule information
 
+Control your battery with:
+- Immediate battery control (charge, discharge, idle)
+- Scheduled battery operations
+- Local mode management
+- Parameter configuration
+
 ## Install
 
 ```bash
@@ -46,20 +52,20 @@ async def main():
             websession=session,
         )
         await homevolt_connection.update_info()
-        
+
         device = homevolt_connection.get_device()
         print(f"Device ID: {device.device_id}")
         print(f"Current Power: {device.sensors['Power'].value} W")
         print(f"Battery SOC: {device.sensors['Battery State of Charge'].value * 100}%")
-        
+
         # Access all sensors
         for sensor_name, sensor in device.sensors.items():
             print(f"{sensor_name}: {sensor.value} ({sensor.type.value})")
-        
+
         # Access device metadata
         for device_id, metadata in device.device_metadata.items():
             print(f"{device_id}: {metadata.name} ({metadata.model})")
-        
+
         await homevolt_connection.close_connection()
 
 
@@ -83,10 +89,10 @@ async def main():
             websession=session,
         ) as homevolt_connection:
             await homevolt_connection.update_info()
-            
+
             device = homevolt_connection.get_device()
             await device.update_info()  # Refresh data
-            
+
             print(f"Device ID: {device.device_id}")
             print(f"Available sensors: {list(device.sensors.keys())}")
 
@@ -95,6 +101,76 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+## Battery Control Example
+
+```python
+import asyncio
+import aiohttp
+import homevolt
+
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        async with homevolt.Homevolt(
+            ip_address="192.168.1.100",
+            password="optional_password",
+            websession=session,
+        ) as homevolt_connection:
+            await homevolt_connection.update_info()
+            device = homevolt_connection.get_device()
+
+            # Enable local mode to prevent remote schedule overrides
+            await device.enable_local_mode()
+
+            # Charge battery immediately (up to 3000W, stop at 90% SOC)
+            await device.charge_battery(max_power=3000, max_soc=90)
+
+            # Or use the full control method
+            await device.set_battery_mode(
+                mode=1,  # Inverter Charge
+                max_charge=3000,
+                max_soc=90,
+            )
+
+            # Schedule night charging (11 PM - 7 AM)
+            from datetime import datetime, timedelta
+            tonight = datetime.now().replace(hour=23, minute=0, second=0)
+            tomorrow = (tonight + timedelta(days=1)).replace(hour=7, minute=0, second=0)
+
+            await device.add_schedule(
+                mode=1,  # Inverter Charge
+                from_time=tonight.isoformat(),
+                to_time=tomorrow.isoformat(),
+                max_charge=3000,
+                max_soc=80,
+            )
+
+            # Set battery to idle
+            await device.set_battery_idle()
+
+            # Discharge during peak hours
+            await device.discharge_battery(max_power=2500, min_soc=30)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Battery Control Modes
+
+The following modes are available for battery control:
+
+- `0`: Idle - Battery standby (no charge/discharge)
+- `1`: Inverter Charge - Charge battery via inverter from grid/solar
+- `2`: Inverter Discharge - Discharge battery via inverter to home/grid
+- `3`: Grid Charge - Charge from grid with power setpoint
+- `4`: Grid Discharge - Discharge to grid with power setpoint
+- `5`: Grid Charge/Discharge - Bidirectional grid control
+- `6`: Frequency Reserve - Frequency regulation service mode
+- `7`: Solar Charge - Charge from solar production only
+- `8`: Solar Charge/Discharge - Solar-based grid management
+- `9`: Full Solar Export - Export all solar production
+
 ## API Reference
 
 ### Homevolt
@@ -132,6 +208,28 @@ Represents a Homevolt EMS device.
 - `async fetch_ems_data()`: Fetch EMS data specifically
 - `async fetch_schedule_data()`: Fetch schedule data specifically
 
+#### Battery Control Methods
+
+**Immediate Control:**
+- `async set_battery_mode(mode, **kwargs)`: Set immediate battery control mode
+- `async charge_battery(**kwargs)`: Charge battery using inverter
+- `async discharge_battery(**kwargs)`: Discharge battery using inverter
+- `async set_battery_idle(**kwargs)`: Set battery to idle mode
+- `async charge_from_grid(**kwargs)`: Charge from grid with power setpoint
+- `async discharge_to_grid(**kwargs)`: Discharge to grid with power setpoint
+- `async charge_from_solar(**kwargs)`: Charge from solar only
+
+**Scheduled Control:**
+- `async add_schedule(mode, **kwargs)`: Add a scheduled battery control entry
+- `async delete_schedule(schedule_id)`: Delete a schedule by ID
+- `async clear_all_schedules()`: Clear all schedules
+
+**Configuration:**
+- `async enable_local_mode()`: Enable local mode (prevents remote overrides)
+- `async disable_local_mode()`: Disable local mode (allows remote overrides)
+- `async set_parameter(key, value)`: Set a device parameter
+- `async get_parameter(key)`: Get a device parameter value
+
 ### Data Models
 
 #### Sensor
@@ -163,7 +261,7 @@ Enumeration of sensor types:
 
 ### Exceptions
 
-- `HomevoltException`: Base exception for all Homevolt errors
+- `HomevoltError`: Base exception for all Homevolt errors
 - `HomevoltConnectionError`: Connection or network errors
 - `HomevoltAuthenticationError`: Authentication failures
 - `HomevoltDataError`: Data parsing errors

homevolt-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+homevolt/__init__.py,sha256=HAK08jrG9KyS7Nd3tJT4QRhmx3a3AY4tlh_szh_09cg,504
+homevolt/const.py,sha256=hpiyo292WKIOfULnaJVY7n7afkn5cSQtqQFhQlQBpa4,609
+homevolt/device.py,sha256=8WYdKfRIADr74t1LtFTlrainq7guaS1xXlCzJ0qwDs4,28362
+homevolt/exceptions.py,sha256=TeG1J92JsbBpJok6Qpbdu4ENm9OjVMNgeHPcUoYjzdw,488
+homevolt/homevolt.py,sha256=tRvXZvTrOixV3mFT3gkVNWfFiYLmVoDk1TXsHdUNj5o,2515
+homevolt/models.py,sha256=YrzTuAsFbfG4c-XhZMYtIZAe6qhEsDmZZdL5zPLHnOA,928
+homevolt-0.2.0.dist-info/METADATA,sha256=khhm9i6bcr5WrUDF-p8ev3JtKxg7LjSTb4q3N_x0qiU,8064
+homevolt-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+homevolt-0.2.0.dist-info/top_level.txt,sha256=eOPhiXXDJEiBEdExWtFc_UqWSnbLbFpEsMm3fCXrBTA,9
+homevolt-0.2.0.dist-info/RECORD,,

homevolt-0.1.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-homevolt/__init__.py,sha256=ClavtnqHSLlElc7yiUCnDFzIwHyTPWBqGmvsg_4iqnw,513
-homevolt/const.py,sha256=0PpvS_X9aE0t2B-ekj_BhA1qNKQHqo4r2EoF3hJKxqM,457
-homevolt/device.py,sha256=xWmfguczg-ZNM1Xj1_YTwvNe2GsKCa8lCKxGmsOTfvA,13271
-homevolt/exceptions.py,sha256=YfXXS944vTKwb6sQ9AWfOsAjY1ONSBYu_DdL_g6NaZc,505
-homevolt/homevolt.py,sha256=XnoWwiY5j8lCNH60S9rBumFQNzn47WIfZVWsFrMEIMo,2468
-homevolt/models.py,sha256=8m3uCGrOiB3FPVhz8k4sUIJTnJENHa96uv4z-0NPRuk,929
-homevolt-0.1.0.dist-info/METADATA,sha256=RDFWrj8iKYkKqBoRX9xj6ECOTeAVi_qh_QRc1nY1Yyc,4533
-homevolt-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-homevolt-0.1.0.dist-info/top_level.txt,sha256=eOPhiXXDJEiBEdExWtFc_UqWSnbLbFpEsMm3fCXrBTA,9
-homevolt-0.1.0.dist-info/RECORD,,