evsemaster 1.0.0__tar.gz

evsemaster-1.0.0/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Original TypeScript project:
+Copyright (c) 2024 johnwoo-nl
+
+Python port / adaptations:
+Copyright (c) 2025 Rafaël Schridi @RafaelSchridi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

evsemaster-1.0.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: evsemaster
+Version: 1.0.0
+Summary: Python implementation of the EVSEMaster App
+License: MIT
+Author: Rafaël Schridi
+Author-email: rafael@schridi.nl
+Requires-Python: >=3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: pydantic (>=2.10.0,<3.0.0)
+Requires-Dist: tzdata (>=2025.1,<2026.0)
+Description-Content-Type: text/markdown
+
+# evsemaster
+
+Python client library for communicating with a EVSE chargers that use the EVSEMaster app. I've only done my testing on a Telestar EC311S, but it *should* work with any EVSE that uses the EVSEMaster app protocol.   
+I'm intenting to keep this a simple implementation, so it does not have all the features of the original TypeScript project, but it should be sufficient for basic use cases like Home Assistant integration.
+
+This is based on the original TypeScript project by [johnwoo-nl](https://github.com/johnwoo-nl/emproto)
+
+## Currently Implemented
+- Get EVSE device info
+- Get EVSE status
+- Get EVSE charging status
+- Start/Stop charging
+
+## Being Implemented
+- Create/Update charging schedule
+- Get/Set charging limits
+- Getting/Setting device properties like name, time, language, etc.
+
+## Not Planned
+- Home Assistant or MQTT integration (see [evsemaster-homeassistant](https://github.com/RafaelSchridi/evsemaster-homeassistant))
+- Connecting to the EVSE via Bluetooth (ie. connecting the EVSE to wifi)
+  * Even though the EVSEMaster app is awful to use, using it once to connect the EVSE to wifi is sufficient for most use cases.
+
+
+## Usage
+```python
+from evsemaster.evse_protocol import SimpleEVSEProtocol
+
+def event_callback(event, data):
+    print(f"Event: {event}, Data: {data}")
+
+async def main():
+    evse = SimpleEVSEProtocol(
+        host="10.0.0.1",  # IP address of the EVSE
+        password="123456",  # 6 digit password of the EVSE
+        callback=event_callback,  # Callback function for events
+    )
+    await evse.connect()  # Connect to the EVSE
+    await evse.request_status() # Request the current status of the EVSE
+    await evse.start_charging()  # Start charging
+    await evse.stop_charging()  # Stop charging
+    await evse.disconnect()  # Disconnect from the EVSE
+```
+
+There is a test script `test.py` that can be used to test the library. 
+Its a bit messy as it just prints the output while accepting commands, but it can be useful for quick testing.
+```bash
+poetry run python test.py 10.0.0.1 123456
+```
+

evsemaster-1.0.0/README.md

@@ -0,0 +1,49 @@
+# evsemaster
+
+Python client library for communicating with a EVSE chargers that use the EVSEMaster app. I've only done my testing on a Telestar EC311S, but it *should* work with any EVSE that uses the EVSEMaster app protocol.   
+I'm intenting to keep this a simple implementation, so it does not have all the features of the original TypeScript project, but it should be sufficient for basic use cases like Home Assistant integration.
+
+This is based on the original TypeScript project by [johnwoo-nl](https://github.com/johnwoo-nl/emproto)
+
+## Currently Implemented
+- Get EVSE device info
+- Get EVSE status
+- Get EVSE charging status
+- Start/Stop charging
+
+## Being Implemented
+- Create/Update charging schedule
+- Get/Set charging limits
+- Getting/Setting device properties like name, time, language, etc.
+
+## Not Planned
+- Home Assistant or MQTT integration (see [evsemaster-homeassistant](https://github.com/RafaelSchridi/evsemaster-homeassistant))
+- Connecting to the EVSE via Bluetooth (ie. connecting the EVSE to wifi)
+  * Even though the EVSEMaster app is awful to use, using it once to connect the EVSE to wifi is sufficient for most use cases.
+
+
+## Usage
+```python
+from evsemaster.evse_protocol import SimpleEVSEProtocol
+
+def event_callback(event, data):
+    print(f"Event: {event}, Data: {data}")
+
+async def main():
+    evse = SimpleEVSEProtocol(
+        host="10.0.0.1",  # IP address of the EVSE
+        password="123456",  # 6 digit password of the EVSE
+        callback=event_callback,  # Callback function for events
+    )
+    await evse.connect()  # Connect to the EVSE
+    await evse.request_status() # Request the current status of the EVSE
+    await evse.start_charging()  # Start charging
+    await evse.stop_charging()  # Stop charging
+    await evse.disconnect()  # Disconnect from the EVSE
+```
+
+There is a test script `test.py` that can be used to test the library. 
+Its a bit messy as it just prints the output while accepting commands, but it can be useful for quick testing.
+```bash
+poetry run python test.py 10.0.0.1 123456
+```

evsemaster-1.0.0/evsemaster/data_types.py

@@ -0,0 +1,203 @@
+from dataclasses import dataclass, field
+from struct import unpack
+import logging
+from enum import IntEnum
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+log = logging.getLogger(__name__)
+
+
+class BaseSchema(BaseModel):
+    """Base schema for all data types."""
+
+    class Config:
+        str_strip_whitespace = True
+
+
+class CommandEnum(IntEnum):
+    # request = client-initiated (you send)
+    # event = anything incoming (EVSE -> you), whether it’s a reply or unsolicited
+    # response = what you send back to an event that requires it
+
+    NOT_LOGGED_IN_EVENT = 0x0001
+    LOGIN_REQUEST = 0x8002
+    LOGIN_SUCCESS_EVENT = 0x0002
+    LOGIN_CONFIRM_RESPONSE = 0x8001
+    PASSWORD_ERROR_EVENT = 0x0155
+
+    # Heading commands
+    HEADING_EVENT = 0x0003
+    HEADING_RESPONSE = 0x8003
+
+    # Status commands
+    CURRENT_STATUS_EVENT = 0x0004
+    CURRENT_STATUS_RESPONSE = 0x8004
+    CURRENT_CHARGING_STATUS_EVENT = 0x0005  #  Always incoming, sent automatically by EVSE
+    CURRENT_CHARGING_STATUS_RESPONSE = 0x0006
+
+    # Charge control commands
+    CHARGE_START_REQUEST = 0x8007
+    CHARGE_START_RESPONSE = 0x0007
+    CHARGE_STOP_REQUEST = 0x8008
+    CHARGE_STOP_RESPONSE = 0x0008
+
+    #### Haven't touched yet ####
+
+    # Charge record commands
+    CURRENT_CHARGE_RECORD = 0x0009
+    UPLOAD_LOCAL_CHARGE_RECORD = 0x000A
+    REQUEST_STATUS_RECORD = 0x000D
+    REQUEST_CHARGE_STATUS_RECORD = 0x800D
+    CURRENT_CHARGE_RECORD_RESPONSE = 0x8009
+
+    # System settings commands
+    SET_AND_GET_SYSTEM_TIME = 33025
+    SET_AND_GET_SYSTEM_TIME_RESPONSE = 257
+    GET_VERSION = 33030
+    GET_VERSION_RESPONSE = 262
+    SET_AND_GET_OUTPUT_ELECTRICITY = 33031
+    SET_AND_GET_OUTPUT_ELECTRICITY_RESPONSE = 263
+    SET_AND_GET_NICK_NAME = 33032
+    SET_AND_GET_NICK_NAME_RESPONSE = 264
+    SET_AND_GET_OFF_LINE_CHARGE = 33037
+    SET_AND_GET_OFF_LINE_CHARGE_RESPONSE = 269
+    SET_AND_GET_LANGUAGE = 33039
+    SET_AND_GET_LANGUAGE_RESPONSE = 271
+    SET_AND_GET_TEMPERATURE_UNIT = 33042
+    SET_AND_GET_TEMPERATURE_UNIT_RESPONSE = 274
+
+    # Fee and strategy commands
+    SET_AND_GET_CHARGE_FEE_RESPONSE = 0x0104
+    SET_AND_GET_SERVICE_FEE_RESPONSE = 0x0105
+    SET_AND_GET_ALARM_CHARGE_STRATEGY_RESPONSE = 0x010E
+
+    # Error responses
+    PASSWORD_ERROR_RESPONSE = 341
+
+
+class PlugStateEnum(IntEnum):
+    DISCONNECTED = 1
+    CONNECTED_UNLOCKED = 2
+    CONNECTED_LOCKED = 4
+
+
+class CurrentStateEnum(IntEnum):
+    EVSE_FAULT = 1
+    CHARGING_FAULT_2 = 2
+    CHARGING_FAULT_3 = 3
+    WAITING_FOR_SWIPE = 10
+    WAITING_FOR_BUTTON = 11
+    NOT_CONNECTED = 12
+    READY_TO_CHARGE = 13
+    CHARGING = 14
+    COMPLETED = 15
+    COMPLETED_FULL_CHARGE = 17
+    CHARGING_RESERVATION = 20
+
+
+class EvseDeviceInfo(BaseSchema):
+    type: int
+    brand: str
+    model: str
+    hardware_version: str
+    max_power: int
+    max_amps: int
+
+
+class EvseStatus(BaseSchema):
+    line_id: int  # no idea what this is, but its in the data
+    inner_temperature: float
+    outer_temperature: float
+    emergency_stop: bool
+    plug_state: PlugStateEnum
+    output_state: int
+    current_state: CurrentStateEnum
+    errors: int
+    l1_voltage: float = Field(default=0.0)
+    l1_amps: float = Field(default=0.0)
+    l2_voltage: float = Field(default=0.0)
+    l2_amps: float = Field(default=0.0)
+    l3_voltage: float = Field(default=0.0)
+    l3_amps: float = Field(default=0.0)
+    current_power: int = Field(default=0)
+    total_kwh: float = Field(default=0)
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+
+class ChargingStatus(BaseSchema):
+    line_id: int
+    current_state: CurrentStateEnum
+    charge_id: str
+    start_type: int
+    charge_type: int
+    max_duration_minutes: int | None = None
+    max_energy_kwh: float | None = None
+    charge_param3: float | None = None
+    reservation_date: datetime
+    user_id: str
+    max_electricity: int
+    start_date: datetime
+    duration_seconds: int
+    start_kwh_counter: float
+    current_kwh_counter: float
+    charge_kwh: float
+    charge_price: float
+    fee_type: int
+    charge_fee: float
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+
+class DataPacket:
+    """Class for incomind data with unpack functions."""
+
+    def __init__(self, data: bytes):
+        if data is None or not isinstance(data, bytes):
+            raise ValueError("Data must be a non-empty bytes object")
+        if len(data) < 25:
+            raise ValueError("Data must be at least 25 bytes long")
+        # Check header
+        header = unpack(">H", data[0:2])[0]
+        if header != 0x0601:
+            raise ValueError(f"Invalid header: {header:#04x}, expected 0x0601")
+        self.command: CommandEnum = CommandEnum(unpack(">H", data[19:21])[0])
+        if self.command not in CommandEnum:
+            raise ValueError(f"Unknown command: {self.command}")
+        # how its done in TS:
+        # this.deviceSerial = buffer.toString("hex", 5, 13);
+        self.device_serial = data[5:13].hex()  # Device serial number
+        self.data = data[21:]  # drop all bytes before the data section
+        log.debug(self.__repr__())
+
+    def __repr__(self):
+        return f"DataPacket: {self.command.name}, s/n={self.device_serial}, len={len(self.data)}"
+
+    def length(self) -> int:
+        """Get the length of the data."""
+        return len(self.data)
+
+    def get_string(self, offset: int, length: int = 1) -> str:
+        """Read string from byte data."""
+        end = offset + length
+        string_data = self.data[offset:end]
+        null_pos = string_data.find(b"\x00")
+        if null_pos >= 0:
+            string_data = string_data[:null_pos]
+        return string_data.decode("ascii", errors="ignore")
+
+    def get_buffer(self, offset: int, length: int = 1) -> bytes:
+        """Read buffer from byte data."""
+        end = offset + length
+        return self.data[offset:end]
+
+    def get_int(self, offset: int, length: int = 1) -> int:
+        """Read integer from byte data."""
+        end = offset + length
+        return int.from_bytes(self.data[offset:end], byteorder="big", signed=False)
+
+    def read_temperature(self, offset: int) -> float:
+        """Read temperature from byte data."""
+        temp = self.get_int(offset, 2)
+        if temp == 0xFFFF:
+            return -1.0
+        return round((temp - 20000) / 100, 1)

evsemaster-1.0.0/evsemaster/evse_protocol.py

@@ -0,0 +1,445 @@
+"""Simple EVSE protocol implementation for Home Assistant integration."""
+
+import logging
+import struct
+import socket
+from typing import Dict, Any, Optional
+from datetime import datetime
+import asyncio
+import zoneinfo
+from .data_types import CommandEnum, DataPacket, EvseDeviceInfo, EvseStatus, ChargingStatus, CurrentStateEnum
+
+log = logging.getLogger(__name__)
+
+
+class SimpleEVSEProtocol:
+    """Simple implementation of EVSE protocol for HA integration."""
+
+    def __init__(self, host: str, password: str, event_callback: callable = None):
+        """Initialize protocol handler."""
+        self.host = host
+        self.password = password
+        self._event_callback = event_callback
+        self.listen_port = 28376  # Port to listen for incoming datagrams
+        self.send_port = 7248  # Default port to send to (will be updated by discovery)
+        self.serial_number = "00000000"  # Placeholder for device serial number
+        self.user_id = "evsemaster_python"  # Do all actions as this "user"
+        self._listen_socket: Optional[socket.socket] = None
+        self._send_socket: Optional[socket.socket] = None
+        self._logged_in = False
+        self._status: Optional[EvseStatus] = None
+        self._device_info: Optional[EvseDeviceInfo] = None
+        self._charging_status: Optional[ChargingStatus] = None
+        self._discovery_running = False
+
+    async def send_packet(self, data: bytes):
+        """Send a packet to the EVSE."""
+        if not self._send_socket:
+            log.error("Send socket is not initialized")
+            return
+
+        try:
+            self._send_socket.sendto(data, (self.host, self.send_port))
+        except Exception as e:
+            log.error("Failed to send packet: %s", e)
+
+    async def connect(self) -> bool:
+        """Connect to EVSE and start discovery."""
+        try:
+            # Create listen socket for receiving datagrams from EVSE
+            self._listen_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            self._listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            self._listen_socket.bind(("0.0.0.0", self.listen_port))
+            self._listen_socket.settimeout(10.0)
+
+            # Create send socket for sending commands to EVSE
+            self._send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            self._send_socket.settimeout(10.0)
+
+            log.info(
+                "Connected to EVSE at %s, listening on port %d",
+                self.host,
+                self.listen_port,
+            )
+            return True
+        except Exception as err:
+            log.error("Failed to connect: %s", err)
+            return False
+
+    async def disconnect(self):
+        """Disconnect from EVSE."""
+        self._discovery_running = False
+        if self._listen_socket:
+            self._listen_socket.close()
+            self._listen_socket = None
+        if self._send_socket:
+            self._send_socket.close()
+            self._send_socket = None
+        self._logged_in = False
+
+    async def login(self) -> bool:
+        """Login to EVSE."""
+        if self._logged_in:
+            log.info("Already logged in to EVSE,reconnecting")
+            await self.disconnect()
+
+        if not self._send_socket or not self._listen_socket:
+            if not await self.connect():
+                return False
+
+        try:
+            # Start discovery to find the correct port
+            await self._discover_evse_port()
+
+            await self.send_packet(self._build_packet(CommandEnum.LOGIN_REQUEST))
+
+            # Try to receive response
+            try:
+                data, addr = self._listen_socket.recvfrom(1024)
+                packet = DataPacket(data)  # Parse incoming data packet
+                if self._parse_login_response(packet):
+                    # If login response is successful, send confirm
+                    await self.send_packet(self._build_packet(CommandEnum.LOGIN_CONFIRM_RESPONSE))
+                    data, addr = self._listen_socket.recvfrom(1024)
+                    data_packet = DataPacket(data)  # Parse confirm response
+                    self._parse_login_response(data_packet)
+                    self._logged_in = True
+                    if data_packet.device_serial:
+                        self.serial_number = data_packet.device_serial
+                    log.info("Login successful")
+                    # Start listener loop in background
+                    asyncio.create_task(self.listener_loop())
+                    return True
+            except socket.timeout:
+                log.warning("Login timeout")
+
+            return False
+
+        except Exception as err:
+            log.exception("Failed to login: %s", err)
+            return False
+
+    def send_event(self, event_type: str, data: Any):
+        """Handle events from the EVSE."""
+        if self._event_callback:
+            try:
+                self._event_callback(event_type, data)
+            except Exception as e:
+                log.error(f"Error in event callback: {e}")
+
+    async def listener_loop(self):
+        """Run the listener loop to handle incoming datagrams."""
+        if not self._listen_socket:
+            return
+
+        log.info("Starting listener loop on port %d", self.listen_port)
+        while self._logged_in:
+            try:
+                data, addr = self._listen_socket.recvfrom(1024)
+                try:
+                    data_packet = DataPacket(data)  # Parse incoming data packet and slices the preamble
+                except ValueError as e:
+                    log.error(f"Invalid data packet received: {e}")
+                    continue
+                match data_packet.command:
+                    case CommandEnum.HEADING_EVENT:
+                        # response to keepalive, need to send back HEADING_RESPONSE
+                        await self.send_packet(self._build_packet(CommandEnum.HEADING_RESPONSE))
+                    case CommandEnum.NOT_LOGGED_IN_EVENT:
+                        # not logged in, try to login
+                        self._logged_in = False
+                        log.warning("Logged out by EVSE.")
+                    case CommandEnum.LOGIN_SUCCESS_EVENT:
+                        # Handle login response
+                        if self._parse_login_response(data_packet):
+                            log.info("Login response received, sending confirm")
+                            await self.send_packet(self._build_packet(CommandEnum.LOGIN_CONFIRM_RESPONSE))
+                    case CommandEnum.CURRENT_STATUS_EVENT:
+                        log.debug(self._parse_status_response(data_packet))
+                        # Do we need to send a response?
+                        await self.send_packet(self._build_packet(CommandEnum.CURRENT_STATUS_RESPONSE))
+                        self.send_event(EvseStatus.__name__, self._status)
+                    case CommandEnum.CURRENT_CHARGING_STATUS_EVENT:
+                        log.debug(self._parse_ac_charging_status(data_packet))
+                        self.send_event(ChargingStatus.__name__, self._charging_status)
+                    case CommandEnum.UPLOAD_LOCAL_CHARGE_RECORD:
+                        pass
+                    case _:
+                        log.warning("Unhandled command: %s", data_packet.command.name)
+                await asyncio.sleep(0.1)  # Avoid busy loop
+            except socket.timeout:
+                log.warning("Listener socket timeout, retrying...")
+                continue
+                await asyncio.sleep(1)  # Give the system some time to recover
+            except Exception as e:
+                log.error(f"Listener loop error: {e}, restarting.")
+                await asyncio.sleep(1)  # Give the system some time to recover
+                continue
+
+    async def _discover_evse_port(self) -> bool:
+        """Discover EVSE port by listening for incoming datagrams."""
+        if not self._listen_socket:
+            return False
+
+        log.info("Starting EVSE port discovery on %s", self.host)
+
+        # Send a discovery packet to the default port to trigger a response
+        discovery_packet = self._build_packet(CommandEnum.LOGIN_REQUEST)
+        if self._send_socket:
+            self._send_socket.sendto(discovery_packet, (self.host, self.send_port))
+
+        # Listen for any incoming datagram from our target EVSE
+        for _ in range(5):  # Try for up to 5 attempts
+            try:
+                data, addr = self._listen_socket.recvfrom(1024)
+                if addr[0] == self.host:
+                    # Found a datagram from our EVSE, update the port
+                    discovered_port = addr[1]
+                    if discovered_port != self.send_port:
+                        log.info(
+                            "Discovered EVSE port: %d (was using %d)",
+                            discovered_port,
+                            self.send_port,
+                        )
+                        self.send_port = discovered_port
+                    return True
+            except socket.timeout:
+                # Try sending another discovery packet
+                if self._send_socket:
+                    self._send_socket.sendto(discovery_packet, (self.host, self.send_port))
+                continue
+
+        log.warning("Could not discover EVSE port, using default %d", self.send_port)
+        return False
+
+    async def request_status(self) -> Dict[str, Any]:
+        """Get EVSE status."""
+        if not self._logged_in or not self._send_socket:
+            return False
+
+        try:
+            # Send status request
+            await self.send_packet(self._build_packet(CommandEnum.CURRENT_STATUS_EVENT))
+            return True
+        
+        except Exception as err:
+            log.error("Failed to get status: %s", err)
+            return False
+
+    async def start_charging(
+        self, max_amps: int = 16, start_date: datetime = datetime.now(), duration_minutes: int = 65535
+    ) -> bool:
+        """Start charging."""
+        if not self._logged_in or not self._send_socket:
+            return False
+
+        try:
+            if self._status and self._status.current_state == CurrentStateEnum.CHARGING_RESERVATION:
+                log.warning("Start charge send while a reservation is active, cancelling reservation first")
+                await self.stop_charging()
+            extra_payload = bytearray(47)
+
+            # Line ID (seems to be always one 1, are there any devices with multiple lines?)
+            struct.pack_into(">B", extra_payload, 0, 1)
+            # User ID (16 bytes, ASCII encoded)
+            struct.pack_into(">16s", extra_payload, 1, self.user_id.encode("ascii")[:16])
+            # Charge ID (16 bytes, ASCII encoded)
+            struct.pack_into(">16s", extra_payload, 17, start_date.strftime("%Y%m%d%H%M").encode("ascii")[:16])
+            # Reservation: 0 for now, 1 if future reservation
+            struct.pack_into(">B", extra_payload, 33, 0 if datetime.now() > start_date else 1)
+            # Reservation date (current time in Shanghai epoch)
+            struct.pack_into(">I", extra_payload, 34, self._datetime_to_shanghai_epoch(start_date))
+            # Start type (always 1)
+            struct.pack_into(">B", extra_payload, 38, 1)
+            # Charge type (always 1)
+            struct.pack_into(">B", extra_payload, 39, 1)
+            # Max duration (65535 = highest possible, unlimited)
+            struct.pack_into(">H", extra_payload, 40, duration_minutes)
+            # Max energy (65535 = highest possible, unlimited)
+            struct.pack_into(">H", extra_payload, 42, 65535)
+            # Charge param 3 (always 65535)
+            struct.pack_into(">H", extra_payload, 44, 65535)
+            # Max electricity in amps
+            struct.pack_into(">B", extra_payload, 46, max_amps)
+
+            packet = self._build_packet(CommandEnum.CHARGE_START_REQUEST, extra_payload)
+            await self.send_packet(packet)
+            log.info("Sent charge start command")
+            return True
+        except Exception as err:
+            log.error("Failed to start charging: %s", err)
+            return False
+
+    def _datetime_to_shanghai_epoch(self, dt: datetime) -> int:
+        """
+        Convert datetime to Shanghai timestamp.
+        """
+        log.debug(f"Converting time {dt.timestamp()} in {dt.tzinfo} to Shanghai epoch")
+        shanghai_tz = zoneinfo.ZoneInfo("Asia/Shanghai")
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=shanghai_tz)
+        elif dt.tzinfo.zone != "Asia/Shanghai":
+            dt = dt.astimezone(shanghai_tz)
+        log.debug(f"Converted time is now {dt.timestamp()} in {dt.tzinfo}")
+        return int(dt.timestamp())
+
+    async def stop_charging(self) -> bool:
+        """Stop charging."""
+        if not self._logged_in or not self._send_socket:
+            return False
+
+        try:
+            extra_payload = bytearray(1)  # Extra payload for charge stop
+            extra_payload[0] = 1  # Port to stop charging on
+            packet = self._build_packet(CommandEnum.CHARGE_STOP_REQUEST, extra_payload)
+            await self.send_packet(packet)
+            log.info("Sent charge stop command")
+            return True
+        except Exception as err:
+            log.error("Failed to stop charging: %s", err)
+            return False
+
+    def _build_packet(self, cmd: CommandEnum, payload: bytes = b"") -> bytes:
+        """Generic method to build a packet with given command and payload."""
+        packet = bytearray(25 + len(payload))
+
+        # Header (0x0601)
+        struct.pack_into(">H", packet, 0, 0x0601)
+        # Length
+        struct.pack_into(">H", packet, 2, len(packet))
+        # Key type
+        packet[4] = 0x00
+        # Device serial (8 bytes) - use zeros for now
+        # Password (6 bytes)
+        if self.password:
+            password_bytes = self.password.encode("ascii")[:6]
+        else:
+            password_bytes = b"\x00\x00\x00\x00\x00\x00"
+        packet[13 : 13 + len(password_bytes)] = password_bytes
+        # Command
+        struct.pack_into(">H", packet, 19, cmd)
+        # Payload
+        packet[21 : 21 + len(payload)] = payload
+        # Checksum
+        checksum = sum(packet[:-4]) % 0xFFFF
+        struct.pack_into(">H", packet, len(packet) - 4, checksum)
+        # Tail (0x0f02)
+        struct.pack_into(">H", packet, len(packet) - 2, 0x0F02)
+
+        return bytes(packet)
+
+    def _parse_login_response(self, data: DataPacket) -> bool:
+        """Parse login response."""
+        try:
+            if data.command == CommandEnum.LOGIN_SUCCESS_EVENT:
+                # Login response - extract device info
+                self._parse_device_info(data)
+                return True
+            elif data.command == CommandEnum.PASSWORD_ERROR_EVENT:
+                # Password error
+                log.error("Password error received")
+                return False
+
+            return False
+
+        except Exception as err:
+            log.error("Failed to parse login response: %s", err)
+            return False
+
+    def _parse_device_info(self, data: DataPacket):
+        """Parse device information from login response."""
+        try:
+            if data.length() < 25:
+                return
+
+            self._device_info = EvseDeviceInfo(
+                type=data.get_int(0, 1),
+                brand=data.get_string(1, 16),
+                model=data.get_string(17, 16),
+                hardware_version=data.get_string(33, 16),
+                max_power=data.get_int(49, 4),
+                max_amps=data.get_int(53, 1),
+            )
+
+        except Exception as err:
+            log.error("Failed to parse device info: %s", err)
+
+    def _parse_status_response(self, data: DataPacket):
+        """Parse status response."""
+        try:
+            if data.length() < 33:
+                return
+
+            self._status = EvseStatus(
+                line_id=data.get_int(0, 1),
+                l1_voltage=data.get_int(1, 2) / 10,
+                l1_amps=data.get_int(3, 2) / 100,
+                current_power=data.get_int(5, 4),
+                total_kwh=data.get_int(9, 4) / 100,
+                inner_temperature=data.read_temperature(13),
+                outer_temperature=data.read_temperature(15),
+                emergency_stop=data.get_int(17, 1),
+                plug_state=data.get_int(18, 1),
+                output_state=data.get_int(19, 1),
+                current_state=data.get_int(20, 1),
+                errors=data.get_int(21, 4),
+                l2_voltage=data.get_int(25, 2) / 10,
+                l2_amps=data.get_int(27, 2) / 100,
+                l3_voltage=data.get_int(29, 2) / 10,
+                l3_amps=data.get_int(31, 2) / 100,
+            )
+
+            return self._status
+
+        except Exception as err:
+            log.error("Failed to parse status response: %s", err)
+
+    def _parse_ac_charging_status(self, data: DataPacket):
+        """Parse AC charging status response."""
+        try:
+            if data.length() < 25:
+                return
+
+            self._charging_status = ChargingStatus(
+                line_id=data.get_int(0, 1),
+                current_state=data.get_int(1, 1),
+                charge_id=data.get_string(2, 16),
+                start_type=data.get_int(18, 1),
+                charge_type=data.get_int(19, 1),
+                max_duration_minutes=None if data.get_int(20, 2) == 65535 else data.get_int(20, 2),
+                max_energy_kwh=None if data.get_int(22, 2) == 65535 else data.get_int(22, 2) * 0.01,
+                charge_param3=None if data.get_int(24, 2) == 65535 else data.get_int(24, 2) * 0.01,
+                reservation_date=datetime.fromtimestamp(data.get_int(26, 4)),
+                user_id=data.get_string(30, 16),
+                max_electricity=data.get_int(46, 1),
+                start_date=datetime.fromtimestamp(data.get_int(47, 4)),
+                duration_seconds=data.get_int(51, 4),
+                start_kwh_counter=data.get_int(55, 4) * 0.01,
+                current_kwh_counter=data.get_int(59, 4) * 0.01,
+                charge_kwh=data.get_int(63, 4) * 0.01,
+                charge_price=data.get_int(67, 4) * 0.01,
+                fee_type=data.get_int(71, 1),
+                charge_fee=data.get_int(72, 2) * 0.01,
+            )
+
+            return self._charging_status
+
+        except Exception as err:
+            log.error("Failed to parse AC charging status: %s", err)
+
+    def get_latest_device_info(self) -> Optional[EvseDeviceInfo]:
+        """Get the latest device info."""
+        return self._device_info
+
+    def get_latest_status(self) -> Optional[EvseStatus]:
+        """Get the latest EVSE status."""
+        return self._status
+
+    def get_latest_charging_status(self) -> Optional[ChargingStatus]:
+        """Get the latest charging status."""
+        return self._charging_status
+
+    @property
+    def is_logged_in(self) -> bool:
+        """Check if logged in."""
+        return self._logged_in

evsemaster-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "evsemaster"
+version = "1.0.0"
+description = "Python implementation of the EVSEMaster App"
+authors = [
+    "Rafaël Schridi <rafael@schridi.nl>"
+]
+license = "MIT"
+readme = "README.md"
+packages = [
+    { include = "evsemaster" }
+]
+
+[tool.poetry.dependencies]
+python = ">=3.13"
+pydantic = "^2.10.0"
+tzdata = "^2025.1"
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.12.8"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+line-length = 120