odxtools 7.2.0__py3-none-any.whl → 7.4.0__py3-none-any.whl

odxtools/dyndefinedspec.py

@@ -0,0 +1,179 @@
+# 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] = {}
+
+        result.update(self._build_odxlinks())
+
+        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/encodestate.py

@@ -1,16 +1,19 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass, field
-from typing import Dict, Optional, SupportsBytes
+from typing import TYPE_CHECKING, Dict, List, Optional, SupportsBytes, Tuple
 
 from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
-from .odxtypes import AtomicOdxType, DataType
+from .odxtypes import AtomicOdxType, DataType, ParameterValue
 
 try:
     import bitstruct.c as bitstruct
 except ImportError:
     import bitstruct
 
+if TYPE_CHECKING:
+    from .parameters.parameter import Parameter
+
 
 @dataclass
 class EncodeState:
@@ -56,6 +59,15 @@ class EncodeState:
     #: (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

odxtools/environmentdatadescription.py

@@ -1,17 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
 
 from .complexdop import ComplexDop
 from .decodestate import DecodeState
+from .dtcdop import DtcDop
 from .encodestate import EncodeState
 from .environmentdata import EnvironmentData
 from .exceptions import odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .odxtypes import ParameterValue
+from .odxtypes import ParameterValue, ParameterValueDict
+from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
@@ -27,16 +29,26 @@ class EnvironmentDataDescription(ComplexDop):
 
     """
 
+    param_snref: Optional[str]
+    param_snpathref: Optional[str]
+
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not
     # present
     env_datas: List[EnvironmentData]
     env_data_refs: List[OdxLinkRef]
-    param_snref: Optional[str]
-    param_snpathref: Optional[str]
 
-    def __post_init__(self) -> None:
-        self.bit_length = None
+    @property
+    def param(self) -> Parameter:
+        # the parameter referenced via SNREF cannot be resolved here
+        # because the relevant list of parameters depends on the
+        # concrete codec object processed, whilst an environment data
+        # description object can be featured in an arbitrary number of
+        # responses. Instead, lookup of the appropriate parameter is
+        # done within the encode and decode methods.
+        odxraise("The parameter of ENV-DATA-DESC objects cannot be resolved "
+                 "because it depends on the context")
+        return cast(None, Parameter)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -71,8 +83,9 @@ class EnvironmentDataDescription(ComplexDop):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
-        for ed in self.env_datas:
-            odxlinks.update(ed._build_odxlinks())
+        if not self.env_data_refs:
+            for ed in self.env_datas:
+                odxlinks.update(ed._build_odxlinks())
 
         return odxlinks
 
@@ -96,17 +109,125 @@ class EnvironmentDataDescription(ComplexDop):
     def encode_into_pdu(self, physical_value: Optional[ParameterValue],
                         encode_state: EncodeState) -> None:
         """Convert a physical value into bytes and emplace them into a PDU.
-
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an EncodeError exception.
         """
-        odxraise("EnvironmentDataDescription DOPs cannot be encoded or decoded")
+
+        # retrieve the relevant DTC parameter which must be located in
+        # front of the environment data description.
+        if self.param_snref is None:
+            odxraise("Specifying the DTC parameter for environment data "
+                     "descriptions via SNPATHREF is not supported yet")
+            return None
+
+        dtc_param: Optional[Parameter] = None
+        dtc_dop: Optional[DtcDop] = None
+        dtc_param_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(encode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                dtc_param = prev_param
+                prev_dop = getattr(prev_param, "dop", None)
+                if not isinstance(prev_dop, DtcDop):
+                    odxraise(f"The DOP of the parameter referenced by environment data "
+                             f"descriptions must be a DTC-DOP (is '{type(prev_dop).__name__}')")
+                    return
+                dtc_dop = prev_dop
+                dtc_param_value = prev_param_value
+                break
+
+        if dtc_param is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced value parameter.")
+            return
+
+        if dtc_param_value is None or dtc_dop is None:
+            # this should never happen
+            odxraise()
+            return
+
+        numerical_dtc = dtc_dop.convert_to_numerical_trouble_code(dtc_param_value)
+
+        # deal with the "all value" environment data. This holds
+        # parameters that are common to all DTCs. Be aware that the
+        # specification mandates that there is at most one such
+        # environment data object
+        for env_data in self.env_datas:
+            if env_data.all_value:
+                tmp = encode_state.allow_unknown_parameters
+                encode_state.allow_unknown_parameters = True
+                env_data.encode_into_pdu(physical_value, encode_state)
+                encode_state.allow_unknown_parameters = tmp
+                break
+
+        # find the environment data corresponding to the given trouble
+        # code
+        for env_data in self.env_datas:
+            if numerical_dtc in env_data.dtc_values:
+                tmp = encode_state.allow_unknown_parameters
+                encode_state.allow_unknown_parameters = True
+                env_data.encode_into_pdu(physical_value, encode_state)
+                encode_state.allow_unknown_parameters = tmp
+                break
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         """Extract the bytes from a PDU and convert them to a physical value.
-
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an DecodeError exception.
         """
-        odxraise("EnvironmentDataDescription DOPs cannot be encoded or decoded")
+
+        # retrieve the relevant DTC parameter which must be located in
+        # front of the environment data description.
+        if self.param_snref is None:
+            odxraise("Specifying the DTC parameter for environment data "
+                     "descriptions via SNPATHREF is not supported yet")
+            return None
+
+        dtc_param: Optional[Parameter] = None
+        dtc_dop: Optional[DtcDop] = None
+        dtc_param_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(decode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                dtc_param = prev_param
+                prev_dop = getattr(prev_param, "dop", None)
+                if not isinstance(prev_dop, DtcDop):
+                    odxraise(f"The DOP of the parameter referenced by environment data "
+                             f"descriptions must be a DTC-DOP (is '{type(prev_dop).__name__}')")
+                    return
+                dtc_dop = prev_dop
+                dtc_param_value = prev_param_value
+                break
+
+        if dtc_param is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced value parameter.")
+            return
+
+        if dtc_param_value is None or dtc_dop is None:
+            # this should never happen
+            odxraise()
+            return
+
+        numerical_dtc = dtc_dop.convert_to_numerical_trouble_code(dtc_param_value)
+
+        result: ParameterValueDict = {}
+
+        # deal with the "all value" environment data. This holds
+        # parameters that are common to all DTCs. Be aware that the
+        # specification mandates that there is at most one such
+        # environment data object
+        for env_data in self.env_datas:
+            if env_data.all_value:
+                tmp = env_data.decode_from_pdu(decode_state)
+                if not isinstance(tmp, dict):
+                    odxraise()
+                result.update(tmp)
+                break
+
+        # find the environment data corresponding to the given trouble
+        # code
+        for env_data in self.env_datas:
+            if numerical_dtc in env_data.dtc_values:
+                tmp = env_data.decode_from_pdu(decode_state)
+                if not isinstance(tmp, dict):
+                    odxraise()
+                result.update(tmp)
+                break
+
+        return result

odxtools/exceptions.py

@@ -9,13 +9,22 @@ class OdxError(Exception):
 
 
 class EncodeError(Warning, OdxError):
-    """Encoding of a message to raw data failed."""
+    """Encoding of a message to raw data failed"""
 
 
 class DecodeError(Warning, OdxError):
     """Decoding raw data failed."""
 
 
+class DecodeMismatch(DecodeError):
+    """Decoding failed because some parameters exhibit an incorrect value
+
+    This is can happen if NRC-CONST or environment data descriptions
+    are present.
+
+    """
+
+
 class OdxWarning(Warning):
     """Any warning that happens during interacting with diagnostic objects."""
 

odxtools/multiplexer.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,7 +8,7 @@ from typing_extensions import override
 from .complexdop import ComplexDop
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .multiplexercase import MultiplexerCase
 from .multiplexerdefaultcase import MultiplexerDefaultCase
 from .multiplexerswitchkey import MultiplexerSwitchKey
@@ -79,87 +79,123 @@ class Multiplexer(ComplexDop):
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
 
         if encode_state.cursor_bit_position != 0:
-            raise EncodeError(f"Multiplexer must be aligned, i.e. bit_position=0, but "
+            raise EncodeError(f"Multiplexer parameters must be aligned, i.e. bit_position=0, but "
                               f"{self.short_name} was passed the bit position "
                               f"{encode_state.cursor_bit_position}")
 
-        if not isinstance(physical_value, dict) or len(physical_value) != 1:
-            raise EncodeError("""Multiplexer should be defined as a dict
-            with only one key equal to the desired case""")
-
         orig_origin = encode_state.origin_byte_position
-
         encode_state.origin_byte_position = encode_state.cursor_byte_position
 
-        case_name, case_value = next(iter(physical_value.items()))
-
-        for mux_case in self.cases or []:
-            if mux_case.short_name == case_name:
-                key_value, _ = self._get_case_limits(mux_case)
-
-                if self.switch_key.byte_position is not None:
-                    encode_state.cursor_byte_position = encode_state.origin_byte_position + self.switch_key.byte_position
-                encode_state.cursor_bit_position = self.switch_key.bit_position or 0
-
-                self.switch_key.dop.encode_into_pdu(
-                    physical_value=key_value, encode_state=encode_state)
-
-                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 = 0
-
-                if mux_case._structure is None:
-                    odxraise(f"Multiplexer case '{mux_case.short_name}' does not "
-                             f"reference a structure.")
-                    return
-
-                mux_case.structure.encode_into_pdu(
-                    physical_value=key_value, encode_state=encode_state)
-
-                encode_state.origin_byte_position = orig_origin
-                return
-
-        raise EncodeError(f"The case {case_name} is not found in Multiplexer {self.short_name}")
+        if isinstance(physical_value, (list, tuple)) and len(physical_value) == 2:
+            case_spec, case_value = physical_value
+        elif isinstance(physical_value, dict) and len(physical_value) == 1:
+            case_spec, case_value = next(iter(physical_value.items()))
+        else:
+            raise EncodeError(
+                f"Values of multiplexer parameters must be defined as a "
+                f"(case_name, content_value) tuple instead of as '{physical_value!r}'")
+
+        mux_case: Union[MultiplexerCase, MultiplexerDefaultCase]
+        if isinstance(case_spec, str):
+            applicable_cases = [x for x in self.cases if x.short_name == case_spec]
+            if len(applicable_cases) == 0:
+                raise EncodeError(
+                    f"Multiplexer {self.short_name} does not know any case called {case_spec}")
+
+            odxassert(len(applicable_cases) == 1)
+            mux_case = applicable_cases[0]
+            key_value, _ = self._get_case_limits(mux_case)
+        elif isinstance(case_spec, int):
+            applicable_cases = []
+            for x in self.cases:
+                lower, upper = cast(Tuple[int, int], self._get_case_limits(x))
+                if lower <= case_spec and case_spec <= upper:
+                    applicable_cases.append(x)
+
+            if len(applicable_cases) == 0:
+                if self.default_case is None:
+                    raise EncodeError(
+                        f"Multiplexer {self.short_name} does not know any case called {case_spec}")
+                mux_case = self.default_case
+                key_value = case_spec
+            else:
+                mux_case = applicable_cases[0]
+                key_value = case_spec
+        elif isinstance(case_spec, MultiplexerCase):
+            mux_case = case_spec
+            key_value, _ = self._get_case_limits(mux_case)
+        elif case_spec is None:
+            if self.default_case is None:
+                raise EncodeError(f"Multiplexer {self.short_name} does not define a default case")
+            key_value = 0
+        else:
+            raise EncodeError(f"Illegal case specification '{case_spec}' for "
+                              f"multiplexer {self.short_name}")
+
+        # the byte position of the switch key is relative to
+        # the multiplexer's position
+        encode_state.cursor_byte_position = encode_state.origin_byte_position + self.switch_key.byte_position
+        encode_state.cursor_bit_position = self.switch_key.bit_position or 0
+        self.switch_key.dop.encode_into_pdu(physical_value=key_value, encode_state=encode_state)
+        encode_state.cursor_bit_position = 0
+
+        if mux_case.structure is not None:
+            # the byte position of the content is specified by the
+            # BYTE-POSITION attribute of the multiplexer
+            encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
+            mux_case.structure.encode_into_pdu(physical_value=case_value, encode_state=encode_state)
+
+        encode_state.origin_byte_position = orig_origin
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-
-        # multiplexers are structures and thus the origin position
-        # must be moved to the start of the multiplexer
         orig_origin = decode_state.origin_byte_position
-        if self.byte_position is not None:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
+        # Decode the switch key. Its BYTE-POSITION is relative to the
+        # that of the multiplexer.
+        if self.switch_key.byte_position is not None:
+            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.switch_key.byte_position
+        decode_state.cursor_bit_position = self.switch_key.bit_position or 0
         key_value = self.switch_key.dop.decode_from_pdu(decode_state)
+        decode_state.cursor_bit_position = 0
 
         if not isinstance(key_value, int):
             odxraise(f"Multiplexer keys must be integers (is '{type(key_value).__name__}'"
                      f" for multiplexer '{self.short_name}')")
 
-        case_value: Optional[ParameterValue] = None
-        mux_case = None
-        for mux_case in self.cases or []:
+        # "If a matching CASE is found, the referenced STRUCTURE is
+        # analyzed at the BYTE-POSITION (child element of MUX)
+        # relatively to the byte position of the MUX."
+        decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
+
+        applicable_case: Optional[Union[MultiplexerCase, MultiplexerDefaultCase]] = None
+        for mux_case in self.cases:
             lower, upper = self._get_case_limits(mux_case)
             if lower <= key_value and key_value <= upper:  # type: ignore[operator]
-                if mux_case._structure:
-                    case_value = mux_case._structure.decode_from_pdu(decode_state)
+                applicable_case = mux_case
                 break
 
-        if case_value is None and self.default_case is not None:
-            if self.default_case._structure:
-                case_value = self.default_case._structure.decode_from_pdu(decode_state)
+        if applicable_case is None:
+            applicable_case = self.default_case
+
+        if applicable_case is None:
+            odxraise(
+                f"Cannot find an applicable case for value {key_value} in "
+                f"multiplexer {self.short_name}", DecodeError)
+            decode_state.origin_byte_position = orig_origin
+            return (None, None)
 
-        if mux_case is None or case_value is None:
-            odxraise(f"Failed to find a matching case in {self.short_name} for value {key_value!r}",
-                     DecodeError)
+        if applicable_case.structure is not None:
+            case_value = applicable_case.structure.decode_from_pdu(decode_state)
+        else:
+            case_value = {}
 
-        mux_value = (mux_case.short_name, case_value)
+        result = (applicable_case.short_name, case_value)
 
-        # go back to the original origin
         decode_state.origin_byte_position = orig_origin
 
-        return mux_value
+        return result
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]: