- Added max registers per request option for WebAPI client (related to #14 tests)

Author: AN3Orik

custom_components/systemair/__init__.py

@@ -21,6 +21,8 @@
     CONF_SERIAL_PORT,
     CONF_SLAVE_ID,
     CONF_STOPBITS,
+    CONF_WEB_API_MAX_REGISTERS,
+    DEFAULT_WEB_API_MAX_REGISTERS,
 )
 from .coordinator import SystemairDataUpdateCoordinator
 from .data import SystemairConfigEntry, SystemairData
@@ -46,9 +48,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: SystemairConfigEntry) ->
     api_type = entry.data.get(CONF_API_TYPE, API_TYPE_MODBUS_TCP)
 
     if api_type == API_TYPE_MODBUS_WEBAPI:
+        max_registers = entry.options.get(CONF_WEB_API_MAX_REGISTERS, DEFAULT_WEB_API_MAX_REGISTERS)
         client = SystemairWebApiClient(
             address=entry.data[CONF_IP_ADDRESS],
             session=async_get_clientsession(hass),
+            max_registers_per_request=max_registers,
         )
     elif api_type == API_TYPE_MODBUS_SERIAL:
         client = SystemairSerialClient(

custom_components/systemair/api.py

@@ -26,6 +26,7 @@
 
 MODBUS_DEVICE_BUSY_EXCEPTION = 6
 MODBUS_GATEWAY_TARGET_FAILED_TO_RESPOND = 11
+WEB_API_MAX_REGISTERS_PER_REQUEST = 30
 
 READ_BLOCKS = [
     (1001, 62),
@@ -530,11 +531,13 @@ def __init__(
         self,
         address: str,
         session: aiohttp.ClientSession,
+        max_registers_per_request: int = WEB_API_MAX_REGISTERS_PER_REQUEST,
     ) -> None:
         """Systemair API Client."""
         self._address = address
         self._session = session
         self._lock = asyncio.Lock()
+        self._max_registers_per_request = max_registers_per_request
 
     @property
     def address(self) -> str:
@@ -620,21 +623,32 @@ async def get_all_data(self) -> dict[str, Any]:
             return all_registers
 
     async def _read_block(self, start: int, count: int) -> dict[str, Any]:
-        """Read a single block of registers."""
-        # Build list of registers for this block
-        regs = [start - 1 + offset for offset in range(count)]
+        """Read a single block of registers, splitting into smaller chunks if needed to avoid URL length limit."""
+        all_data = {}
 
-        # Build query params
-        query_params = ",".join(f"%22{reg}%22:1" for reg in regs)
-        url = f"http://{self._address}/mread?{{{query_params}}}"
+        # Split large blocks into smaller chunks to avoid 414 URI Too Long error
+        chunks_needed = (count + self._max_registers_per_request - 1) // self._max_registers_per_request
 
-        try:
-            result = await self._api_wrapper(method="get", url=url)
-            # Convert result to match Modbus TCP format (string keys)
-            return {str(k): v for k, v in result.items()}
-        except SystemairApiClientError as e:
-            msg = f"Failed to read block starting at {start}: {e}"
-            raise ModbusConnectionError(msg) from e
+        for chunk_idx in range(chunks_needed):
+            chunk_start = start + (chunk_idx * self._max_registers_per_request)
+            chunk_count = min(self._max_registers_per_request, count - (chunk_idx * self._max_registers_per_request))
+
+            # Build list of registers for this chunk
+            regs = [chunk_start - 1 + offset for offset in range(chunk_count)]
+
+            # Build query params
+            query_params = ",".join(f"%22{reg}%22:1" for reg in regs)
+            url = f"http://{self._address}/mread?{{{query_params}}}"
+
+            try:
+                result = await self._api_wrapper(method="get", url=url)
+                # Convert result to match Modbus TCP format (string keys)
+                all_data.update({str(k): v for k, v in result.items()})
+            except SystemairApiClientError as e:
+                msg = f"Failed to read block chunk starting at {chunk_start}: {e}"
+                raise ModbusConnectionError(msg) from e
+
+        return all_data
 
     async def _parse_response(self, response: aiohttp.ClientResponse, *, retry: bool) -> Any:
         """Parse the response."""

custom_components/systemair/config_flow.py

@@ -29,13 +29,15 @@
     CONF_SERIAL_PORT,
     CONF_SLAVE_ID,
     CONF_STOPBITS,
+    CONF_WEB_API_MAX_REGISTERS,
     DEFAULT_BAUDRATE,
     DEFAULT_BYTESIZE,
     DEFAULT_PARITY,
     DEFAULT_PORT,
     DEFAULT_SERIAL_PORT,
     DEFAULT_SLAVE_ID,
     DEFAULT_STOPBITS,
+    DEFAULT_WEB_API_MAX_REGISTERS,
     DOMAIN,
     LOGGER,
     MODEL_SPECS,
@@ -337,17 +339,30 @@ async def async_step_init(self, user_input: dict | None = None) -> config_entrie
             return self.async_create_entry(title="", data=user_input)
 
         default_model = self.config_entry.options.get(CONF_MODEL, self.config_entry.data.get(CONF_MODEL, "VSR 300"))
+        api_type = self.config_entry.data.get(CONF_API_TYPE)
+
+        # Base schema with model selection
+        schema_dict = {
+            vol.Required(CONF_MODEL, default=default_model): selector.SelectSelector(
+                selector.SelectSelectorConfig(
+                    options=list(MODEL_SPECS.keys()),
+                    mode=selector.SelectSelectorMode.DROPDOWN,
+                )
+            ),
+        }
+
+        # Web API specific options
+        if api_type == API_TYPE_MODBUS_WEBAPI:
+            default_max_registers = self.config_entry.options.get(CONF_WEB_API_MAX_REGISTERS, DEFAULT_WEB_API_MAX_REGISTERS)
+            schema_dict[vol.Optional(CONF_WEB_API_MAX_REGISTERS, default=default_max_registers)] = selector.NumberSelector(
+                selector.NumberSelectorConfig(
+                    min=30,
+                    max=125,
+                    mode=selector.NumberSelectorMode.BOX,
+                )
+            )
 
         return self.async_show_form(
             step_id="init",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_MODEL, default=default_model): selector.SelectSelector(
-                        selector.SelectSelectorConfig(
-                            options=list(MODEL_SPECS.keys()),
-                            mode=selector.SelectSelectorMode.DROPDOWN,
-                        )
-                    ),
-                }
-            ),
+            data_schema=vol.Schema(schema_dict),
         )

custom_components/systemair/const.py

@@ -11,8 +11,10 @@
 CONF_MODEL = "model"
 CONF_SLAVE_ID = "slave_id"
 CONF_API_TYPE = "api_type"
+CONF_WEB_API_MAX_REGISTERS = "web_api_max_registers"
 DEFAULT_PORT = 502
 DEFAULT_SLAVE_ID = 1
+DEFAULT_WEB_API_MAX_REGISTERS = 30
 
 # --- API Types ---
 API_TYPE_MODBUS_TCP = "modbus_tcp"

custom_components/systemair/manifest.json

@@ -15,5 +15,5 @@
     "aiohttp",
     "async-timeout"
   ],
-  "version": "1.0.14"
+  "version": "1.0.15"
 }

custom_components/systemair/translations/en.json

@@ -51,7 +51,11 @@
             "init": {
                 "title": "Systemair Settings",
                 "data": {
-                    "model": "Ventilation Unit Model"
+                    "model": "Ventilation Unit Model",
+                    "web_api_max_registers": "Max registers per Web API request"
+                },
+                "data_description": {
+                    "web_api_max_registers": "Maximum number of registers to read in a single Web API request. Range: 30-125."
                 }
             }
         }

custom_components/systemair/translations/ru.json

@@ -51,7 +51,11 @@
             "init": {
                 "title": "Настройки Systemair",
                 "data": {
-                    "model": "Модель устройства"
+                    "model": "Модель устройства",
+                    "web_api_max_registers": "Макс. регистров на запрос Web API"
+                },
+                "data_description": {
+                    "web_api_max_registers": "Максимальное количество регистров, читаемых за один запрос Web API. Диапазон: 30-125."
                 }
             }
         }