pybls21 4.3.0__tar.gz → 4.4.0__tar.gz

{pybls21-4.3.0 → pybls21-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybls21
-Version: 4.3.0
+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
@@ -11,6 +11,7 @@ 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
@@ -46,6 +47,8 @@ The following functions are available:
 `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
@@ -94,3 +97,45 @@ 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.3.0 → pybls21-4.4.0}/README.md

@@ -21,6 +21,8 @@ The following functions are available:
 `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
@@ -69,3 +71,45 @@ 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.3.0 → pybls21-4.4.0}/pybls21/client.py

@@ -83,6 +83,18 @@ 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))
@@ -146,13 +158,23 @@ class S21Client:
         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_bypass_position(self) -> Optional[int]:
-        response = await self.client.read_input_registers(IR_StatusBpsRotor, count=1)
-        # Older firmware has no IR51. Only Illegal Data Address is optional;
+    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, 1, "read bypass position")[0]
+        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)
@@ -201,6 +223,7 @@ 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 = _parse_temperature(
@@ -227,11 +250,22 @@ class S21Client:
             if bypass_type != BypassType.NOT_AVAILABLE
             else None
         )
-        bypass_position = (
-            await self._read_bypass_position()
+        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,
@@ -302,8 +336,28 @@ class S21Client:
             filter_countdown_days=input_registers[IR_CurFILTER_TIMER_DAYS],
             bypass_type=bypass_type,
             bypass_mode=bypass_mode,
-            bypass_position=bypass_position,
+            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

{pybls21-4.3.0 → pybls21-4.4.0}/pybls21/constants.py

@@ -1,5 +1,7 @@
 # Coils
 CL_POWER = 0
+CL_TIMER = 1
+CL_WEEK = 2
 CL_Boost_MODE = 3
 CL_BoostSWITCH_CTRL = 13
 CL_RESET_FILTER_TIMER = 17
@@ -11,6 +13,7 @@ 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
@@ -21,16 +24,29 @@ 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

{pybls21-4.3.0 → pybls21-4.4.0}/pybls21/models.py

@@ -78,3 +78,16 @@ class ClimateDevice(NamedTuple):
     bypass_mode: Optional[BypassMode] = None
     bypass_position: Optional[int] = None
     manual_bypass_position: Optional[int] = None
+    is_timer: bool = False
+    timer_countdown: Optional[str] = None
+    is_schedule_mode: bool = False
+    fan_level_schedule_mode: Optional[int] = None
+    fan_level_timer_mode: Optional[int] = None
+    alarm_codes: Optional[List[int]] = None
+    supply_airflow: Optional[int] = None
+    extract_airflow: Optional[int] = None
+    operating_time_minutes: Optional[int] = None
+    filter_countdown_hours: Optional[int] = None
+    filter_countdown_minutes: Optional[int] = None
+    supply_fan_speed_percent: Optional[int] = None
+    extract_fan_speed_percent: Optional[int] = None

{pybls21-4.3.0 → pybls21-4.4.0}/pybls21.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybls21
-Version: 4.3.0
+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
@@ -11,6 +11,7 @@ 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
@@ -46,6 +47,8 @@ The following functions are available:
 `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
@@ -94,3 +97,45 @@ 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.3.0 → pybls21-4.4.0}/pybls21.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+THIRD_PARTY_NOTICES
 setup.py
 pybls21/__init__.py
 pybls21/client.py

{pybls21-4.3.0 → pybls21-4.4.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="pybls21",
-    version="4.3.0",
+    version="4.4.0",
     author="Julius Vitkauskas",
     author_email="zadintuvas@gmail.com",
     description="An api allowing control of AC state (temperature, on/off, speed) of an Blauberg S21 device locally over TCP",
@@ -13,6 +13,7 @@ setuptools.setup(
     long_description_content_type="text/markdown",
     url="https://github.com/jvitkauskas/pybls21",
     packages=setuptools.find_packages(exclude=["tests"]),
+    license_files=["LICENSE", "THIRD_PARTY_NOTICES"],
     install_requires=["pymodbus>=3.13.1,<4.0"],
     classifiers=[
         "Programming Language :: Python :: 3",

{pybls21-4.3.0 → pybls21-4.4.0}/tests/test_client.py

@@ -179,6 +179,14 @@ class TestClient(unittest.IsolatedAsyncioTestCase):
         self.server.data_bank.set_input_registers(IR_CurSuPRESS, [45])
         self.server.data_bank.set_input_registers(IR_CurExPRESS, [50])
         self.server.data_bank.set_input_registers(IR_CurFILTER_TIMER_DAYS, [69])
+        self.server.data_bank.set_input_registers(IR_CurFILTER_TIMER_HOURS_MINUTES, [0x0809])
+        self.server.data_bank.set_input_registers(IR_CurTIMER_TIME, [0x112B])
+        self.server.data_bank.set_input_registers(IR_CurTIMER_TIME_HOURS, [0xAB02])
+        self.server.data_bank.set_input_registers(IR_TotalWorkingTime_HOURS_MINUTES, [0x0304])
+        self.server.data_bank.set_input_registers(IR_TotalWorkingTime_DAYS, [2])
+        self.server.data_bank.set_input_registers(IR_CurSuAirFLOW, [123])
+        self.server.data_bank.set_input_registers(IR_CurExAirFLOW, [456])
+        self.server.data_bank.set_input_registers(IR_CurSuFanSpeed, [35, 45])
         self.server.data_bank.set_input_registers(
             IR_VerMAIN_FMW_start, [36, 2053, 2019]
         )
@@ -233,6 +241,19 @@ class TestClient(unittest.IsolatedAsyncioTestCase):
                 bypass_mode=None,
                 bypass_position=None,
                 manual_bypass_position=None,
+                is_timer=False,
+                timer_countdown="02:17:43",
+                is_schedule_mode=False,
+                fan_level_schedule_mode=0,
+                fan_level_timer_mode=0,
+                alarm_codes=[],
+                supply_airflow=123,
+                extract_airflow=456,
+                operating_time_minutes=3064,
+                filter_countdown_hours=8,
+                filter_countdown_minutes=9,
+                supply_fan_speed_percent=35,
+                extract_fan_speed_percent=45,
             ),
         )
 
@@ -279,6 +300,95 @@ class TestClient(unittest.IsolatedAsyncioTestCase):
                     self.server.data_bank.set_input_registers(address, [100])
                     self.assertEqual(getattr(await client.poll(), field), 10.0)
 
+    async def test_version_43_model_constructor_remains_supported(self):
+        device = await S21Client(self.server.host, self.server.port).poll()
+        # Version 4.3.0 had 37 fields, including its sensor and bypass additions.
+        positional = ClimateDevice(*device[:37])
+        keyword = ClimateDevice(**dict(zip(device._fields[:37], device[:37])))
+        self.assertEqual(positional, keyword)
+        self.assertIsInstance(positional, tuple)
+        self.assertEqual(positional[:37], device[:37])
+        self.assertIsNone(positional.supply_fan_speed_percent)
+        self.assertIsNone(positional.alarm_codes)
+
+    async def test_timer_and_schedule_controls(self):
+        controls = (
+            ("set_timer_on", CL_TIMER, True, "is_timer"),
+            ("set_timer_off", CL_TIMER, False, "is_timer"),
+            ("set_scheduler_mode_on", CL_WEEK, True, "is_schedule_mode"),
+            ("set_scheduler_mode_off", CL_WEEK, False, "is_schedule_mode"),
+        )
+        client = S21Client(self.server.host, self.server.port)
+        for method, address, enabled, field in controls:
+            with self.subTest(method=method):
+                self.server.data_bank.set_coils(address, [not enabled])
+                await getattr(client, method)()
+                self.assertEqual(self.server.data_bank.get_coils(address, 1), [enabled])
+                self.assertEqual(getattr(await client.poll(), field), enabled)
+
+    async def test_timer_and_schedule_preserve_configured_fan_mode(self):
+        bank = self.server.data_bank
+        bank.set_holding_registers(HR_MaxSPEED_MODE, [3])
+        bank.set_holding_registers(HR_SPEED_MODE, [2])
+        bank.set_holding_registers(HR_TIMER_MODE, [1])
+        bank.set_input_registers(IR_CurWeekSpeed, [0])  # Scheduled standby
+        bank.set_coils(CL_TIMER, [True])
+        bank.set_coils(CL_WEEK, [True])
+        bank.set_coils(CL_Boost_MODE, [True])
+        device = await S21Client(self.server.host, self.server.port).poll()
+        self.assertTrue(device.is_timer)
+        self.assertTrue(device.is_schedule_mode)
+        self.assertEqual(device.fan_mode, 2)
+        self.assertEqual(device.fan_level_timer_mode, 1)
+        self.assertEqual(device.fan_level_schedule_mode, 0)
+
+    async def test_alarm_codes_are_read_only_for_active_alarms_or_warnings(self):
+        client = S21Client(self.server.host, self.server.port)
+        client.client.read_discrete_inputs = Mock(wraps=client.client.read_discrete_inputs)
+        bank = self.server.data_bank
+        bank.set_discrete_inputs(DI_ALARM_START, [True])
+        bank.set_discrete_inputs(DI_ALARM_START + DI_ALARM_COUNT - 1, [True])
+        for state, expected in ((0, []), (1, [0, 52]), (2, [0, 52]), (0, [])):
+            with self.subTest(state=state):
+                bank.set_input_registers(IR_ALARM, [state])
+                self.assertEqual((await client.poll()).alarm_codes, expected)
+        self.assertEqual(client.client.read_discrete_inputs.call_count, 2)
+        client.client.read_discrete_inputs.assert_called_with(19, count=53)
+
+    async def test_alarm_code_byte_padding_is_ignored(self):
+        self.server.data_bank.set_input_registers(IR_ALARM, [1])
+        client = S21Client(self.server.host, self.server.port)
+        client.client.read_discrete_inputs = AsyncMock(
+            return_value=SuccessResponse(bits=[False] * 53 + [True] * 3)
+        )
+        self.assertEqual((await client.poll()).alarm_codes, [])
+
+    async def test_alarm_read_errors_invalidate_availability(self):
+        for response in (None, ErrorResponse(), SuccessResponse(bits=[False] * 8)):
+            with self.subTest(response=response):
+                self.server.data_bank.set_input_registers(IR_ALARM, [0])
+                client = S21Client(self.server.host, self.server.port)
+                await client.poll()
+                self.server.data_bank.set_input_registers(IR_ALARM, [1])
+                client.client.read_discrete_inputs = AsyncMock(return_value=response)
+                with self.assertRaises(ModbusCommunicationException):
+                    await client.poll()
+                self.assertFalse(client.device.available)
+                self.assertFalse(client.client.connected)
+
+    async def test_operating_time_and_filter_countdown_zero_and_rollover(self):
+        bank = self.server.data_bank
+        client = S21Client(self.server.host, self.server.port)
+        device = await client.poll()
+        self.assertEqual(device.operating_time_minutes, 0)
+        self.assertEqual(device.filter_countdown_hours, 0)
+        self.assertEqual(device.filter_countdown_minutes, 0)
+        self.assertEqual(device.timer_countdown, "00:00:00")
+        for days, hours, minutes, expected in ((1, 23, 59, 2879), (2, 0, 0, 2880)):
+            bank.set_input_registers(IR_TotalWorkingTime_HOURS_MINUTES,
+                                     [(hours << 8) | minutes, days])
+            self.assertEqual((await client.poll()).operating_time_minutes, expected)
+
     async def test_extract_and_exhaust_temperatures_support_negative_and_zero(self):
         self.server.data_bank.set_input_registers(IR_CurTEMP_ExAirIn, [0xFFF6])
         self.server.data_bank.set_input_registers(IR_CurTEMP_ExAirOut, [0])
@@ -652,6 +762,8 @@ class TestClient(unittest.IsolatedAsyncioTestCase):
             self.assertEqual(device.current_temperature, 21.5)
             self.assertEqual(device.bypass_mode, BypassMode.AUTO)
             self.assertIsNone(device.bypass_position)
+            self.assertIsNone(device.supply_fan_speed_percent)
+            self.assertIsNone(device.extract_fan_speed_percent)
 
     async def test_no_bypass_skips_optional_position_read(self):
         client = S21Client(self.server.host, self.server.port)
@@ -663,7 +775,41 @@ class TestClient(unittest.IsolatedAsyncioTestCase):
         self.assertIsNone(device.bypass_position)
         self.assertIsNone(device.bypass_mode)
         self.assertIsNone(device.manual_bypass_position)
-        self.assertEqual(client.client.read_input_registers.call_count, 2)
+        self.assertEqual(client.client.read_input_registers.call_count, 3)
+        client.client.read_input_registers.assert_any_call(IR_CurSuFanSpeed, count=2)
+
+    async def test_fan_percentages_do_not_change_rpm_readings(self):
+        bank = self.server.data_bank
+        bank.set_input_registers(IR_SuRPM, [1700, 1800])
+        bank.set_input_registers(IR_CurSuFanSpeed, [0, 100])
+        device = await S21Client(self.server.host, self.server.port).poll()
+        self.assertEqual(device.supply_fan_speed, 1700)
+        self.assertEqual(device.extract_fan_speed, 1800)
+        self.assertEqual(device.supply_fan_speed_percent, 0)
+        self.assertEqual(device.extract_fan_speed_percent, 100)
+
+    async def test_fan_percentage_errors_are_not_hidden(self):
+        for response in (None, ExceptionResponse(4, 4),
+                         SuccessResponse(registers=[10]), TimeoutError("Timed out")):
+            with self.subTest(response=response):
+                client = S21Client(self.server.host, self.server.port)
+                await client.poll()
+                original_read = client.client.read_input_registers
+
+                async def read(address, *, count):
+                    if address == IR_CurSuFanSpeed:
+                        if isinstance(response, Exception):
+                            raise response
+                        return response
+                    return await original_read(address, count=count)
+
+                client.client.read_input_registers = AsyncMock(side_effect=read)
+                expected = (TimeoutError if isinstance(response, TimeoutError)
+                            else ModbusCommunicationException)
+                with self.assertRaises(expected):
+                    await client.poll()
+                self.assertFalse(client.device.available)
+                self.assertFalse(client.client.connected)
 
     async def test_optional_position_does_not_hide_communication_errors(self):
         self.server.data_bank.set_holding_registers(HR_BPS_ROTOR_TYPE, [2])