python-intelbras-solar-local 0.1.0__py3-none-any.whl

intelbras_solar_local/__init__.py

@@ -0,0 +1,43 @@
+"""Async Python client for Intelbras solar inverters (Sungrow WiNet-S) over the LAN."""
+from .client import IntelbrasSolarClient
+from .const import (
+    DEFAULT_PORT,
+    DEFAULT_UNIT,
+    DEFAULT_WINET_PORT,
+    DEVICE_MODELS,
+    WORK_STATES,
+)
+from .exceptions import (
+    IntelbrasSolarConnectionError,
+    IntelbrasSolarError,
+    IntelbrasSolarProtocolError,
+)
+from .modbus import ModbusTcpClient
+from .models import (
+    DataloggerStatus,
+    InverterStatus,
+    Mppt,
+    parse_datalogger,
+    parse_registers,
+)
+from .winet import WiNetClient
+
+__all__ = [
+    "IntelbrasSolarClient",
+    "InverterStatus",
+    "DataloggerStatus",
+    "Mppt",
+    "parse_registers",
+    "parse_datalogger",
+    "ModbusTcpClient",
+    "WiNetClient",
+    "IntelbrasSolarError",
+    "IntelbrasSolarConnectionError",
+    "IntelbrasSolarProtocolError",
+    "DEFAULT_PORT",
+    "DEFAULT_UNIT",
+    "DEFAULT_WINET_PORT",
+    "DEVICE_MODELS",
+    "WORK_STATES",
+]
+__version__ = "0.1.0"

intelbras_solar_local/client.py

@@ -0,0 +1,138 @@
+"""Async client for Intelbras solar inverters over the local network."""
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from types import TracebackType
+
+import aiohttp
+
+from .const import (
+    DEFAULT_PORT,
+    DEFAULT_UNIT,
+    DEFAULT_WINET_PORT,
+    DISABLE,
+    ENABLE,
+    FC_READ_HOLDING,
+    FC_READ_INPUT,
+    HOLDING_BLOCKS,
+    INPUT_BLOCKS,
+    REG_CLOCK,
+    REG_POWER_LIMIT,
+    REG_POWER_LIMIT_SWITCH,
+    REG_START_STOP,
+    START,
+    STOP,
+)
+from .exceptions import IntelbrasSolarError
+from .modbus import ModbusTcpClient
+from .models import InverterStatus, parse_registers
+from .winet import WiNetClient
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class IntelbrasSolarClient:
+    """Talks to one inverter through its WiNet-S datalogger.
+
+    Modbus TCP is the primary source; the WiNet-S WebSocket adds datalogger
+    connectivity, the fault list and the commercial model, best-effort.
+
+    Args:
+        host: IP or hostname of the WiNet-S datalogger.
+        port: Modbus TCP port.
+        unit: Modbus unit id of the inverter.
+        session: optional ``aiohttp`` session for the WebSocket; one is created
+            (and closed by :meth:`async_close`) when omitted.
+        winet_port: WebSocket port of the datalogger web UI.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        port: int = DEFAULT_PORT,
+        unit: int = DEFAULT_UNIT,
+        session: aiohttp.ClientSession | None = None,
+        winet_port: int = DEFAULT_WINET_PORT,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.unit = unit
+        self.winet_port = winet_port
+        self._session = session
+        self._owns_session = session is None
+        self.modbus = ModbusTcpClient(host, port, unit)
+
+    async def __aenter__(self) -> IntelbrasSolarClient:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.async_close()
+
+    async def async_close(self) -> None:
+        """Close the Modbus connection and the session this client created."""
+        await self.modbus.async_close()
+        if self._owns_session and self._session is not None:
+            await self._session.close()
+            self._session = None
+
+    @property
+    def winet(self) -> WiNetClient:
+        """WebSocket client for the datalogger, sharing this client's session."""
+        if self._session is None:
+            self._session = aiohttp.ClientSession()
+        return WiNetClient(self.host, self._session, self.winet_port)
+
+    async def async_get_inverter_data(self) -> InverterStatus:
+        """Read every polled register block over Modbus.
+
+        Raises:
+            IntelbrasSolarConnectionError: datalogger unreachable.
+            IntelbrasSolarProtocolError: Modbus exception reply.
+        """
+        inp: dict[int, int] = {}
+        hold: dict[int, int] = {}
+        for start, count in INPUT_BLOCKS:
+            inp |= await self.modbus.async_read(FC_READ_INPUT, start, count)
+        for start, count in HOLDING_BLOCKS:
+            hold |= await self.modbus.async_read(FC_READ_HOLDING, start, count)
+        return parse_registers(inp, hold)
+
+    async def async_get_status(self) -> InverterStatus:
+        """Modbus snapshot plus datalogger state (``datalogger`` may be None).
+
+        A WebSocket failure never fails the call; only Modbus errors raise.
+        """
+        status = await self.async_get_inverter_data()
+        try:
+            status.datalogger = await self.winet.async_get_status()
+        except IntelbrasSolarError as err:
+            _LOGGER.debug("WiNet datalogger read failed: %s", err)
+        return status
+
+    async def async_set_inverter_on(self, on: bool) -> None:
+        """Start (``True``) or stop (``False``) power generation."""
+        await self.modbus.async_write(REG_START_STOP, START if on else STOP)
+
+    async def async_set_power_limit_enabled(self, enabled: bool) -> None:
+        """Turn the active power limitation on or off."""
+        await self.modbus.async_write(
+            REG_POWER_LIMIT_SWITCH, ENABLE if enabled else DISABLE
+        )
+
+    async def async_set_power_limit(self, percent: float) -> None:
+        """Set the active power limit, 0–100 % of nominal power."""
+        if not 0 <= percent <= 100:
+            raise ValueError("percent must be between 0 and 100")
+        await self.modbus.async_write(REG_POWER_LIMIT, round(percent * 10))
+
+    async def async_set_clock(self, when: datetime) -> None:
+        """Set the inverter clock (one register per field)."""
+        fields = (when.year, when.month, when.day, when.hour, when.minute, when.second)
+        for offset, value in enumerate(fields):
+            await self.modbus.async_write(REG_CLOCK + offset, value)

intelbras_solar_local/const.py

@@ -0,0 +1,55 @@
+"""Protocol constants for Intelbras (Sungrow WiNet-S) inverters.
+
+Register addresses are 0-based, as sent on the wire. Sungrow's public
+documentation numbers them 1-based, so ``doc address - 1`` maps to the
+values below.
+"""
+from __future__ import annotations
+
+DEFAULT_PORT = 502
+DEFAULT_UNIT = 1
+DEFAULT_WINET_PORT = 8082
+WINET_WS_PATH = "/ws/home/overview"
+
+MODBUS_TIMEOUT = 5
+WINET_TIMEOUT = 10
+
+FC_READ_HOLDING = 3
+FC_READ_INPUT = 4
+FC_WRITE_SINGLE = 6
+
+# (start, count) blocks polled on every cycle. The holding block stops before
+# 5019: reading it in a block fails with Modbus exception 4 on the IONS-5K M5.
+INPUT_BLOCKS: tuple[tuple[int, int], ...] = ((4989, 61), (5050, 100), (5225, 2))
+HOLDING_BLOCKS: tuple[tuple[int, int], ...] = ((4999, 9),)
+
+# Writable holding registers
+REG_CLOCK = 4999  # year, month, day, hour, minute, second (6 registers)
+REG_START_STOP = 5005
+REG_POWER_LIMIT_SWITCH = 5006
+REG_POWER_LIMIT = 5007  # 0.1 %
+
+START = 0xCF
+STOP = 0xCE
+ENABLE = 0xAA
+DISABLE = 0x55
+
+WORK_STATES: dict[int, str] = {
+    0x0000: "running",
+    0x8000: "stopped",
+    0x1300: "key_stop",
+    0x1500: "emergency_stop",
+    0x1400: "standby",
+    0x1200: "initial_standby",
+    0x1600: "starting",
+    0x9100: "alarm_run",
+    0x8100: "derating_run",
+    0x8200: "dispatch_run",
+    0x5500: "fault",
+    0x2500: "communication_fault",
+}
+PRODUCING_STATES = frozenset({0x0000, 0x9100, 0x8100, 0x8200})
+FAULT_STATE = 0x5500
+
+# Sungrow device type codes seen behind the Intelbras brand.
+DEVICE_MODELS: dict[int, str] = {0x2614: "IONS-5K M5"}

intelbras_solar_local/exceptions.py

@@ -0,0 +1,14 @@
+"""Exceptions for the Intelbras Solar local client."""
+from __future__ import annotations
+
+
+class IntelbrasSolarError(Exception):
+    """Base error for all Intelbras Solar client failures."""
+
+
+class IntelbrasSolarConnectionError(IntelbrasSolarError):
+    """Raised when the datalogger is unreachable or the transport fails."""
+
+
+class IntelbrasSolarProtocolError(IntelbrasSolarError):
+    """Raised when the device answers with an error (Modbus exception, bad reply)."""

intelbras_solar_local/modbus.py

@@ -0,0 +1,99 @@
+"""Minimal asyncio Modbus TCP client (FC3, FC4, FC6).
+
+Only what the inverter needs, with no third-party dependency, so it never
+clashes with the ``pymodbus`` version pinned by Home Assistant.
+"""
+from __future__ import annotations
+
+import asyncio
+import struct
+
+from .const import (
+    DEFAULT_PORT,
+    DEFAULT_UNIT,
+    FC_WRITE_SINGLE,
+    MODBUS_TIMEOUT,
+)
+from .exceptions import IntelbrasSolarConnectionError, IntelbrasSolarProtocolError
+
+_MBAP = struct.Struct(">HHHB")
+
+
+class ModbusTcpClient:
+    """One persistent Modbus TCP connection, reopened on demand after errors."""
+
+    def __init__(
+        self,
+        host: str,
+        port: int = DEFAULT_PORT,
+        unit: int = DEFAULT_UNIT,
+        timeout: float = MODBUS_TIMEOUT,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.unit = unit
+        self.timeout = timeout
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: asyncio.StreamWriter | None = None
+        self._tid = 0
+        # The WiNet-S serves one request at a time; serialize every call.
+        self._lock = asyncio.Lock()
+
+    async def async_close(self) -> None:
+        """Close the TCP connection (it reopens on the next request)."""
+        if self._writer is not None:
+            self._writer.close()
+        self._reader = self._writer = None
+
+    async def async_read(
+        self, function: int, address: int, count: int
+    ) -> dict[int, int]:
+        """Read ``count`` registers starting at ``address``.
+
+        Args:
+            function: ``3`` (holding) or ``4`` (input).
+            address: 0-based start register.
+            count: number of registers (max 125).
+
+        Returns:
+            Mapping of register address to its unsigned 16-bit value.
+        """
+        body = await self._request(struct.pack(">BHH", function, address, count))
+        size = body[1]
+        values = struct.unpack(f">{size // 2}H", body[2 : 2 + size])
+        return {address + i: v for i, v in enumerate(values)}
+
+    async def async_write(self, address: int, value: int) -> None:
+        """Write one holding register (FC6)."""
+        await self._request(struct.pack(">BHH", FC_WRITE_SINGLE, address, value))
+
+    async def _request(self, pdu: bytes) -> bytes:
+        async with self._lock:
+            try:
+                body = await asyncio.wait_for(self._roundtrip(pdu), self.timeout)
+            except (OSError, TimeoutError, asyncio.IncompleteReadError) as err:
+                await self.async_close()
+                raise IntelbrasSolarConnectionError(
+                    f"Modbus {self.host}:{self.port}: {err!r}"
+                ) from err
+        if body[0] & 0x80:
+            raise IntelbrasSolarProtocolError(
+                f"Modbus exception {body[1]} on function {body[0] & 0x7F}"
+            )
+        return body
+
+    async def _roundtrip(self, pdu: bytes) -> bytes:
+        if self._writer is None:
+            self._reader, self._writer = await asyncio.open_connection(
+                self.host, self.port
+            )
+        assert self._reader is not None
+        self._tid = (self._tid + 1) & 0xFFFF
+        self._writer.write(_MBAP.pack(self._tid, 0, len(pdu) + 1, self.unit) + pdu)
+        await self._writer.drain()
+        while True:
+            tid, _, length, _ = _MBAP.unpack(await self._reader.readexactly(7))
+            body = await self._reader.readexactly(length - 1)
+            # Drop late replies to a request that already timed out.
+            if tid == self._tid:
+                return body

intelbras_solar_local/models.py

@@ -0,0 +1,188 @@
+"""Typed models parsed from inverter registers and datalogger messages."""
+from __future__ import annotations
+
+import struct
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from .const import (
+    DEVICE_MODELS,
+    ENABLE,
+    FAULT_STATE,
+    PRODUCING_STATES,
+    REG_POWER_LIMIT,
+    REG_POWER_LIMIT_SWITCH,
+    REG_START_STOP,
+    STOP,
+    WORK_STATES,
+)
+
+
+@dataclass
+class Mppt:
+    """One MPPT (string) input."""
+
+    voltage: float
+    current: float
+
+    @property
+    def power(self) -> int:
+        """DC power of this input in W."""
+        return round(self.voltage * self.current)
+
+
+@dataclass
+class DataloggerStatus:
+    """State reported by the WiNet-S WebSocket."""
+
+    model: str | None = None
+    wifi_connected: bool | None = None
+    cloud_connected: bool | None = None
+    total_faults: int = 0
+    total_alarms: int = 0
+    faults: list[dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass
+class InverterStatus:
+    """Snapshot of the inverter at a point in time.
+
+    ``online`` is ``False`` when the datalogger could not be read (typically at
+    night, when the inverter powers down); every other field is then ``None``.
+    """
+
+    online: bool = True
+    serial: str | None = None
+    device_type_code: int | None = None
+    nominal_power: float | None = None  # kW
+    energy_today: float | None = None  # kWh
+    energy_month: float | None = None  # kWh
+    energy_year: float | None = None  # kWh
+    energy_total: float | None = None  # kWh
+    running_hours_total: int | None = None
+    running_minutes_today: int | None = None
+    temperature: float | None = None  # °C
+    power_ac: int | None = None  # W
+    power_dc: int | None = None  # W
+    power_apparent: int | None = None  # VA
+    power_reactive: int | None = None  # var
+    power_factor: float | None = None
+    grid_voltage: float | None = None  # V
+    grid_current: float | None = None  # A
+    grid_frequency: float | None = None  # Hz
+    bus_voltage: float | None = None  # V
+    insulation_resistance: int | None = None  # kΩ
+    work_state_code: int | None = None
+    fault_code: int | None = None
+    inverter_on: bool | None = None
+    power_limit_enabled: bool | None = None
+    power_limit: float | None = None  # %
+    clock: datetime | None = None
+    mppts: list[Mppt] = field(default_factory=list)
+    datalogger: DataloggerStatus | None = None
+
+    @property
+    def model(self) -> str | None:
+        """Commercial model: from the datalogger, else the device type table."""
+        if self.datalogger and self.datalogger.model:
+            return self.datalogger.model
+        if self.device_type_code is None:
+            return None
+        return DEVICE_MODELS.get(
+            self.device_type_code, f"Sungrow 0x{self.device_type_code:04X}"
+        )
+
+    @property
+    def work_state(self) -> str | None:
+        """Work state as a snake_case key (see ``WORK_STATES``)."""
+        if self.work_state_code is None:
+            return None
+        return WORK_STATES.get(self.work_state_code, "unknown")
+
+    @property
+    def producing(self) -> bool | None:
+        """True while the inverter is feeding the grid."""
+        if self.work_state_code is None:
+            return None
+        return self.work_state_code in PRODUCING_STATES
+
+    @property
+    def has_fault(self) -> bool | None:
+        """True on a Modbus fault code, a fault state or a datalogger fault."""
+        if self.work_state_code is None:
+            return None
+        return bool(
+            self.fault_code
+            or self.work_state_code == FAULT_STATE
+            or (self.datalogger and self.datalogger.total_faults)
+        )
+
+
+def parse_registers(inp: dict[int, int], hold: dict[int, int]) -> InverterStatus:
+    """Build an :class:`InverterStatus` from raw input and holding registers.
+
+    Sungrow stores 32-bit values low word first.
+    """
+
+    def u32(a: int) -> int:
+        return inp[a] | inp[a + 1] << 16
+
+    def s16(v: int) -> int:
+        return v - 0x10000 if v & 0x8000 else v
+
+    def s32(a: int) -> int:
+        v = u32(a)
+        return v - 0x100000000 if v & 0x80000000 else v
+
+    serial = b"".join(struct.pack(">H", inp[a]) for a in range(4989, 4999))
+    try:
+        clock = datetime(*(hold[a] for a in range(4999, 5005)))
+    except ValueError:
+        clock = None
+    return InverterStatus(
+        serial=serial.decode("ascii", "ignore").strip("\x00 "),
+        device_type_code=inp[4999],
+        nominal_power=inp[5000] / 10,
+        energy_today=inp[5002] / 10,
+        energy_month=u32(5127) / 10,
+        energy_year=u32(5225) / 10,
+        energy_total=u32(5143) / 10,
+        running_hours_total=u32(5005),
+        running_minutes_today=inp[5112],
+        temperature=s16(inp[5007]) / 10,
+        power_apparent=u32(5008),
+        power_dc=u32(5016),
+        power_ac=u32(5030),
+        power_reactive=s32(5032),
+        power_factor=s16(inp[5034]) / 1000,
+        grid_voltage=inp[5018] / 10,
+        grid_current=inp[5021] / 10,
+        grid_frequency=inp[5147] / 100,
+        bus_voltage=inp[5146] / 10,
+        insulation_resistance=inp[5070],
+        work_state_code=inp[5037],
+        fault_code=inp[5044],
+        inverter_on=hold[REG_START_STOP] != STOP,
+        power_limit_enabled=hold[REG_POWER_LIMIT_SWITCH] == ENABLE,
+        power_limit=hold[REG_POWER_LIMIT] / 10,
+        clock=clock,
+        # Two MPPTs on the IONS-5K M5; models with a third use 5014/5015.
+        mppts=[Mppt(inp[a] / 10, inp[a + 1] / 10) for a in (5010, 5012)],
+    )
+
+
+def parse_datalogger(
+    state: dict[str, Any], faults: dict[str, Any], devices: dict[str, Any]
+) -> DataloggerStatus:
+    """Build a :class:`DataloggerStatus` from WiNet-S ``result_data`` payloads."""
+    device = (devices.get("list") or [{}])[0]
+    return DataloggerStatus(
+        model=device.get("dev_model"),
+        wifi_connected=state.get("wifi_conn_sts") == "1",
+        cloud_connected=state.get("cloud_conn_sts") == "1",
+        total_faults=int(state.get("total_fault", 0) or 0),
+        total_alarms=int(state.get("total_alarm", 0) or 0),
+        faults=list(faults.get("list") or []),
+    )
+

intelbras_solar_local/winet.py

@@ -0,0 +1,72 @@
+"""WebSocket client for the WiNet-S datalogger web UI (port 8082).
+
+No login is needed to read: ``connect`` hands out a session token that the
+other read services accept.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+
+import aiohttp
+
+from .const import DEFAULT_WINET_PORT, WINET_TIMEOUT, WINET_WS_PATH
+from .exceptions import IntelbrasSolarConnectionError, IntelbrasSolarProtocolError
+from .models import DataloggerStatus, parse_datalogger
+
+
+class WiNetClient:
+    """Reads datalogger state, faults and the device list over WebSocket."""
+
+    def __init__(
+        self,
+        host: str,
+        session: aiohttp.ClientSession,
+        port: int = DEFAULT_WINET_PORT,
+        timeout: float = WINET_TIMEOUT,
+    ) -> None:
+        self.url = f"ws://{host}:{port}{WINET_WS_PATH}"
+        self._session = session
+        self._timeout = timeout
+
+    async def async_get_status(self) -> DataloggerStatus:
+        """Open a session, read ``state``, ``fault`` and ``devicelist``, close."""
+        try:
+            async with asyncio.timeout(self._timeout):
+                async with self._session.ws_connect(self.url) as ws:
+                    token = (await _call(ws, "connect", token=""))["token"]
+                    state = await _call(ws, "state", token=token)
+                    faults = await _call(ws, "fault", token=token)
+                    devices = await _call(
+                        ws, "devicelist", token=token, type="0", is_check_token="0"
+                    )
+        except (aiohttp.ClientError, TimeoutError) as err:
+            raise IntelbrasSolarConnectionError(f"WiNet {self.url}: {err!r}") from err
+        return parse_datalogger(state, faults, devices)
+
+
+async def _call(
+    ws: aiohttp.ClientWebSocketResponse, service: str, **extra: Any
+) -> dict[str, Any]:
+    """Send one request and wait for the reply of the same ``service``.
+
+    The server also pushes unsolicited ``notice`` messages; they are skipped.
+    """
+    await ws.send_str(json.dumps({"lang": "en_us", "service": service, **extra}))
+    async for msg in ws:
+        if msg.type is not aiohttp.WSMsgType.TEXT:
+            continue
+        try:
+            reply = json.loads(msg.data)
+        except ValueError as err:
+            raise IntelbrasSolarProtocolError(f"WiNet {service}: bad JSON") from err
+        data = reply.get("result_data") or {}
+        if data.get("service") != service:
+            continue
+        if reply.get("result_code") != 1:
+            raise IntelbrasSolarProtocolError(
+                f"WiNet {service}: {reply.get('result_msg')}"
+            )
+        return data
+    raise IntelbrasSolarConnectionError(f"WiNet {service}: connection closed")

python_intelbras_solar_local-0.1.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.5
+Name: python-intelbras-solar-local
+Version: 0.1.0
+Summary: Async Python client for Intelbras solar inverters (Sungrow WiNet-S) over Modbus TCP and the datalogger WebSocket
+Project-URL: Homepage, https://github.com/hudsonbrendon/python-intelbras-solar-local
+Project-URL: Documentation, https://hudsonbrendon.github.io/python-intelbras-solar-local/
+Project-URL: Issues, https://github.com/hudsonbrendon/python-intelbras-solar-local/issues
+Author-email: Hudson Brendon <contato.hudsonbrendon@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: aiohttp,async,home-assistant,intelbras,inverter,modbus,solar,sungrow,winet
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.25; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Requires-Dist: ruff; extra == 'test'
+Description-Content-Type: text/markdown
+
+<p align="center"><img src="docs/assets/logo.png" width="300" alt="Intelbras"></p>
+
+# python-intelbras-solar-local
+
+[![Tests](https://github.com/hudsonbrendon/python-intelbras-solar-local/actions/workflows/tests.yml/badge.svg)](https://github.com/hudsonbrendon/python-intelbras-solar-local/actions/workflows/tests.yml)
+[![PyPI version](https://img.shields.io/pypi/v/python-intelbras-solar-local.svg)](https://pypi.org/project/python-intelbras-solar-local/)
+[![Python](https://img.shields.io/pypi/pyversions/python-intelbras-solar-local.svg)](https://pypi.org/project/python-intelbras-solar-local/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+This is an async Python client that reads and controls **Intelbras solar inverters** over the local network, with no cloud
+and no account. It was built for the
+[`ha-intelbras-solar-local`](https://github.com/hudsonbrendon/ha-intelbras-solar-local) Home Assistant integration.
+
+Intelbras IONS inverters are rebranded **Sungrow** string inverters, and their Wi-Fi datalogger is a Sungrow **WiNet-S**.
+The datalogger exposes two interfaces without a login, and this library uses both:
+
+- **Modbus TCP** on port `502`, using the Sungrow SG-RS register map. This is the main data source.
+- The **datalogger WebSocket** on port `8082`, which the built-in web UI uses. It provides Wi-Fi and cloud link state,
+  active faults and alarms, and the commercial model.
+
+## Features
+
+- ⚡ Power readings: AC, DC, apparent and reactive power, plus power factor.
+- 🔋 Energy counters for today, the month, the year and the lifetime total (0.1 kWh resolution).
+- ☀️ Voltage, current and power for each MPPT input.
+- 🔌 Grid voltage, current and frequency (0.01 Hz).
+- 🩺 Health data: work state, internal temperature, bus voltage, insulation resistance and fault code.
+- 📡 Datalogger data: Wi-Fi and cloud connectivity, active fault list and alarm count.
+- 🛠️ Controls: start or stop the inverter, switch power limitation on or off, set the power limit (%), set the clock.
+- No `pymodbus` dependency. The library ships a tiny asyncio Modbus TCP client, so it never clashes with the version
+  that Home Assistant pins.
+- Fully async (`aiohttp`) and typed (`py.typed`).
+
+## Installation
+
+```bash
+pip install python-intelbras-solar-local
+```
+
+## Quickstart
+
+```python
+import asyncio
+from intelbras_solar_local import IntelbrasSolarClient
+
+
+async def main() -> None:
+    async with IntelbrasSolarClient("192.168.31.17") as client:
+        status = await client.async_get_status()
+        print(status.model, status.serial, status.work_state)
+        print(f"{status.power_ac} W now, {status.energy_today} kWh today")
+        for n, mppt in enumerate(status.mppts, 1):
+            print(f"MPPT{n}: {mppt.voltage} V x {mppt.current} A = {mppt.power} W")
+
+
+asyncio.run(main())
+```
+
+## Supported hardware
+
+| Inverter | Datalogger firmware | Sungrow type code |
+|---|---|---|
+| Intelbras IONS-5K M5 | `WIFI-SV300.001.03.P002` (WiNet-S) | `0x2614` |
+
+Other Intelbras IONS models and Sungrow SG-RS inverters behind a WiNet-S should work as well.
+If yours differs, open an issue with the output of `examples/status.py`.
+
+## API overview
+
+| Method | Description |
+|--------|-------------|
+| `async_get_status()` | Returns an `InverterStatus` from Modbus, with a `DataloggerStatus` when the WebSocket answers (best-effort) |
+| `async_get_inverter_data()` | Modbus-only `InverterStatus` |
+| `winet.async_get_status()` | Datalogger-only `DataloggerStatus` |
+| `async_set_inverter_on(on)` | Starts or stops generation (holding register 5005) |
+| `async_set_power_limit_enabled(enabled)` | Switches power limitation on or off (5006) |
+| `async_set_power_limit(percent)` | Sets the power limit, 0–100 % (5007) |
+| `async_set_clock(datetime)` | Sets the inverter clock (4999–5004) |
+
+The register map and the WebSocket protocol are documented in the
+[docs](https://hudsonbrendon.github.io/python-intelbras-solar-local/protocol/).
+
+## Development
+
+```bash
+uv venv && uv pip install -e ".[test]"
+pytest
+ruff check .
+```
+
+## License
+
+MIT © Hudson Brendon. This project is not affiliated with Intelbras or Sungrow.

python_intelbras_solar_local-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+intelbras_solar_local/__init__.py,sha256=sB6R2ZazZlVSt1urJRLclV263luVJsX9JpRuNpSaWkc,972
+intelbras_solar_local/client.py,sha256=P0wRlYhh-TfINIcV_zn8O73sJy-EbSDXoqJPR3TbiVY,4864
+intelbras_solar_local/const.py,sha256=119Ha_oIqfjT02km-rOQXna18gxurQBONGLelMObIas,1548
+intelbras_solar_local/exceptions.py,sha256=HLUYEQCusH6uTsYG68k6y6ZOHGRbsUHlLYvljUMd5hw,472
+intelbras_solar_local/modbus.py,sha256=qnJAP0ZvffRsXp_jRYP1raKZEdWgHWfweOGG8DYqpGI,3542
+intelbras_solar_local/models.py,sha256=vMStsRm9X0lZK4_AuEYHPAhAViNWuvo7YExPG98Jzds,6166
+intelbras_solar_local/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+intelbras_solar_local/winet.py,sha256=wXyO9SSzx-dZ7ywR_NFSGp488wj04_HoqaOb7KbDqZQ,2721
+python_intelbras_solar_local-0.1.0.dist-info/METADATA,sha256=fBnGdHez4RGoMf4OoNjN_MNfNhBd37-Ewvu_sMOpPIk,5533
+python_intelbras_solar_local-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+python_intelbras_solar_local-0.1.0.dist-info/licenses/LICENSE,sha256=4Zgd3fbLJqWSkwKA-hh1rNN6DC9tNQ3rWLX93fingOw,1071
+python_intelbras_solar_local-0.1.0.dist-info/RECORD,,

python_intelbras_solar_local-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

python_intelbras_solar_local-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hudson Brendon
+
+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.