odxtools 6.6.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/odxtypes.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type, Union, overload
+from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, Optional, Tuple, Type, Union,
+                    overload)
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxraise, odxrequire
@@ -28,7 +29,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"], "DiagnosticTroubleCode"]
+                       Iterable["ParameterValue"], "DiagnosticTroubleCode"]
 ParameterValueDict = Dict[str, ParameterValue]
 
 
@@ -63,8 +64,8 @@ def bool_to_odxstr(bool_val: bool) -> str:
 
 def parse_int(value: str) -> int:
     try:
-        return int(value)
-    except ValueError:
+        return int(value, 0)
+    except (ValueError, TypeError):
         try:
             v = float(value)
         except Exception as e:
@@ -102,6 +103,71 @@ _ODX_TYPE_TO_PYTHON_TYPE: Dict[str, Type[AtomicOdxType]] = {
 }
 
 
+def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
+    # this function implements the comparison according to the ODX
+    # specification. (cf section 7.3.6.5)
+
+    # numeric values are compared numerically (duh!)
+    if isinstance(a, (int, float)):
+        if not isinstance(b, (int, float)):
+            odxraise()
+
+        tmp = a - b
+        if tmp < 0:
+            return -1
+        elif tmp > 0:
+            return 1
+        return 0
+
+    # strings are compared lexicographically. (the spec only allows
+    # equals, but this cannot easily implemented using a single
+    # comparison function.
+    if isinstance(a, str):
+        if not isinstance(b, str):
+            odxraise()
+
+        if a < b:
+            return -1
+        elif b < a:
+            return 1
+        else:
+            return 0
+
+    # bytefields are treated like long integers: to pad the shorter
+    # object with zeros and treat the results like strings.
+    if isinstance(a, (bytes, bytearray)):
+        if not isinstance(b, (bytes, bytearray)):
+            odxraise()
+
+        obj_len = max(len(a), len(b))
+
+        tmp_a = a.ljust(obj_len, b'\x00')
+        tmp_b = b.ljust(obj_len, b'\x00')
+
+        if tmp_a > tmp_b:
+            return 1
+        elif tmp_a < tmp_b:
+            return -1
+        else:
+            return 0
+
+    odxraise(f"Unhandled comparsion between objects of type {type(a).__name__} "
+             f"and {type(b).__name__}")
+
+
+# format specifiers for the data type using the bitstruct module
+_BITSTRUCT_FORMAT_LETTER_MAP__ = {
+    "A_INT32": "s",
+    "A_UINT32": "u",
+    "A_FLOAT32": "f",
+    "A_FLOAT64": "f",
+    "A_BYTEFIELD": "r",
+    "A_UNICODE2STRING": "r",  # UTF-16 strings must be converted explicitly
+    "A_ASCIISTRING": "r",
+    "A_UTF8STRING": "r",
+}
+
+
 class DataType(Enum):
     """Types for the physical and internal value.
 
@@ -125,9 +191,14 @@ class DataType(Enum):
     A_ASCIISTRING = "A_ASCIISTRING"
     A_UTF8STRING = "A_UTF8STRING"
 
-    def as_python_type(self) -> type:
+    @property
+    def python_type(self) -> Type[AtomicOdxType]:
         return _ODX_TYPE_TO_PYTHON_TYPE[self.value]
 
+    @property
+    def bitstruct_format_letter(self) -> str:
+        return _BITSTRUCT_FORMAT_LETTER_MAP__[self.value]
+
     def from_string(self, value: str) -> AtomicOdxType:
         return _PARSE_ODX_TYPE[self.value](value)
 
@@ -158,15 +229,29 @@ class DataType(Enum):
             return self.from_string(value)
         else:
             # regular type cast of python objects
-            return self.as_python_type()(value)
+            return self.python_type(value)
 
     def isinstance(self, value: Any) -> bool:
-        expected_type = self.as_python_type()
+        expected_type = self.python_type
         if isinstance(value, expected_type):
             return True
-        elif expected_type == float and isinstance(value, (int, float)):
+        elif expected_type is float and isinstance(value, (int, float)):
             return True
         elif self == DataType.A_BYTEFIELD and isinstance(value, (bytearray, bytes)):
             return True
         else:
             return False
+
+    def __str__(self) -> str:
+        if self == DataType.A_INT32:
+            return "int"
+        elif self == DataType.A_UINT32:
+            return "uint"
+        elif self in (DataType.A_FLOAT32, DataType.A_FLOAT64):
+            return "float"
+        elif self == DataType.A_BYTEFIELD:
+            return "bytefield"
+        elif self in (DataType.A_UNICODE2STRING, DataType.A_ASCIISTRING, DataType.A_UTF8STRING):
+            return "string"
+        else:
+            return f"<unknown type '{self.value}'>"

odxtools/outputparam.py

@@ -1,24 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from deprecation import deprecated
-
 from .dopbase import DopBase
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class OutputParam(IdentifiableElement):
     dop_base_ref: OdxLinkRef
-    oid: Optional[str]
     semantic: Optional[str]
 
     @staticmethod
@@ -27,25 +22,19 @@ class OutputParam(IdentifiableElement):
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
         dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
         semantic = et_element.get("SEMANTIC")
-        oid = et_element.get("OID")
 
-        return OutputParam(dop_base_ref=dop_base_ref, semantic=semantic, oid=oid, **kwargs)
+        return OutputParam(dop_base_ref=dop_base_ref, semantic=semantic, **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._dop_base = odxlinks.resolve(self.dop_base_ref)
+        self._dop_base = odxlinks.resolve(self.dop_base_ref, DopBase)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property
     def dop_base(self) -> DopBase:
         """The data object property describing this parameter."""
         return self._dop_base
-
-    @property
-    @deprecated(details="use .dop_base")
-    def dop(self) -> DopBase:
-        return self._dop_base

odxtools/parameterinfo.py

@@ -1,98 +1,256 @@
 # SPDX-License-Identifier: MIT
-import re
-from typing import Iterable, Union
+import textwrap
+from io import StringIO
+from typing import Iterable
 
+from .compumethods.compucodecompumethod import CompuCodeCompuMethod
 from .compumethods.identicalcompumethod import IdenticalCompuMethod
 from .compumethods.limit import IntervalType
 from .compumethods.linearcompumethod import LinearCompuMethod
+from .compumethods.linearsegment import LinearSegment
+from .compumethods.ratfunccompumethod import RatFuncCompuMethod
+from .compumethods.ratfuncsegment import RatFuncSegment
+from .compumethods.scalelinearcompumethod import ScaleLinearCompuMethod
+from .compumethods.scaleratfunccompumethod import ScaleRatFuncCompuMethod
 from .compumethods.texttablecompumethod import TexttableCompuMethod
 from .dataobjectproperty import DataObjectProperty
+from .dtcdop import DtcDop
+from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
-from .odxtypes import DataType
+from .exceptions import odxrequire
+from .multiplexer import Multiplexer
 from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.matchingrequestparameter import MatchingRequestParameter
+from .parameters.nrcconstparameter import NrcConstParameter
 from .parameters.parameter import Parameter
 from .parameters.parameterwithdop import ParameterWithDOP
 from .parameters.reservedparameter import ReservedParameter
+from .parameters.systemparameter import SystemParameter
+from .parameters.tablekeyparameter import TableKeyParameter
+from .parameters.tablestructparameter import TableStructParameter
+from .paramlengthinfotype import ParamLengthInfoType
+from .staticfield import StaticField
 
 
-def parameter_info(param_list: Iterable[Union[Parameter, EndOfPduField]]) -> str:
-    result = ""
+def _get_linear_segment_info(segment: LinearSegment) -> str:
+    ll = segment.physical_lower_limit
+    if ll is None or ll.interval_type == IntervalType.INFINITE:
+        ll_str = "(-inf"
+    else:
+        ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
+        ll_str = f"{ll_delim}{ll._value!r}"
+
+    ul = segment.physical_upper_limit
+    if ul is None or ul.interval_type == IntervalType.INFINITE:
+        ul_str = "inf)"
+    else:
+        ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
+        ul_str = f"{ul._value!r}{ul_delim}"
+
+    return f"{ll_str}, {ul_str}"
+
+
+def _get_rat_func_segment_info(segment: RatFuncSegment) -> str:
+    ll = segment.lower_limit
+    if ll is None or ll.interval_type == IntervalType.INFINITE:
+        ll_str = "(-inf"
+    else:
+        ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
+        ll_str = f"{ll_delim}{ll._value!r}"
+
+    ul = segment.upper_limit
+    if ul is None or ul.interval_type == IntervalType.INFINITE:
+        ul_str = "inf)"
+    else:
+        ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
+        ul_str = f"{ul._value!r}{ul_delim}"
+
+    return f"{ll_str}, {ul_str}"
+
+
+def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False) -> str:
+    q = "'" if quoted_names else ""
+    of = StringIO()
     for param in param_list:
         if isinstance(param, CodedConstParameter):
-            result += f"{param.short_name} : const = {param._coded_value_str}\n"
+            of.write(f"{q}{param.short_name}{q}: const = {param._coded_value_str}\n")
             continue
         elif isinstance(param, MatchingRequestParameter):
-            result += f"{param.short_name} : <matches request>\n"
+            of.write(f"{q}{param.short_name}{q}: <matches request>\n")
+            continue
+        elif isinstance(param, NrcConstParameter):
+            of.write(f"{q}{param.short_name}{q}: const; choices = {param.coded_values}\n")
             continue
         elif isinstance(param, ReservedParameter):
-            result += f"{param.short_name} : <reserved>\n"
+            of.write(f"{q}{param.short_name}{q}: <reserved>\n")
             continue
-        elif not isinstance(param, ParameterWithDOP):
-            result += f"{param.short_name} : <unhandled parameter type>\n"
+        elif isinstance(param, SystemParameter):
+            of.write(
+                f"{q}{param.short_name}{q}: <system; kind = \"{param.sysparam}\">; required = {param.is_required}\n"
+            )
             continue
+        elif isinstance(param, TableKeyParameter):
+            of.write(
+                f"{q}{param.short_name}{q}: <optional> table key; table = '{param.table.short_name}'; choices:\n"
+            )
+            for tr in param.table.table_rows:
+                of.write(f"  '{tr.short_name}',\n")
 
-        dop = param.dop
-
-        if isinstance(dop, EndOfPduField):
-            result += f"{param.short_name} : <optional> list({{\n"
-            tmp = parameter_info(dop.structure.parameters).strip()
-            tmp = re.sub("^", "  ", tmp)
-            result += tmp + "\n"
-            result += f"}})\n"
             continue
+        elif isinstance(param, TableStructParameter):
+            of.write(
+                f"{q}{param.short_name}{q}: table struct; key = '{param.table_key.short_name}'; choices:\n"
+            )
+            for tr in param.table_key.table.table_rows:
+                of.write(f"  ('{tr.short_name}',\n")
+                of.write(f"   {{\n")
+                of.write(
+                    textwrap.indent(
+                        parameter_info(odxrequire(tr.structure).parameters, True), "    "))
+                of.write(f"   }}),\n")
 
-        result += f"{param.short_name}"
+            continue
+        elif not isinstance(param, ParameterWithDOP):
+            of.write(
+                f"{q}{param.short_name}{q}: <unhandled parameter type '{type(param).__name__}'>\n")
+            continue
 
+        dop = param.dop
         if dop is None:
-            result += ": <no DOP>\n"
+            of.write("{q}{param.short_name}{q}: <no DOP>\n")
             continue
-        elif not isinstance(dop, DataObjectProperty):
-            result += ": <unhandled DOP>\n"
+        elif isinstance(dop, EndOfPduField):
+            of.write(f"{q}{param.short_name}{q}: list({{\n")
+            of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
+            of.write(f"}})\n")
             continue
-
-        if (cm := dop.compu_method) is None:
-            result += ": <no compu method>\n"
+        elif isinstance(dop, StaticField):
+            of.write(f"{q}{param.short_name}{q}: length={dop.fixed_number_of_items}; list({{\n")
+            of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
+            of.write(f"}})\n")
+            continue
+        elif isinstance(dop, DynamicLengthField):
+            of.write(f"{q}{param.short_name}{q}: list({{\n")
+            of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
+            of.write(f"}})\n")
             continue
+        elif isinstance(dop, ParamLengthInfoType):
+            of.write(f"{q}{param.short_name}{q}: ")
+            of.write("<optional> ")
+            of.write(f"int; length_key='{dop.length_key.short_name}'\n")
+            continue
+        elif isinstance(dop, DtcDop):
+            of.write(f"{q}{param.short_name}{q}: ")
+            of.write(f"DTC; choices:\n")
+            for dtc in dop.dtcs:
+                if dtc.display_trouble_code is not None:
+                    dtc_desc = dtc.text and f"; \"{dtc.text}\""
+                    of.write(
+                        f"  '{dtc.display_trouble_code}' (0x{dtc.trouble_code:06x}{dtc_desc})\n")
+                else:
+                    dtc_desc = dtc.text and f" (\"{dtc.text}\")"
+                    of.write(f"  0x{dtc.trouble_code:06x}{dtc_desc}\n")
+            continue
+        elif isinstance(dop, Multiplexer):
+            of.write(f"{q}{param.short_name}{q}: ")
+            if dop.default_case is not None:
+                of.write(f"<optional>")
+            of.write(f"multiplexer; choices:\n")
+            for mux_case in dop.cases:
+                of.write(f"  ({repr(mux_case.short_name)}, {{\n")
+                if (struc := mux_case.structure) is not None:
+                    of.write(textwrap.indent(parameter_info(struc.parameters, True), "    "))
+                of.write(f"   }})\n")
+            continue
+        elif isinstance(dop, DataObjectProperty):
+            # a "simple" DOP
+            if (cm := dop.compu_method) is None:
+                of.write(f"{q}{param.short_name}{q}: <no compu method>\n")
+                continue
 
-        if isinstance(cm, TexttableCompuMethod):
-            result += f": enum; choices:\n"
-            for scale in cm.internal_to_phys:
-                result += f"  '{str(scale.compu_const)}'\n"
-
-        elif isinstance(cm, IdenticalCompuMethod):
-            bdt = dop.physical_type.base_data_type
-            if bdt in (DataType.A_UTF8STRING, DataType.A_UNICODE2STRING, DataType.A_ASCIISTRING):
-                result += f": str"
-            elif bdt in (DataType.A_BYTEFIELD,):
-                result += f": bytes"
-            elif bdt.name.startswith("A_FLOAT"):
-                result += f": float"
-            elif bdt.name.startswith("A_UINT"):
-                result += f": uint"
-            elif bdt.name.startswith("A_INT"):
-                result += f": int"
-            else:
-                result += f": <unknown type>"
+            if isinstance(cm, TexttableCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: enum; choices:\n")
+                for scale in odxrequire(cm.compu_internal_to_phys).compu_scales:
+                    val_str = ""
+                    if scale.lower_limit is not None:
+                        val_str = f"({repr(scale.lower_limit.value)})"
+
+                    if scale.compu_const is None:
+                        of.write(f"  <ERROR in ODX data: no value specified>\n")
+                    else:
+                        vt = scale.compu_const.vt
+                        v = scale.compu_const.v
+                        if vt is not None:
+                            of.write(f"  \"{vt}\" {val_str}\n")
+                        else:
+                            of.write(f"  {v}\n")
+
+            elif isinstance(cm, IdenticalCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}\n")
+
+            elif isinstance(cm, ScaleLinearCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                seg_list = [_get_linear_segment_info(x) for x in cm.segments]
+                of.write(f"; ranges = {{ {', '.join(seg_list)} }}")
+
+                unit = dop.unit
+                unit_str = unit.display_name if unit is not None else None
+                if unit_str is not None:
+                    of.write(f"; unit: {unit_str}")
+
+                of.write("\n")
 
-            if (bl := dop.get_static_bit_length()) is not None:
-                result += f"{bl}"
+            elif isinstance(cm, LinearCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                of.write(f"; range: {_get_linear_segment_info(cm.segment)}")
 
-            result += "\n"
+                unit = dop.unit
+                unit_str = unit.display_name if unit is not None else None
+                if unit_str is not None:
+                    of.write(f"; unit: {unit_str}")
 
-        elif isinstance(cm, LinearCompuMethod):
-            result += f": float\n"
-            ll = cm.physical_lower_limit
-            ul = cm.physical_upper_limit
-            result += (f" range: "
-                       f"{'[' if ll.interval_type == IntervalType.CLOSED else '('}"
-                       f"{ll.value!r}, "
-                       f"{ul.value!r}"
-                       f"{']' if ul.interval_type == IntervalType.CLOSED else ')'}\n")
+                of.write("\n")
 
-            unit = dop.unit
-            unit_str = unit.display_name if unit is not None else None
-            if unit_str is not None:
-                result += f" unit: {unit_str}\n"
+            elif isinstance(cm, ScaleRatFuncCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                if cm._phys_to_int_segments is None:
+                    of.write("<NOT ENCODABLE>")
+                else:
+                    seg_list = [_get_rat_func_segment_info(x) for x in cm._phys_to_int_segments]
+                    of.write(f"; ranges = {{ {', '.join(seg_list)} }}")
+
+                    unit = dop.unit
+                    unit_str = unit.display_name if unit is not None else None
+                    if unit_str is not None:
+                        of.write(f"; unit: {unit_str}")
+
+                    of.write("\n")
+
+            elif isinstance(cm, RatFuncCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                if cm._phys_to_int_segment is None:
+                    of.write("<NOT ENCODABLE>")
+                else:
+                    of.write(f"; range: {_get_rat_func_segment_info(cm._phys_to_int_segment)}")
+
+                    unit = dop.unit
+                    unit_str = unit.display_name if unit is not None else None
+                    if unit_str is not None:
+                        of.write(f"; unit: {unit_str}")
+
+                of.write("\n")
+
+            elif isinstance(cm, CompuCodeCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                of.write(f"; <programmatic translation>")
+
+                of.write("\n")
+
+            else:
+                of.write(
+                    f"{q}{param.short_name}{q}: unknown compu method {type(dop.compu_method).__name__}\n"
+                )
+        else:
+            of.write(f"{q}{param.short_name}{q}: <unhandled DOP '{type(dop).__name__}'>\n")
 
-    return result
+    return of.getvalue()

odxtools/parameters/codedconstparameter.py

@@ -1,19 +1,21 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
 
+from typing_extensions import override
+
+from ..createanydiagcodedtype import create_any_diag_coded_type_from_et
 from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError
-from ..odxlink import OdxLinkDatabase, OdxLinkId
-from ..odxtypes import AtomicOdxType, DataType
+from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkId
+from ..odxtypes import AtomicOdxType, DataType, ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class CodedConstParameter(Parameter):
@@ -21,10 +23,27 @@ class CodedConstParameter(Parameter):
     diag_coded_type: DiagCodedType
     coded_value: AtomicOdxType
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "CodedConstParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
+        diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, doc_frags)
+        coded_value = diag_coded_type.base_data_type.from_string(
+            odxrequire(et_element.findtext("CODED-VALUE")))
+
+        return CodedConstParameter(
+            diag_coded_type=diag_coded_type, coded_value=coded_value, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "CODED-CONST"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -32,12 +51,7 @@ class CodedConstParameter(Parameter):
 
         return result
 
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
-
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
 
@@ -46,32 +60,33 @@ class CodedConstParameter(Parameter):
         return self.diag_coded_type.base_data_type
 
     @property
+    @override
     def is_required(self) -> bool:
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         return False
 
-    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}"
-                            " and thus can not be changed.")
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        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) -> AtomicOdxType:
-        # Extract coded values
-        orig_cursor_pos = decode_state.cursor_byte_position
-        if self.byte_position is not None:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
-
-        decode_state.cursor_bit_position = self.bit_position or 0
+    @override
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        if physical_value is not None and physical_value != self.coded_value:
+            odxraise(
+                f"Value for constant parameter `{self.short_name}` name can "
+                f"only be specified as {self.coded_value!r} (is: {physical_value!r})", EncodeError)
+
+        internal_value = self.coded_value
+
+        self.diag_coded_type.encode_into_pdu(
+            internal_value=internal_value, encode_state=encode_state)
+
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         coded_val = self.diag_coded_type.decode_from_pdu(decode_state)
 
-        # Check if the coded value in the message is correct.
+        # Check if the coded value contained by the message is correct.
         if self.coded_value != coded_val:
             warnings.warn(
                 f"Coded constant parameter does not match! "
@@ -83,8 +98,6 @@ class CodedConstParameter(Parameter):
                 stacklevel=1,
             )
 
-        decode_state.cursor_byte_position = max(orig_cursor_pos, decode_state.cursor_byte_position)
-
         return coded_val
 
     @property