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

odxtools/dyndefinedspec.py

@@ -0,0 +1,177 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Union
+from xml.etree import ElementTree
+
+from .diagcomm import DiagClassType, DiagComm
+from .exceptions import odxraise, odxrequire
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+from .table import Table
+
+
+@dataclass
+class DynIdDefModeInfo:
+    def_mode: str
+
+    clear_dyn_def_message_ref: Optional[OdxLinkRef]
+    clear_dyn_def_message_snref: Optional[str]
+
+    read_dyn_def_message_ref: Optional[OdxLinkRef]
+    read_dyn_def_message_snref: Optional[str]
+
+    dyn_def_message_ref: Optional[OdxLinkRef]
+    dyn_def_message_snref: Optional[str]
+
+    supported_dyn_ids: List[bytes]
+    selection_table_refs: List[Union[OdxLinkRef, str]]
+
+    @property
+    def clear_dyn_def_message(self) -> DiagComm:
+        return self._clear_dyn_def_message
+
+    @property
+    def read_dyn_def_message(self) -> DiagComm:
+        return self._read_dyn_def_message
+
+    @property
+    def dyn_def_message(self) -> DiagComm:
+        return self._dyn_def_message
+
+    @property
+    def selection_tables(self) -> NamedItemList[Table]:
+        return self._selection_tables
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynIdDefModeInfo":
+        def_mode = odxrequire(et_element.findtext("DEF-MODE"))
+
+        clear_dyn_def_message_ref = OdxLinkRef.from_et(
+            et_element.find("CLEAR-DYN-DEF-MESSAGE-REF"), doc_frags)
+        if (snref_elem := et_element.find("CLEAR-DYN-DEF-MESSAGE-SNREF")) is not None:
+            clear_dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+
+        read_dyn_def_message_ref = OdxLinkRef.from_et(
+            et_element.find("READ-DYN-DEF-MESSAGE-REF"), doc_frags)
+        if (snref_elem := et_element.find("READ-DYN-DEF-MESSAGE-SNREF")) is not None:
+            read_dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+
+        dyn_def_message_ref = OdxLinkRef.from_et(et_element.find("DYN-DEF-MESSAGE-REF"), doc_frags)
+        if (snref_elem := et_element.find("DYN-DEF-MESSAGE-SNREF")) is not None:
+            dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+
+        supported_dyn_ids = [
+            bytes.fromhex(odxrequire(x.text))
+            for x in et_element.iterfind("SUPPORTED-DYN-IDS/SUPPORTED-DYN-ID")
+        ]
+
+        selection_table_refs: List[Union[OdxLinkRef, str]] = []
+        if (st_elems := et_element.find("SELECTION-TABLE-REFS")) is not None:
+            for st_elem in st_elems:
+                if st_elem.tag == "SELECTION-TABLE-REF":
+                    selection_table_refs.append(OdxLinkRef.from_et(st_elem, doc_frags))
+                elif st_elem.tag == "SELECTION-TABLE-SNREF":
+                    selection_table_refs.append(odxrequire(st_elem.get("SHORT-NAME")))
+                else:
+                    odxraise()
+
+        return DynIdDefModeInfo(
+            def_mode=def_mode,
+            clear_dyn_def_message_ref=clear_dyn_def_message_ref,
+            clear_dyn_def_message_snref=clear_dyn_def_message_snref,
+            read_dyn_def_message_ref=read_dyn_def_message_ref,
+            read_dyn_def_message_snref=read_dyn_def_message_snref,
+            dyn_def_message_ref=dyn_def_message_ref,
+            dyn_def_message_snref=dyn_def_message_snref,
+            supported_dyn_ids=supported_dyn_ids,
+            selection_table_refs=selection_table_refs,
+        )
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result: Dict[OdxLinkId, Any] = {}
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._selection_tables = NamedItemList[Table]()
+
+        if self.clear_dyn_def_message_ref is not None:
+            self._clear_dyn_def_message = odxlinks.resolve(self.clear_dyn_def_message_ref, DiagComm)
+
+        if self.read_dyn_def_message_ref is not None:
+            self._read_dyn_def_message = odxlinks.resolve(self.read_dyn_def_message_ref, DiagComm)
+
+        if self.dyn_def_message_ref is not None:
+            self._dyn_def_message = odxlinks.resolve(self.dyn_def_message_ref, DiagComm)
+
+        # resolve the selection tables referenced using ODXLINK
+        for x in self.selection_table_refs:
+            if isinstance(x, OdxLinkRef):
+                self._selection_tables.append(odxlinks.resolve(x, Table))
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        diag_layer = odxrequire(context.diag_layer)
+
+        if self.clear_dyn_def_message_snref is not None:
+            self._clear_dyn_def_message = resolve_snref(self.clear_dyn_def_message_snref,
+                                                        diag_layer.diag_comms, DiagComm)
+
+        if self.read_dyn_def_message_snref is not None:
+            self._read_dyn_def_message = resolve_snref(self.read_dyn_def_message_snref,
+                                                       diag_layer.diag_comms, DiagComm)
+
+        if self.dyn_def_message_snref is not None:
+            self._dyn_def_message = resolve_snref(self.dyn_def_message_snref, diag_layer.diag_comms,
+                                                  DiagComm)
+
+        if self._clear_dyn_def_message.diagnostic_class != DiagClassType.CLEAR_DYN_DEF_MESSAGE:
+            odxraise(
+                f"Diagnostic communication object of wrong type referenced: "
+                f"({odxrequire(self._clear_dyn_def_message.diagnostic_class).value} instead of "
+                f"CLEAR-DYN-DEF-MESSAGE)")
+        if self._read_dyn_def_message.diagnostic_class != DiagClassType.READ_DYN_DEFINED_MESSAGE:
+            odxraise(f"Diagnostic communication object of wrong type referenced: "
+                     f"({odxrequire(self._read_dyn_def_message.diagnostic_class).value} instead of "
+                     f"READ-DYN-DEFINED-MESSAGE)")
+        if self._dyn_def_message.diagnostic_class != DiagClassType.DYN_DEF_MESSAGE:
+            odxraise(f"Diagnostic communication object of wrong type referenced: "
+                     f"({odxrequire(self._dyn_def_message.diagnostic_class).value} instead of "
+                     f"DYN-DEF-MESSAGE)")
+
+        # resolve the remaining selection tables that are referenced via SNREF
+        for i, x in enumerate(self.selection_table_refs):
+            if isinstance(x, str):
+                ddd_spec = odxrequire(diag_layer.diag_data_dictionary_spec)
+                self._selection_tables.insert(i, resolve_snref(x, ddd_spec.tables, Table))
+
+
+@dataclass
+class DynDefinedSpec:
+    dyn_id_def_mode_infos: List[DynIdDefModeInfo]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynDefinedSpec":
+        dyn_id_def_mode_infos = [
+            DynIdDefModeInfo.from_et(x, doc_frags)
+            for x in et_element.iterfind("DYN-ID-DEF-MODE-INFOS/DYN-ID-DEF-MODE-INFO")
+        ]
+        return DynDefinedSpec(dyn_id_def_mode_infos=dyn_id_def_mode_infos)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result: Dict[OdxLinkId, Any] = {}
+
+        for didmi in self.dyn_id_def_mode_infos:
+            result.update(didmi._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for didmi in self.dyn_id_def_mode_infos:
+            didmi._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for didmi in self.dyn_id_def_mode_infos:
+            didmi._resolve_snrefs(context)

odxtools/dynenddopref.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, overload
+from xml.etree import ElementTree
+
+from .exceptions import odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkRef
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class DynEndDopRef(OdxLinkRef):
+    termination_value_raw: str
+
+    @staticmethod
+    @overload
+    def from_et(et_element: None, source_doc_frags: List[OdxDocFragment]) -> None:
+        ...
+
+    @staticmethod
+    @overload
+    def from_et(et_element: ElementTree.Element,
+                source_doc_frags: List[OdxDocFragment]) -> "DynEndDopRef":
+        ...
+
+    @staticmethod
+    def from_et(et_element: Optional[ElementTree.Element],
+                source_doc_frags: List[OdxDocFragment]) -> Optional["DynEndDopRef"]:
+
+        if et_element is None:
+            odxraise("Mandatory DYN-END-DOP-REF tag is missing")
+            return None
+
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, source_doc_frags))
+
+        termination_value_raw = odxrequire(et_element.findtext("TERMINATION-VALUE"))
+
+        return DynEndDopRef(termination_value_raw=termination_value_raw, **kwargs)

odxtools/ecuvariantmatcher.py

@@ -2,10 +2,11 @@
 from enum import Enum
 from typing import Dict, Generator, List, Optional
 
-from .diaglayer import DiagLayer
-from .diaglayertype import DiagLayerType
+from .diaglayers.diaglayer import DiagLayer
+from .diaglayers.diaglayertype import DiagLayerType
+from .diaglayers.ecuvariant import EcuVariant
 from .diagservice import DiagService
-from .exceptions import OdxError, odxassert
+from .exceptions import OdxError, odxassert, odxrequire
 from .matchingparameter import MatchingParameter
 from .odxtypes import ParameterValue
 from .response import Response
@@ -42,9 +43,7 @@ class EcuVariantMatcher:
     @staticmethod
     def get_ident_service(diag_layer: DiagLayer, matching_param: MatchingParameter) -> DiagService:
         service_name = matching_param.diag_comm_snref
-        odxassert(service_name in [x.short_name for x in diag_layer.services])
-        service = diag_layer.services[service_name]
-        odxassert(isinstance(service, DiagService))
+        service = odxrequire(diag_layer.services.get(service_name))
         return service
 
     @staticmethod
@@ -89,7 +88,7 @@ class EcuVariantMatcher:
         raise OdxError(f"The snref or snpathref '{matching_param.out_param_if}' is cannot be \
                 resolved for any positive or negative response.")
 
-    def __init__(self, ecu_variant_candidates: List[DiagLayer], use_cache: bool = True):
+    def __init__(self, ecu_variant_candidates: List[EcuVariant], use_cache: bool = True):
 
         self.ecus = ecu_variant_candidates
         for ecu in self.ecus:

odxtools/element.py

@@ -2,42 +2,40 @@ from dataclasses import dataclass
 from typing import List, Optional
 from xml.etree import ElementTree
 
+from .description import Description
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkId
-from .utils import create_description_from_et, dataclass_fields_asdict
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
 class NamedElement:
     short_name: str
     long_name: Optional[str]
-    description: Optional[str]
+    description: Optional[Description]
 
     @staticmethod
-    def from_et(
-        et_element: ElementTree.Element,
-        doc_frags: List[OdxDocFragment],
-    ) -> "NamedElement":
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "NamedElement":
 
         return NamedElement(
             short_name=odxrequire(et_element.findtext("SHORT-NAME")),
             long_name=et_element.findtext("LONG-NAME"),
-            description=create_description_from_et(et_element.find("DESC")),
+            description=Description.from_et(et_element.find("DESC"), doc_frags),
         )
 
 
 @dataclass
 class IdentifiableElement(NamedElement):
     odx_id: OdxLinkId
+    oid: Optional[str]
 
     @staticmethod
-    def from_et(
-        et_element: ElementTree.Element,
-        doc_frags: List[OdxDocFragment],
-    ) -> "IdentifiableElement":
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "IdentifiableElement":
 
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
-        return IdentifiableElement(
-            **kwargs,
-            odx_id=odxrequire(OdxLinkId.from_et(et_element, doc_frags)),
-        )
+
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+        oid = et_element.get("OID")
+
+        return IdentifiableElement(**kwargs, odx_id=odx_id, oid=oid)

odxtools/encodestate.py

@@ -1,12 +1,18 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional, SupportsBytes, Tuple
 
-from .exceptions import OdxWarning
+from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
+from .odxtypes import AtomicOdxType, DataType, ParameterValue
+
+try:
+    import bitstruct.c as bitstruct
+except ImportError:
+    import bitstruct
 
 if TYPE_CHECKING:
-    from .tablerow import TableRow
+    from .parameters.parameter import Parameter
 
 
 @dataclass
@@ -15,10 +21,23 @@ class EncodeState:
     """
 
     #: payload that has been constructed so far
-    coded_message: bytearray
+    coded_message: bytearray = field(default_factory=bytearray)
+
+    #: the bits of the payload that are used
+    used_mask: bytearray = field(default_factory=bytearray)
+
+    #: The absolute position in bytes from the beginning of the PDU to
+    #: which relative positions refer to, e.g., the beginning of the
+    #: structure.
+    origin_byte_position: int = 0
+
+    #: The absolute position in bytes from the beginning of the PDU
+    #: where the next object ought to be placed into the PDU
+    cursor_byte_position: int = 0
 
-    #: a mapping from short name to value for each parameter
-    parameter_values: Dict[str, Any]
+    #: The bit position [0-7] where the next object ought to be
+    #: placed into the PDU
+    cursor_bit_position: int = 0
 
     #: If encoding a response: request that triggered the response
     triggering_request: Optional[bytes] = None
@@ -28,31 +47,189 @@ class EncodeState:
     length_keys: Dict[str, int] = field(default_factory=dict)
 
     #: Mapping from the short name of a table-key parameter to the
-    #: corresponding row of the table (specified by TableKeyParameter)
-    table_keys: Dict[str, "TableRow"] = field(default_factory=dict)
+    #: short name of the corresponding row of the table (specified by
+    #: TableKeyParameter)
+    table_keys: Dict[str, str] = field(default_factory=dict)
+
+    #: The cursor position where a given length- or table key is located
+    #: in the PDU
+    key_pos: Dict[str, int] = field(default_factory=dict)
 
     #: Flag whether we are currently the last parameter of the PDU
-    #: (needed for MinMaxLengthType)
-    is_end_of_pdu: bool = False
+    #: (needed for MinMaxLengthType, EndOfPduField, etc.)
+    is_end_of_pdu: bool = True
+
+    #: list of parameters that have been encoded so far. The journal
+    #: is used by some types of parameters which depend on the values of
+    #: other parameters; e.g., environment data description parameters
+    journal: List[Tuple["Parameter", Optional[ParameterValue]]] = field(default_factory=list)
+
+    #: If this is True, specifying unknown parameters for encoding
+    #: will raise an OdxError exception in strict mode.
+    allow_unknown_parameters = False
+
+    def __post_init__(self) -> None:
+        # if a coded message has been specified, but no used_mask, we
+        # assume that all of the bits of the coded message are
+        # currently used.
+        if len(self.coded_message) > len(self.used_mask):
+            self.used_mask += b'\xff' * (len(self.coded_message) - len(self.used_mask))
+        if len(self.coded_message) < len(self.used_mask):
+            odxraise(f"The specified bit mask 0x{self.used_mask.hex()} for used bits "
+                     f"is not suitable for representing the coded_message "
+                     f"0x{self.coded_message.hex()}")
+            self.used_mask = self.used_mask[:len(self.coded_message)]
+
+    def emplace_atomic_value(
+        self,
+        *,
+        internal_value: AtomicOdxType,
+        bit_length: int,
+        base_data_type: DataType,
+        is_highlow_byte_order: bool,
+        used_mask: Optional[bytes],
+    ) -> None:
+        """Convert the internal_value to bytes and emplace this into the PDU"""
+
+        raw_value: AtomicOdxType
+
+        # Check that bytes and strings actually fit into the bit length
+        if base_data_type == DataType.A_BYTEFIELD:
+            if not isinstance(internal_value, (bytes, bytearray, SupportsBytes)):
+                odxraise()
+            if 8 * len(internal_value) > bit_length:
+                raise EncodeError(f"The bytefield {internal_value.hex()} is too large "
+                                  f"({len(internal_value)} bytes)."
+                                  f" The maximum length is {bit_length//8}.")
+            raw_value = bytes(internal_value)
+        elif base_data_type == DataType.A_ASCIISTRING:
+            if not isinstance(internal_value, str):
+                odxraise()
+
+            # The spec says ASCII, meaning only byte values 0-127.
+            # But in practice, vendors use iso-8859-1, aka latin-1
+            # reason being iso-8859-1 never fails since it has a valid
+            # character mapping for every possible byte sequence.
+            raw_value = internal_value.encode("iso-8859-1")
+
+            if 8 * len(raw_value) > bit_length:
+                raise EncodeError(f"The string {repr(internal_value)} is too large."
+                                  f" The maximum number of characters is {bit_length//8}.")
+        elif base_data_type == DataType.A_UTF8STRING:
+            if not isinstance(internal_value, str):
+                odxraise()
+
+            raw_value = internal_value.encode("utf-8")
+
+            if 8 * len(raw_value) > bit_length:
+                raise EncodeError(f"The string {repr(internal_value)} is too large."
+                                  f" The maximum number of bytes is {bit_length//8}.")
 
-    def emplace_atomic_value(self,
-                             new_data: bytes,
-                             param_name: str,
-                             pos: Optional[int] = None) -> None:
-        if pos is None:
-            pos = len(self.coded_message)
+        elif base_data_type == DataType.A_UNICODE2STRING:
+            if not isinstance(internal_value, str):
+                odxraise()
+
+            text_encoding = "utf-16-be" if is_highlow_byte_order else "utf-16-le"
+            raw_value = internal_value.encode(text_encoding)
+
+            if 8 * len(raw_value) > bit_length:
+                raise EncodeError(f"The string {repr(internal_value)} is too large."
+                                  f" The maximum number of characters is {bit_length//16}.")
+        else:
+            raw_value = internal_value
+
+        # If the bit length is zero, return empty bytes
+        if bit_length == 0:
+            if (base_data_type.value in [
+                    DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
+            ] and base_data_type.value != 0):
+                odxraise(
+                    f"The number {repr(internal_value)} cannot be encoded into {bit_length} bits.",
+                    EncodeError)
+            self.emplace_bytes(b'')
+            return
+
+        char = base_data_type.bitstruct_format_letter
+        padding = (8 - ((bit_length + self.cursor_bit_position) % 8)) % 8
+        odxassert((0 <= padding and padding < 8 and
+                   (padding + bit_length + self.cursor_bit_position) % 8 == 0),
+                  f"Incorrect padding {padding}")
+        left_pad = f"p{padding}" if padding > 0 else ""
+
+        # actually encode the value
+        coded = bitstruct.pack(f"{left_pad}{char}{bit_length}", raw_value)
+
+        # create the raw mask of used bits for numeric objects
+        used_mask_raw = used_mask
+        if base_data_type in [DataType.A_INT32, DataType.A_UINT32
+                             ] and (self.cursor_bit_position != 0 or
+                                    (self.cursor_bit_position + bit_length) % 8 != 0):
+            if used_mask is None:
+                tmp = (1 << bit_length) - 1
+            else:
+                tmp = int.from_bytes(used_mask, "big")
+            tmp <<= self.cursor_bit_position
+
+            used_mask_raw = tmp.to_bytes((self.cursor_bit_position + bit_length + 7) // 8, "big")
+
+        # apply byte order to numeric objects
+        if not is_highlow_byte_order and base_data_type in [
+                DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
+        ]:
+            coded = coded[::-1]
+
+            if used_mask_raw is not None:
+                used_mask_raw = used_mask_raw[::-1]
+
+        self.cursor_bit_position = 0
+        self.emplace_bytes(coded, obj_used_mask=used_mask_raw)
+
+    def emplace_bytes(self,
+                      new_data: bytes,
+                      obj_name: Optional[str] = None,
+                      obj_used_mask: Optional[bytes] = None) -> None:
+        if self.cursor_bit_position != 0:
+            odxraise("EncodeState.emplace_bytes can only be called "
+                     "for a bit position of 0!", RuntimeError)
+
+        pos = self.cursor_byte_position
 
         # Make blob longer if necessary
         min_length = pos + len(new_data)
         if len(self.coded_message) < min_length:
-            self.coded_message.extend([0] * (min_length - len(self.coded_message)))
+            pad = b'\x00' * (min_length - len(self.coded_message))
+            self.coded_message += pad
+            self.used_mask += pad
+
+        if obj_used_mask is None:
+            # Happy path for when no obj_used_mask has been
+            # specified. In this case we assume that all bits of the
+            # new data to be emplaced are used.
+            n = len(new_data)
 
-        for byte_idx_val, byte_idx_rpc in enumerate(range(pos, pos + len(new_data))):
-            # insert byte value
-            if self.coded_message[byte_idx_rpc] & new_data[byte_idx_val] != 0:
+            if self.used_mask[pos:pos + n] != b'\x00' * n:
                 warnings.warn(
-                    f"Object '{param_name}' overlaps with another parameter (bytes are already set)",
+                    f"Overlapping objects detected in between bytes {pos} and "
+                    f"{pos+n}",
                     OdxWarning,
                     stacklevel=1,
                 )
-            self.coded_message[byte_idx_rpc] |= new_data[byte_idx_val]
+            self.coded_message[pos:pos + n] = new_data
+            self.used_mask[pos:pos + n] = b'\xff' * n
+        else:
+            # insert data the hard way, i.e. we have to look at each
+            # individual byte to determine if it has already been used
+            # somewhere else (it would be nice if bytearrays supported
+            # bitwise operations!)
+            for i in range(len(new_data)):
+                if self.used_mask[pos + i] & obj_used_mask[i] != 0:
+                    warnings.warn(
+                        f"Overlapping objects detected at position {pos + i}",
+                        OdxWarning,
+                        stacklevel=1,
+                    )
+                self.coded_message[pos + i] &= ~obj_used_mask[i]
+                self.coded_message[pos + i] |= new_data[i] & obj_used_mask[i]
+                self.used_mask[pos + i] |= obj_used_mask[i]
+
+        self.cursor_byte_position += len(new_data)

odxtools/endofpdufield.py

@@ -1,8 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List, Optional, Sequence
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .decodestate import DecodeState
 from .encodestate import EncodeState
 from .exceptions import EncodeError, odxassert, odxraise
@@ -39,30 +41,39 @@ class EndOfPduField(Field):
 
         return eopf
 
-    def convert_physical_to_bytes(
-        self,
-        physical_values: ParameterValue,
-        encode_state: EncodeState,
-        bit_position: int = 0,
-    ) -> bytes:
-
-        odxassert(
-            bit_position == 0, "End of PDU field must be byte aligned. "
-            "Is there an error in reading the .odx?", EncodeError)
-        if not isinstance(physical_values, list):
+    @override
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        odxassert(not encode_state.cursor_bit_position,
+                  "No bit position can be specified for end-of-pdu fields!")
+        odxassert(encode_state.is_end_of_pdu,
+                  "End-of-pdu fields can only be located at the end of PDUs!")
+
+        if not isinstance(physical_value, Sequence):
             odxraise(
-                f"Expected a list of values for end-of-pdu field {self.short_name}, "
-                f"got {type(physical_values)}", EncodeError)
+                f"Invalid type {type(physical_value).__name__} of physical "
+                f"value for end-of-pdu field, expected a list", EncodeError)
+            return
+
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
 
-        coded_message = b''
-        for value in physical_values:
-            coded_message += self.structure.convert_physical_to_bytes(value, encode_state)
-        return coded_message
+        for i, value in enumerate(physical_value):
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
 
+            self.structure.encode_into_pdu(value, encode_state)
+
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         odxassert(not decode_state.cursor_bit_position,
                   "No bit position can be specified for end-of-pdu fields!")
 
+        orig_origin = decode_state.origin_byte_position
+        decode_state.origin_byte_position = decode_state.cursor_byte_position
+
         result: List[ParameterValue] = []
         while decode_state.cursor_byte_position < len(decode_state.coded_message):
             # ATTENTION: the ODX specification is very misleading
@@ -71,4 +82,6 @@ class EndOfPduField(Field):
             # repeated are identical, not their values
             result.append(self.structure.decode_from_pdu(decode_state))
 
+        decode_state.origin_byte_position = orig_origin
+
         return result

odxtools/environmentdata.py

@@ -11,7 +11,14 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class EnvironmentData(BasicStructure):
-    """This class represents Environment Data that describes the circumstances in which the error occurred."""
+    """This class represents Environment Data that describes the
+    circumstances in which the error occurred.
+
+    This is one of the many multiplexer mechanisms specified by the
+    ODX standard, because an environment data parameter must only be
+    used if a DTC parameter has a certain set of values. (In this
+    sense, it is quite similar to NRC-CONST parameters.)
+    """
 
     all_value: Optional[bool]
     dtc_values: List[int]