Try/all

README.md

@@ -256,8 +256,8 @@ print(parameters.get("ID_Ba_Hz_akt").options()) # returns a list of possible val
 
 # Now we increase the heating controller target temperature by 2 Kelvin
 heating_offset = l.holdings.get(2)    # Get an object for the offset
-heating_offset.value = 2.0            # Set the desired value
-l.holdings["heating_mode"] = "Offset" # Set the value to activate the offset mode
+heating_offset.value = 2.0            # Queue the desired value by setting the field's value
+l.holdings["heating_mode"] = "Offset" # Queue the value to activate the offset mode
 l.write()                             # Write down the values to the heatpump
 ```
 

luxtronik/__init__.py

@@ -6,7 +6,7 @@
 
 import logging
 
-from luxtronik.common import get_host_lock
+from luxtronik.common import LuxtronikSettings, get_host_lock  # noqa: F401
 from luxtronik.discover import discover  # noqa: F401
 
 from luxtronik.cfi import (

luxtronik/cfi/calculations.py

@@ -8,10 +8,11 @@
     CALCULATIONS_DEFINITIONS_LIST,
     CALCULATIONS_OFFSET,
     CALCULATIONS_DEFAULT_DATA_TYPE,
+    CALCULATIONS_OUTDATED,
 )
 
 from luxtronik.cfi.constants import CALCULATIONS_FIELD_NAME
-from luxtronik.data_vector import DataVector
+from luxtronik.cfi.vector import DataVectorConfig
 from luxtronik.datatypes import Base
 
 
@@ -24,28 +25,16 @@
     CALCULATIONS_DEFAULT_DATA_TYPE
 )
 
-class Calculations(DataVector):
+class Calculations(DataVectorConfig):
     """Class that holds all calculations."""
 
     name = CALCULATIONS_FIELD_NAME
     definitions = CALCULATIONS_DEFINITIONS
-
-    _obsolete = {
-        "ID_WEB_SoftStand": "get_firmware_version()"
-    }
-
-    def __init__(self):
-        super().__init__()
-        for d in CALCULATIONS_DEFINITIONS:
-            self._data.add(d, d.create_field())
-
-    @property
-    def calculations(self):
-        return self._data
+    _outdated = CALCULATIONS_OUTDATED
 
     def get_firmware_version(self):
         """Get the firmware version as string."""
-        return "".join([super(Calculations, self).get(i).value for i in range(81, 91)])
+        return "".join([str(super(Calculations, self).get(i).value) for i in range(81, 91)])
 
     def _get_firmware_version(self):
         """Get the firmware version as string like in previous versions."""

luxtronik/cfi/interface.py

@@ -5,7 +5,7 @@
 import struct
 import time
 
-from luxtronik.common import get_host_lock
+from luxtronik.common import LuxtronikSettings, get_host_lock
 from luxtronik.cfi.constants import (
     LUXTRONIK_DEFAULT_PORT,
     LUXTRONIK_PARAMETERS_WRITE,
@@ -162,23 +162,27 @@ def _write_and_read(self, parameters, data):
         return self._read(data)
 
     def _write(self, parameters):
-        for index, value in parameters.queue.items():
-            if not isinstance(index, int) or not isinstance(value, int):
-                LOGGER.warning(
-                    "%s: Parameter id '%s' or value '%s' invalid!",
-                    self._host,
-                    index,
-                    value,
-                )
-                continue
-            LOGGER.info("%s: Parameter '%d' set to '%s'", self._host, index, value)
-            self._send_ints(LUXTRONIK_PARAMETERS_WRITE, index, value)
-            cmd = self._read_int()
-            LOGGER.debug("%s: Command %s", self._host, cmd)
-            val = self._read_int()
-            LOGGER.debug("%s: Value %s", self._host, val)
-        # Flush queue after writing all values
-        parameters.queue = {}
+        if not isinstance(parameters, Parameters):
+            LOGGER.error(f"Only parameters are writable!"):
+            return
+        for definition, field in parameters.items():
+            if field.write_pending:
+                field.write_pending = False
+                value = field.raw
+                if not isinstance(definition.index, int) or not field.check_for_write(parameters.safe):
+                    LOGGER.warning(
+                        "%s: Parameter id '%s' or value '%s' invalid!",
+                        self._host,
+                        definition.index,
+                        value,
+                    )
+                    continue
+                LOGGER.info("%s: Parameter '%d' set to '%s'", self._host, definition.index, value)
+                self._send_ints(LUXTRONIK_PARAMETERS_WRITE, definition.index, value)
+                cmd = self._read_int()
+                LOGGER.debug("%s: Command %s", self._host, cmd)
+                val = self._read_int()
+                LOGGER.debug("%s: Value %s", self._host, val)
         # Give the heatpump a short time to handle the value changes/calculations:
         time.sleep(WAIT_TIME_AFTER_PARAMETER_WRITE)
 
@@ -274,17 +278,20 @@ def _parse(self, data_vector, raw_data):
         undefined = {i for i in range(0, raw_len)}
 
         # integrate the data into the fields
-        for pair in data_vector.data.pairs():
+        for pair in data_vector.data.items():
             definition, field = pair
             # skip this field if there are not enough data
             next_idx = definition.index + definition.count
             if next_idx > raw_len:
                 # not enough registers
-                field.raw = None
+                if not LuxtronikSettings.preserve_last_read_value_on_fail:
+                    field.raw = None
                 continue
             # remove all used indices from the list of undefined indices
             for index in range(definition.index, next_idx):
                 undefined.discard(index)
+            # integrate_data() also resets the write_pending flag,
+            # intentionally only for read fields
             pair.integrate_data(raw_data, LUXTRONIK_CFI_REGISTER_BIT_SIZE)
 
         # create an unknown field for additional data

luxtronik/cfi/parameters.py

@@ -8,10 +8,11 @@
     PARAMETERS_DEFINITIONS_LIST,
     PARAMETERS_OFFSET,
     PARAMETERS_DEFAULT_DATA_TYPE,
+    PARAMETERS_OUTDATED,
 )
 
 from luxtronik.cfi.constants import PARAMETERS_FIELD_NAME
-from luxtronik.data_vector import DataVector
+from luxtronik.cfi.vector import DataVectorConfig
 
 
 LOGGER = logging.getLogger(__name__)
@@ -23,35 +24,9 @@
     PARAMETERS_DEFAULT_DATA_TYPE
 )
 
-class Parameters(DataVector):
+class Parameters(DataVectorConfig):
     """Class that holds all parameters."""
 
     name = PARAMETERS_FIELD_NAME
     definitions = PARAMETERS_DEFINITIONS
-
-    def __init__(self, safe=True):
-        """Initialize parameters class."""
-        super().__init__()
-        self.safe = safe
-        self.queue = {}
-        for d in PARAMETERS_DEFINITIONS:
-            self._data.add(d, d.create_field())
-
-    @property
-    def parameters(self):
-        return self._data
-
-    def set(self, target, value):
-        """Set parameter to new value."""
-        index, parameter = self._lookup(target, with_index=True)
-        if index is not None:
-            if parameter.writeable or not self.safe:
-                raw = parameter.to_heatpump(value)
-                if isinstance(raw, int):
-                    self.queue[index] = raw
-                else:
-                    LOGGER.error("Value '%s' for Parameter '%s' not valid!", value, parameter.name)
-            else:
-                LOGGER.warning("Parameter '%s' not safe for writing!", parameter.name)
-        else:
-            LOGGER.warning("Parameter '%s' not found", target)
+    _outdated = PARAMETERS_OUTDATED

luxtronik/cfi/vector.py

@@ -0,0 +1,83 @@
+
+import logging
+
+from luxtronik.data_vector import DataVector
+
+
+LOGGER = logging.getLogger(__name__)
+
+###############################################################################
+# Configuration interface data-vector
+###############################################################################
+
+class DataVectorConfig(DataVector):
+    """Specialized DataVector for Luxtronik configuration fields."""
+
+    def _init_instance(self, safe):
+        """Re-usable method to initialize all instance variables."""
+        super()._init_instance(safe)
+
+    def __init__(self, safe=True):
+        """
+        Initialize the data-vector instance.
+        Creates field objects for definitions and stores them in the data vector.
+
+        Args:
+            safe (bool): If true, prevent fields marked as
+                not secure from being written to.
+        """
+        self._init_instance(safe)
+
+        # Add all available fields
+        for d in self.definitions:
+            self._data.add(d, d.create_field())
+
+    @classmethod
+    def empty(cls, safe=True):
+        """
+        Initialize the data-vector instance without any fields.
+
+        Args:
+            safe (bool): If true, prevent fields marked as
+                not secure from being written to.
+        """
+        obj = cls.__new__(cls) # this don't call __init__()
+        obj._init_instance(safe)
+        return obj
+
+    def add(self, def_field_name_or_idx, alias=None):
+        """
+        Adds an additional field to this data vector.
+        Mainly used for data vectors created via `empty()`
+        to read/write individual fields. Existing fields will not be overwritten.
+
+        Args:
+            def_field_name_or_idx (LuxtronikDefinition | Base | str | int):
+                Field to add. Either by definition, name or index, or the field itself.
+            alias (Hashable | None): Alias, which can be used to access the field again.
+
+        Returns:
+            Base | None: The added field object if this could be added or
+                the existing field, otherwise None. In case a field
+
+        Note:
+            It is not possible to add fields which are not defined.
+            To add custom fields, add them to the used `LuxtronikDefinitionsList`
+            (`cls.definitions`) first.
+            If multiple fields added for the same index/name, the last added takes precedence.
+        """
+        # Look-up the related definition
+        definition, field = self._get_definition(def_field_name_or_idx, True)
+        if definition is None:
+            return None
+
+        # Check if the field already exists
+        existing_field = self._data.get(definition, None)
+        if existing_field is not None:
+            return existing_field
+
+        # Add a (new) field
+        if field is None:
+            field = definition.create_field()
+        self._data.add_sorted(definition, field, alias)
+        return field

luxtronik/cfi/visibilities.py

@@ -8,10 +8,11 @@
     VISIBILITIES_DEFINITIONS_LIST,
     VISIBILITIES_OFFSET,
     VISIBILITIES_DEFAULT_DATA_TYPE,
+    VISIBILITIES_OUTDATED,
 )
 
 from luxtronik.cfi.constants import VISIBILITIES_FIELD_NAME
-from luxtronik.data_vector import DataVector
+from luxtronik.cfi.vector import DataVectorConfig
 
 
 LOGGER = logging.getLogger(__name__)
@@ -23,17 +24,9 @@
     VISIBILITIES_DEFAULT_DATA_TYPE,
 )
 
-class Visibilities(DataVector):
+class Visibilities(DataVectorConfig):
     """Class that holds all visibilities."""
 
     name = VISIBILITIES_FIELD_NAME
     definitions = VISIBILITIES_DEFINITIONS
-
-    def __init__(self):
-        super().__init__()
-        for d in VISIBILITIES_DEFINITIONS:
-            self._data.add(d, d.create_field())
-
-    @property
-    def visibilities(self):
-        return self._data
+    _outdated = VISIBILITIES_OUTDATED

luxtronik/collections.py

@@ -205,8 +205,7 @@ def integrate_data(self, raw_data, num_bits, data_offset=-1):
 
 class LuxtronikFieldsDictionary:
     """
-    Dictionary that behaves like the earlier data vector dictionaries (index-field-dictionary),
-    with the addition that obsolete fields are also supported and can be addressed by name.
+    Dictionary that maps definitions, names or indices to added fields.
     Aliases are also supported.
     """
 
@@ -228,15 +227,12 @@ def __getitem__(self, def_field_name_or_idx):
         return self.get(def_field_name_or_idx)
 
     def __len__(self):
-        return len(self._def_lookup._index_dict)
+        """Return the number of added fields."""
+        return len(self._pairs)
 
     def __iter__(self):
-        """
-        Iterate over all non-obsolete indices. If an index is assigned multiple times,
-        only the index of the preferred definition will be output.
-        """
-        all_related_defs = self._def_lookup._index_dict.values()
-        return iter([d.index for d in self._pairs if d in all_related_defs])
+        """Return the iterator over all definitions related to the added fields."""
+        return iter([d for d, _ in self._pairs])
 
     def __contains__(self, def_field_name_or_idx):
         """
@@ -265,26 +261,16 @@ def __contains__(self, def_field_name_or_idx):
             return def_field_name_or_idx in self._def_lookup
 
     def values(self):
-        """
-        Iterator for all added non-obsolete fields. If an index is assigned multiple times,
-        only the field of the preferred definition will be output.
-        """
-        all_related_defs = self._def_lookup._index_dict.values()
-        return iter([f for d, f in self._pairs if d in all_related_defs])
+        """Return the iterator over all added fields."""
+        return iter([f for _, f in self._pairs])
 
     def items(self):
-        """
-        Iterator for all non-obsolete index-field-pairs (list of tuples with
-        0: index, 1: field) contained herein. If an index is assigned multiple times,
-        only the index-field-pair of the preferred definition will be output.
-        """
-        all_related_defs = self._def_lookup._index_dict.values()
-        return iter([(d.index, f) for d, f in self._pairs if d in all_related_defs])
+        """Return the iterator over all added definition-field-pairs."""
+        return iter(self._pairs)
 
+    @property
     def pairs(self):
-        """
-        Return all definition-field-pairs contained herein.
-        """
+        """Return all definition-field-pairs contained herein."""
         return self._pairs
 
     @property

luxtronik/common.py

@@ -1,6 +1,16 @@
 
 from threading import RLock
 
+###############################################################################
+# User adjust-able settings class
+###############################################################################
+
+class LuxtronikSettings:
+
+    # If False, overwrite existing values with None in case of a transmission error.
+    # Otherwise, leave the previous value unchanged.
+    preserve_last_read_value_on_fail = True
+
 ###############################################################################
 # Multi-threading lock mechanism
 ###############################################################################

luxtronik/constants.py

@@ -17,7 +17,3 @@
 # Since version 3.92.0, all unavailable 16 bit signed data fields
 # have been returning this value (0x7FFF)
 LUXTRONIK_VALUE_FUNCTION_NOT_AVAILABLE: Final = 32767
-
-LUXTRONIK_NAME_CHECK_NONE: Final = "none"
-LUXTRONIK_NAME_CHECK_PREFERRED: Final = "preferred"
-LUXTRONIK_NAME_CHECK_OBSOLETE: Final = "obsolete"