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

odxtools/parameters/nrcconstparameter.py

@@ -1,38 +1,65 @@
 # SPDX-License-Identifier: MIT
-import warnings
 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 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, EncodeError
-from ..odxlink import OdxLinkDatabase, OdxLinkId
-from ..odxtypes import AtomicOdxType, DataType
+from ..exceptions import DecodeMismatch, 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 NrcConstParameter(Parameter):
-    """A param of type NRC-CONST defines a set of values to be matched.
-
-    An NRC-CONST can only be used in a negative response.
-    Its encoding behaviour is similar to a VALUE parameter with a TEXTTABLE.
-    However, an NRC-CONST is used for matching a response (similar to a CODED-CONST).
+    """A parameter of type NRC-CONST defines a set of values to be
+    matched for a negative response object to apply
+
+    The behaviour of NRC-CONST parameters is similar to CODED-CONST
+    parameters in that they allow to specify which coding objects
+    apply to a binary string, but in contrast to CODED-CONST
+    parameters they allow to specify multiple values. Thus, the value
+    of a CODED-CONST parameter is usually set using an overlapping
+    VALUE parameter. Since NRC-CONST parameters can only be specified
+    for negative responses, they can thus be regarded as a multiplexer
+    mechanism that is specific to negative responses.
 
     See ASAM MCD-2 D (ODX), p. 77-79.
+
     """
 
     diag_coded_type: DiagCodedType
     coded_values: List[AtomicOdxType]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "NrcConstParameter":
+
+        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_values = [
+            diag_coded_type.base_data_type.from_string(odxrequire(val.text))
+            for val in et_element.iterfind("CODED-VALUES/CODED-VALUE")
+        ]
+
+        return NrcConstParameter(
+            diag_coded_type=diag_coded_type, coded_values=coded_values, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "NRC-CONST"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -40,12 +67,7 @@ class NrcConstParameter(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()
 
@@ -54,52 +76,52 @@ class NrcConstParameter(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:
-            if encode_state.parameter_values[self.short_name] not in self.coded_values:
-                raise EncodeError(f"The parameter '{self.short_name}' must have"
-                                  f" one of the constant values {self.coded_values}")
-            else:
-                coded_value = encode_state.parameter_values[self.short_name]
-        else:
-            # If the user does not select one, just select any.
-            # I think it does not matter ...
-            coded_value = self.coded_values[0]
-
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        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) -> AtomicOdxType:
-        orig_cursor = decode_state.cursor_byte_position
-        if self.byte_position is not None:
-            # Update cursor position
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
-
-        # Extract coded values
-        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:
+        # NRC-CONST parameters are not encoding any value on its
+        # own. instead, it is supposed to overlap with a value
+        # parameter.
+        if physical_value is not None:
+            odxraise("The value of NRC-CONST parameters cannot be set directly!", EncodeError)
+
+        # TODO (?): extract the parameter and check if it is one of
+        # the values of self.coded_values. if not, throw an
+        # EncodeMismatch exception! This is probably a bad idea
+        # because the parameter which determines the value of the
+        # NRC-CONST might possibly be specified after the NRC-CONST.
+
+        # move the cursor forward by the size of the parameter
+        bit_pos = encode_state.cursor_bit_position
+        bit_len = self.diag_coded_type.get_static_bit_length()
+
+        if bit_len is None:
+            odxraise("The diag coded type of NRC-CONST parameters must "
+                     "exhibit a static size")
+            return
+
+        encode_state.cursor_byte_position += (bit_pos + bit_len + 7) // 8
+        encode_state.cursor_bit_position = 0
+
+        encode_state.emplace_bytes(b'', self.short_name)
+
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
+        # Extract coded value
         coded_value = self.diag_coded_type.decode_from_pdu(decode_state)
 
         # Check if the coded value in the message is correct.
         if coded_value not in self.coded_values:
-            warnings.warn(
-                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.cursor_byte_position} "
-                f"in coded message {decode_state.coded_message.hex()}.",
-                DecodeError,
-                stacklevel=1,
-            )
-
-        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
+            raise DecodeMismatch(f"NRC-CONST parameter {self.short_name} does not apply")
 
         return coded_value
 

odxtools/parameters/parameter.py

@@ -1,17 +1,18 @@
 # SPDX-License-Identifier: MIT
-import abc
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import final, override
 
 from ..decodestate import DecodeState
 from ..element import NamedElement
 from ..encodestate import EncodeState
-from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
+from ..snrefcontext import SnRefContext
 from ..specialdatagroup import SpecialDataGroup
-
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
+from ..utils import dataclass_fields_asdict
 
 ParameterType = Literal[
     "CODED-CONST",
@@ -30,12 +31,49 @@ ParameterType = Literal[
 
 
 @dataclass
-class Parameter(NamedElement, abc.ABC):
+class Parameter(NamedElement):
+    """This class corresponds to POSITIONABLE-PARAM in the ODX
+    specification
+
+    All parameter classes must adhere to the `Codec` type protocol, so
+    `isinstance(param, Codec)` ought to be true.  Be aware that, even
+    though the ODX specification seems to make the distinction of
+    "positionable" and "normal" parameters, it does not define any
+    non-positionable parameter types.
+
+    """
+    oid: Optional[str]
     byte_position: Optional[int]
     bit_position: Optional[int]
     semantic: Optional[str]
     sdgs: List[SpecialDataGroup]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Parameter":
+
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        oid = et_element.get("OID")
+        semantic = et_element.get("SEMANTIC")
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
+
+        byte_position_str = et_element.findtext("BYTE-POSITION")
+        bit_position_str = et_element.findtext("BIT-POSITION")
+
+        byte_position = int(byte_position_str) if byte_position_str is not None else None
+        bit_position = int(bit_position_str) if bit_position_str is not None else None
+
+        return Parameter(
+            oid=oid,
+            byte_position=byte_position,
+            bit_position=bit_position,
+            semantic=semantic,
+            sdgs=sdgs,
+            **kwargs)
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {}
 
@@ -48,14 +86,14 @@ class Parameter(NamedElement, abc.ABC):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
     @property
-    @abc.abstractmethod
     def parameter_type(self) -> ParameterType:
-        pass
+        raise NotImplementedError(
+            ".parameter_type is not implemented by the concrete parameter class")
 
     def get_static_bit_length(self) -> Optional[int]:
         return None
@@ -70,7 +108,7 @@ class Parameter(NamedElement, abc.ABC):
         specified.
 
         """
-        raise NotImplementedError
+        raise NotImplementedError(".is_required is not implemented by the concrete parameter class")
 
     @property
     def is_settable(self) -> bool:
@@ -81,78 +119,64 @@ class Parameter(NamedElement, abc.ABC):
         have a default value are settable but not required to be
         specified.
         """
-        raise NotImplementedError
+        raise NotImplementedError(".is_settable is not implemented by the concrete parameter class")
 
-    @abc.abstractmethod
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        """Get the coded value of the parameter given the encode state.
-        Note that this method is called by `encode_into_pdu`.
-        """
-        pass
+    @final
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        """Convert a physical value into its encoded form and place it
+        into the PDU
+
+        Also, adapt the `encode_state` so that it points to where the
+        next parameter is located (if the next parameter does not
+        explicitly specify a position)
 
-    @abc.abstractmethod
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        """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
-        at this byte position and the function parameter `default_byte_position` is ignored.
-
-        If the parameter does not have a byte position and a byte position is passed,
-        the bytes are extracted at the byte position given by the argument `default_byte_position`.
-
-        If the parameter does not have a byte position and the argument `default_byte_position` is None,
-        this function throws a `DecodeError`.
-
-        Parameters
-        ----------
-        decode_state : DecodeState
-            The decoding state containing
-            * the byte message to be decoded
-            * the parameter values that are already decoded
-            * the next byte position that is used iff the parameter does not specify a byte position
-
-        Returns
-        -------
-        ParameterValuePair | List[ParameterValuePair]
-            the decoded parameter value (the type is defined by the DOP)
-        int
-            the next byte position after the extracted parameter
         """
-        pass
 
-    def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
-        """Encode the value of a parameter into a binary blob and return it
+        if self.byte_position is not None:
+            encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
+
+        encode_state.cursor_bit_position = self.bit_position or 0
+
+        self._encode_positioned_into_pdu(physical_value, encode_state)
 
-        If the byte position of the parameter is not defined,
-        the byte code is appended to the blob.
+        encode_state.cursor_bit_position = 0
 
-        Technical note for subclasses: The default implementation
-        tries to compute the coded value via
-        `self.get_coded_value_as_bytes(encoded_state)` and inserts it
-        into the PDU. Thus it usually suffices to overwrite
-        `get_coded_value_as_bytes()` instead of `encode_into_pdu()`.
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        """Method which actually encodes the parameter
 
-        Parameters:
-        ----------
-        encode_state: EncodeState, i.e. a named tuple with attributes
-            * coded_message: bytes, the message encoded so far
-            * parameter_values: List[ParameterValuePairs]
-            * triggering_coded_request: bytes
+        Its location is managed by `Parameter`."""
+        raise NotImplementedError(
+            f"Required method '_encode_positioned_into_pdu()' not implemented by "
+            f"child class {type(self).__name__}")
+
+    @final
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        """Retrieve the raw data for the parameter from the PDU and
+        convert it to its physical interpretation
 
-        Returns:
-        -------
-        bytes
-            the message's blob after adding the encoded parameter into it
+        Also, adapt the `encode_state` so that it points to where the
+        next parameter is located (if the next parameter does not
+        explicitly specify a position)
 
         """
-        msg_blob = encode_state.coded_message
-        param_blob = self.get_coded_value_as_bytes(encode_state)
 
         if self.byte_position is not None:
-            byte_position = self.byte_position
-        else:
-            byte_position = len(msg_blob)
+            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
+
+        decode_state.cursor_bit_position = self.bit_position or 0
+
+        result = self._decode_positioned_from_pdu(decode_state)
+
+        decode_state.cursor_bit_position = 0
+
+        return result
 
-        encode_state.emplace_atomic_value(param_blob, self.short_name, byte_position)
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        """Method which actually decodes the parameter
 
-        return encode_state.coded_message
+        Its location is managed by `Parameter`."""
+        raise NotImplementedError(
+            f"Required method '_decode_positioned_from_pdu()' not implemented by "
+            f"child class {type(self).__name__}")

odxtools/parameters/parameterwithdop.py

@@ -1,6 +1,9 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import Any, Dict, List, Optional, cast
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..dataobjectproperty import DataObjectProperty
 from ..decodestate import DecodeState
@@ -8,53 +11,65 @@ from ..dopbase import DopBase
 from ..dtcdop import DtcDop
 from ..encodestate import EncodeState
 from ..exceptions import odxassert, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from ..odxtypes import ParameterValue
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..odxtypes import AtomicOdxType, ParameterValue
 from ..physicaltype import PhysicalType
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class ParameterWithDOP(Parameter):
     dop_ref: Optional[OdxLinkRef]
     dop_snref: Optional[str]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "ParameterWithDOP":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        dop_ref = OdxLinkRef.from_et(et_element.find("DOP-REF"), doc_frags)
+        dop_snref = None
+        if (dop_snref_elem := et_element.find("DOP-SNREF")) is not None:
+            dop_snref = odxrequire(dop_snref_elem.get("SHORT-NAME"))
+
+        return ParameterWithDOP(dop_ref=dop_ref, dop_snref=dop_snref, **kwargs)
+
     def __post_init__(self) -> None:
         odxassert(self.dop_snref is not None or self.dop_ref is not None,
                   f"Param {self.short_name} without a DOP-(SN)REF should not exist!")
-        self._dop: Optional[DopBase] = None
+        self._dop: DopBase
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
         if self.dop_ref is not None:
             odxassert(self.dop_snref is None)
-            # TODO: do not do lenient resolves here. The problem is
-            # that currently not all kinds of DOPs are internalized
-            # (e.g., static and dynamic fields)
-            self._dop = odxlinks.resolve_lenient(self.dop_ref)
+            self._dop = odxlinks.resolve(self.dop_ref)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    @override
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         if self.dop_snref:
-            ddds = diag_layer.diag_data_dictionary_spec
-            self._dop = odxrequire(ddds.all_data_object_properties.get(self.dop_snref))
+            ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
+            self._dop = resolve_snref(self.dop_snref, ddds.all_data_object_properties, DopBase)
 
     @property
     def dop(self) -> DopBase:
-        """may be a DataObjectProperty, a Structure or None"""
+        """This is usually a DataObjectProperty or a Structure object"""
 
-        return odxrequire(
-            self._dop, "Specifying a data object property is mandatory but it "
-            "could not be resolved")
+        return self._dop
 
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         if self._dop is not None:
             return self._dop.get_static_bit_length()
@@ -68,23 +83,11 @@ class ParameterWithDOP(Parameter):
         else:
             return None
 
-    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) -> ParameterValue:
-        orig_cursor = 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
-
-        # Use DOP to decode
-        phys_val = self.dop.decode_from_pdu(decode_state)
-
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
+    @override
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        self.dop.encode_into_pdu(cast(AtomicOdxType, physical_value), encode_state)
 
-        return phys_val
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        return self.dop.decode_from_pdu(decode_state)

odxtools/parameters/physicalconstantparameter.py

@@ -1,37 +1,55 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..dataobjectproperty import DataObjectProperty
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError, odxraise, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class PhysicalConstantParameter(ParameterWithDOP):
 
     physical_constant_value_raw: str
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "PhysicalConstantParameter":
+
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+
+        physical_constant_value_raw = odxrequire(et_element.findtext("PHYS-CONSTANT-VALUE"))
+
+        return PhysicalConstantParameter(
+            physical_constant_value_raw=physical_constant_value_raw, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "PHYS-CONST"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
+    @override
     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 _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         dop = odxrequire(self.dop)
         if not isinstance(dop, DataObjectProperty):
@@ -44,28 +62,30 @@ class PhysicalConstantParameter(ParameterWithDOP):
         return self._physical_constant_value
 
     @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:
-        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):
-            raise TypeError(
-                f"The parameter '{self.short_name}' is constant {self.physical_constant_value!r}"
-                f" and thus can not be changed.")
+    @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.physical_constant_value:
+            odxraise(
+                f"Value for constant parameter `{self.short_name}` name can "
+                f"only be specified as {self.physical_constant_value!r} (is: {physical_value!r})",
+                EncodeError)
 
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return dop.convert_physical_to_bytes(
-            self.physical_constant_value, encode_state, bit_position=bit_position_int)
+        self.dop.encode_into_pdu(self.physical_constant_value, encode_state)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         # Decode value
-        phys_val = super().decode_from_pdu(decode_state)
+        phys_val = super()._decode_positioned_from_pdu(decode_state)
 
         # Check if decoded value matches expected value
         if phys_val != self.physical_constant_value:
@@ -75,4 +95,5 @@ class PhysicalConstantParameter(ParameterWithDOP):
                 f"{self.physical_constant_value!r} but got {phys_val!r} "
                 f"at byte position {decode_state.cursor_byte_position} "
                 f"in coded message {decode_state.coded_message.hex()}.", DecodeError)
+
         return phys_val