odxtools 5.3.1__py3-none-any.whl → 6.0.1__py3-none-any.whl

odxtools/odxlink.py

@@ -153,7 +153,7 @@ class OdxLinkRef:
 
         # we must reference at to at least of the ID's document
         # fragments
-        if not any([ref_doc in odx_id.doc_fragments for ref_doc in self.ref_docs]):
+        if not any(ref_doc in odx_id.doc_fragments for ref_doc in self.ref_docs):
             return False
 
         # the local ID of the reference and the object ID must match
@@ -199,6 +199,7 @@ class OdxLinkDatabase:
                     f"Warning: Unknown document fragment {ref_frag} "
                     f"when resolving reference {ref}",
                     OdxWarning,
+                    stacklevel=1,
                 )
                 continue
 
@@ -241,6 +242,7 @@ class OdxLinkDatabase:
                     f"Warning: Unknown document fragment {ref_frag} "
                     f"when resolving reference {ref}",
                     OdxWarning,
+                    stacklevel=1,
                 )
                 continue
 
@@ -265,6 +267,6 @@ class OdxLinkDatabase:
         for odx_id, obj in new_entries.items():
             for doc_frag in odx_id.doc_fragments:
                 if doc_frag not in self._db:
-                    self._db[doc_frag] = dict()
+                    self._db[doc_frag] = {}
 
                 self._db[doc_frag][odx_id] = obj

odxtools/odxtypes.py

@@ -6,12 +6,13 @@ from xml.etree import ElementTree
 from .exceptions import odxassert, odxraise, odxrequire
 
 if TYPE_CHECKING:
-    from .parameters.parameter import Parameter
+    from odxtools.diagnostictroublecode import DiagnosticTroubleCode
+    from odxtools.parameters.parameter import Parameter
 
 
 def bytefield_to_bytearray(bytefield: str) -> bytearray:
     bytes_string = [bytefield[i:i + 2] for i in range(0, len(bytefield), 2)]
-    return bytearray(map(lambda x: int(x, 16), bytes_string))
+    return bytearray([int(x, 16) for x in bytes_string])
 
 
 AtomicOdxType = Union[str, int, float, bytes]
@@ -27,7 +28,7 @@ ParameterDict = Dict[str, Union["Parameter", "ParameterDict"]]
 # multiple items, so this can be a list of objects.
 TableStructParameterValue = Tuple[str, "ParameterValue"]
 ParameterValue = Union[AtomicOdxType, "ParameterValueDict", TableStructParameterValue,
-                       List["ParameterValue"]]
+                       List["ParameterValue"], "DiagnosticTroubleCode"]
 ParameterValueDict = Dict[str, ParameterValue]
 
 

odxtools/parameterinfo.py

@@ -75,10 +75,10 @@ def parameter_info(param_list: Iterable[Union[Parameter, EndOfPduField]]) -> str
             else:
                 result += f": <unknown type>"
 
-            if dop.bit_length is not None:
-                result += f"{dop.bit_length}\n"
-            else:
-                result += "\n"
+            if (bl := dop.get_static_bit_length()) is not None:
+                result += f"{bl}"
+
+            result += "\n"
 
         elif isinstance(cm, LinearCompuMethod):
             result += f": float\n"
@@ -86,8 +86,8 @@ def parameter_info(param_list: Iterable[Union[Parameter, EndOfPduField]]) -> str
             ul = cm.physical_upper_limit
             result += (f" range: "
                        f"{'[' if ll.interval_type == IntervalType.CLOSED else '('}"
-                       f"{ll.value}, "
-                       f"{ul.value}"
+                       f"{ll.value!r}, "
+                       f"{ul.value!r}"
                        f"{']' if ul.interval_type == IntervalType.CLOSED else ')'}\n")
 
             unit = dop.unit

odxtools/parameters/codedconstparameter.py

@@ -2,7 +2,7 @@
 import warnings
 from copy import copy
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
 
 from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
@@ -39,9 +39,8 @@ class CodedConstParameter(Parameter):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
-    @property
-    def bit_length(self):
-        return self.diag_coded_type.bit_length
+    def get_static_bit_length(self) -> Optional[int]:
+        return getattr(self.diag_coded_type, "bit_length", None)
 
     @property
     def internal_data_type(self) -> DataType:
@@ -55,10 +54,7 @@ class CodedConstParameter(Parameter):
     def is_settable(self) -> bool:
         return False
 
-    def get_coded_value(self):
-        return self.coded_value
-
-    def get_coded_value_as_bytes(self, encode_state: EncodeState):
+    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         if (self.short_name in encode_state.parameter_values and
                 encode_state.parameter_values[self.short_name] != self.coded_value):
             raise TypeError(f"The parameter '{self.short_name}' is constant {self._coded_value_str}"
@@ -67,15 +63,15 @@ class CodedConstParameter(Parameter):
         return self.diag_coded_type.convert_internal_to_bytes(
             self.coded_value, encode_state=encode_state, bit_position=bit_position_int)
 
-    def decode_from_pdu(self, decode_state: DecodeState):
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[AtomicOdxType, int]:
         decode_state = copy(decode_state)
-        if self.byte_position is not None and self.byte_position != decode_state.next_byte_position:
+        if self.byte_position is not None and self.byte_position != decode_state.cursor_position:
             # Update byte position
-            decode_state.next_byte_position = self.byte_position
+            decode_state.cursor_position = self.byte_position
 
         # Extract coded values
         bit_position_int = self.bit_position if self.bit_position is not None else 0
-        coded_val, next_byte_position = self.diag_coded_type.convert_bytes_to_internal(
+        coded_val, cursor_position = self.diag_coded_type.convert_bytes_to_internal(
             decode_state, bit_position=bit_position_int)
 
         # Check if the coded value in the message is correct.
@@ -84,25 +80,19 @@ class CodedConstParameter(Parameter):
                 f"Coded constant parameter does not match! "
                 f"The parameter {self.short_name} expected coded "
                 f"value {str(self._coded_value_str)} but got {str(coded_val)} "
-                f"at byte position {decode_state.next_byte_position} "
+                f"at byte position {decode_state.cursor_position} "
                 f"in coded message {decode_state.coded_message.hex()}.",
                 DecodeError,
+                stacklevel=1,
             )
 
-        return coded_val, next_byte_position
-
-    def _as_dict(self):
-        d = super()._as_dict()
-        if self.bit_length is not None:
-            d["bit_length"] = self.bit_length
-        d["coded_value"] = hex(self.coded_value)
-        return d
+        return coded_val, cursor_position
 
     @property
-    def _coded_value_str(self):
-        if isinstance(self.coded_value, int):
-            return str(self.coded_value)
-        return self.coded_value.hex()
+    def _coded_value_str(self) -> str:
+        if isinstance(self.coded_value, bytes):
+            return self.coded_value.hex()
+        return str(self.coded_value)
 
     def get_description_of_valid_values(self) -> str:
         """return a human-understandable description of valid physical values"""

odxtools/parameters/createanyparameter.py

@@ -115,7 +115,7 @@ def create_any_parameter_from_et(et_element: ElementTree.Element,
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
 
         return ReservedParameter(
-            bit_length_raw=bit_length,
+            bit_length=bit_length,
             semantic=semantic,
             byte_position=byte_position,
             bit_position=bit_position,

odxtools/parameters/dynamicparameter.py

@@ -1,6 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import Tuple
 
+from ..decodestate import DecodeState
+from ..encodestate import EncodeState
+from ..odxtypes import ParameterValue
 from .parameter import Parameter, ParameterType
 
 
@@ -19,11 +23,8 @@ class DynamicParameter(Parameter):
     def is_settable(self) -> bool:
         raise NotImplementedError(".is_settable for a DynamicParameter")
 
-    def get_coded_value(self):
+    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         raise NotImplementedError("Encoding a DynamicParameter is not implemented yet.")
 
-    def get_coded_value_as_bytes(self):
-        raise NotImplementedError("Encoding a DynamicParameter is not implemented yet.")
-
-    def decode_from_pdu(self, coded_message, default_byte_position=None):
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
         raise NotImplementedError("Decoding a DynamicParameter is not implemented yet.")

odxtools/parameters/lengthkeyparameter.py

@@ -6,6 +6,7 @@ from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import odxrequire
 from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..odxtypes import ParameterValue
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
@@ -65,5 +66,5 @@ class LengthKeyParameter(ParameterWithDOP):
     def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
         return super().encode_into_pdu(encode_state)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[Any, int]:
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
         return super().decode_from_pdu(decode_state)

odxtools/parameters/matchingrequestparameter.py

@@ -1,9 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import Optional, Tuple
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import EncodeError
+from ..odxtypes import ParameterValue
 from .parameter import Parameter, ParameterType
 
 
@@ -16,8 +18,7 @@ class MatchingRequestParameter(Parameter):
     def parameter_type(self) -> ParameterType:
         return "MATCHING-REQUEST-PARAM"
 
-    @property
-    def bit_length(self):
+    def get_static_bit_length(self) -> Optional[int]:
         return 8 * self.byte_length
 
     @property
@@ -28,10 +29,7 @@ class MatchingRequestParameter(Parameter):
     def is_settable(self) -> bool:
         return False
 
-    def get_coded_value(self, request_value=None):
-        return request_value
-
-    def get_coded_value_as_bytes(self, encode_state: EncodeState):
+    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         if not encode_state.triggering_request:
             raise EncodeError(f"Parameter '{self.short_name}' is of matching request type,"
                               " but no original request has been specified.")
@@ -39,12 +37,11 @@ class MatchingRequestParameter(Parameter):
                                                .request_byte_position:self.request_byte_position +
                                                self.byte_length]
 
-    def decode_from_pdu(self, decode_state: DecodeState):
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
         byte_position = (
-            self.byte_position
-            if self.byte_position is not None else decode_state.next_byte_position)
-        bit_position = self.bit_position if self.bit_position is not None else 0
-        byte_length = (self.bit_length + bit_position + 7) // 8
+            self.byte_position if self.byte_position is not None else decode_state.cursor_position)
+        bit_position = self.bit_position or 0
+        byte_length = (8 * self.byte_length + bit_position + 7) // 8
         val_as_bytes = decode_state.coded_message[byte_position:byte_position + byte_length]
 
         return val_as_bytes, byte_position + byte_length

odxtools/parameters/nrcconstparameter.py

@@ -2,7 +2,7 @@
 import warnings
 from copy import copy
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 
 from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
@@ -47,9 +47,8 @@ class NrcConstParameter(Parameter):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
-    @property
-    def bit_length(self):
-        return self.diag_coded_type.bit_length
+    def get_static_bit_length(self) -> Optional[int]:
+        return self.diag_coded_type.get_static_bit_length()
 
     @property
     def internal_data_type(self) -> DataType:
@@ -63,10 +62,7 @@ class NrcConstParameter(Parameter):
     def is_settable(self) -> bool:
         return False
 
-    def get_coded_value(self):
-        return self.coded_value
-
-    def get_coded_value_as_bytes(self, encode_state: EncodeState):
+    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         if self.short_name in encode_state.parameter_values:
             if encode_state.parameter_values[self.short_name] not in self.coded_values:
                 raise EncodeError(f"The parameter '{self.short_name}' must have"
@@ -82,15 +78,15 @@ class NrcConstParameter(Parameter):
         return self.diag_coded_type.convert_internal_to_bytes(
             coded_value, encode_state, bit_position=bit_position_int)
 
-    def decode_from_pdu(self, decode_state: DecodeState):
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[AtomicOdxType, int]:
         decode_state = copy(decode_state)
-        if self.byte_position is not None and self.byte_position != decode_state.next_byte_position:
+        if self.byte_position is not None and self.byte_position != decode_state.cursor_position:
             # Update byte position
-            decode_state.next_byte_position = self.byte_position
+            decode_state.cursor_position = self.byte_position
 
         # Extract coded values
         bit_position_int = self.bit_position if self.bit_position is not None else 0
-        coded_value, next_byte_position = self.diag_coded_type.convert_bytes_to_internal(
+        coded_value, cursor_position = self.diag_coded_type.convert_bytes_to_internal(
             decode_state, bit_position=bit_position_int)
 
         # Check if the coded value in the message is correct.
@@ -99,19 +95,13 @@ class NrcConstParameter(Parameter):
                 f"Coded constant parameter does not match! "
                 f"The parameter {self.short_name} expected a coded "
                 f"value in {str(self.coded_values)} but got {str(coded_value)} "
-                f"at byte position {decode_state.next_byte_position} "
+                f"at byte position {decode_state.cursor_position} "
                 f"in coded message {decode_state.coded_message.hex()}.",
                 DecodeError,
+                stacklevel=1,
             )
 
-        return coded_value, next_byte_position
-
-    def _as_dict(self):
-        d = super()._as_dict()
-        if self.bit_length is not None:
-            d["bit_length"] = self.bit_length
-        d["coded_values"] = self.coded_values
-        return d
+        return coded_value, cursor_position
 
     def get_description_of_valid_values(self) -> str:
         """return a human-understandable description of valid physical values"""

odxtools/parameters/parameter.py

@@ -9,6 +9,7 @@ from ..element import NamedElement
 from ..encodestate import EncodeState
 from ..exceptions import OdxWarning
 from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..odxtypes import ParameterValue
 from ..specialdatagroup import SpecialDataGroup
 
 if TYPE_CHECKING:
@@ -58,8 +59,7 @@ class Parameter(NamedElement, abc.ABC):
     def parameter_type(self) -> ParameterType:
         pass
 
-    @property
-    def bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> Optional[int]:
         return None
 
     @property
@@ -85,10 +85,6 @@ class Parameter(NamedElement, abc.ABC):
         """
         raise NotImplementedError
 
-    @abc.abstractmethod
-    def get_coded_value(self):
-        pass
-
     @abc.abstractmethod
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         """Get the coded value of the parameter given the encode state.
@@ -97,7 +93,7 @@ class Parameter(NamedElement, abc.ABC):
         pass
 
     @abc.abstractmethod
-    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[Any, int]:
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
         """Decode the parameter value from the coded message.
 
         If the parameter does have a byte position property, the coded bytes the parameter covers are extracted
@@ -178,18 +174,8 @@ class Parameter(NamedElement, abc.ABC):
                 warnings.warn(
                     f"Parameter {self.short_name} overlaps with another parameter (bytes are already set)",
                     OdxWarning,
+                    stacklevel=1,
                 )
             result_blob[byte_idx_rpc] |= new_data[byte_idx_val]
 
         return result_blob
-
-    def _as_dict(self):
-        """
-        Mostly for pretty printing purposes (specifically not for reconstructing the object)
-        """
-        d = {"short_name": self.short_name, "type": self.parameter_type, "semantic": self.semantic}
-        if self.byte_position is not None:
-            d["byte_position"] = self.byte_position
-        if self.bit_position is not None:
-            d["bit_position"] = self.bit_position
-        return d

odxtools/parameters/parameterwithdop.py

@@ -10,6 +10,7 @@ from ..dtcdop import DtcDop
 from ..encodestate import EncodeState
 from ..exceptions import odxassert, odxrequire
 from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxtypes import ParameterValue
 from ..physicaltype import PhysicalType
 from .parameter import Parameter
 
@@ -54,15 +55,16 @@ class ParameterWithDOP(Parameter):
                 spec.env_datas.get(self.dop_snref))
 
     @property
-    def dop(self) -> Optional[DopBase]:
+    def dop(self) -> DopBase:
         """may be a DataObjectProperty, a Structure or None"""
 
-        return self._dop
+        return odxrequire(
+            self._dop, "Specifying a data object property is mandatory but it "
+            "could not be resolved")
 
-    @property
-    def bit_length(self):
-        if self.dop is not None:
-            return self.dop.bit_length
+    def get_static_bit_length(self) -> Optional[int]:
+        if self._dop is not None:
+            return self._dop.get_static_bit_length()
         else:
             return None
 
@@ -73,38 +75,21 @@ class ParameterWithDOP(Parameter):
         else:
             return None
 
-    def get_coded_value(self, physical_value=None):
-        return self.dop.convert_physical_to_internal(physical_value)
-
-    def get_coded_value_as_bytes(self, encode_state: EncodeState):
+    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         dop = odxrequire(self.dop, "Reference to DOP is not resolved")
         physical_value = encode_state.parameter_values[self.short_name]
         bit_position_int = self.bit_position if self.bit_position is not None else 0
         return dop.convert_physical_to_bytes(
             physical_value, encode_state, bit_position=bit_position_int)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[Any, int]:
-        dop = odxrequire(self.dop, "Reference to DOP is not resolved")
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
         decode_state = copy(decode_state)
-        if self.byte_position is not None and self.byte_position != decode_state.next_byte_position:
-            decode_state.next_byte_position = self.byte_position
+        if self.byte_position is not None and self.byte_position != decode_state.cursor_position:
+            decode_state.cursor_position = self.byte_position
 
         # Use DOP to decode
         bit_position_int = self.bit_position if self.bit_position is not None else 0
-        phys_val, next_byte_position = dop.convert_bytes_to_physical(
+        phys_val, cursor_position = self.dop.convert_bytes_to_physical(
             decode_state, bit_position=bit_position_int)
 
-        return phys_val, next_byte_position
-
-    def _as_dict(self):
-        d = super()._as_dict()
-        if self.dop is not None:
-            if self.bit_length is not None:
-                d["bit_length"] = self.bit_length
-            d["dop_ref"] = OdxLinkRef.from_id(self.dop.odx_id)
-        elif self.dop_ref is not None:
-            d["dop_ref"] = self.dop_ref
-        elif self.dop_snref is not None:
-            d["dop_snref"] = self.dop_snref
-
-        return d
+        return phys_val, cursor_position

odxtools/parameters/physicalconstantparameter.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict
+from typing import TYPE_CHECKING, Any, Dict, Tuple
 
 from ..dataobjectproperty import DataObjectProperty
 from ..decodestate import DecodeState
@@ -52,10 +52,7 @@ class PhysicalConstantParameter(ParameterWithDOP):
     def is_settable(self) -> bool:
         return False
 
-    def get_coded_value(self):
-        return self.dop.convert_physical_to_internal(self.physical_constant_value)
-
-    def get_coded_value_as_bytes(self, encode_state: EncodeState):
+    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         dop = odxrequire(self.dop, "Reference to DOP is not resolved")
         if (self.short_name in encode_state.parameter_values and
                 encode_state.parameter_values[self.short_name] != self.physical_constant_value):
@@ -67,17 +64,18 @@ class PhysicalConstantParameter(ParameterWithDOP):
         return dop.convert_physical_to_bytes(
             self.physical_constant_value, encode_state, bit_position=bit_position_int)
 
-    def decode_from_pdu(self, decode_state: DecodeState):
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
         # Decode value
-        phys_val, next_byte_position = super().decode_from_pdu(decode_state)
+        phys_val, cursor_position = super().decode_from_pdu(decode_state)
 
         # Check if decoded value matches expected value
         if phys_val != self.physical_constant_value:
             warnings.warn(
                 f"Physical constant parameter does not match! "
                 f"The parameter {self.short_name} expected physical value {self.physical_constant_value!r} but got {phys_val!r} "
-                f"at byte position {next_byte_position} "
+                f"at byte position {cursor_position} "
                 f"in coded message {decode_state.coded_message.hex()}.",
                 DecodeError,
+                stacklevel=1,
             )
-        return phys_val, next_byte_position
+        return phys_val, cursor_position

odxtools/parameters/reservedparameter.py

@@ -1,15 +1,16 @@
 # SPDX-License-Identifier: MIT
-import warnings
 from dataclasses import dataclass
+from typing import Optional, Tuple, cast
 
 from ..decodestate import DecodeState
-from ..exceptions import DecodeError
+from ..encodestate import EncodeState
+from ..odxtypes import ParameterValue
 from .parameter import Parameter, ParameterType
 
 
 @dataclass
 class ReservedParameter(Parameter):
-    bit_length_raw: int
+    bit_length: int
 
     @property
     def parameter_type(self) -> ParameterType:
@@ -23,44 +24,22 @@ class ReservedParameter(Parameter):
     def is_settable(self) -> bool:
         return False
 
-    @property
-    def bit_length(self) -> int:
-        # this is a bit hacky: the parent class already specifies
-        # bit_length as a function property, and we need to change
-        # this to return the value from the XML here. Since function
-        # attributes cannot be overridden by non-function ones, we
-        # need to take the "bit_length_raw" detour...
-        return self.bit_length_raw
-
-    def get_coded_value(self):
-        return 0
+    def get_static_bit_length(self) -> Optional[int]:
+        return self.bit_length
 
-    def get_coded_value_as_bytes(self, encode_state):
+    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return int(0).to_bytes((self.bit_length + bit_position_int + 7) // 8, "big")
+        return (0).to_bytes((self.bit_length + bit_position_int + 7) // 8, "big")
 
-    def decode_from_pdu(self, decode_state: DecodeState):
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
         byte_position = (
-            self.byte_position
-            if self.byte_position is not None else decode_state.next_byte_position)
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        byte_length = (self.bit_length_raw + bit_position_int + 7) // 8
-        val_as_bytes = decode_state.coded_message[byte_position:byte_position + byte_length]
-        next_byte_position = byte_position + byte_length
-
-        # Check that reserved bits are 0
-        expected = sum(
-            2**i for i in range(bit_position_int, bit_position_int + self.bit_length_raw))
-        actual = int.from_bytes(val_as_bytes, "big")
+            self.byte_position if self.byte_position is not None else decode_state.cursor_position)
+        abs_bit_position = byte_position * 8 + (self.bit_position or 0)
+        bit_length = self.bit_length
 
-        # Bit-wise compare if reserved bits are 0.
-        if expected & actual != 0:
-            warnings.warn(
-                f"Reserved bits must be Zero! "
-                f"The parameter {self.short_name} expected {self.bit_length} bits to be Zero starting at bit position {bit_position_int} "
-                f"at byte position {byte_position} "
-                f"in coded message {decode_state.coded_message.hex()}.",
-                DecodeError,
-            )
+        # the cursor points to the first byte which has not been fully
+        # consumed
+        cursor_position = (abs_bit_position + bit_length) // 8
 
-        return None, next_byte_position
+        # ignore the value of the parameter data
+        return cast(int, None), cursor_position

odxtools/parameters/systemparameter.py

@@ -1,6 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import Tuple
 
+from ..decodestate import DecodeState
+from ..encodestate import EncodeState
+from ..odxtypes import ParameterValue
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
@@ -21,11 +25,8 @@ class SystemParameter(ParameterWithDOP):
     def is_settable(self) -> bool:
         raise NotImplementedError("SystemParameter.is_settable is not implemented yet.")
 
-    def get_coded_value(self):
+    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         raise NotImplementedError("Encoding a SystemParameter is not implemented yet.")
 
-    def get_coded_value_as_bytes(self):
-        raise NotImplementedError("Encoding a SystemParameter is not implemented yet.")
-
-    def decode_from_pdu(self, coded_message, default_byte_position=None):
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
         raise NotImplementedError("Decoding a SystemParameter is not implemented yet.")

odxtools/parameters/tableentryparameter.py

@@ -1,7 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import Tuple
 
+from ..decodestate import DecodeState
+from ..encodestate import EncodeState
 from ..odxlink import OdxLinkRef
+from ..odxtypes import ParameterValue
 from .parameter import Parameter, ParameterType
 
 
@@ -22,11 +26,8 @@ class TableEntryParameter(Parameter):
     def is_settable(self) -> bool:
         raise NotImplementedError("TableKeyParameter.is_settable is not implemented yet.")
 
-    def get_coded_value(self):
+    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         raise NotImplementedError("Encoding a TableKeyParameter is not implemented yet.")
 
-    def get_coded_value_as_bytes(self):
-        raise NotImplementedError("Encoding a TableKeyParameter is not implemented yet.")
-
-    def decode_from_pdu(self, coded_message, default_byte_position=None):
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
         raise NotImplementedError("Decoding a TableKeyParameter is not implemented yet.")