PyPlumIO 0.5.28__py3-none-any.whl → 0.5.30__py3-none-any.whl

{PyPlumIO-0.5.28.dist-info → PyPlumIO-0.5.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPlumIO
-Version: 0.5.28
+Version: 0.5.30
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -22,27 +22,27 @@ Classifier: Topic :: Home Automation
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dataslots ==1.2.0
-Requires-Dist: pyserial-asyncio ==0.6
-Requires-Dist: typing-extensions ==4.12.2
-Provides-Extra: dev
-Requires-Dist: pyplumio[docs,test] ; extra == 'dev'
-Requires-Dist: pre-commit ==3.8.0 ; extra == 'dev'
-Requires-Dist: tomli ==2.0.1 ; extra == 'dev'
-Provides-Extra: docs
-Requires-Dist: sphinx ==7.4.7 ; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme ==2.0.0 ; extra == 'docs'
-Requires-Dist: readthedocs-sphinx-search ==0.3.2 ; extra == 'docs'
+Requires-Dist: dataslots==1.2.0
+Requires-Dist: pyserial-asyncio==0.6
+Requires-Dist: typing-extensions==4.12.2
 Provides-Extra: test
-Requires-Dist: codespell ==2.3.0 ; extra == 'test'
-Requires-Dist: coverage ==7.6.1 ; extra == 'test'
-Requires-Dist: mypy ==1.11.2 ; extra == 'test'
-Requires-Dist: pyserial-asyncio-fast ==0.14 ; extra == 'test'
-Requires-Dist: pytest ==8.3.2 ; extra == 'test'
-Requires-Dist: pytest-asyncio ==0.24.0 ; extra == 'test'
-Requires-Dist: ruff ==0.6.3 ; extra == 'test'
-Requires-Dist: tox ==4.18.0 ; extra == 'test'
-Requires-Dist: types-pyserial ==3.5.0.20240826 ; extra == 'test'
+Requires-Dist: codespell==2.3.0; extra == "test"
+Requires-Dist: coverage==7.6.8; extra == "test"
+Requires-Dist: mypy==1.13.0; extra == "test"
+Requires-Dist: pyserial-asyncio-fast==0.14; extra == "test"
+Requires-Dist: pytest==8.3.4; extra == "test"
+Requires-Dist: pytest-asyncio==0.24.0; extra == "test"
+Requires-Dist: ruff==0.8.1; extra == "test"
+Requires-Dist: tox==4.23.2; extra == "test"
+Requires-Dist: types-pyserial==3.5.0.20240826; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx==8.1.3; extra == "docs"
+Requires-Dist: sphinx_rtd_theme==3.0.2; extra == "docs"
+Requires-Dist: readthedocs-sphinx-search==0.3.2; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: pyplumio[docs,test]; extra == "dev"
+Requires-Dist: pre-commit==4.0.1; extra == "dev"
+Requires-Dist: tomli==2.2.1; extra == "dev"
 
 # PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 [![PyPI version](https://badge.fury.io/py/PyPlumIO.svg)](https://badge.fury.io/py/PyPlumIO)

{PyPlumIO-0.5.28.dist-info → PyPlumIO-0.5.30.dist-info}/RECORD

@@ -1,29 +1,29 @@
 pyplumio/__init__.py,sha256=ditJTIOFGJDg60atHzOpiggdUrZHpSynno7MtpZUGVk,3299
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=CKxZe-gNrWXIa-w5PqPynJOQ9nZVzuvxxoFx7QtLKfw,413
+pyplumio/_version.py,sha256=PRcySwknPDLJzIxasFyVZNYI8LFj_28fjnJMHK2q0Ko,413
 pyplumio/connection.py,sha256=6mUbcjGxxEhMVIbzZgCqH-Ez-fcYoRj7ZbVSzpikpNA,5949
 pyplumio/const.py,sha256=LyXa5aVy2KxnZq7H7F8s5SYsAgEC2UzZYMMRauliB2E,5502
 pyplumio/exceptions.py,sha256=Wn-y5AJ5xfaBlHhTUVKB27_0Us8_OVHqh-sicnr9sYA,700
-pyplumio/filters.py,sha256=r2DZHwHG0cPWzTcsIX1pjAH19BR3iCOQsaqJ3T106t4,11188
+pyplumio/filters.py,sha256=KK_AV_EHy5gj9s9BNZbn9i0RnT3uZsdEg6gdve1WYrY,11152
 pyplumio/protocol.py,sha256=VRxrj8vZ1FMawqblKkyxg_V61TBSvVynd9u0JXYnMUU,8090
 pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyplumio/stream.py,sha256=IVCQFKBtRafRgUkr93p_wN5mXZAD3Jw1d091dfEIK20,4479
+pyplumio/stream.py,sha256=mtMpnUR3TfEmL5JUGXr6GnpPGBwzCokqIKDWp4vYiVg,4654
 pyplumio/utils.py,sha256=TnBzRopinyp92wruguijxcIYmaeyNVTFX0dygI5FCMU,823
-pyplumio/devices/__init__.py,sha256=uKziGOX_pcd-MEt7eqdwyZidLk7-9Uu07_U49Hlel78,6532
-pyplumio/devices/ecomax.py,sha256=oLl6aYbgC6MtsxCiW0eLSevpXVjVOYar--fn0Qzaz9w,16878
+pyplumio/devices/__init__.py,sha256=YN09bGsyJ5WVmF8_-veUckqUl57eBwmfNr8M5qhyqy0,8149
+pyplumio/devices/ecomax.py,sha256=ybFLJN7O3unBcyzuVmYTssBv86bPiiTGvFpFJezwUE4,15478
 pyplumio/devices/ecoster.py,sha256=jNWli7ye9T6yfkcFJZhhUHH7KOv-L6AgYFp_dKyv3OM,263
-pyplumio/devices/mixer.py,sha256=VE9Kjpq-sTLGgR8F-qnQjOuN8BrD4edrvu1L2X6m4uM,3199
-pyplumio/devices/thermostat.py,sha256=1vOUWppTzY7iN6zDhNUFlb5rrqOCs4_cegn25h_bags,2609
-pyplumio/frames/__init__.py,sha256=QqghzVt0r1STmeDlYs_hriHfzZj96-hzRQsxlFdv6Ls,7497
+pyplumio/devices/mixer.py,sha256=CnHWrJELtFgs2YTHGpQwKr2UTRdetX76OvLBA2PH-fs,3207
+pyplumio/devices/thermostat.py,sha256=-CZNRyywoDU6csFu85KSmQ5woVXY0x6peXkeOsi_fqg,2617
+pyplumio/frames/__init__.py,sha256=30ECFT_5IneUrpOJGxjHyeuX-i4S1ikX8Pg1HO8Yxkg,7686
 pyplumio/frames/messages.py,sha256=iDwZOPdVOZaIcEHYnkwtCazH_N6BjyEDtiJBjTRaePY,3570
 pyplumio/frames/requests.py,sha256=nbSuOLue2rI4WgtXslqTGfFnWBlwzLE6I9wraKC1uqg,6854
 pyplumio/frames/responses.py,sha256=Ch1AVBmD6Ek7BazoEMDDEa6ad_fUdUXf4bNssQOu0sI,6228
 pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,31
-pyplumio/helpers/data_types.py,sha256=fNQmZ-fifqNl01jDXoF0BjmBJoDKVr4spZNHBuiUVEY,9059
+pyplumio/helpers/data_types.py,sha256=nB3afOLmppgSCWkZoX1-1yWPNMMNSem77x7XQ1Mi8H8,9103
 pyplumio/helpers/event_manager.py,sha256=xQOfiP_nP1Pz5zhB6HU5gXyyJXjhisYshL8_HRxDgt8,6412
 pyplumio/helpers/factory.py,sha256=6ArzJDq3MiiMaRpMEP0kC6wJWsoqOqe32V1RCxg1478,1005
-pyplumio/helpers/parameter.py,sha256=iCtKkYXJI0Zj4ifU3HCwoq_qqSE03giblSP1rqsWzcY,11463
-pyplumio/helpers/schedule.py,sha256=l-dQwy8TUjlPqiMFcQaMCTxzgtAvQpyuutRIdfI06zo,5302
+pyplumio/helpers/parameter.py,sha256=yO3KSX8FtU-dMe5FzNW-RXs5yW-lYu2F5Po-4ghcSnM,12533
+pyplumio/helpers/schedule.py,sha256=PnVEkgthg6tHpHvZK9fXJz9VKNDyQ_7BFT4TTVEwNhI,5310
 pyplumio/helpers/task_manager.py,sha256=HAd69yGTRL0zQsu-ywnbLu1UXiJzgHWuhYWA--vs4lQ,1181
 pyplumio/helpers/timeout.py,sha256=JAhWNtIpcXyVILIwHWVy5mYofqbbRDGKLdTUKkQuajs,772
 pyplumio/helpers/uid.py,sha256=J7gN8i8LE0g6tfL66BJbwsQQqzBBxWx7giyvqaJh4BM,976
@@ -31,13 +31,13 @@ pyplumio/structures/__init__.py,sha256=EjK-5qJZ0F7lpP2b6epvTMg9cIBl4Kn91nqNkEcLw
 pyplumio/structures/alerts.py,sha256=8ievMl5_tUBlnTLCiZoIloucIngCcoAYy6uI9sSXrt0,3664
 pyplumio/structures/boiler_load.py,sha256=p3mOzZUU-g7A2tG_yp8podEqpI81hlsOZmHELyPNRY8,838
 pyplumio/structures/boiler_power.py,sha256=72qsvccg49FdRdXv2f2K5sGpjT7wAOLFjlIGWpO-DVg,901
-pyplumio/structures/ecomax_parameters.py,sha256=tV97N6uQ1VQmY88Rdtm_BhX2kR7tDGDOfGYFCpynX0A,27880
+pyplumio/structures/ecomax_parameters.py,sha256=ki9YSzVRhCD_rYHFogJoyk0NwyNlWdZrHcp-rrCuKCU,28440
 pyplumio/structures/fan_power.py,sha256=Q5fv-7_2NVuLeQPIVIylvgN7M8-a9D8rRUE0QGjyS3w,871
 pyplumio/structures/frame_versions.py,sha256=hbcVuhuPNy5qd39Vk7w4WdPCW-TNx1cAYWzA2mXocyk,1548
 pyplumio/structures/fuel_consumption.py,sha256=_p2dI4H67Eopn7IF0Gj77A8c_8lNKhhDDAtmugxLd4s,976
 pyplumio/structures/fuel_level.py,sha256=mJpp1dnRD1wXi_6EyNX7TNXosjcr905rSHOnuZ5VD74,1069
 pyplumio/structures/lambda_sensor.py,sha256=JNSCiBJoM8Uk3OGbmFIigaLOntQST5U_UrmCpaQBlM0,1595
-pyplumio/structures/mixer_parameters.py,sha256=4PR_BgNVpeBzR3Q29GtpF9uJnHxPZ4jgyfhyysPmAUA,8919
+pyplumio/structures/mixer_parameters.py,sha256=S_YOigzM9TsdEjk5EluME5fJ8owO84-xOFT9tTdBgEo,9553
 pyplumio/structures/mixer_sensors.py,sha256=-cN7U-Fr2fmAQ5McQL7bZUC8CFlb1y8TN0f_dqy3UK0,2312
 pyplumio/structures/modules.py,sha256=oXUIqrOAV1dZzBV5zUH3HDUSFvNOjpUSx0TF9nZVnbs,2569
 pyplumio/structures/network_info.py,sha256=kPxmIaDGm5SyLRKVFzcrODlUtB0u5JjiZqekoKSyDpA,4159
@@ -46,15 +46,15 @@ pyplumio/structures/outputs.py,sha256=1xsJPkjN643-aFawqVoupGatUIUJfQG_g252n051Qi
 pyplumio/structures/pending_alerts.py,sha256=Uq9WpB4MW9AhDkqmDhk-g0J0h4pVq0Q50z12dYEv6kY,739
 pyplumio/structures/product_info.py,sha256=uiEN6DFQlzmBvQByTirFzXQShoex0YGdFS9WI-MAxPc,2405
 pyplumio/structures/program_version.py,sha256=R-medELYHDlk_ALsw5HOVbZRb7JD3yBUsGwqwVCjrkU,2550
-pyplumio/structures/regulator_data.py,sha256=wqtRWPiwC4H_98nu9g1Po5wCqqoqUMuPBE0w93vIcuI,2271
+pyplumio/structures/regulator_data.py,sha256=z2mSE-cxImn8YRr_yZCcDlIbXnKdETkN7GigV5vEJqA,2265
 pyplumio/structures/regulator_data_schema.py,sha256=XM6M9ep3NyogbLPqp88mMTg8Sa9e5SFzV5I5pSYw5GY,1487
-pyplumio/structures/schedules.py,sha256=YzlfgprZq4pDfl-NBHl-EblhxatmDYr0UOkkHBW0Jok,6707
+pyplumio/structures/schedules.py,sha256=rKPWC5qcKAh6xxs91oY23NqQcWby8e3gXrD6qJAVDGo,7153
 pyplumio/structures/statuses.py,sha256=wkoynyMRr1VREwfBC6vU48kPA8ZQ83pcXuciy2xHJrk,1166
 pyplumio/structures/temperatures.py,sha256=1CDzehNmbALz1Jyt_9gZNIk52q6Wv-xQXjijVDCVYec,2337
-pyplumio/structures/thermostat_parameters.py,sha256=EzJVZZhZ19beshRG7X6lw9VWDdq4mQoMFSOhWuW7_0U,8064
+pyplumio/structures/thermostat_parameters.py,sha256=6r8_EU9T1IJ0vzZMduiLzsAaaWr6cKW_zHHAGsfGZI4,8804
 pyplumio/structures/thermostat_sensors.py,sha256=8e1TxYIJTQKT0kIGO9gG4hGdLOBUpIhiPToQyOMyeNE,3237
-PyPlumIO-0.5.28.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-PyPlumIO-0.5.28.dist-info/METADATA,sha256=eFyYRpMwxZF6tmMLwiG2_5HZeacgq7ndFuzBSK8luAE,5490
-PyPlumIO-0.5.28.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-PyPlumIO-0.5.28.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-PyPlumIO-0.5.28.dist-info/RECORD,,
+PyPlumIO-0.5.30.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+PyPlumIO-0.5.30.dist-info/METADATA,sha256=KMMtx2B4gTlnFBoLVzVHGs75Od9qf6BN1tH3pqeYgqM,5458
+PyPlumIO-0.5.30.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+PyPlumIO-0.5.30.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+PyPlumIO-0.5.30.dist-info/RECORD,,

{PyPlumIO-0.5.28.dist-info → PyPlumIO-0.5.30.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.2)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyplumio/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.28'
-__version_tuple__ = version_tuple = (0, 5, 28)
+__version__ = version = '0.5.30'
+__version_tuple__ = version_tuple = (0, 5, 30)

pyplumio/devices/__init__.py

@@ -5,17 +5,21 @@ from __future__ import annotations
 from abc import ABC
 import asyncio
 from functools import cache
+import logging
 from typing import Any, ClassVar
 
 from pyplumio.const import ATTR_FRAME_ERRORS, ATTR_LOADED, DeviceType, FrameType
 from pyplumio.exceptions import UnknownDeviceError
-from pyplumio.frames import DataFrameDescription, Frame, Request
+from pyplumio.frames import DataFrameDescription, Frame, Request, is_known_frame_type
 from pyplumio.helpers.event_manager import EventManager
 from pyplumio.helpers.factory import create_instance
 from pyplumio.helpers.parameter import Parameter, ParameterValue
+from pyplumio.structures.frame_versions import ATTR_FRAME_VERSIONS
 from pyplumio.structures.network_info import NetworkInfo
 from pyplumio.utils import to_camelcase
 
+_LOGGER = logging.getLogger(__name__)
+
 
 @cache
 def is_known_device_type(device_type: int) -> bool:
@@ -45,7 +49,7 @@ class Device(ABC, EventManager):
 
     queue: asyncio.Queue[Frame]
 
-    def __init__(self, queue: asyncio.Queue[Frame]):
+    def __init__(self, queue: asyncio.Queue[Frame]) -> None:
         """Initialize a new device."""
         super().__init__()
         self.queue = queue
@@ -125,15 +129,48 @@ class PhysicalDevice(Device, ABC):
     address: ClassVar[int]
     _network: NetworkInfo
     _setup_frames: tuple[DataFrameDescription, ...]
+    _frame_versions: dict[int, int]
 
-    def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo):
+    def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo) -> None:
         """Initialize a new physical device."""
         super().__init__(queue)
         self._network = network
+        self._frame_versions = {}
+
+        async def update_frame_versions(versions: dict[int, int]) -> None:
+            """Check frame versions and update outdated frames."""
+            for frame_type, version in versions.items():
+                if (
+                    is_known_frame_type(frame_type)
+                    and self.supports_frame_type(frame_type)
+                    and not self.has_frame_version(frame_type, version)
+                ):
+                    _LOGGER.debug(
+                        "Updating frame %s to version %i", repr(frame_type), version
+                    )
+                    request = await Request.create(frame_type, recipient=self.address)
+                    self.queue.put_nowait(request)
+                    self._frame_versions[frame_type] = version
+
+        self.subscribe(ATTR_FRAME_VERSIONS, update_frame_versions)
+
+    def has_frame_version(self, frame_type: int, version: int | None = None) -> bool:
+        """Return True if frame data is up to date, False otherwise."""
+        if frame_type not in self._frame_versions:
+            return False
+
+        if version is None or self._frame_versions[frame_type] == version:
+            return True
+
+        return False
+
+    def supports_frame_type(self, frame_type: int) -> bool:
+        """Check if frame type is supported by the device."""
+        return frame_type not in self.data.get(ATTR_FRAME_ERRORS, [])
 
     def handle_frame(self, frame: Frame) -> None:
         """Handle frame received from the device."""
-        frame.sender_device = self
+        frame.assign_to(self)
         if frame.data is not None:
             for name, value in frame.data.items():
                 self.dispatch_nowait(name, value)
@@ -188,7 +225,7 @@ class VirtualDevice(Device, ABC):
 
     def __init__(
         self, queue: asyncio.Queue[Frame], parent: PhysicalDevice, index: int = 0
-    ):
+    ) -> None:
         """Initialize a new sub-device."""
         super().__init__(queue)
         self.parent = parent

pyplumio/devices/ecomax.py

@@ -9,7 +9,6 @@ import time
 from typing import Any, Final
 
 from pyplumio.const import (
-    ATTR_FRAME_ERRORS,
     ATTR_PASSWORD,
     ATTR_SENSORS,
     ATTR_STATE,
@@ -21,7 +20,7 @@ from pyplumio.devices import PhysicalDevice
 from pyplumio.devices.mixer import Mixer
 from pyplumio.devices.thermostat import Thermostat
 from pyplumio.filters import on_change
-from pyplumio.frames import DataFrameDescription, Frame, Request, is_known_frame_type
+from pyplumio.frames import DataFrameDescription, Frame, Request
 from pyplumio.helpers.parameter import ParameterValues
 from pyplumio.helpers.schedule import Schedule, ScheduleDay
 from pyplumio.structures.alerts import ATTR_TOTAL_ALERTS
@@ -35,7 +34,6 @@ from pyplumio.structures.ecomax_parameters import (
     EcomaxSwitch,
     EcomaxSwitchDescription,
 )
-from pyplumio.structures.frame_versions import ATTR_FRAME_VERSIONS
 from pyplumio.structures.fuel_consumption import ATTR_FUEL_CONSUMPTION
 from pyplumio.structures.mixer_parameters import ATTR_MIXER_PARAMETERS
 from pyplumio.structures.mixer_sensors import ATTR_MIXER_SENSORS
@@ -106,17 +104,14 @@ class EcoMAX(PhysicalDevice):
 
     address = DeviceType.ECOMAX
 
-    _frame_versions: dict[int, int]
     _fuel_burned_timestamp_ns: int
     _setup_frames = SETUP_FRAME_TYPES
 
-    def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo):
+    def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo) -> None:
         """Initialize a new ecoMAX controller."""
         super().__init__(queue, network)
-        self._frame_versions = {}
         self._fuel_burned_timestamp_ns = time.perf_counter_ns()
         self.subscribe(ATTR_ECOMAX_PARAMETERS, self._handle_ecomax_parameters)
-        self.subscribe(ATTR_FRAME_VERSIONS, self._update_frame_versions)
         self.subscribe(ATTR_FUEL_CONSUMPTION, self._add_burned_fuel_counter)
         self.subscribe(ATTR_MIXER_PARAMETERS, self._handle_mixer_parameters)
         self.subscribe(ATTR_MIXER_SENSORS, self._handle_mixer_sensors)
@@ -142,17 +137,6 @@ class EcoMAX(PhysicalDevice):
 
         super().handle_frame(frame)
 
-    def _has_frame_version(self, frame_type: FrameType | int, version: int) -> bool:
-        """Check if ecoMAX controller has this version of the frame."""
-        return (
-            frame_type in self._frame_versions
-            and self._frame_versions[frame_type] == version
-        )
-
-    def _frame_is_supported(self, frame_type: FrameType | int) -> bool:
-        """Check if frame is supported by the device."""
-        return frame_type not in self.data.get(ATTR_FRAME_ERRORS, [])
-
     def _mixers(self, indexes: Iterable[int]) -> Generator[Mixer, None, None]:
         """Iterate through the mixer indexes.
 
@@ -224,19 +208,6 @@ class EcoMAX(PhysicalDevice):
         await asyncio.gather(*_ecomax_parameter_events())
         return True
 
-    async def _update_frame_versions(self, versions: dict[int, int]) -> None:
-        """Check frame versions and update outdated frames."""
-        for frame_type, version in versions.items():
-            if (
-                is_known_frame_type(frame_type)
-                and self._frame_is_supported(frame_type)
-                and not self._has_frame_version(frame_type, version)
-            ):
-                # We don't have this frame or it's version has changed.
-                request = await Request.create(frame_type, recipient=self.address)
-                self.queue.put_nowait(request)
-                self._frame_versions[frame_type] = version
-
     async def _add_burned_fuel_counter(self, fuel_consumption: float) -> None:
         """Calculate fuel burned since last sensor's data message."""
         current_timestamp_ns = time.perf_counter_ns()

pyplumio/devices/mixer.py

@@ -30,7 +30,7 @@ class Mixer(VirtualDevice):
 
     def __init__(
         self, queue: asyncio.Queue[Frame], parent: PhysicalDevice, index: int = 0
-    ):
+    ) -> None:
         """Initialize a new mixer."""
         super().__init__(queue, parent, index)
         self.subscribe(ATTR_MIXER_SENSORS, self._handle_mixer_sensors)

pyplumio/devices/thermostat.py

@@ -26,7 +26,7 @@ class Thermostat(VirtualDevice):
 
     def __init__(
         self, queue: asyncio.Queue[Frame], parent: PhysicalDevice, index: int = 0
-    ):
+    ) -> None:
         """Initialize a new thermostat."""
         super().__init__(queue, parent, index)
         self.subscribe(ATTR_THERMOSTAT_SENSORS, self._handle_thermostat_sensors)

pyplumio/filters.py

@@ -66,13 +66,12 @@ def _significantly_changed(
 def _significantly_changed(old: Comparable, new: Comparable) -> bool:
     """Check if value is significantly changed."""
     if isinstance(old, Parameter) and isinstance(new, Parameter):
-        result = new.pending_update or old.values != new.values
-    elif isinstance(old, SupportsFloat) and isinstance(new, SupportsFloat):
-        result = not math.isclose(old, new, abs_tol=TOLERANCE)
-    else:
-        result = old != new
+        return new.pending_update or old.values.__ne__(new.values)
 
-    return result
+    if isinstance(old, SupportsFloat) and isinstance(new, SupportsFloat):
+        return not math.isclose(old, new, abs_tol=TOLERANCE)
+
+    return old.__ne__(new)
 
 
 @overload
@@ -91,10 +90,11 @@ def _diffence_between(
     """Return a difference between values."""
     if isinstance(old, list) and isinstance(new, list):
         return [x for x in new if x not in old]
-    elif isinstance(old, SupportsSubtraction) and isinstance(new, SupportsSubtraction):
-        return new - old
-    else:
-        return None
+
+    if isinstance(old, SupportsSubtraction) and isinstance(new, SupportsSubtraction):
+        return new.__sub__(old)
+
+    return None
 
 
 class Filter(ABC):

pyplumio/frames/__init__.py

@@ -24,6 +24,7 @@ ECONET_VERSION: Final = 5
 
 # Frame header structure.
 struct_header = struct.Struct("<BH4B")
+HEADER_SIZE = struct_header.size
 
 if TYPE_CHECKING:
     from pyplumio.devices import PhysicalDevice
@@ -73,22 +74,20 @@ class Frame(ABC):
 
     __slots__ = (
         "recipient",
-        "recipient_device",
         "sender",
-        "sender_device",
         "econet_type",
         "econet_version",
+        "_handler",
         "_message",
         "_data",
     )
 
     recipient: DeviceType
-    recipient_device: PhysicalDevice | None
     sender: DeviceType
-    sender_device: PhysicalDevice | None
     econet_type: int
     econet_version: int
     frame_type: ClassVar[FrameType]
+    _handler: PhysicalDevice | None
     _message: bytearray | None
     _data: dict[str, Any] | None
 
@@ -104,11 +103,10 @@ class Frame(ABC):
     ) -> None:
         """Process a frame data and message."""
         self.recipient = recipient
-        self.recipient_device = None
         self.sender = sender
-        self.sender_device = None
         self.econet_type = econet_type
         self.econet_version = econet_version
+        self._handler = None
         self._data = data if not kwargs else ensure_dict(data, kwargs)
         self._message = message
 
@@ -153,6 +151,15 @@ class Frame(ABC):
         """Return a frame message represented as hex string."""
         return self.bytes.hex(*args, **kwargs)
 
+    def assign_to(self, device: PhysicalDevice) -> None:
+        """Assign device to the frame."""
+        self._handler = device
+
+    @property
+    def handler(self) -> PhysicalDevice | None:
+        """Return the device associated to the frame."""
+        return self._handler
+
     @property
     def data(self) -> dict[str, Any]:
         """Return the frame data."""

pyplumio/helpers/data_types.py

@@ -19,7 +19,7 @@ class DataType(ABC, Generic[T]):
     _value: T
     _size: int
 
-    def __init__(self, value: T | None = None):
+    def __init__(self, value: T | None = None) -> None:
         """Initialize a new data type."""
         if value is not None:
             self._value = value
@@ -112,7 +112,7 @@ class BitArray(DataType[int]):
 
     _index: int
 
-    def __init__(self, value: bool | None = None, index: int = 0):
+    def __init__(self, value: bool | None = None, index: int = 0) -> None:
         """Initialize a new bit array."""
         super().__init__(value)
         self._index = index
@@ -199,7 +199,7 @@ class String(DataType[str]):
 
     __slots__ = ()
 
-    def __init__(self, value: str = ""):
+    def __init__(self, value: str = "") -> None:
         """Initialize a new null-terminated string data type."""
         super().__init__(value)
         self._size = len(self.value) + 1
@@ -219,7 +219,7 @@ class VarBytes(DataType[bytes]):
 
     __slots__ = ()
 
-    def __init__(self, value: bytes = b""):
+    def __init__(self, value: bytes = b"") -> None:
         """Initialize a new variable-length bytes data type."""
         super().__init__(value)
         self._size = len(value) + 1
@@ -239,7 +239,7 @@ class VarString(DataType[str]):
 
     __slots__ = ()
 
-    def __init__(self, value: str = ""):
+    def __init__(self, value: str = "") -> None:
         """Initialize a new variable length bytes data type."""
         super().__init__(value)
         self._size = len(value) + 1
@@ -326,7 +326,7 @@ class UnsignedInt(BuiltInDataType[int]):
     _struct = struct.Struct("<I")
 
 
-class Float(BuiltInDataType[int]):
+class Float(BuiltInDataType[float]):
     """Represents a float."""
 
     __slots__ = ()
@@ -334,7 +334,7 @@ class Float(BuiltInDataType[int]):
     _struct = struct.Struct("<f")
 
 
-class Double(BuiltInDataType[int]):
+class Double(BuiltInDataType[float]):
     """Represents a double."""
 
     __slots__ = ()

pyplumio/helpers/parameter.py

@@ -77,11 +77,19 @@ class ParameterDescription:
 class Parameter(ABC):
     """Represents a base parameter."""
 
-    __slots__ = ("device", "description", "_pending_update", "_index", "_values")
+    __slots__ = (
+        "device",
+        "description",
+        "_pending_update",
+        "_previous_value",
+        "_index",
+        "_values",
+    )
 
     device: Device
     description: ParameterDescription
     _pending_update: bool
+    _previous_value: int
     _index: int
     _values: ParameterValues
 
@@ -96,6 +104,7 @@ class Parameter(ABC):
         self.device = device
         self.description = description
         self._pending_update = False
+        self._previous_value = 0
         self._index = index
         self._values = values if values else ParameterValues(0, 0, 0)
 
@@ -185,6 +194,7 @@ class Parameter(ABC):
                 f"Value must be between '{self.min_value}' and '{self.max_value}'"
             )
 
+        self._previous_value = self._values.value
         self._values.value = value
         self._pending_update = True
         while self.pending_update:
@@ -196,6 +206,9 @@ class Parameter(ABC):
                 return False
 
             await self.device.queue.put(await self.create_request())
+            if not self.is_tracking_changes:
+                await self.force_refresh()
+
             await asyncio.sleep(timeout)
             retries -= 1
 
@@ -203,8 +216,19 @@ class Parameter(ABC):
 
     def update(self, values: ParameterValues) -> None:
         """Update the parameter values."""
+        if self.pending_update and self._previous_value != values.value:
+            self._pending_update = False
+
         self._values = values
-        self._pending_update = False
+
+    async def force_refresh(self) -> None:
+        """Refresh the parameter from remote."""
+        await self.device.queue.put(await self.create_refresh_request())
+
+    @property
+    def is_tracking_changes(self) -> bool:
+        """Return True if remote's tracking changes, False otherwise."""
+        return False
 
     @property
     def pending_update(self) -> bool:
@@ -254,6 +278,10 @@ class Parameter(ABC):
     async def create_request(self) -> Request:
         """Create a request to change the parameter."""
 
+    @abstractmethod
+    async def create_refresh_request(self) -> Request:
+        """Create a request to refresh the parameter."""
+
 
 @dataslots
 @dataclass
@@ -286,6 +314,10 @@ class Number(Parameter):
         """Create a request to change the number."""
         return Request()
 
+    async def create_refresh_request(self) -> Request:
+        """Create a request to refresh the number."""
+        return Request()
+
     @property
     def value(self) -> int | float:
         """Return the value."""
@@ -362,6 +394,10 @@ class Switch(Parameter):
         """Create a request to change the switch."""
         return Request()
 
+    async def create_refresh_request(self) -> Request:
+        """Create a request to refresh the switch."""
+        return Request()
+
     @property
     def value(self) -> Literal["off", "on"]:
         """Return the value."""

pyplumio/helpers/schedule.py

@@ -70,7 +70,7 @@ class ScheduleDay(MutableMapping):
 
     _intervals: list[bool]
 
-    def __init__(self, intervals: list[bool]):
+    def __init__(self, intervals: list[bool]) -> None:
         """Initialize a new schedule day."""
         self._intervals = intervals
 

pyplumio/stream.py

@@ -10,7 +10,14 @@ from typing import Final, NamedTuple
 from pyplumio.const import DeviceType
 from pyplumio.devices import is_known_device_type
 from pyplumio.exceptions import ChecksumError, ReadError, UnknownDeviceError
-from pyplumio.frames import FRAME_START, Frame, bcc, struct_header
+from pyplumio.frames import (
+    DELIMITER_SIZE,
+    FRAME_START,
+    HEADER_SIZE,
+    Frame,
+    bcc,
+    struct_header,
+)
 from pyplumio.helpers.timeout import timeout
 
 READER_TIMEOUT: Final = 10
@@ -29,7 +36,7 @@ class FrameWriter:
 
     _writer: StreamWriter
 
-    def __init__(self, writer: StreamWriter):
+    def __init__(self, writer: StreamWriter) -> None:
         """Initialize a new frame writer."""
         self._writer = writer
 
@@ -46,7 +53,7 @@ class FrameWriter:
             self._writer.close()
             await self.wait_closed()
         except (OSError, asyncio.TimeoutError):
-            _LOGGER.exception("Unexpected error while closing the writer")
+            _LOGGER.exception("Unexpected error, while closing the writer")
 
     @timeout(WRITER_TIMEOUT)
     async def wait_closed(self) -> None:
@@ -57,8 +64,6 @@ class FrameWriter:
 class Header(NamedTuple):
     """Represents a frame header."""
 
-    bytes: bytes
-    frame_start: int
     frame_length: int
     recipient: int
     sender: int
@@ -73,25 +78,28 @@ class FrameReader:
 
     _reader: StreamReader
 
-    def __init__(self, reader: StreamReader):
+    def __init__(self, reader: StreamReader) -> None:
         """Initialize a new frame reader."""
         self._reader = reader
 
-    async def _read_header(self) -> Header:
+    async def _read_header(self) -> tuple[Header, bytes]:
         """Locate and read a frame header.
 
         Raise pyplumio.ReadError if header size is too small and
         OSError if serial connection is broken.
         """
-        while buffer := await self._reader.read(1):
+        while buffer := await self._reader.read(DELIMITER_SIZE):
             if FRAME_START not in buffer:
                 continue
 
-            buffer += await self._reader.read(struct_header.size - 1)
-            if len(buffer) < struct_header.size:
-                raise ReadError(f"Header can't be less than {struct_header.size} bytes")
+            try:
+                buffer += await self._reader.readexactly(HEADER_SIZE - DELIMITER_SIZE)
+            except IncompleteReadError as e:
+                raise ReadError(
+                    f"Got incomplete header, while trying to read {e.expected} bytes"
+                ) from e
 
-            return Header(buffer, *struct_header.unpack_from(buffer))
+            return Header(*struct_header.unpack_from(buffer)[DELIMITER_SIZE:]), buffer
 
         raise OSError("Serial connection broken")
 
@@ -99,21 +107,16 @@ class FrameReader:
     async def read(self) -> Frame | None:
         """Read the frame and return corresponding handler object.
 
-        Raise pyplumio.ReadError on unexpected frame length or
-        incomplete frame and pyplumio. Raise ChecksumError on incorrect
-        frame checksum.
+        Raise pyplumio.UnknownDeviceError when sender device has an
+        unknown address, raise pyplumio.ReadError on unexpected frame
+        length or incomplete frame, raise pyplumio.ChecksumError on
+        incorrect frame checksum.
         """
-        (
-            header_bytes,
-            _,
-            frame_length,
-            recipient,
-            sender,
-            econet_type,
-            econet_version,
-        ) = await self._read_header()
+        header, buffer = await self._read_header()
+        frame_length, recipient, sender, econet_type, econet_version = header
 
         if recipient not in (DeviceType.ECONET, DeviceType.ALL):
+            # Not an intended recipient, ignore the frame.
             return None
 
         if not is_known_device_type(sender):
@@ -123,25 +126,24 @@ class FrameReader:
             raise ReadError(f"Unexpected frame length ({frame_length})")
 
         try:
-            payload = await self._reader.readexactly(frame_length - struct_header.size)
+            buffer += await self._reader.readexactly(frame_length - HEADER_SIZE)
         except IncompleteReadError as e:
             raise ReadError(
-                "Got an incomplete frame while trying to read "
-                + f"'{frame_length - struct_header.size}' bytes"
+                f"Got incomplete frame, while trying to read {e.expected} bytes"
             ) from e
 
-        if (checksum := bcc(header_bytes + payload[:-2])) and checksum != payload[-2]:
+        if (checksum := bcc(buffer[:-2])) and checksum != buffer[-2]:
             raise ChecksumError(
-                f"Incorrect frame checksum ({checksum} != {payload[-2]})"
+                f"Incorrect frame checksum ({checksum} != {buffer[-2]})"
             )
 
         frame = await Frame.create(
-            frame_type=payload[0],
+            frame_type=buffer[HEADER_SIZE],
             recipient=DeviceType(recipient),
             sender=DeviceType(sender),
             econet_type=econet_type,
             econet_version=econet_version,
-            message=payload[1:-2],
+            message=buffer[HEADER_SIZE + 1 : -2],
         )
         _LOGGER.debug("Received frame: %s", frame)
 

pyplumio/structures/ecomax_parameters.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from collections.abc import Generator
 from dataclasses import dataclass
 from functools import partial
-from typing import Any, Final
+from typing import TYPE_CHECKING, Any, Final
 
 from dataslots import dataslots
 
@@ -19,7 +19,6 @@ from pyplumio.const import (
     ProductType,
     UnitOfMeasurement,
 )
-from pyplumio.devices import PhysicalDevice
 from pyplumio.frames import Request
 from pyplumio.helpers.parameter import (
     Number,
@@ -35,6 +34,9 @@ from pyplumio.structures import StructureDecoder
 from pyplumio.structures.thermostat_parameters import ATTR_THERMOSTAT_PROFILE
 from pyplumio.utils import ensure_dict
 
+if TYPE_CHECKING:
+    from pyplumio.devices.ecomax import EcoMAX
+
 ATTR_ECOMAX_CONTROL: Final = "ecomax_control"
 ATTR_ECOMAX_PARAMETERS: Final = "ecomax_parameters"
 
@@ -53,19 +55,20 @@ class EcomaxParameter(Parameter):
 
     __slots__ = ()
 
-    device: PhysicalDevice
+    device: EcoMAX
     description: EcomaxParameterDescription
 
     async def create_request(self) -> Request:
         """Create a request to change the parameter."""
         handler = partial(Request.create, recipient=self.device.address)
         if self.description.name == ATTR_ECOMAX_CONTROL:
-            request = await handler(
+            return await handler(
                 frame_type=FrameType.REQUEST_ECOMAX_CONTROL,
                 data={ATTR_VALUE: self.values.value},
             )
-        elif self.description.name == ATTR_THERMOSTAT_PROFILE:
-            request = await handler(
+
+        if self.description.name == ATTR_THERMOSTAT_PROFILE:
+            return await handler(
                 frame_type=FrameType.REQUEST_SET_THERMOSTAT_PARAMETER,
                 data={
                     ATTR_INDEX: self._index,
@@ -74,13 +77,22 @@ class EcomaxParameter(Parameter):
                     ATTR_SIZE: 1,
                 },
             )
-        else:
-            request = await handler(
-                frame_type=FrameType.REQUEST_SET_ECOMAX_PARAMETER,
-                data={ATTR_INDEX: self._index, ATTR_VALUE: self.values.value},
-            )
 
-        return request
+        return await handler(
+            frame_type=FrameType.REQUEST_SET_ECOMAX_PARAMETER,
+            data={ATTR_INDEX: self._index, ATTR_VALUE: self.values.value},
+        )
+
+    async def create_refresh_request(self) -> Request:
+        """Create a request to refresh the parameter."""
+        return await Request.create(
+            FrameType.REQUEST_ECOMAX_PARAMETERS, recipient=self.device.address
+        )
+
+    @property
+    def is_tracking_changes(self) -> bool:
+        """Return True if remote's tracking changes, False otherwise."""
+        return self.device.has_frame_version(FrameType.REQUEST_ECOMAX_PARAMETERS)
 
 
 @dataslots
@@ -90,6 +102,7 @@ class EcomaxNumberDescription(EcomaxParameterDescription, NumberDescription):
 
     multiplier: float = 1.0
     offset: int = 0
+    precision: int = 6
 
 
 class EcomaxNumber(EcomaxParameter, Number):
@@ -103,29 +116,27 @@ class EcomaxNumber(EcomaxParameter, Number):
         self, value: float | int, retries: int = 5, timeout: float = 5.0
     ) -> bool:
         """Set a parameter value."""
-        value = (value + self.description.offset) / self.description.multiplier
+        value += self.description.offset
+        value = round(value / self.description.multiplier, self.description.precision)
         return await super().set(value, retries, timeout)
 
     @property
     def value(self) -> float:
         """Return the value."""
-        return (
-            self.values.value - self.description.offset
-        ) * self.description.multiplier
+        value = self.values.value - self.description.offset
+        return round(value * self.description.multiplier, self.description.precision)
 
     @property
     def min_value(self) -> float:
         """Return the minimum allowed value."""
-        return (
-            self.values.min_value - self.description.offset
-        ) * self.description.multiplier
+        value = self.values.min_value - self.description.offset
+        return round(value * self.description.multiplier, self.description.precision)
 
     @property
     def max_value(self) -> float:
         """Return the maximum allowed value."""
-        return (
-            self.values.max_value - self.description.offset
-        ) * self.description.multiplier
+        value = self.values.max_value - self.description.offset
+        return round(value * self.description.multiplier, self.description.precision)
 
 
 @dataslots
@@ -292,11 +303,11 @@ ECOMAX_PARAMETERS: dict[ProductType, tuple[EcomaxParameterDescription, ...]] = {
             unit_of_measurement=UnitOfMeasurement.CELSIUS,
         ),
         EcomaxNumberDescription(
-            name="supervision_airflow_work",
+            name="grate_fan_work",
             unit_of_measurement=UnitOfMeasurement.SECONDS,
         ),
         EcomaxNumberDescription(
-            name="supervision_airflow_pause",
+            name="grate_fan_pause",
             unit_of_measurement=UnitOfMeasurement.MINUTES,
         ),
         EcomaxNumberDescription(
@@ -416,10 +427,10 @@ ECOMAX_PARAMETERS: dict[ProductType, tuple[EcomaxParameterDescription, ...]] = {
             unit_of_measurement=PERCENTAGE,
         ),
         EcomaxNumberDescription(
-            name="burning_off_airflow_work",
+            name="burning_off_fan_work",
         ),
         EcomaxNumberDescription(
-            name="burning_off_airflow_pause",
+            name="burning_off_fan_pause",
         ),
         EcomaxNumberDescription(
             name="start_burning_off",

pyplumio/structures/mixer_parameters.py

@@ -65,6 +65,17 @@ class MixerParameter(Parameter):
             },
         )
 
+    async def create_refresh_request(self) -> Request:
+        """Create a request to refresh the parameter."""
+        return await Request.create(
+            FrameType.REQUEST_MIXER_PARAMETERS, recipient=self.device.parent.address
+        )
+
+    @property
+    def is_tracking_changes(self) -> bool:
+        """Return True if remote's tracking changes, False otherwise."""
+        return self.device.parent.has_frame_version(FrameType.REQUEST_MIXER_PARAMETERS)
+
 
 @dataslots
 @dataclass
@@ -73,6 +84,7 @@ class MixerNumberDescription(MixerParameterDescription, NumberDescription):
 
     multiplier: float = 1.0
     offset: int = 0
+    precision: int = 6
 
 
 class MixerNumber(MixerParameter, Number):
@@ -86,29 +98,27 @@ class MixerNumber(MixerParameter, Number):
         self, value: int | float, retries: int = 5, timeout: float = 5.0
     ) -> bool:
         """Set a parameter value."""
-        value = (value + self.description.offset) / self.description.multiplier
+        value += self.description.offset
+        value = round(value / self.description.multiplier, self.description.precision)
         return await super().set(value, retries, timeout)
 
     @property
     def value(self) -> float:
         """Return the parameter value."""
-        return (
-            self.values.value - self.description.offset
-        ) * self.description.multiplier
+        value = self.values.value - self.description.offset
+        return round(value * self.description.multiplier, self.description.precision)
 
     @property
     def min_value(self) -> float:
         """Return the minimum allowed value."""
-        return (
-            self.values.min_value - self.description.offset
-        ) * self.description.multiplier
+        value = self.values.min_value - self.description.offset
+        return round(value * self.description.multiplier, self.description.precision)
 
     @property
     def max_value(self) -> float:
         """Return the maximum allowed value."""
-        return (
-            self.values.max_value - self.description.offset
-        ) * self.description.multiplier
+        value = self.values.max_value - self.description.offset
+        return round(value * self.description.multiplier, self.description.precision)
 
 
 @dataslots

pyplumio/structures/regulator_data.py

@@ -53,7 +53,7 @@ class RegulatorDataStructure(StructureDecoder):
             message, offset + 2, data
         )
 
-        if (device := self.frame.sender_device) is not None and (
+        if (device := self.frame.handler) is not None and (
             schema := device.get_nowait(ATTR_REGDATA_SCHEMA, [])
         ):
             self._bitarray_index = 0

pyplumio/structures/schedules.py

@@ -100,13 +100,24 @@ class ScheduleParameter(Parameter):
 
     async def create_request(self) -> Request:
         """Create a request to change the parameter."""
-        schedule_name, _ = self.description.name.split("_schedule_", 1)
+        schedule_name = self.description.name.split("_schedule_", 1)[0]
         return await Request.create(
             FrameType.REQUEST_SET_SCHEDULE,
             recipient=self.device.address,
             data=collect_schedule_data(schedule_name, self.device),
         )
 
+    async def create_refresh_request(self) -> Request:
+        """Create a request to refresh the parameter."""
+        return await Request.create(
+            FrameType.REQUEST_SCHEDULES, recipient=self.device.address
+        )
+
+    @property
+    def is_tracking_changes(self) -> bool:
+        """Return True if remote's tracking changes, False otherwise."""
+        return self.device.has_frame_version(FrameType.REQUEST_SCHEDULES)
+
 
 @dataslots
 @dataclass
@@ -163,7 +174,7 @@ def _split_byte(byte: int) -> list[bool]:
 
 def _join_bits(bits: Sequence[int | bool]) -> int:
     """Join eight bits into a single byte."""
-    return reduce(lambda x, y: (x << 1) | y, bits)
+    return reduce(lambda bit, byte: (bit << 1) | byte, bits)
 
 
 class SchedulesStructure(Structure):

pyplumio/structures/thermostat_parameters.py

@@ -66,7 +66,7 @@ class ThermostatParameter(Parameter):
         values: ParameterValues | None = None,
         index: int = 0,
         offset: int = 0,
-    ):
+    ) -> None:
         """Initialize a new thermostat parameter."""
         self.offset = offset
         super().__init__(device, description, values, index)
@@ -86,6 +86,20 @@ class ThermostatParameter(Parameter):
             },
         )
 
+    async def create_refresh_request(self) -> Request:
+        """Create a request to refresh the parameter."""
+        return await Request.create(
+            FrameType.REQUEST_THERMOSTAT_PARAMETERS,
+            recipient=self.device.parent.address,
+        )
+
+    @property
+    def is_tracking_changes(self) -> bool:
+        """Return True if remote's tracking changes, False otherwise."""
+        return self.device.parent.has_frame_version(
+            FrameType.REQUEST_THERMOSTAT_PARAMETERS
+        )
+
 
 @dataslots
 @dataclass
@@ -93,6 +107,7 @@ class ThermostatNumberDescription(ThermostatParameterDescription, NumberDescript
     """Represent a thermostat number description."""
 
     multiplier: float = 1.0
+    precision: int = 6
 
 
 class ThermostatNumber(ThermostatParameter, Number):
@@ -106,23 +121,26 @@ class ThermostatNumber(ThermostatParameter, Number):
         self, value: int | float, retries: int = 5, timeout: float = 5.0
     ) -> bool:
         """Set a parameter value."""
-        value = value / self.description.multiplier
+        value = round(value / self.description.multiplier, self.description.precision)
         return await super().set(value, retries, timeout)
 
     @property
     def value(self) -> float:
         """Return the value."""
-        return self.values.value * self.description.multiplier
+        value = self.values.value * self.description.multiplier
+        return round(value, self.description.precision)
 
     @property
     def min_value(self) -> float:
         """Return the minimum allowed value."""
-        return self.values.min_value * self.description.multiplier
+        value = self.values.min_value * self.description.multiplier
+        return round(value, self.description.precision)
 
     @property
     def max_value(self) -> float:
         """Return the maximum allowed value."""
-        return self.values.max_value * self.description.multiplier
+        value = self.values.max_value * self.description.multiplier
+        return round(value, self.description.precision)
 
 
 @dataslots
@@ -247,7 +265,7 @@ class ThermostatParametersStructure(StructureDecoder):
         self, message: bytearray, offset: int = 0, data: dict[str, Any] | None = None
     ) -> tuple[dict[str, Any], int]:
         """Decode bytes and return message data and offset."""
-        if (device := self.frame.sender_device) is not None and (
+        if (device := self.frame.handler) is not None and (
             thermostats := device.get_nowait(ATTR_THERMOSTATS_AVAILABLE, 0)
         ) == 0:
             return (