odxtools 9.6.1__py3-none-any.whl → 9.7.0__py3-none-any.whl

odxtools/addressing.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class Addressing(Enum):
+    FUNCTIONAL = "FUNCTIONAL"
+    PHYSICAL = "PHYSICAL"
+    FUNCTIONAL_OR_PHYSICAL = "FUNCTIONAL-OR-PHYSICAL"

odxtools/basecomparam.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
@@ -8,23 +7,11 @@ from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
+from .standardizationlevel import StandardizationLevel
+from .usage import Usage
 from .utils import dataclass_fields_asdict
 
 
-class StandardizationLevel(Enum):
-    STANDARD = "STANDARD"
-    OEM_SPECIFIC = "OEM-SPECIFIC"
-    OPTIONAL = "OPTIONAL"
-    OEM_OPTIONAL = "OEM-OPTIONAL"
-
-
-class Usage(Enum):
-    ECU_SOFTWARE = "ECU-SOFTWARE"
-    ECU_COMM = "ECU-COMM"
-    APPLICATION = "APPLICATION"
-    TESTER = "TESTER"
-
-
 @dataclass
 class BaseComparam(IdentifiableElement):
     param_class: str

odxtools/basicstructure.py

@@ -5,10 +5,11 @@ from xml.etree import ElementTree
 
 from typing_extensions import override
 
-from .codec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
-                    composite_codec_get_free_parameters, composite_codec_get_required_parameters,
-                    composite_codec_get_static_bit_length)
 from .complexdop import ComplexDop
+from .compositecodec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
+                             composite_codec_get_free_parameters,
+                             composite_codec_get_required_parameters,
+                             composite_codec_get_static_bit_length)
 from .decodestate import DecodeState
 from .encodestate import EncodeState
 from .exceptions import DecodeError, odxraise

odxtools/codec.py

@@ -1,15 +1,10 @@
 # SPDX-License-Identifier: MIT
 import typing
-from typing import List, Optional, runtime_checkable
+from typing import Optional, runtime_checkable
 
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import EncodeError, odxraise
 from .odxtypes import ParameterValue
-from .parameters.codedconstparameter import CodedConstParameter
-from .parameters.matchingrequestparameter import MatchingRequestParameter
-from .parameters.parameter import Parameter
-from .parameters.physicalconstantparameter import PhysicalConstantParameter
 
 
 @runtime_checkable
@@ -31,181 +26,3 @@ class Codec(typing.Protocol):
 
     def get_static_bit_length(self) -> Optional[int]:
         ...
-
-
-@runtime_checkable
-class CompositeCodec(Codec, typing.Protocol):
-    """Any object which can be en- or decoded to be transferred over
-    the wire which is composed of multiple parameter implements this
-    API.
-
-    """
-
-    @property
-    def parameters(self) -> List[Parameter]:
-        return []
-
-    @property
-    def required_parameters(self) -> List[Parameter]:
-        return []
-
-    @property
-    def free_parameters(self) -> List[Parameter]:
-        return []
-
-
-# some helper functions useful for composite codec objects
-def composite_codec_get_static_bit_length(codec: CompositeCodec) -> Optional[int]:
-    """Compute the length of a composite codec object in bits
-
-    This is basically the sum of the lengths of all parameters. If the
-    length of any parameter can only determined at runtime, `None` is
-    returned.
-    """
-
-    cursor = 0
-    byte_length = 0
-    for param in codec.parameters:
-        param_bit_length = param.get_static_bit_length()
-        if param_bit_length is None:
-            # We were not able to calculate a static bit length
-            return None
-        elif param.byte_position is not None:
-            cursor = param.byte_position
-
-        cursor += ((param.bit_position or 0) + param_bit_length + 7) // 8
-        byte_length = max(byte_length, cursor)
-
-    return byte_length * 8
-
-
-def composite_codec_get_required_parameters(codec: CompositeCodec) -> List[Parameter]:
-    """Return the list of parameters which are required to be
-    specified for encoding the composite codec object
-
-    I.e., all free parameters that do not exhibit a default value.
-    """
-    return [p for p in codec.parameters if p.is_required]
-
-
-def composite_codec_get_free_parameters(codec: CompositeCodec) -> List[Parameter]:
-    """Return the list of parameters which can be freely specified by
-    the user when encoding the composite codec object
-
-    This means all required parameters plus parameters that can be
-    omitted because they specify a default.
-    """
-    return [p for p in codec.parameters if p.is_settable]
-
-
-def composite_codec_get_coded_const_prefix(codec: CompositeCodec,
-                                           request_prefix: bytes = b'') -> bytes:
-    encode_state = EncodeState(coded_message=bytearray(), triggering_request=request_prefix)
-
-    for param in codec.parameters:
-        if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
-            isinstance(param, (CodedConstParameter, PhysicalConstantParameter)):
-            param.encode_into_pdu(physical_value=None, encode_state=encode_state)
-        else:
-            break
-
-    return encode_state.coded_message
-
-
-def composite_codec_encode_into_pdu(codec: CompositeCodec, physical_value: Optional[ParameterValue],
-                                    encode_state: EncodeState) -> None:
-    from .parameters.lengthkeyparameter import LengthKeyParameter
-    from .parameters.tablekeyparameter import TableKeyParameter
-
-    if not isinstance(physical_value, dict):
-        odxraise(
-            f"Expected a dictionary for the values of {codec.short_name}, "
-            f"got {type(physical_value).__name__}", EncodeError)
-    elif encode_state.cursor_bit_position != 0:
-        odxraise(
-            f"Compositional codec objecs must be byte aligned, but "
-            f"{codec.short_name} requested to be at bit position "
-            f"{encode_state.cursor_bit_position}", EncodeError)
-        encode_state.bit_position = 0
-
-    orig_origin = encode_state.origin_byte_position
-    encode_state.origin_byte_position = encode_state.cursor_byte_position
-
-    orig_is_end_of_pdu = encode_state.is_end_of_pdu
-    encode_state.is_end_of_pdu = False
-
-    # ensure that no values for unknown parameters are specified.
-    if not encode_state.allow_unknown_parameters:
-        param_names = {param.short_name for param in codec.parameters}
-        for param_value_name in physical_value:
-            if param_value_name not in param_names:
-                odxraise(f"Value for unknown parameter '{param_value_name}' specified "
-                         f"for composite codec object {codec.short_name}")
-
-    for param in codec.parameters:
-        if id(param) == id(codec.parameters[-1]):
-            # The last parameter of the composite codec object is at
-            # the end of the PDU if the codec object itself is at the
-            # end of the PDU.
-            #
-            # TODO: This assumes that the last parameter specified in
-            # the ODX is located last in the PDU...
-            encode_state.is_end_of_pdu = orig_is_end_of_pdu
-
-        if isinstance(param, (LengthKeyParameter, TableKeyParameter)):
-            # At this point, we encode a placeholder value for length-
-            # and table keys, since these can be specified
-            # implicitly (i.e., by means of parameters that use
-            # these keys). To avoid getting an "overlapping
-            # parameter" warning, we must encode a value of zero
-            # into the PDU here and add the real value of the
-            # parameter in a post-processing step.
-            param.encode_placeholder_into_pdu(
-                physical_value=physical_value.get(param.short_name), encode_state=encode_state)
-
-            continue
-
-        if param.is_required and param.short_name not in physical_value:
-            odxraise(f"No value for required parameter {param.short_name} specified", EncodeError)
-
-        param_phys_value = physical_value.get(param.short_name)
-        param.encode_into_pdu(physical_value=param_phys_value, encode_state=encode_state)
-
-        encode_state.journal.append((param, param_phys_value))
-
-    encode_state.is_end_of_pdu = False
-
-    # encode the length- and table keys. This cannot be done above
-    # because we allow these to be defined implicitly (i.e. they
-    # are defined by their respective users)
-    for param in codec.parameters:
-        if not isinstance(param, (LengthKeyParameter, TableKeyParameter)):
-            # the current parameter is neither a length- nor a table key
-            continue
-
-        # Encode the value of the key parameter into the message
-        param.encode_value_into_pdu(encode_state=encode_state)
-
-    encode_state.origin_byte_position = orig_origin
-
-
-def composite_codec_decode_from_pdu(codec: CompositeCodec,
-                                    decode_state: DecodeState) -> ParameterValue:
-    # move the origin since positions specified by sub-parameters of
-    # composite codec objects are relative to the beginning of the
-    # object.
-    orig_origin = decode_state.origin_byte_position
-    decode_state.origin_byte_position = decode_state.cursor_byte_position
-
-    result = {}
-    for param in codec.parameters:
-        value = param.decode_from_pdu(decode_state)
-
-        decode_state.journal.append((param, value))
-        result[param.short_name] = value
-
-    # decoding of the composite codec object finished. go back the
-    # original origin.
-    decode_state.origin_byte_position = orig_origin
-
-    return result

odxtools/commrelation.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
+from .commrelationvaluetype import CommRelationValueType
 from .description import Description
 from .diagcomm import DiagComm
 from .diagservice import DiagService
@@ -14,13 +14,6 @@ from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
 
 
-class CommRelationValueType(Enum):
-    CURRENT = "CURRENT"
-    STORED = "STORED"
-    STATIC = "STATIC"
-    SUBSTITUTED = "SUBSTITUTED"
-
-
 @dataclass
 class CommRelation:
     description: Optional[Description]

odxtools/commrelationvaluetype.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class CommRelationValueType(Enum):
+    CURRENT = "CURRENT"
+    STORED = "STORED"
+    STATIC = "STATIC"
+    SUBSTITUTED = "SUBSTITUTED"

odxtools/compositecodec.py

@@ -0,0 +1,191 @@
+# SPDX-License-Identifier: MIT
+import typing
+from typing import List, Optional, runtime_checkable
+
+from .codec import Codec
+from .decodestate import DecodeState
+from .encodestate import EncodeState
+from .exceptions import EncodeError, odxraise
+from .odxtypes import ParameterValue
+from .parameters.codedconstparameter import CodedConstParameter
+from .parameters.matchingrequestparameter import MatchingRequestParameter
+from .parameters.parameter import Parameter
+from .parameters.physicalconstantparameter import PhysicalConstantParameter
+
+
+@runtime_checkable
+class CompositeCodec(Codec, typing.Protocol):
+    """Any object which can be en- or decoded to be transferred over
+    the wire which is composed of multiple parameter implements this
+    API.
+
+    """
+
+    @property
+    def parameters(self) -> List[Parameter]:
+        return []
+
+    @property
+    def required_parameters(self) -> List[Parameter]:
+        return []
+
+    @property
+    def free_parameters(self) -> List[Parameter]:
+        return []
+
+
+# some helper functions useful for composite codec objects
+def composite_codec_get_static_bit_length(codec: CompositeCodec) -> Optional[int]:
+    """Compute the length of a composite codec object in bits
+
+    This is basically the sum of the lengths of all parameters. If the
+    length of any parameter can only determined at runtime, `None` is
+    returned.
+    """
+
+    cursor = 0
+    byte_length = 0
+    for param in codec.parameters:
+        param_bit_length = param.get_static_bit_length()
+        if param_bit_length is None:
+            # We were not able to calculate a static bit length
+            return None
+        elif param.byte_position is not None:
+            cursor = param.byte_position
+
+        cursor += ((param.bit_position or 0) + param_bit_length + 7) // 8
+        byte_length = max(byte_length, cursor)
+
+    return byte_length * 8
+
+
+def composite_codec_get_required_parameters(codec: CompositeCodec) -> List[Parameter]:
+    """Return the list of parameters which are required to be
+    specified for encoding the composite codec object
+
+    I.e., all free parameters that do not exhibit a default value.
+    """
+    return [p for p in codec.parameters if p.is_required]
+
+
+def composite_codec_get_free_parameters(codec: CompositeCodec) -> List[Parameter]:
+    """Return the list of parameters which can be freely specified by
+    the user when encoding the composite codec object
+
+    This means all required parameters plus parameters that can be
+    omitted because they specify a default.
+    """
+    return [p for p in codec.parameters if p.is_settable]
+
+
+def composite_codec_get_coded_const_prefix(codec: CompositeCodec,
+                                           request_prefix: bytes = b'') -> bytes:
+    encode_state = EncodeState(coded_message=bytearray(), triggering_request=request_prefix)
+
+    for param in codec.parameters:
+        if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
+            isinstance(param, (CodedConstParameter, PhysicalConstantParameter)):
+            param.encode_into_pdu(physical_value=None, encode_state=encode_state)
+        else:
+            break
+
+    return encode_state.coded_message
+
+
+def composite_codec_encode_into_pdu(codec: CompositeCodec, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+    from .parameters.lengthkeyparameter import LengthKeyParameter
+    from .parameters.tablekeyparameter import TableKeyParameter
+
+    if not isinstance(physical_value, dict):
+        odxraise(
+            f"Expected a dictionary for the values of {codec.short_name}, "
+            f"got {type(physical_value).__name__}", EncodeError)
+    elif encode_state.cursor_bit_position != 0:
+        odxraise(
+            f"Compositional codec objecs must be byte aligned, but "
+            f"{codec.short_name} requested to be at bit position "
+            f"{encode_state.cursor_bit_position}", EncodeError)
+        encode_state.bit_position = 0
+
+    orig_origin = encode_state.origin_byte_position
+    encode_state.origin_byte_position = encode_state.cursor_byte_position
+
+    orig_is_end_of_pdu = encode_state.is_end_of_pdu
+    encode_state.is_end_of_pdu = False
+
+    # ensure that no values for unknown parameters are specified.
+    if not encode_state.allow_unknown_parameters:
+        param_names = {param.short_name for param in codec.parameters}
+        for param_value_name in physical_value:
+            if param_value_name not in param_names:
+                odxraise(f"Value for unknown parameter '{param_value_name}' specified "
+                         f"for composite codec object {codec.short_name}")
+
+    for param in codec.parameters:
+        if id(param) == id(codec.parameters[-1]):
+            # The last parameter of the composite codec object is at
+            # the end of the PDU if the codec object itself is at the
+            # end of the PDU.
+            #
+            # TODO: This assumes that the last parameter specified in
+            # the ODX is located last in the PDU...
+            encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+        if isinstance(param, (LengthKeyParameter, TableKeyParameter)):
+            # At this point, we encode a placeholder value for length-
+            # and table keys, since these can be specified
+            # implicitly (i.e., by means of parameters that use
+            # these keys). To avoid getting an "overlapping
+            # parameter" warning, we must encode a value of zero
+            # into the PDU here and add the real value of the
+            # parameter in a post-processing step.
+            param.encode_placeholder_into_pdu(
+                physical_value=physical_value.get(param.short_name), encode_state=encode_state)
+
+            continue
+
+        if param.is_required and param.short_name not in physical_value:
+            odxraise(f"No value for required parameter {param.short_name} specified", EncodeError)
+
+        param_phys_value = physical_value.get(param.short_name)
+        param.encode_into_pdu(physical_value=param_phys_value, encode_state=encode_state)
+
+        encode_state.journal.append((param, param_phys_value))
+
+    encode_state.is_end_of_pdu = False
+
+    # encode the length- and table keys. This cannot be done above
+    # because we allow these to be defined implicitly (i.e. they
+    # are defined by their respective users)
+    for param in codec.parameters:
+        if not isinstance(param, (LengthKeyParameter, TableKeyParameter)):
+            # the current parameter is neither a length- nor a table key
+            continue
+
+        # Encode the value of the key parameter into the message
+        param.encode_value_into_pdu(encode_state=encode_state)
+
+    encode_state.origin_byte_position = orig_origin
+
+
+def composite_codec_decode_from_pdu(codec: CompositeCodec,
+                                    decode_state: DecodeState) -> ParameterValue:
+    # move the origin since positions specified by sub-parameters of
+    # composite codec objects are relative to the beginning of the
+    # object.
+    orig_origin = decode_state.origin_byte_position
+    decode_state.origin_byte_position = decode_state.cursor_byte_position
+
+    result = {}
+    for param in codec.parameters:
+        value = param.decode_from_pdu(decode_state)
+
+        decode_state.journal.append((param, value))
+        result[param.short_name] = value
+
+    # decoding of the composite codec object finished. go back the
+    # original origin.
+    decode_state.origin_byte_position = orig_origin
+
+    return result

odxtools/compumethods/compucategory.py

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class CompuCategory(Enum):
+    IDENTICAL = "IDENTICAL"
+    LINEAR = "LINEAR"
+    SCALE_LINEAR = "SCALE-LINEAR"
+    TEXTTABLE = "TEXTTABLE"
+    COMPUCODE = "COMPUCODE"
+    TAB_INTP = "TAB-INTP"
+    RAT_FUNC = "RAT-FUNC"
+    SCALE_RAT_FUNC = "SCALE-RAT-FUNC"

odxtools/compumethods/compucodecompumethod.py

@@ -8,7 +8,8 @@ from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..progcode import ProgCode
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 
 
 @dataclass

odxtools/compumethods/compumethod.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
@@ -8,21 +7,11 @@ from ..exceptions import odxraise
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType
 from ..snrefcontext import SnRefContext
+from .compucategory import CompuCategory
 from .compuinternaltophys import CompuInternalToPhys
 from .compuphystointernal import CompuPhysToInternal
 
 
-class CompuCategory(Enum):
-    IDENTICAL = "IDENTICAL"
-    LINEAR = "LINEAR"
-    SCALE_LINEAR = "SCALE-LINEAR"
-    TEXTTABLE = "TEXTTABLE"
-    COMPUCODE = "COMPUCODE"
-    TAB_INTP = "TAB-INTP"
-    RAT_FUNC = "RAT-FUNC"
-    SCALE_RAT_FUNC = "SCALE-RAT-FUNC"
-
-
 @dataclass
 class CompuMethod:
     """A compu method translates between the internal representation

odxtools/compumethods/intervaltype.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class IntervalType(Enum):
+    OPEN = "OPEN"
+    CLOSED = "CLOSED"
+    INFINITE = "INFINITE"

odxtools/compumethods/limit.py

@@ -1,18 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
 from typing import List, Optional, overload
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType, compare_odx_values
-
-
-class IntervalType(Enum):
-    OPEN = "OPEN"
-    CLOSED = "CLOSED"
-    INFINITE = "INFINITE"
+from .intervaltype import IntervalType
 
 
 @dataclass

odxtools/compumethods/linearcompumethod.py

@@ -7,7 +7,8 @@ from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 from .linearsegment import LinearSegment
 
 

odxtools/compumethods/ratfunccompumethod.py

@@ -7,7 +7,8 @@ from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 from .ratfuncsegment import RatFuncSegment
 
 

odxtools/compumethods/scalelinearcompumethod.py

@@ -7,8 +7,9 @@ from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
-from .limit import IntervalType
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
+from .intervaltype import IntervalType
 from .linearsegment import LinearSegment
 
 

odxtools/compumethods/scaleratfunccompumethod.py

@@ -7,7 +7,8 @@ from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 from .ratfuncsegment import RatFuncSegment
 
 

odxtools/compumethods/tabintpcompumethod.py

@@ -7,8 +7,10 @@ from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequi
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
-from .limit import IntervalType, Limit
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
+from .intervaltype import IntervalType
+from .limit import Limit
 
 
 @dataclass

odxtools/compumethods/texttablecompumethod.py

@@ -7,7 +7,8 @@ from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequi
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 from .compuscale import CompuScale
 
 

odxtools/description.py

@@ -3,26 +3,10 @@ from typing import List, Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
+from .externaldoc import ExternalDoc
 from .odxlink import OdxDocFragment
 
 
-@dataclass
-class ExternalDoc:
-    description: Optional[str]
-    href: str
-
-    @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element],
-                doc_frags: List[OdxDocFragment]) -> Optional["ExternalDoc"]:
-        if et_element is None:
-            return None
-
-        description = et_element.text
-        href = odxrequire(et_element.get("HREF"))
-
-        return ExternalDoc(description=description, href=href)
-
-
 @dataclass
 class Description:
     text: str

odxtools/diagclasstype.py

@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class DiagClassType(Enum):
+    STARTCOMM = "STARTCOMM"
+    STOPCOMM = "STOPCOMM"
+    VARIANTIDENTIFICATION = "VARIANTIDENTIFICATION"
+    READ_DYN_DEFINED_MESSAGE = "READ-DYN-DEFINED-MESSAGE"
+    DYN_DEF_MESSAGE = "DYN-DEF-MESSAGE"
+    CLEAR_DYN_DEF_MESSAGE = "CLEAR-DYN-DEF-MESSAGE"