pybls21 4.2.2__tar.gz → 4.4.0__tar.gz

pybls21-4.4.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: pybls21
+Version: 4.4.0
+Summary: An api allowing control of AC state (temperature, on/off, speed) of an Blauberg S21 device locally over TCP
+Home-page: https://github.com/jvitkauskas/pybls21
+Author: Julius Vitkauskas
+Author-email: zadintuvas@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES
+Requires-Dist: pymodbus<4.0,>=3.13.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Blauberg S21 Asynchronous Python API
+An api allowing control of AC state (temperature, on/off, speed) of an Blauberg S21 device locally over TCP.
+
+## Usage
+To initialize:
+`client = S21Client("192.168.0.125")`
+
+To load:
+`await client.poll()`
+
+The following functions are available:
+`turn_on()`
+`turn_off()`
+`set_hvac_mode(hvac_mode: HVACMode)`
+`set_fan_mode(mode: int)`
+`set_manual_fan_speed_percent(speed_percent: int)`
+`set_temperature(temp_celsius: int)`
+`reset_filter_change_timer()`
+`reset_alarm()`
+`boost_on()`
+`boost_off()`
+`set_bypass_mode(mode: BypassMode)`
+`set_bypass_position(position_percent: int)`
+`set_timer_on()` / `set_timer_off()`
+`set_scheduler_mode_on()` / `set_scheduler_mode_off()`
+
+
+## Additional readings
+
+`await client.poll()` also returns extract and exhaust air temperatures
+(`current_extract_temperature`, `current_exhaust_temperature`), supply and
+extract duct pressure in Pa (`supply_pressure`, `extract_pressure`), and whole
+days remaining until filter replacement (`filter_countdown_days`).
+
+Missing or short-circuited temperature sensors are reported as `None`, including
+`current_temperature` and `current_intake_temperature`. In AUTO mode,
+`hvac_action` is also `None` when either temperature needed to infer the action
+is unavailable. Other readings remain usable and `available` stays true after
+a successful poll. Connection and communication failures mark
+`client.device.available` false if a previous poll populated the device; a
+successful subsequent poll restores it. Previously returned models are immutable
+snapshots, so read `client.device` for the updated availability.
+
+## Bypass control
+
+```python
+from pybls21.models import BypassMode
+
+# AUTO lets the device control its bypass or rotary heat exchanger.
+await client.set_bypass_mode(BypassMode.AUTO)
+
+# For analogue control, set the manual percentage and select manual mode.
+await client.set_bypass_position(60)
+await client.set_bypass_mode(BypassMode.OPEN)
+```
+
+`CLOSED` closes the bypass or starts the rotor. `OPEN` opens the bypass or stops
+the rotor for discrete control; with analogue control it selects the percentage
+set by `set_bypass_position()`. That setter alone does not change the mode.
+A value of 0 means closed bypass / maximum rotor speed; 100 means open bypass /
+stopped rotor. Choose controls appropriate to the reported `bypass_type`.
+
+The model exposes `bypass_type`, `bypass_mode`, `manual_bypass_position`, and
+`bypass_position`. Position is read separately from optional input register 51.
+On older firmware that rejects this address, `bypass_position` is `None` and
+polling the other readings still succeeds. Other communication errors are
+propagated. When no bypass/rotor is fitted, its mode and positions are `None`
+and the optional read is skipped.
+
+New model fields have defaults, preserving construction with the original
+positional or keyword arguments. The tuple now contains additional fields;
+consumers should access readings by attribute rather than unpacking a fixed
+number of values.
+
+## Timer, scheduler, and telemetry
+
+`set_timer_on()` / `set_timer_off()` enable or disable the device's existing
+main timer. `set_scheduler_mode_on()` / `set_scheduler_mode_off()` enable or
+disable its existing weekly schedule. Configure the timer duration and weekly
+schedule on the device; these methods only toggle their activation.
+
+The following fields are available after `await client.poll()`:
+
+| Field | Meaning |
+| --- | --- |
+| `is_timer` | Whether the main timer is active |
+| `timer_countdown` | Remaining main timer time as `HH:MM:SS` |
+| `is_schedule_mode` | Whether the weekly schedule is enabled |
+| `fan_level_schedule_mode` | Current scheduled fan level; 0 means standby |
+| `fan_level_timer_mode` | Configured timer fan level; 0 means standby |
+| `alarm_codes` | Active numeric alarm codes (0–52); empty list when no alarm or warning is reported |
+| `supply_airflow`, `extract_airflow` | Airflow in m³/h |
+| `operating_time_minutes` | Total device operating time in minutes |
+| `filter_countdown_hours`, `filter_countdown_minutes` | Remaining hours and minutes in addition to `filter_countdown_days` |
+| `supply_fan_speed_percent`, `extract_fan_speed_percent` | Actual fan performance in percent, or `None` on older firmware |
+
+`fan_mode` remains the configured normal fan level and `set_fan_mode(mode)`
+still takes one argument. Timer and schedule levels are separate readings, not
+an inferred effective fan level during overrides. The existing
+`supply_fan_speed` and `extract_fan_speed` fields continue to report **RPM**.
+
+The timer, schedule, airflow, operating time, and filter readings use the blocks
+already fetched by polling. Detailed alarm codes add a discrete-input read only
+when an alarm or warning is active. Fan percentages add a separate read of
+IR52–53; an Illegal Data Address response leaves both percentages unknown without
+interrupting other readings. Timeouts and other errors still propagate and
+invalidate cached availability.
+
+These additions are adapted from [marni-xyz's fork](https://github.com/marni-xyz/pybls21),
+including its operating-time, airflow, and fan-performance work attributed to
+[birdie1](https://github.com/birdie1).
+
+The copyright and MIT terms for these ported portions are retained in
+[THIRD_PARTY_NOTICES](THIRD_PARTY_NOTICES), included in both source and wheel
+distributions.

pybls21-4.4.0/README.md

@@ -0,0 +1,115 @@
+# Blauberg S21 Asynchronous Python API
+An api allowing control of AC state (temperature, on/off, speed) of an Blauberg S21 device locally over TCP.
+
+## Usage
+To initialize:
+`client = S21Client("192.168.0.125")`
+
+To load:
+`await client.poll()`
+
+The following functions are available:
+`turn_on()`
+`turn_off()`
+`set_hvac_mode(hvac_mode: HVACMode)`
+`set_fan_mode(mode: int)`
+`set_manual_fan_speed_percent(speed_percent: int)`
+`set_temperature(temp_celsius: int)`
+`reset_filter_change_timer()`
+`reset_alarm()`
+`boost_on()`
+`boost_off()`
+`set_bypass_mode(mode: BypassMode)`
+`set_bypass_position(position_percent: int)`
+`set_timer_on()` / `set_timer_off()`
+`set_scheduler_mode_on()` / `set_scheduler_mode_off()`
+
+
+## Additional readings
+
+`await client.poll()` also returns extract and exhaust air temperatures
+(`current_extract_temperature`, `current_exhaust_temperature`), supply and
+extract duct pressure in Pa (`supply_pressure`, `extract_pressure`), and whole
+days remaining until filter replacement (`filter_countdown_days`).
+
+Missing or short-circuited temperature sensors are reported as `None`, including
+`current_temperature` and `current_intake_temperature`. In AUTO mode,
+`hvac_action` is also `None` when either temperature needed to infer the action
+is unavailable. Other readings remain usable and `available` stays true after
+a successful poll. Connection and communication failures mark
+`client.device.available` false if a previous poll populated the device; a
+successful subsequent poll restores it. Previously returned models are immutable
+snapshots, so read `client.device` for the updated availability.
+
+## Bypass control
+
+```python
+from pybls21.models import BypassMode
+
+# AUTO lets the device control its bypass or rotary heat exchanger.
+await client.set_bypass_mode(BypassMode.AUTO)
+
+# For analogue control, set the manual percentage and select manual mode.
+await client.set_bypass_position(60)
+await client.set_bypass_mode(BypassMode.OPEN)
+```
+
+`CLOSED` closes the bypass or starts the rotor. `OPEN` opens the bypass or stops
+the rotor for discrete control; with analogue control it selects the percentage
+set by `set_bypass_position()`. That setter alone does not change the mode.
+A value of 0 means closed bypass / maximum rotor speed; 100 means open bypass /
+stopped rotor. Choose controls appropriate to the reported `bypass_type`.
+
+The model exposes `bypass_type`, `bypass_mode`, `manual_bypass_position`, and
+`bypass_position`. Position is read separately from optional input register 51.
+On older firmware that rejects this address, `bypass_position` is `None` and
+polling the other readings still succeeds. Other communication errors are
+propagated. When no bypass/rotor is fitted, its mode and positions are `None`
+and the optional read is skipped.
+
+New model fields have defaults, preserving construction with the original
+positional or keyword arguments. The tuple now contains additional fields;
+consumers should access readings by attribute rather than unpacking a fixed
+number of values.
+
+## Timer, scheduler, and telemetry
+
+`set_timer_on()` / `set_timer_off()` enable or disable the device's existing
+main timer. `set_scheduler_mode_on()` / `set_scheduler_mode_off()` enable or
+disable its existing weekly schedule. Configure the timer duration and weekly
+schedule on the device; these methods only toggle their activation.
+
+The following fields are available after `await client.poll()`:
+
+| Field | Meaning |
+| --- | --- |
+| `is_timer` | Whether the main timer is active |
+| `timer_countdown` | Remaining main timer time as `HH:MM:SS` |
+| `is_schedule_mode` | Whether the weekly schedule is enabled |
+| `fan_level_schedule_mode` | Current scheduled fan level; 0 means standby |
+| `fan_level_timer_mode` | Configured timer fan level; 0 means standby |
+| `alarm_codes` | Active numeric alarm codes (0–52); empty list when no alarm or warning is reported |
+| `supply_airflow`, `extract_airflow` | Airflow in m³/h |
+| `operating_time_minutes` | Total device operating time in minutes |
+| `filter_countdown_hours`, `filter_countdown_minutes` | Remaining hours and minutes in addition to `filter_countdown_days` |
+| `supply_fan_speed_percent`, `extract_fan_speed_percent` | Actual fan performance in percent, or `None` on older firmware |
+
+`fan_mode` remains the configured normal fan level and `set_fan_mode(mode)`
+still takes one argument. Timer and schedule levels are separate readings, not
+an inferred effective fan level during overrides. The existing
+`supply_fan_speed` and `extract_fan_speed` fields continue to report **RPM**.
+
+The timer, schedule, airflow, operating time, and filter readings use the blocks
+already fetched by polling. Detailed alarm codes add a discrete-input read only
+when an alarm or warning is active. Fan percentages add a separate read of
+IR52–53; an Illegal Data Address response leaves both percentages unknown without
+interrupting other readings. Timeouts and other errors still propagate and
+invalidate cached availability.
+
+These additions are adapted from [marni-xyz's fork](https://github.com/marni-xyz/pybls21),
+including its operating-time, airflow, and fan-performance work attributed to
+[birdie1](https://github.com/birdie1).
+
+The copyright and MIT terms for these ported portions are retained in
+[THIRD_PARTY_NOTICES](THIRD_PARTY_NOTICES), included in both source and wheel
+distributions.

pybls21-4.4.0/THIRD_PARTY_NOTICES

@@ -0,0 +1,41 @@
+Third-party notices
+===================
+
+Ported S21 controls and telemetry
+--------------------------------
+
+This project includes code adapted from marni-xyz/pybls21 for timer and
+weekly-schedule activation, alarm details, timer and filter countdowns,
+airflow, operating time, and fan-performance readings. This notice applies
+to those incorporated portions and their adaptations.
+
+Source: https://github.com/marni-xyz/pybls21
+Revision: 4bbd1189811d7e96ec501a632aac7824e2ad907d
+
+The upstream fork attributes the operating-time, airflow, and fan-performance
+additions to birdie1. Contributor acknowledgements are also recorded in the
+README and Git commit history.
+
+The source project's copyright notice and MIT license follow:
+
+MIT License
+
+Copyright (c) 2026 marni-xyz / 2021 Julius Vitkauskas
+
+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.

{pybls21-4.2.2 → pybls21-4.4.0}/pybls21/client.py

@@ -2,11 +2,14 @@ import asyncio
 from typing import Any, Awaitable, Callable, List, Optional
 
 from pymodbus.client import AsyncModbusTcpClient
+from pymodbus.pdu import ExceptionResponse
 
 from .constants import *
 from .exceptions import *
 from .models import (
     TEMP_CELSIUS,
+    BypassMode,
+    BypassType,
     ClimateDevice,
     ClimateEntityFeature,
     HVACAction,
@@ -27,6 +30,13 @@ def _to_signed_16bit(value: int) -> int:
     return value - 0x10000 if value > 0x7FFF else value
 
 
+def _parse_temperature(value: int) -> Optional[float]:
+    # The S21 reserves these values for a missing or short-circuited sensor.
+    if value in (0x8000, 0x7FFF):
+        return None
+    return _to_signed_16bit(value) / 10
+
+
 class S21Client:
     def __init__(self, host: str, port: int = 502):
         self.host = host
@@ -73,6 +83,28 @@ class S21Client:
     async def boost_off(self) -> None:
         await self._do_with_connection(self._set_boost_off)
 
+    async def set_timer_on(self) -> None:
+        await self._do_with_connection(lambda: self._write_coil(CL_TIMER, True))
+
+    async def set_timer_off(self) -> None:
+        await self._do_with_connection(lambda: self._write_coil(CL_TIMER, False))
+
+    async def set_scheduler_mode_on(self) -> None:
+        await self._do_with_connection(lambda: self._write_coil(CL_WEEK, True))
+
+    async def set_scheduler_mode_off(self) -> None:
+        await self._do_with_connection(lambda: self._write_coil(CL_WEEK, False))
+
+    async def set_bypass_mode(self, mode: BypassMode) -> None:
+        mode = BypassMode(mode)
+        await self._do_with_connection(lambda: self._set_bypass_mode(mode))
+
+    async def set_bypass_position(self, position_percent: int) -> None:
+        self._validate_bypass_position(position_percent)
+        await self._do_with_connection(
+            lambda: self._set_bypass_position(position_percent)
+        )
+
     @staticmethod
     def _validate_modbus_response(response: Any, operation: str) -> Any:
         if response is None:
@@ -117,10 +149,33 @@ class S21Client:
         if not isinstance(temp_celsius, int) or not 15 <= temp_celsius <= 30:
             raise ValueError("Temperature must be between 15 and 30 °C")
 
+    @staticmethod
+    def _validate_bypass_position(position_percent: int) -> None:
+        if not isinstance(position_percent, int) or not 0 <= position_percent <= 100:
+            raise ValueError("Bypass position percent must be between 0 and 100")
+
     async def _read_input_registers(self, address: int, count: int) -> List[int]:
         response = await self.client.read_input_registers(address, count=count)
         return self._get_registers(response, count, f"read input registers at {address}")
 
+    async def _read_optional_input_registers(
+        self, address: int, count: int
+    ) -> Optional[List[int]]:
+        response = await self.client.read_input_registers(address, count=count)
+        # Older firmware lacks IR51-53. Only Illegal Data Address is optional;
+        # timeouts, malformed replies and other device errors must still surface.
+        if isinstance(response, ExceptionResponse) and response.exception_code == 2:
+            return None
+        return self._get_registers(response, count, f"read input registers at {address}")
+
+    async def _read_alarm_codes(self) -> List[int]:
+        response = await self.client.read_discrete_inputs(
+            DI_ALARM_START, count=DI_ALARM_COUNT
+        )
+        bits = self._get_bits(response, DI_ALARM_COUNT, "read alarm codes")
+        # Modbus pads bit responses to whole bytes; ignore bits beyond code 52.
+        return [code for code in range(DI_ALARM_COUNT) if bits[code]]
+
     async def _read_holding_registers(self, address: int, count: int) -> List[int]:
         response = await self.client.read_holding_registers(address, count=count)
         return self._get_registers(response, count, f"read holding registers at {address}")
@@ -139,14 +194,17 @@ class S21Client:
 
     async def _do_with_connection(self, func: Callable[[], Awaitable[Any]]) -> Any:
         async with self.lock:  # Device does not support multiple connections
-            if not await self.client.connect():
-                raise ModbusCommunicationException("Failed to open Modbus TCP connection")
-
             try:
+                if not await self.client.connect():
+                    raise ModbusCommunicationException(
+                        "Failed to open Modbus TCP connection"
+                    )
                 return await func()
             except Exception:
                 if isinstance(self.device, ClimateDevice):
-                    self.device.available = False
+                    # ClimateDevice is a NamedTuple and therefore immutable,
+                    # so the flag has to be replaced instead of assigned.
+                    self.device = self.device._replace(available=False)
                 raise
             finally:
                 self.client.close()  # Also, long connections break over time and become unusable
@@ -156,7 +214,7 @@ class S21Client:
             raise UnsupportedDeviceException("Unsupported device (IR_DeviceTYPE != 1)")
 
         coils = await self._read_coils(0, count=4)
-        holding_registers = await self._read_holding_registers(0, count=45)
+        holding_registers = await self._read_holding_registers(0, count=76)
         input_registers = await self._read_input_registers(0, count=39)
 
         is_on: bool = coils[CL_POWER]
@@ -165,12 +223,13 @@ class S21Client:
         current_humidity: int = input_registers[IR_CurRH_Int]
         filter_state: int = input_registers[IR_StateFILTER]
         alarm_state: int = input_registers[IR_ALARM]
+        alarm_codes = await self._read_alarm_codes() if alarm_state else []
         max_fan_level: int = holding_registers[HR_MaxSPEED_MODE]
         current_fan_level: int = holding_registers[HR_SPEED_MODE]  # 255 - manual
-        temp_before_heating_x10: int = _to_signed_16bit(
+        temp_before_heating = _parse_temperature(
             input_registers[IR_CurTEMP_SuAirIn]
         )
-        temp_after_heating_x10: int = _to_signed_16bit(
+        temp_after_heating = _parse_temperature(
             input_registers[IR_CurTEMP_SuAirOut]
         )
         supply_fan_speed: int = input_registers[IR_SuRPM]
@@ -180,6 +239,33 @@ class S21Client:
         ]
         operation_mode: int = holding_registers[HR_OPERATION_MODE]
         manual_fan_speed_percent: int = holding_registers[HR_ManualSPEED]
+        bypass_type: BypassType = BypassType(holding_registers[HR_BPS_ROTOR_TYPE])
+        bypass_mode = (
+            BypassMode(holding_registers[HR_BPS_ROTOR_MODE])
+            if bypass_type != BypassType.NOT_AVAILABLE
+            else None
+        )
+        manual_bypass_position = (
+            holding_registers[HR_SetBpsRotorMANUAL]
+            if bypass_type != BypassType.NOT_AVAILABLE
+            else None
+        )
+        bypass_registers = (
+            await self._read_optional_input_registers(IR_StatusBpsRotor, count=1)
+            if bypass_type != BypassType.NOT_AVAILABLE
+            else None
+        )
+        fan_percentages = await self._read_optional_input_registers(
+            IR_CurSuFanSpeed, count=2
+        )
+        timer_minutes, timer_seconds = divmod(input_registers[IR_CurTIMER_TIME], 256)
+        timer_hours = input_registers[IR_CurTIMER_TIME_HOURS] & 0xFF
+        filter_hours, filter_minutes = divmod(
+            input_registers[IR_CurFILTER_TIMER_HOURS_MINUTES], 256
+        )
+        operating_hours, operating_minutes = divmod(
+            input_registers[IR_TotalWorkingTime_HOURS_MINUTES], 256
+        )
 
         self.device = ClimateDevice(
             available=True,
@@ -187,7 +273,7 @@ class S21Client:
             unique_id=f"S21_{self.host}_{self.port}",
             temperature_unit=TEMP_CELSIUS,  # Seems like no Fahrenheit option is available
             precision=1,
-            current_temperature=temp_after_heating_x10 / 10,
+            current_temperature=temp_after_heating,
             target_temperature=set_temperature,
             target_temperature_step=1,
             min_temp=15,
@@ -210,10 +296,12 @@ class S21Client:
             if operation_mode == 1
             else HVACAction.COOLING
             if operation_mode == 2
+            else None
+            if temp_before_heating is None or temp_after_heating is None
             else HVACAction.HEATING
-            if temp_before_heating_x10 < temp_after_heating_x10
+            if temp_before_heating < temp_after_heating
             else HVACAction.COOLING
-            if temp_before_heating_x10 > temp_after_heating_x10
+            if temp_before_heating > temp_after_heating
             else HVACAction.IDLE,
             hvac_modes=[
                 HVACMode.OFF,
@@ -230,13 +318,46 @@ class S21Client:
             model="S21",
             sw_version=_parse_firmware_version(firmware_info),
             is_boosting=is_boosting,
-            current_intake_temperature=temp_before_heating_x10 / 10,
+            current_intake_temperature=temp_before_heating,
             manual_fan_speed_percent=manual_fan_speed_percent,
             max_fan_level=max_fan_level,
             filter_state=filter_state,
             alarm_state=alarm_state,
             supply_fan_speed=supply_fan_speed,
             extract_fan_speed=extract_fan_speed,
+            current_extract_temperature=_parse_temperature(
+                input_registers[IR_CurTEMP_ExAirIn]
+            ),
+            current_exhaust_temperature=_parse_temperature(
+                input_registers[IR_CurTEMP_ExAirOut]
+            ),
+            supply_pressure=input_registers[IR_CurSuPRESS],
+            extract_pressure=input_registers[IR_CurExPRESS],
+            filter_countdown_days=input_registers[IR_CurFILTER_TIMER_DAYS],
+            bypass_type=bypass_type,
+            bypass_mode=bypass_mode,
+            bypass_position=bypass_registers[0] if bypass_registers is not None else None,
+            manual_bypass_position=manual_bypass_position,
+            is_timer=coils[CL_TIMER],
+            timer_countdown=f"{timer_hours:02d}:{timer_minutes:02d}:{timer_seconds:02d}",
+            is_schedule_mode=coils[CL_WEEK],
+            fan_level_schedule_mode=input_registers[IR_CurWeekSpeed],
+            fan_level_timer_mode=holding_registers[HR_TIMER_MODE],
+            alarm_codes=alarm_codes,
+            supply_airflow=input_registers[IR_CurSuAirFLOW],
+            extract_airflow=input_registers[IR_CurExAirFLOW],
+            operating_time_minutes=(
+                input_registers[IR_TotalWorkingTime_DAYS] * 1440
+                + operating_hours * 60 + operating_minutes
+            ),
+            filter_countdown_hours=filter_hours,
+            filter_countdown_minutes=filter_minutes,
+            supply_fan_speed_percent=(
+                fan_percentages[0] if fan_percentages is not None else None
+            ),
+            extract_fan_speed_percent=(
+                fan_percentages[1] if fan_percentages is not None else None
+            ),
         )
 
         return self.device
@@ -283,3 +404,9 @@ class S21Client:
 
     async def _set_boost_off(self) -> None:
         await self._write_coil(CL_BoostSWITCH_CTRL, False)
+
+    async def _set_bypass_mode(self, mode: BypassMode) -> None:
+        await self._write_register(HR_BPS_ROTOR_MODE, int(mode))
+
+    async def _set_bypass_position(self, position_percent: int) -> None:
+        await self._write_register(HR_SetBpsRotorMANUAL, position_percent)

pybls21-4.4.0/pybls21/constants.py

@@ -0,0 +1,52 @@
+# Coils
+CL_POWER = 0
+CL_TIMER = 1
+CL_WEEK = 2
+CL_Boost_MODE = 3
+CL_BoostSWITCH_CTRL = 13
+CL_RESET_FILTER_TIMER = 17
+CL_RESET_ALARM = 18
+
+# Holding registers
+HR_MaxSPEED_MODE = 1
+HR_SPEED_MODE = 2
+HR_ManualSPEED = 17
+HR_OPERATION_MODE = 43
+HR_SetTEMP = 44
+HR_TIMER_MODE = 49
+HR_BPS_ROTOR_TYPE = 57
+HR_BPS_ROTOR_MODE = 74
+HR_SetBpsRotorMANUAL = 75
+
+# Input registers
+IR_CurTEMP_SuAirIn = 1
+IR_CurTEMP_SuAirOut = 2
+IR_CurTEMP_ExAirIn = 3  # Extract air from the rooms, at the unit inlet
+IR_CurTEMP_ExAirOut = 4  # Exhaust air to the outside, at the unit outlet
+IR_CurRH_Int = 10
+IR_CurSuAirFLOW = 19  # Supply airflow, m³/h
+IR_CurExAirFLOW = 20  # Extract airflow, m³/h
+IR_CurSuPRESS = 21  # Supply duct pressure, Pa
+IR_CurExPRESS = 22  # Extract duct pressure, Pa
+IR_SuRPM = 23
+IR_ExRPM = 24
+IR_CurTIMER_TIME = 25  # High byte: minutes, low byte: seconds
+IR_CurTIMER_TIME_HOURS = 26  # Low byte: hours
+IR_CurFILTER_TIMER_HOURS_MINUTES = 27  # High byte: hours, low byte: minutes
+IR_CurFILTER_TIMER_DAYS = 28
+IR_TotalWorkingTime_HOURS_MINUTES = 29  # High byte: hours, low byte: minutes
+IR_TotalWorkingTime_DAYS = 30
+IR_StateFILTER = 31
+IR_CurWeekSpeed = 32  # 0: standby, 1-5: scheduled speed
+IR_VerMAIN_FMW_start = 34
+IR_VerMAIN_FMW_end = 36
+IR_DeviceTYPE = 37
+IR_ALARM = 38
+IR_BPS_ROTOR_U = 45
+IR_StatusBpsRotor = 51
+IR_CurSuFanSpeed = 52  # Actual supply fan performance, percent
+IR_CurExFanSpeed = 53  # Actual extract fan performance, percent
+
+# Discrete inputs: alarm codes 0 through 52
+DI_ALARM_START = 19
+DI_ALARM_COUNT = 53