odxtools 4.0.5__tar.gz → 4.1.0__tar.gz

{odxtools-4.0.5 → odxtools-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: odxtools
-Version: 4.0.5
+Version: 4.1.0
 Summary: Utilities to work with the automotive diagnostics standard ODX.
 Home-page: https://github.com/Daimler/odxtools
 Author: Katrin Bauer, Andreas Lauser

{odxtools-4.0.5 → odxtools-4.1.0}/examples/somersaultecu.py

@@ -34,7 +34,7 @@ from odxtools.nameditemlist import NamedItemList
 from odxtools.odxlink import OdxDocFragment, OdxLinkId, OdxLinkRef
 from odxtools.odxtypes import DataType
 from odxtools.parameters import (CodedConstParameter, MatchingRequestParameter, NrcConstParameter,
-                                 ValueParameter)
+                                 TableKeyParameter, TableStructParameter, ValueParameter)
 from odxtools.parentref import ParentRef
 from odxtools.physicaltype import PhysicalType
 from odxtools.service import DiagService
@@ -292,6 +292,15 @@ somersault_diagcodedtypes = {
             is_condensed_raw=None,
             is_highlow_byte_order_raw=None,
         ),
+    "float32":
+        StandardLengthType(
+            base_data_type="A_FLOAT32",
+            bit_length=32,
+            bit_mask=None,
+            is_condensed_raw=None,
+            is_highlow_byte_order_raw=None,
+            base_type_encoding=None,
+        ),
 }
 
 somersault_physical_dimensions = {
@@ -388,6 +397,8 @@ somersault_unit_groups = {
 somersault_compumethods = {
     "uint_passthrough":
         IdenticalCompuMethod(internal_type="A_UINT32", physical_type="A_UINT32"),
+    "float_passthrough":
+        IdenticalCompuMethod(internal_type="A_FLOAT32", physical_type="A_FLOAT32"),
     "boolean":
         TexttableCompuMethod(
             internal_type="A_UINT32",
@@ -505,8 +516,37 @@ somersault_dops = {
             is_visible_raw=None,
             sdgs=[],
         ),
+    "uint8":
+        DataObjectProperty(
+            odx_id=OdxLinkId("somersault.DOP.uint8", doc_frags),
+            short_name="uint8",
+            long_name=None,
+            description=None,
+            diag_coded_type=somersault_diagcodedtypes["uint8"],
+            physical_type=PhysicalType(DataType.A_UINT32, display_radix=None, precision=None),
+            compu_method=somersault_compumethods["uint_passthrough"],
+            unit_ref=None,
+            is_visible_raw=None,
+            sdgs=[],
+        ),
+    "float":
+        DataObjectProperty(
+            odx_id=OdxLinkId("somersault.DOP.float", doc_frags),
+            short_name="float",
+            long_name=None,
+            description=None,
+            diag_coded_type=somersault_diagcodedtypes["float32"],
+            physical_type=PhysicalType(DataType.A_FLOAT32, display_radix=None, precision=None),
+            compu_method=somersault_compumethods["float_passthrough"],
+            unit_ref=None,
+            is_visible_raw=None,
+            sdgs=[],
+        ),
 }
 
+last_flip_details_table_id = OdxLinkId("somersault.table.last_flip_details", doc_frags)
+last_flip_details_table_ref = OdxLinkRef.from_id(last_flip_details_table_id)
+
 # positive responses
 somersault_positive_responses = {
     "session":
@@ -702,15 +742,27 @@ somersault_positive_responses = {
                         bit_position=None,
                         sdgs=[],
                     ),
-                    # TODO (?): non-byte aligned MatchingRequestParameters
-                    MatchingRequestParameter(
+                    ValueParameter(
                         short_name="num_flips_done",
                         long_name=None,
                         semantic=None,
                         description=None,
-                        request_byte_position=3,
-                        byte_position=1,
-                        byte_length=1,
+                        physical_default_value_raw=None,
+                        dop_ref=OdxLinkRef("somersault.DOP.uint8", doc_frags),
+                        dop_snref=None,
+                        byte_position=None,
+                        bit_position=None,
+                        sdgs=[],
+                    ),
+                    ValueParameter(
+                        short_name="grumpiness_level",
+                        long_name=None,
+                        semantic=None,
+                        description=None,
+                        physical_default_value_raw=None,
+                        dop_ref=OdxLinkRef("somersault.DOP.uint8", doc_frags),
+                        dop_snref=None,
+                        byte_position=None,
                         bit_position=None,
                         sdgs=[],
                     ),
@@ -767,6 +819,33 @@ somersault_positive_responses = {
                         bit_position=None,
                         sdgs=[],
                     ),
+                    TableKeyParameter(
+                        odx_id=OdxLinkId("somersault.PR.report_status.last_pos_response_key",
+                                         doc_frags),
+                        short_name="last_pos_response_key",
+                        long_name=None,
+                        semantic=None,
+                        description=None,
+                        table_ref=last_flip_details_table_ref,
+                        table_snref=None,
+                        table_row_ref=None,
+                        table_row_snref=None,
+                        byte_position=3,
+                        bit_position=None,
+                        sdgs=[],
+                    ),
+                    TableStructParameter(
+                        short_name="last_pos_response",
+                        long_name=None,
+                        semantic=None,
+                        description=None,
+                        table_key_ref=OdxLinkRef(
+                            "somersault.PR.report_status.last_pos_response_key", doc_frags),
+                        table_key_snref=None,
+                        byte_position=None,
+                        bit_position=None,
+                        sdgs=[],
+                    ),
                 ],
             ),
             byte_size=None,
@@ -1026,51 +1105,82 @@ somersault_global_negative_responses = {
 }
 
 # tables
+flip_quality_table_id = OdxLinkId("somersault.table.flip_quality", doc_frags)
+flip_quality_table_ref = OdxLinkRef.from_id(flip_quality_table_id)
 somersault_tables = {
-    "flip_quality":
+    "last_flip_details":
         Table(
-            odx_id=OdxLinkId("somersault.table.flip_quality", doc_frags),
-            short_name="flip_quality",
-            long_name="Flip Quality",
-            description="<p>The quality the flip (average, good or best)</p>",
-            semantic="QUALITY",
-            key_dop_ref=OdxLinkRef.from_id(somersault_dops["num_flips"].odx_id),
-            table_rows=[
+            odx_id=last_flip_details_table_id,
+            short_name="last_flip_details",
+            long_name="Flip Details",
+            description="<p>The details the last successfully executed request</p>",
+            semantic="DETAILS",
+            admin_data=None,
+            key_label="key",
+            struct_label="response",
+            key_dop_ref=OdxLinkRef.from_id(somersault_dops["uint8"].odx_id),
+            table_rows_raw=[
                 TableRow(
-                    odx_id=OdxLinkId("somersault.table.flip_quality.average", doc_frags),
-                    short_name="average",
-                    long_name="Average",
-                    key=3,
-                    structure_ref=OdxLinkRef.from_id(somersault_dops["num_flips"].odx_id),
-                    description="<p>The quality of the flip is average</p>",
-                    semantic="QUALITY-KEY",
+                    table_ref=last_flip_details_table_ref,
+                    odx_id=OdxLinkId("somersault.table.last_flip_details.none", doc_frags),
+                    short_name="none",
+                    long_name="No Flips Done Yet",
+                    key_raw="0",
+                    structure_ref=None,
+                    structure_snref=None,
+                    description="<p>We have not done any flips yet!</p>",
+                    semantic="DETAILS-KEY",
+                    dop_ref=OdxLinkRef.from_id(somersault_dops["soberness_check"].odx_id),
+                    dop_snref=None,
+                    sdgs=[],
+                ),
+                TableRow(
+                    table_ref=last_flip_details_table_ref,
+                    odx_id=OdxLinkId("somersault.table.last_flip_details.forward_grudging",
+                                     doc_frags),
+                    short_name="forward_grudging",
+                    long_name="Forward Flips Grudgingly Done",
+                    key_raw="3",
+                    structure_ref=OdxLinkRef.from_id(
+                        somersault_positive_responses["forward_flips_grudgingly_done"].odx_id),
+                    structure_snref=None,
+                    description="<p>The the last forward flip was grudgingly done</p>",
+                    semantic="DETAILS-KEY",
                     dop_ref=None,
+                    dop_snref=None,
                     sdgs=[],
                 ),
                 TableRow(
-                    odx_id=OdxLinkId("somersault.table.flip_quality.good", doc_frags),
-                    short_name="good",
-                    long_name="Good",
+                    table_ref=last_flip_details_table_ref,
+                    odx_id=OdxLinkId("somersault.table.last_flip_details.forward_happy", doc_frags),
+                    short_name="forward_happily",
+                    long_name="Forward Flips Happily Done",
                     description=None,
                     semantic=None,
-                    key=5,
-                    structure_ref=OdxLinkRef.from_id(somersault_dops["num_flips"].odx_id),
+                    key_raw="5",
+                    structure_ref=OdxLinkRef.from_id(
+                        somersault_positive_responses["forward_flips_happily_done"].odx_id),
+                    structure_snref=None,
                     dop_ref=None,
+                    dop_snref=None,
                     sdgs=[],
                 ),
                 TableRow(
-                    odx_id=OdxLinkId("somersault.table.flip_quality.best", doc_frags),
-                    short_name="best",
-                    long_name="Best",
+                    table_ref=last_flip_details_table_ref,
+                    odx_id=OdxLinkId("somersault.table.last_flip_details.backward", doc_frags),
+                    short_name="backward_grudging",
+                    long_name="Backward Flips",
                     description=None,
                     semantic=None,
-                    key=10,
-                    structure_ref=OdxLinkRef.from_id(somersault_dops["num_flips"].odx_id),
+                    key_raw="10",
+                    structure_ref=OdxLinkRef.from_id(
+                        somersault_positive_responses["backward_flips_grudgingly_done"].odx_id),
+                    structure_snref=None,
                     dop_ref=None,
+                    dop_snref=None,
                     sdgs=[],
                 ),
             ],
-            table_row_refs=[],
             sdgs=[],
         )
 }
@@ -1196,7 +1306,7 @@ somersault_requests = {
                     sdgs=[],
                 ),
                 CodedConstParameter(
-                    short_name="odx_id",
+                    short_name="id",
                     long_name=None,
                     semantic=None,
                     description=None,
@@ -1230,7 +1340,7 @@ somersault_requests = {
                     sdgs=[],
                 ),
                 CodedConstParameter(
-                    short_name="odx_id",
+                    short_name="id",
                     long_name=None,
                     semantic=None,
                     description=None,
@@ -1264,7 +1374,7 @@ somersault_requests = {
                     sdgs=[],
                 ),
                 CodedConstParameter(
-                    short_name="odx_id",
+                    short_name="id",
                     long_name=None,
                     semantic=None,
                     description=None,
@@ -1430,7 +1540,7 @@ somersault_requests = {
                     sdgs=[],
                 ),
                 CodedConstParameter(
-                    short_name="odx_id",
+                    short_name="id",
                     long_name=None,
                     semantic=None,
                     description=None,

{odxtools-4.0.5 → odxtools-4.1.0}/examples/somersaultlazy.py

@@ -158,38 +158,24 @@ class SomersaultLazyEcu:
 
         self.isotp_socket = create_isotp_socket(
             can_channel,
-            rxid=somersault_lazy_diag_layer.get_receive_id(),
-            txid=somersault_lazy_diag_layer.get_send_id(),
+            rxid=somersault_lazy_diag_layer.get_can_receive_id(),
+            txid=somersault_lazy_diag_layer.get_can_send_id(),
         )
 
         ##############
         # extract the tester present parameters from the ECU's
         # communication parameters.
-        #
-        # TODO: move this into the DiagLayer analogous to
-        # get_receive_id() plus deal with more parameters.
         ##############
 
-        # the timeout on inactivity [s]
-        cps = [
-            x for x in somersault_lazy_diag_layer.communication_parameters
-            if x.id_ref == "ISO_14230_3.CP_TesterPresentTime"
-        ]
-
-        if len(cps):
-            assert len(cps) == 1
-            self._idle_timeout = int(cps[0].value) / 1e6
-        else:
+        # determine the timeout on inactivity [s]
+        self._idle_timeout = somersault_lazy_diag_layer.get_tester_present_time()
+        if self._idle_timeout is None:
             self._idle_timeout = 3.0  # default specified by the standard
 
         # we send a response to tester present messages. make sure
         # that this is specified
-        cps = [
-            x for x in somersault_lazy_diag_layer.communication_parameters
-            if x.id_ref == "ISO_15765_3.CP_TesterPresentReqRsp"
-        ]
-        assert len(cps) == 1
-        assert cps[0].value == "Response expected" or cps[0].value == "1"
+        cp = somersault_lazy_diag_layer.get_communication_parameter("CP_TesterPresentReqRsp")
+        assert cp.value == "Response expected" or cp.value == "1"
 
     async def _handle_requests_task(self):
         loop = asyncio.get_running_loop()
@@ -288,8 +274,7 @@ class SomersaultLazyEcu:
         num_flips = message.param_dict["num_flips"]
 
         if soberness_check != 0x12:
-            response = [x for x in service.negative_responses if x.short_name == "flips_not_done"
-                       ][0]
+            response = service.negative_responses.flips_not_done
             response_data = response.encode(
                 coded_request=message.coded_message,
                 reason=0,  # -> not sober
@@ -301,9 +286,7 @@ class SomersaultLazyEcu:
         # we cannot do all flips because we are too dizzy
         if self.dizziness_level + num_flips > self.max_dizziness_level:
 
-            response = [
-                x for x in service.positive_responses if x.short_name == "grudging_forward"
-            ][0]
+            response = service.positive_responses.grudging_forward
             response_data = response.encode(
                 coded_request=message.coded_message,
                 reason=1,  # -> too dizzy
@@ -317,9 +300,7 @@ class SomersaultLazyEcu:
         # because we stumble
         for i in range(0, num_flips):
             if random.randrange(0, 10000) < 100:
-                response = [
-                    x for x in service.negative_responses if x.short_name == "flips_not_done"
-                ]
+                response = service.negative_responses.flips_not_done
                 response_data = response.encode(
                     coded_request=message.coded_message,
                     reason=2,  # -> stumbled
@@ -330,7 +311,7 @@ class SomersaultLazyEcu:
 
             self.dizziness_level += 1
 
-        response = [x for x in service.positive_responses if x.short_name == "grudging_forward"][0]
+        response = service.positive_responses.grudging_forward
         response_data = response.encode(coded_request=message.coded_message)
         await ecu_send(self.isotp_socket, response_data)
 
@@ -428,8 +409,8 @@ async def tester_main():
     # reversed.
     isotp_socket = create_isotp_socket(
         can_channel,
-        txid=somersault_lazy_diag_layer.get_receive_id(),
-        rxid=somersault_lazy_diag_layer.get_send_id(),
+        txid=somersault_lazy_diag_layer.get_can_receive_id(),
+        rxid=somersault_lazy_diag_layer.get_can_send_id(),
     )
 
     # try to to do a single forward flip without having an active session (ought to fail)
@@ -507,9 +488,6 @@ async def main(args):
     else:
         assert args.mode == "unittest"
 
-        logging.basicConfig(level=logging.DEBUG)
-        logging.getLogger("odxtools").setLevel(logging.WARNING)
-
         # run both tasks in parallel. Since the server task does not
         # complete, we need to wait until the first task is completed
         # and then manually that this was the server task
@@ -550,6 +528,11 @@ parser.add_argument(
 
 args = parser.parse_args()  # deals with the help message handling
 
+# set the verbosity of the log output
+logging.basicConfig(level=logging.DEBUG)  # log messages from the ECU itself
+logging.getLogger("odxtools").setLevel(
+    logging.WARNING)  # log messages stemming from the odxtools library
+
 can_channel = args.channel
 
 asyncio.run(main(args))

{odxtools-4.0.5 → odxtools-4.1.0}/odxtools/compumethods/compuscale.py

@@ -2,6 +2,7 @@
 # Copyright (c) 2022 MBition GmbH
 from typing import NamedTuple, Optional, Union
 
+from ..odxtypes import AtomicOdxType
 from .compurationalcoeffs import CompuRationalCoeffs
 from .limit import Limit
 
@@ -33,6 +34,6 @@ class CompuScale(NamedTuple):
     description: Optional[str] = None
     lower_limit: Optional[Limit] = None
     upper_limit: Optional[Limit] = None
-    compu_inverse_value: Optional[Union[float, str, bytearray]] = None
+    compu_inverse_value: Optional[AtomicOdxType] = None
     compu_const: Optional[Union[float, str]] = None
     compu_rational_coeffs: Optional[CompuRationalCoeffs] = None

{odxtools-4.0.5 → odxtools-4.1.0}/odxtools/compumethods/limit.py

@@ -37,7 +37,7 @@ class Limit(NamedTuple):
             hex_text = et_element.text
             if len(hex_text) % 2 == 1:
                 hex_text = "0" + hex_text
-            return Limit(bytearray.fromhex(hex_text), interval_type)
+            return Limit(bytes.fromhex(hex_text), interval_type)
         else:
             return Limit(internal_type.from_string(et_element.text), interval_type)
 

{odxtools-4.0.5 → odxtools-4.1.0}/odxtools/dataobjectproperty.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 # Copyright (c) 2022 MBition GmbH
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
 
 from .compumethods import CompuMethod, create_any_compu_method_from_et
 from .decodestate import DecodeState
@@ -42,8 +42,6 @@ class DopBase:
         result += hash(self.long_name)
         result += hash(self.description)
         result += hash(self.is_visible_raw)
-        for sdg in self.sdgs:
-            result += hash(sdg)
 
         return result
 
@@ -166,12 +164,16 @@ class DataObjectProperty(DopBase):
         return dop
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return super()._build_odxlinks()
+        result = super()._build_odxlinks()
+        result.update(self.diag_coded_type._build_odxlinks())
+        return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase):
         """Resolves the reference to the unit"""
         super()._resolve_odxlinks(odxlinks)
 
+        self.diag_coded_type._resolve_odxlinks(odxlinks)
+
         self._unit: Optional[Unit] = None
         if self.unit_ref:
             self._unit = odxlinks.resolve(self.unit_ref, Unit)
@@ -179,6 +181,8 @@ class DataObjectProperty(DopBase):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
+        self.diag_coded_type._resolve_snrefs(diag_layer)
+
     @property
     def unit(self) -> Optional[Unit]:
         return self._unit
@@ -192,14 +196,21 @@ class DataObjectProperty(DopBase):
         else:
             return None
 
-    def convert_physical_to_internal(self, physical_value):
+    def convert_physical_to_internal(self, physical_value: Any) -> Any:
+        """
+        Convert a physical representation of a parameter to its internal counterpart
+        """
         assert self.physical_type.base_data_type.isinstance(
             physical_value
         ), f"Expected {self.physical_type.base_data_type.value}, got {type(physical_value)}"
 
         return self.compu_method.convert_physical_to_internal(physical_value)
 
-    def convert_physical_to_bytes(self, physical_value, encode_state, bit_position):
+    def convert_physical_to_bytes(self, physical_value: Any, encode_state: EncodeState,
+                                  bit_position: int) -> bytes:
+        """
+        Convert a physical representation of a parameter to a string bytes that can be send over the wire
+        """
         if not self.is_valid_physical_value(physical_value):
             raise EncodeError(f"The value {repr(physical_value)} of type {type(physical_value)}"
                               f" is not a valid." +
@@ -211,7 +222,14 @@ class DataObjectProperty(DopBase):
         return self.diag_coded_type.convert_internal_to_bytes(
             internal_val, encode_state, bit_position=bit_position)
 
-    def convert_bytes_to_physical(self, decode_state, bit_position: int = 0):
+    def convert_bytes_to_physical(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[Any, int]:
+        """
+        Convert the internal representation of a value into its physical value.
+
+        Returns a (physical_value, start_position_of_next_parameter) tuple.
+        """
         assert 0 <= bit_position and bit_position < 8
 
         internal, next_byte_position = self.diag_coded_type.convert_bytes_to_internal(
@@ -255,7 +273,7 @@ class DiagnosticTroubleCode:
     short_name: Optional[str]
     text: Optional[str]
     display_trouble_code: Optional[str]
-    level: Union[bytes, bytearray, None]
+    level: Union[bytes, None]
     is_temporary_raw: Optional[bool]
     sdgs: List[SpecialDataGroup]
 

odxtools-4.1.0/odxtools/decodestate.py

@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2022 MBition GmbH
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Dict, List, NamedTuple, Union
+
+from .odxtypes import ParameterValueDict
+
+if TYPE_CHECKING:
+    from .parameters.parameterbase import Parameter
+    from .tablerow import TableRow
+
+
+@dataclass
+class DecodeState:
+    """Utility class to be used while decoding a message."""
+
+    #: bytes to be decoded
+    coded_message: bytes
+
+    #: values of already decoded parameters
+    parameter_values: ParameterValueDict
+
+    #: Position of the next parameter if its position is not specified in ODX
+    next_byte_position: int