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

odxtools/parameterinfo.py

@@ -1,105 +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 (bl := dop.get_static_bit_length()) is not None:
-                result += f"{bl}"
+                    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")
 
-            result += "\n"
+            elif isinstance(cm, IdenticalCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}\n")
 
-        elif isinstance(cm, LinearCompuMethod):
-            result += f": float\n"
-            ll = cm.physical_lower_limit
-            ul = cm.physical_upper_limit
-            if ll is None:
-                ll_str = "(inf"
-            else:
-                ll_delim = '[' if ll.interval_type == IntervalType.CLOSED else '('
-                ll_str = f"{ll_delim}{ll._value!r}"
+            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)} }}")
 
-            if ul is None:
-                ul_str = "inf)"
-            else:
-                ul_delim = ']' if ul.interval_type == IntervalType.CLOSED else ')'
-                ul_str = f"{ul._value!r}{ul_delim}"
-            result += f" range: {ll_str}, {ul_str}\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}")
+
+                of.write("\n")
+
+            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)}")
+
+                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")
 
-            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,7 +1,7 @@
 # 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
@@ -10,15 +10,12 @@ 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, odxrequire
-from ..odxlink import OdxDocFragment, 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):
@@ -54,14 +51,6 @@ class CodedConstParameter(Parameter):
 
         return result
 
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    @override
-    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()
@@ -81,20 +70,23 @@ class CodedConstParameter(Parameter):
         return False
 
     @override
-    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 _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! "

odxtools/parameters/dynamicparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -41,9 +41,10 @@ class DynamicParameter(Parameter):
         raise NotImplementedError(".is_settable for a DynamicParameter")
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        raise NotImplementedError("Encoding a DynamicParameter is not implemented yet.")
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        raise NotImplementedError("Encoding DynamicParameter is not implemented yet.")
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding a DynamicParameter is not implemented yet.")
+        raise NotImplementedError("Decoding DynamicParameter is not implemented yet.")

odxtools/parameters/lengthkeyparameter.py

@@ -1,22 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from typing_extensions import override
+from typing_extensions import final, override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..exceptions import EncodeError, odxraise, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class LengthKeyParameter(ParameterWithDOP):
@@ -55,14 +52,6 @@ class LengthKeyParameter(ParameterWithDOP):
 
         return result
 
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
-
     @property
     @override
     def is_required(self) -> bool:
@@ -77,17 +66,62 @@ class LengthKeyParameter(ParameterWithDOP):
         return True
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        physical_value = encode_state.parameter_values.get(self.short_name, 0)
-
-        bit_pos = self.bit_position or 0
-        dop = odxrequire(super().dop,
-                         f"A DOP is required for length key parameter {self.short_name}")
-        return dop.convert_physical_to_bytes(physical_value, encode_state, bit_position=bit_pos)
-
-    @override
-    def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
-        return super().encode_into_pdu(encode_state)
+    @final
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        # if you get this exception, you ought to use
+        # `.encode_placeholder_into_pdu()` followed by (after the
+        # value of the length key has been determined)
+        # `.encode_value_into_pdu()`.
+        raise RuntimeError("_encode_positioned_into_pdu() cannot be called for length keys.")
+
+    def encode_placeholder_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+
+        if physical_value is not None:
+            if not self.dop.is_valid_physical_value(physical_value):
+                odxraise(f"Invalid explicitly specified physical value '{physical_value!r}' "
+                         f"for length key '{self.short_name}'.")
+
+            lkv = encode_state.length_keys.get(self.short_name)
+            if lkv is not None and lkv != physical_value:
+                odxraise(f"Got conflicting values for length key {self.short_name}: "
+                         f"{lkv} and {physical_value!r}")
+
+            if not isinstance(physical_value, int):
+                odxraise(
+                    f"Value of length key {self.short_name} is of type {type(physical_value).__name__} "
+                    f"instead of int")
+
+            encode_state.length_keys[self.short_name] = physical_value
+
+        pos = encode_state.cursor_byte_position
+        if self.byte_position is not None:
+            pos = encode_state.origin_byte_position + self.byte_position
+        encode_state.key_pos[self.short_name] = pos
+        encode_state.cursor_byte_position = pos
+        encode_state.cursor_bit_position = self.bit_position or 0
+
+        # emplace a value of zero into the encode state, but pretend the bits not to be used
+        n = odxrequire(self.dop.get_static_bit_length()) + encode_state.cursor_bit_position
+        tmp_val = b'\x00' * ((n + 7) // 8)
+        encode_state.cursor_bit_position = 0
+        encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
+
+    def encode_value_into_pdu(self, encode_state: EncodeState) -> None:
+
+        if self.short_name not in encode_state.length_keys:
+            odxraise(
+                f"Length key {self.short_name} has not been defined before "
+                f"it is required.", EncodeError)
+            return
+        else:
+            physical_value = encode_state.length_keys[self.short_name]
+
+        encode_state.cursor_byte_position = encode_state.key_pos[self.short_name]
+        encode_state.cursor_bit_position = self.bit_position or 0
+
+        self.dop.encode_into_pdu(encode_state=encode_state, physical_value=physical_value)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/parameters/matchingrequestparameter.py

@@ -7,7 +7,7 @@ from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import EncodeError, odxrequire
+from ..exceptions import EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
@@ -52,19 +52,31 @@ class MatchingRequestParameter(Parameter):
         return False
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        if not encode_state.triggering_request:
-            raise EncodeError(f"Parameter '{self.short_name}' is of matching request type,"
-                              " but no original request has been specified.")
-        return encode_state.triggering_request[self
-                                               .request_byte_position:self.request_byte_position +
-                                               self.byte_length]
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        if encode_state.triggering_request is None:
+            odxraise(
+                f"Parameter '{self.short_name}' is of matching request type,"
+                f" but no original request has been specified.", EncodeError)
+            return
+
+        rq_pos = self.request_byte_position
+        rq_len = self.byte_length
+
+        if len(encode_state.triggering_request) < rq_pos + rq_len:
+            odxraise(
+                f"Specified triggering request 0x{encode_state.triggering_request.hex()} "
+                f"is not long enough to encode matching request parameter "
+                f"'{self.short_name}': Have {len(encode_state.triggering_request)} "
+                f"bytes, need at least {rq_pos + rq_len} bytes", EncodeError)
+            return
+
+        encode_state.emplace_bytes(encode_state.triggering_request[rq_pos:rq_pos + rq_len],
+                                   self.short_name)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        result = decode_state.extract_atomic_value(
+        return decode_state.extract_atomic_value(
             bit_length=self.byte_length * 8,
             base_data_type=DataType.A_UINT32,
             is_highlow_byte_order=False)
-
-        return result