pystudernext 0.0.1__tar.gz

pystudernext-0.0.1/LICENSE

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

pystudernext-0.0.1/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: pystudernext
+Version: 0.0.1
+Summary: Python library to communicate with Studer-Innotec Next devices on the local network via Modbus protocol
+Author-email: Anko Hanse <anko_hanse@hotmail.com>
+Project-URL: Homepage, https://github.com/ankohanse/pystudernext
+Project-URL: Issues, https://github.com/ankohanse/pystudernext/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx
+Requires-Dist: pymodbus
+Requires-Dist: aiofiles
+Requires-Dist: orjson
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-asyncio; extra == "tests"
+Dynamic: license-file
+
+[![license](https://img.shields.io/github/license/ankohanse/pystudernext?style=for-the-badge)](LICENSE)
+[![buy_me_a_coffee](https://img.shields.io/badge/If%20you%20like%20it-Buy%20me%20a%20coffee-yellow.svg?style=for-the-badge)](https://www.buymeacoffee.com/ankohanse)
+
+
+# pystudernext
+
+Python library for retrieving sensor information from Studer-Innotec devices.
+This component connects directly over the local network using the Studer Next modbus protocol.
+
+The custom component is comfirmed to be compatible with:
+- Next3 (three-phase)
+- Next1 (single-phase)
+
+Disclaimer: this library is NOT created by Studer-Innotec, but is based on their documentation of the Studer Next modbus protocol.
+That documentation can be found on:
+[Studer-Innotec Download Center](https://www.studer-innotec.com/en/downloads/) *-> Openstuder -> Communication protocol next modbus*
+
+# Prerequisites
+
+This library depends on the Next3/Next1 configured have modbus TCP enabled:
+- Open the Studer Next Web Config
+- Go to 'Monitoring'
+- To the right of 'Modbus' press the 'Config' button
+- Turn 'Modbus mode' On
+- Use the following properties:
+    * Modbus mode: TCP
+    * Base address: 0
+- Make a note of the other properties:
+    * IP address (address of the Next3 or Next1)
+    * Port (default is 502)
+
+After a few seconds, the Studer modbus configuration should indicate status: 'Ready and listening'.
+
+# Usage
+
+The library is available from PyPi using:
+`pip install pystudernext`
+
+To read or write to a param:
+
+```
+import logging
+from pystudernext import NextApi, NextDeviceFamilies, NextDataset
+
+logger = logging.getLogger(__name__)
+
+# Set these values before running this example
+# Host/ip address and port number of the Next Gateway
+GATEWAY_HOST = "192.168.1.123"
+GATEWAY_PORT = 502
+
+dataset = NextDataset.get_instance()
+param_2103 = dataset.get_by_address(2103, NextDeviceFamilies.SYSTEM)
+param_0318 = dataset.get_by_address(318,  NextDeviceFamilies.BATTERY)
+param_5100 = dataset.get_by_address(5100, NextDeviceFamilies.NEXT3)
+param_1815 = dataset.get_by_address(1815, NextDeviceFamilies.AC_SOURCE)
+
+api = NextApi(GATEWAY_HOST, GATEWAY_PORT)    
+try:
+    if not api.start():
+        logger.info(f"Did not connect to Next Gateway")
+        return
+
+    # Retrieve individual params
+    value = api.request_value(param_2103, "SYS")    # System slave range is 1 to 1, or use "SYS"
+    logger.info(f"SYS {param_2103.address}: {value} {param_2103.unit or ''} ({param_2103.name})")
+
+    value = api.request_value(param_0318, "BAT_1")  # Battery slave range is 2 to 6, or use "BAT_1" to "BAT_5"
+    logger.info(f"BAT_1 {param_0318.address}: {value} {param_0318.unit or ''} ({param_0318.name})")
+
+    value = api.request_value(param_5100, "NX3_1")  # Next3 slave range is 14 to 28, or use "NX3_1" to "NX3_15"
+    logger.info(f"NZ3_1 {param_5100.address}: {param_5100.enum_value(value)} {param_5100.unit or ''} ({param_5100.name})")
+
+    # Retrieve and Update param 1815 (Grid feedin allowed))
+    logger.info(f"")
+    logger.info(f"Retrieve and then update a param")
+
+    value = api.request_value(param_1815, "ACS_1")  # AC Source slave range is 7 to 8, or use "ACS_1" to "ACS_2"
+    logger.info(f"ACS_1 {param_1815.address}: {value} {param_1815.unit} ({param_1815.name})")
+
+    value = True
+    if api.update_value(param_1815, value, "ACS_1"):
+        logger.info(f"ACS_1 {param_1815.address} updated to {value} {param_1815.unit} ({param_1815.name})")
+
+
+except Exception as e:
+    logger.info(f"Unexpected exception: {str(e)}")
+
+finally:
+    logger.info(f"")
+    api.stop()
+```
+
+A complete list of param addresses can be found in the source of this library:
+| filename | (sub-)device |
+| ---------| ------------ |
+| `src/pystudernext/datapoints_sys.json` | System |
+| `src/pystudernext/datapoints_bat.json` | Battery |
+| `src/pystudernext/datapoints_acs.json` | AC Source |
+| `src/pystudernext/datapoints_acf.json` | AC FlexLoads |
+| `src/pystudernext/datapoints_nx3.json` | Next3 |
+| `src/pystudernext/datapoints_nx1.json` | Next1 |
+| `src/pystudernext/datapoints_nxg.json` | Next Gateway |
+
+Several other coding examples are provided:
+| Synchronous code | Asynchronous code | Description |
+| ---------------- | ----------------- | ------- |
+| example_api_use.py | example_api_use_async.py | read & write params |
+| example_menu.py | example_menu_async.py | display menu structure |
+| example_discover_devices.py | example_discover_devices_async.py | discover local (sub-)devices |
+| example_discover_gateway.py | example_discover_gateway_async.py | discover url to Studer Next Web-config |
+
+# Param writes are to device RAM
+
+When the value of a Studer param is changed via this library, these are written to the affected device. 
+Changes are stored in the device's on the volatile memory (RAM), not in its persistant/non-volatile memory as you can only write to persistent memory a limited number of times over its lifetime.
+
+After a restart/reboot of the Studer installation the properties are reset to the original values contained in persistent memory. So you may want to periodically repeat the write of changed param values via an automation.
+
+**IMPORTANT**:
+
+Be very carefull in changing params marked as having level Expert or Studer. If you do not know what the effect of a Studer param change is, then do not change it.
+
+# Credits
+
+Special thanks to the following people for providing the information this library is based on and helping out with testing it:
+- [t-baum](https://github.com/t-baum)
+- [anakinch75](https://github.com/anakinch75)

pystudernext-0.0.1/README.md

@@ -0,0 +1,128 @@
+[![license](https://img.shields.io/github/license/ankohanse/pystudernext?style=for-the-badge)](LICENSE)
+[![buy_me_a_coffee](https://img.shields.io/badge/If%20you%20like%20it-Buy%20me%20a%20coffee-yellow.svg?style=for-the-badge)](https://www.buymeacoffee.com/ankohanse)
+
+
+# pystudernext
+
+Python library for retrieving sensor information from Studer-Innotec devices.
+This component connects directly over the local network using the Studer Next modbus protocol.
+
+The custom component is comfirmed to be compatible with:
+- Next3 (three-phase)
+- Next1 (single-phase)
+
+Disclaimer: this library is NOT created by Studer-Innotec, but is based on their documentation of the Studer Next modbus protocol.
+That documentation can be found on:
+[Studer-Innotec Download Center](https://www.studer-innotec.com/en/downloads/) *-> Openstuder -> Communication protocol next modbus*
+
+# Prerequisites
+
+This library depends on the Next3/Next1 configured have modbus TCP enabled:
+- Open the Studer Next Web Config
+- Go to 'Monitoring'
+- To the right of 'Modbus' press the 'Config' button
+- Turn 'Modbus mode' On
+- Use the following properties:
+    * Modbus mode: TCP
+    * Base address: 0
+- Make a note of the other properties:
+    * IP address (address of the Next3 or Next1)
+    * Port (default is 502)
+
+After a few seconds, the Studer modbus configuration should indicate status: 'Ready and listening'.
+
+# Usage
+
+The library is available from PyPi using:
+`pip install pystudernext`
+
+To read or write to a param:
+
+```
+import logging
+from pystudernext import NextApi, NextDeviceFamilies, NextDataset
+
+logger = logging.getLogger(__name__)
+
+# Set these values before running this example
+# Host/ip address and port number of the Next Gateway
+GATEWAY_HOST = "192.168.1.123"
+GATEWAY_PORT = 502
+
+dataset = NextDataset.get_instance()
+param_2103 = dataset.get_by_address(2103, NextDeviceFamilies.SYSTEM)
+param_0318 = dataset.get_by_address(318,  NextDeviceFamilies.BATTERY)
+param_5100 = dataset.get_by_address(5100, NextDeviceFamilies.NEXT3)
+param_1815 = dataset.get_by_address(1815, NextDeviceFamilies.AC_SOURCE)
+
+api = NextApi(GATEWAY_HOST, GATEWAY_PORT)    
+try:
+    if not api.start():
+        logger.info(f"Did not connect to Next Gateway")
+        return
+
+    # Retrieve individual params
+    value = api.request_value(param_2103, "SYS")    # System slave range is 1 to 1, or use "SYS"
+    logger.info(f"SYS {param_2103.address}: {value} {param_2103.unit or ''} ({param_2103.name})")
+
+    value = api.request_value(param_0318, "BAT_1")  # Battery slave range is 2 to 6, or use "BAT_1" to "BAT_5"
+    logger.info(f"BAT_1 {param_0318.address}: {value} {param_0318.unit or ''} ({param_0318.name})")
+
+    value = api.request_value(param_5100, "NX3_1")  # Next3 slave range is 14 to 28, or use "NX3_1" to "NX3_15"
+    logger.info(f"NZ3_1 {param_5100.address}: {param_5100.enum_value(value)} {param_5100.unit or ''} ({param_5100.name})")
+
+    # Retrieve and Update param 1815 (Grid feedin allowed))
+    logger.info(f"")
+    logger.info(f"Retrieve and then update a param")
+
+    value = api.request_value(param_1815, "ACS_1")  # AC Source slave range is 7 to 8, or use "ACS_1" to "ACS_2"
+    logger.info(f"ACS_1 {param_1815.address}: {value} {param_1815.unit} ({param_1815.name})")
+
+    value = True
+    if api.update_value(param_1815, value, "ACS_1"):
+        logger.info(f"ACS_1 {param_1815.address} updated to {value} {param_1815.unit} ({param_1815.name})")
+
+
+except Exception as e:
+    logger.info(f"Unexpected exception: {str(e)}")
+
+finally:
+    logger.info(f"")
+    api.stop()
+```
+
+A complete list of param addresses can be found in the source of this library:
+| filename | (sub-)device |
+| ---------| ------------ |
+| `src/pystudernext/datapoints_sys.json` | System |
+| `src/pystudernext/datapoints_bat.json` | Battery |
+| `src/pystudernext/datapoints_acs.json` | AC Source |
+| `src/pystudernext/datapoints_acf.json` | AC FlexLoads |
+| `src/pystudernext/datapoints_nx3.json` | Next3 |
+| `src/pystudernext/datapoints_nx1.json` | Next1 |
+| `src/pystudernext/datapoints_nxg.json` | Next Gateway |
+
+Several other coding examples are provided:
+| Synchronous code | Asynchronous code | Description |
+| ---------------- | ----------------- | ------- |
+| example_api_use.py | example_api_use_async.py | read & write params |
+| example_menu.py | example_menu_async.py | display menu structure |
+| example_discover_devices.py | example_discover_devices_async.py | discover local (sub-)devices |
+| example_discover_gateway.py | example_discover_gateway_async.py | discover url to Studer Next Web-config |
+
+# Param writes are to device RAM
+
+When the value of a Studer param is changed via this library, these are written to the affected device. 
+Changes are stored in the device's on the volatile memory (RAM), not in its persistant/non-volatile memory as you can only write to persistent memory a limited number of times over its lifetime.
+
+After a restart/reboot of the Studer installation the properties are reset to the original values contained in persistent memory. So you may want to periodically repeat the write of changed param values via an automation.
+
+**IMPORTANT**:
+
+Be very carefull in changing params marked as having level Expert or Studer. If you do not know what the effect of a Studer param change is, then do not change it.
+
+# Credits
+
+Special thanks to the following people for providing the information this library is based on and helping out with testing it:
+- [t-baum](https://github.com/t-baum)
+- [anakinch75](https://github.com/anakinch75)

pystudernext-0.0.1/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "pystudernext"
+version = "0.0.1"
+authors = [
+  { name="Anko Hanse", email="anko_hanse@hotmail.com" },
+]
+description = "Python library to communicate with Studer-Innotec Next devices on the local network via Modbus protocol"
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.8"
+dependencies = [
+  'httpx',
+  'pymodbus',
+  'aiofiles',
+  'orjson',
+]
+
+[project.optional-dependencies]
+tests = [
+  'pytest',
+  'pytest-asyncio',
+]
+ 
+[project.urls]
+Homepage = "https://github.com/ankohanse/pystudernext"
+Issues = "https://github.com/ankohanse/pystudernext/issues"
+
+[build-system]
+requires = [
+    "setuptools>=61.0",
+    "wheel",
+    "cython",
+    "unasyncd",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+pystudernext = ["*.json"]

pystudernext-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pystudernext-0.0.1/src/pystudernext/__init__.py

@@ -0,0 +1,22 @@
+from .shared.studer_types import StuderUserLevel, StuderAccess, StuderTarget, StuderDataType
+from .shared.studer_types import StuderDiscoveredGateway, StuderDiscoveredDevice, StuderDiscoverNotConnected
+from .shared.studer_types import StuderParamException
+from .shared.studer_dataset import StuderDataset, StuderDatapoint, StuderDatapointUnknownException, StuderDatapointSyntaxException, StuderDatapointEnumNotFoundException
+from .shared.studer_families import StuderDeviceFamily, StuderDeviceFamilies, StuderDeviceFamilyUnknownException, StuderDeviceCodeUnknownException, StuderDeviceAddressUnknownException, StuderDeviceSlaveUnknownException
+from .shared.studer_interfaces_async import AsyncStuderApi, AsyncStuderDiscover, StuderDiscoverFlags
+from .shared.studer_interfaces_sync import StuderApi, StuderDiscover
+
+from .api_async import AsyncNextApi
+from .api_sync import NextApi
+from .discover_async import AsyncNextDiscover
+from .discover_sync import NextDiscover
+
+from .const import DEFAULT_HOST, DEFAULT_PORT
+from .data import NextDataType, NextUserLevel
+from .data import NextApiConnectException, NextApiTimeoutException, NextPackException, NextUnpackException
+from .datapoints import NextDataset, NextDatapoint, NextDatasetFlag
+from .families import NextDeviceFamily, NextDeviceFamilies, NextDeviceFamiliesFlag
+from .values import NextValueItem, NextValueSet
+
+# For unit testing
+# - none

pystudernext-0.0.1/src/pystudernext/api_async.py

@@ -0,0 +1,297 @@
+"""
+api.py: communication api to Studer Next via Modbus over TCP.
+"""
+
+import asyncio
+import logging
+
+from datetime import datetime, timedelta
+from pymodbus.client import AsyncModbusTcpClient, ModbusTcpClient
+from typing import Any
+
+from .shared.studer_dataset import StuderDatapoint
+from .shared.studer_interfaces_async import AsyncStuderApi
+from .shared.studer_interfaces_sync import StuderApi
+from .shared.studer_types import StuderAccess, StuderDataType, StuderDiscoveredDevice, StuderParamException
+from .const import DEFAULT_HOST, DEFAULT_PORT, REQ_BURST_PERIOD
+from .data import NextDataType, NextApiConnectException, NextApiReadException, NextApiUpdateException, NextPackException, NextUnpackException
+from .datapoints import NextDatapoint
+from .families import NextDeviceFamilies
+from .values import NextValueItem, NextValueSet
+
+
+_LOGGER = logging.getLogger(__name__)
+logging.getLogger("pymodbus").setLevel(logging.WARNING)
+
+
+class AsyncNextApi(AsyncStuderApi):
+    """
+    The actual Api for requesting and updating parameters via an async modbus tcp client.
+    """
+
+    def __init__(self, host:str=DEFAULT_HOST, port:int=DEFAULT_PORT):
+        """
+        We connect to the MX Gateway.
+        Once it is connected we can send Modbus requests.
+        """
+        self._host = host
+        self._port = port
+
+        self._client: AsyncModbusTcpClient = None
+        self._families = NextDeviceFamilies.get_instance()
+
+        # Diagnostics gathering
+        self._diag_retries = {}
+        self._diag_durations = {}
+
+
+    async def start(self) -> bool:
+        """
+        Connect to the remote gateway
+        """
+        try:
+            await self._get_connected_client()
+            return True
+        
+        except Exception as err:
+            return False
+
+
+    async def stop(self):
+        """
+        Close the client
+        """
+        try:
+            if self._client:
+                await self._client.close()
+
+        except Exception:
+            pass
+
+        finally:
+            self._client = None
+
+
+    @property
+    def connected(self) -> bool:
+        """Returns True if the Next client is connected, otherwise False"""
+        return self._client is not None and self._client.connected
+    
+
+    @property
+    def remote_host(self) -> str|None:
+        """Returns the Host or IP address of the Next Gateway we connect to, otherwise None"""
+        return self._host
+    
+    @property
+    def remote_port(self) -> str|None:
+        """Returns the port of the Next Gateway we connect to, otherwise None"""
+        return self._port
+    
+
+    async def request_value(self, parameter: StuderDatapoint, device: StuderDiscoveredDevice|int|str=None, retries = None, timeout = None, verbose=False) -> Any:
+        """
+        Request a parameter.
+        One of device, slave or code needs to be passed.
+        Returns None if not connected, otherwise returns the requested value
+
+        Throws
+            StuderParamException
+            NextApiConnectException
+            NextApiTimeoutException
+            NextUnpackException
+        """
+
+        # Sanity check
+        if parameter is None:
+            return None
+            
+        if parameter.access not in [StuderAccess.READ, StuderAccess.READ_WRITE]:
+            raise StuderParamException(f"Datapoint {parameter.family_id}:{parameter.address} is not readable")
+            
+        if isinstance(device, StuderDiscoveredDevice):
+            slave = device.slave
+        elif isinstance(device, int):
+            slave = device
+        elif isinstance(device, str):  
+            slave = self._families.get_slave_by_code(code=device)
+        else:
+            raise StuderParamException(f"Parameter 'device' must be a NextDiscoverdDevice, a slave number or a device code in call to request_value")
+
+        # Send the request
+        try:
+            if verbose:
+                _LOGGER.debug(f"Modbus read registers for '{parameter.name}' ({parameter.address} via {slave})")
+            
+            client = await self._get_connected_client()
+            result = await client.read_holding_registers(address=parameter.address, count=parameter.size, device_id=slave)
+
+        except Exception as err:
+            raise NextApiReadException(f"Modbus exception while requesting value for slave {slave}, address {parameter.address}, count {parameter.size}, error: {err}")
+
+        if result.isError():
+            raise NextApiReadException(f"Modbus error while requesting value for slave {slave}, address {parameter.address}, count {parameter.size}, error: {result.exception_code}")
+
+        # Unpack the response value
+        try:
+            value = AsyncModbusTcpClient.convert_from_registers(result.registers, data_type=NextDataType.to_datatype(parameter.data_type))
+
+            match parameter.data_type:
+                case StuderDataType.ENUM32: return parameter.enum_value(value)
+                case StuderDataType.BITFIELD: return parameter.bitfield_value(value)
+                case _: return value
+
+        except Exception as e:
+            raise NextPackException(f"Failed to unpack response value for slave {slave}, address {parameter.address}: registers={result.registers}, format={parameter.data_type}, size={parameter.size}") from None
+
+
+    async def request_values(self, request_data: NextValueSet, retries = None, timeout = None, verbose=False) -> NextValueSet:
+        """
+        Request multiple parameters in one call.
+        Can only retrieve actual device values, NOT the average or sum over multiple devices.
+
+        Returns None if not connected, otherwise returns the list of requested values
+        Throws
+            StuderParamException
+            NextApiConnectException
+            NextApiTimeoutException
+            NextUnpackException
+        """
+
+        # Unlike the Studer Xcom protocol, the Studer Next protocol does not have a function to request multiple
+        # items in one call.
+        # As a result we just resolve all requested values sequentially
+        result_items: list[NextValueItem] = []
+        burst_start = datetime.now()
+
+        for req_single in request_data.items:
+            try:
+                error = None
+                value = await self.request_value(req_single.datapoint, req_single.address, retries=retries, timeout=timeout, verbose=verbose)
+            
+            except Exception as ex:
+                value = None
+                error = str(ex)
+
+            if error is not None:
+                _LOGGER.debug(f"Failed to retrieve info or param {req_single.datapoint.nr}:{req_single.address}; {error}")
+
+            # Add to results
+            rsp_single = NextValueItem(
+                datapoint = req_single.datapoint, 
+                device = req_single.code,
+                value = value,
+                error = error,
+            )
+            result_items.append(rsp_single)
+
+            # Periodically wait for a second. 
+            # This will make sure we do not block the Next Gateway with too many requests at once
+            if (datetime.now() - burst_start).total_seconds() > REQ_BURST_PERIOD:
+                await asyncio.sleep(1)
+                burst_start = datetime.now()
+
+        # Return all reponse items as one XcomValueSet object
+        return NextValueSet(result_items)
+
+
+    async def update_value(self, parameter: NextDatapoint, value: Any, device: StuderDiscoveredDevice|int|str=None, retries = None, timeout = None, verbose=False):
+        """
+        Update a parameter
+        Returns None if not connected, otherwise returns True on success
+
+        Throws
+            StuderParamException
+            NextApiConnectException
+            NextApiTimeoutException
+            NextPackException
+        """
+        # Sanity check
+        if parameter is None or value is None:
+            return None
+
+        if parameter.access not in [StuderAccess.WRITE, StuderAccess.READ_WRITE]:
+            raise StuderParamException(f"Device parameter {parameter.family_id}:{parameter.address} is not writable")
+            
+        if isinstance(device, StuderDiscoveredDevice):
+            slave = device.slave
+        elif isinstance(device, int):
+            slave = device
+        elif isinstance(device, str):  
+            slave = self._families.get_slave_by_code(code=device)
+        else:
+            raise StuderParamException(f"Device parameter must be a NextDiscoverdDevice, a slave number or a device code in call to update_value")
+
+        _LOGGER.debug(f"Update '{parameter.name}' ({parameter.address} via {slave}) to {value}")
+
+        # Pack the data
+        try:
+            client = await self._get_connected_client()
+            regs = AsyncModbusTcpClient.convert_to_registers(value, data_type=NextDataType.to_datatype(parameter.data_type))
+
+        except Exception as e:
+            raise NextPackException(f"Failed to pack value for slave {slave}, address {parameter.address}: value={value}, format={parameter.data_type}, size={parameter.size}") from None
+        
+        # Send the request
+        try:
+            if verbose:
+                _LOGGER.debug(f"Modbus update registers for '{parameter.name}' ({parameter.address} via {slave})")
+            
+            result = await client.write_registers(address=parameter.address, values=regs, device_id=slave)
+
+        except Exception as err:
+            raise NextApiUpdateException(f"Modbus exception while updating value for slave {slave}, address {parameter.address}, error: {err}")
+
+        if result.isError():
+            raise NextApiReadException(f"Modbus error while updating value for slave {slave}, address {parameter.address}, count {parameter.size}, error: {result.exception_code}")    
+
+        return None
+
+
+    async def _get_connected_client(self) -> AsyncModbusTcpClient:
+        """
+        Return a connected client, reconnecting if needed.
+        """
+        if not self.connected:
+            client = self._create_client()
+
+            if await client.connect():
+                self._client = client
+            else:
+                self._client = None
+                raise NextApiConnectException(f"Cannot connect to Studer Gateway at {self._host}:{self._port}")
+            
+        return self._client            
+
+
+    def _create_client(self):
+        """
+        Helper to create the Modbus Client.
+        In a separate function to make it easier to replace the client with a stub for unit-tests.
+        """
+        return AsyncModbusTcpClient(host=self._host, port=self._port)
+
+
+    async def _add_diagnostics(self, retries: int = None, duration: timedelta = None):
+        if retries is not None:
+            if retries not in self._diag_retries:
+                self._diag_retries[retries] = 1
+            else:
+                self._diag_retries[retries] += 1
+
+        if duration is not None:
+            duration = round(duration.total_seconds(), 1)
+            if duration not in self._diag_durations:
+                self._diag_durations[duration] = 1
+            else:
+                self._diag_durations[duration] += 1
+
+
+    async def get_diagnostics(self):
+        return {
+            "statistics": {
+                "retries": dict(sorted(self._diag_retries.items())),
+                "durations": dict(sorted(self._diag_durations.items())),
+            }
+        }
+