pyxcp 0.21.9__tar.gz → 0.21.11__tar.gz

{pyxcp-0.21.9 → pyxcp-0.21.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyxcp
-Version: 0.21.9
+Version: 0.21.11
 Summary: Universal Calibration Protocol for Python
 Keywords: automotive,ecu,xcp,asam,autosar
 Author: Christoph Schueler

{pyxcp-0.21.9 → pyxcp-0.21.11}/pyproject.toml

@@ -92,7 +92,7 @@ dependencies = [
     "traitlets>=5.9.0",
 ]
 name = "pyxcp"
-version = "0.21.9"
+version = "0.21.11"
 readme = "README.md"
 description = "Universal Calibration Protocol for Python"
 keywords = [

{pyxcp-0.21.9 → pyxcp-0.21.11}/pyxcp/__init__.py

@@ -25,4 +25,4 @@ from .transport import SxI
 from .transport import Usb
 
 # if you update this manually, do not forget to update .bumpversion.cfg and pyproject.toml
-__version__ = "0.21.9"
+__version__ = "0.21.11"

{pyxcp-0.21.9 → pyxcp-0.21.11}/pyxcp/cmdline.py

@@ -5,12 +5,14 @@ Parse (transport-layer specific) command line parameters
 and create a XCP master instance.
 """
 import argparse
+import logging
 
 from pyxcp.config import readConfiguration
 from pyxcp.master import Master
 from pyxcp.transport.can import registered_drivers
 from pyxcp.transport.can import try_to_install_system_supplied_drivers
 
+
 try_to_install_system_supplied_drivers()
 
 CAN_DRIVERS = registered_drivers()
@@ -51,6 +53,9 @@ class ArgumentParser:
 
     def run(self, policy=None):
         """"""
+        # Create a default logging context if run as command line
+        logging.basicConfig()
+
         self._args = self.parser.parse_args()
         args = self.args
         if args.conf is None:

{pyxcp-0.21.9 → pyxcp-0.21.11}/pyxcp/logger.py

@@ -2,9 +2,6 @@
 # -*- coding: utf-8 -*-
 import logging
 
-logging.basicConfig()
-
-
 class Logger(object):
 
     LOGGER_BASE_NAME = "pyxcp"

{pyxcp-0.21.9 → pyxcp-0.21.11}/pyxcp/master/master.py

@@ -8,17 +8,17 @@
 .. [1] XCP Specification, Part 2 - Protocol Layer Specification
 """
 import functools
-import logging
 import struct
 import traceback
 import warnings
 from time import sleep
+from typing import Any
 from typing import Callable
 from typing import Collection
 from typing import Dict
 from typing import List
 from typing import Optional
-from typing import Union
+from typing import Tuple
 
 from pyxcp import checksum
 from pyxcp import types
@@ -33,6 +33,7 @@ from pyxcp.constants import makeWordPacker
 from pyxcp.constants import makeWordUnpacker
 from pyxcp.constants import PackerType
 from pyxcp.constants import UnpackerType
+from pyxcp.logger import Logger
 from pyxcp.master.errorhandler import disable_error_handling
 from pyxcp.master.errorhandler import wrapped
 from pyxcp.transport.base import createTransport
@@ -92,8 +93,7 @@ class Master:
         self.ctr = 0
         self.succeeded = True
         self.config = Configuration(self.PARAMETER_MAP or {}, config or {})
-        self.logger = logging.getLogger("pyXCP")
-        self.logger.setLevel(self.config.get("LOGLEVEL"))
+        self.logger = Logger("master.Master", level=self.config.get("LOGLEVEL"))
         disable_error_handling(self.config.get("DISABLE_ERROR_HANDLING"))
 
         self.transport = createTransport(transportName, config, policy)
@@ -124,6 +124,7 @@ class Master:
         self.disconnect_response_optional = self.config.get("DISCONNECT_RESPONSE_OPTIONAL")
         self.slaveProperties = SlaveProperties()
         self.slaveProperties.pgmProcessor = SlaveProperties()
+        self.slaveProperties.transport_layer = self.transport_name.upper()
 
     def __enter__(self):
         """Context manager entry part."""
@@ -1790,12 +1791,13 @@ class Master:
             length = result.length
             if length == 0:
                 continue
-            if length > MAX_PAYLOAD:
-                remaining = length - len(seed)
-                while remaining > 0:
-                    result = self.getSeed(types.XcpGetSeedMode.REMAINING, resource_value)
-                    seed.extend(list(result.seed))
-                    remaining = result.length
+
+            while length - len(seed) > 0:
+                result = self.getSeed(types.XcpGetSeedMode.REMAINING, resource_value)
+                seed.extend(list(result.seed))
+
+            seed = seed[:length]  # maybe there are some padding bytes
+
             result, key = getKey(
                 self.logger,
                 self.seedNKeyDLL,
@@ -1809,9 +1811,8 @@ class Master:
                 offset = 0
                 while offset < total_length:
                     data = key[offset : offset + MAX_PAYLOAD]
-                    key_length = len(data)
-                    offset += key_length
-                    self.unlock(key_length, data)
+                    self.unlock(total_length - offset, data)
+                    offset += len(data)
             else:
                 raise SeedNKeyError("SeedAndKey DLL returned: {}".format(SeedNKeyResult(result).name))
 
@@ -1903,6 +1904,47 @@ class Master:
                 result[name] = response
         return result
 
+    def try_command(self, cmd: Callable, *args, **kws) -> Tuple[types.TryCommandResult, Any]:
+        """Call master functions and handle XCP errors more gracefuly.
+
+        Parameter
+        ---------
+        cmd: Callable
+        args: list
+            variable length arguments to `cmd`.
+        kws: dict
+            keyword arguments to `cmd`.
+
+            `extra_msg`: str
+                Additional info to log message (not passed to `cmd`).
+
+        Returns
+        -------
+
+        Note
+        ----
+        Mainly used for plug-and-play applications, e.g. `id_scanner` may confronted with `ERR_OUT_OF_RANGE` errors, which
+        is normal for this kind of applications -- or to test for optional commands.
+        Use carefuly not to hide serious error causes.
+        """
+        try:
+            extra_msg: Optional[str] = kws.get("extra_msg")
+            if extra_msg:
+                kws.pop("extra_msg")
+            res = cmd(*args, **kws)
+        except SystemExit as e:
+            if e.error_code == types.XcpError.ERR_CMD_UNKNOWN:
+                # This is a rather common use-case, so let the user know that there is some functionality missing.
+                if extra_msg:
+                    self.logger.warning(f"Optional command {cmd.__name__!r} not implemented -- {extra_msg!r}")
+                else:
+                    self.logger.warning(f"Optional command {cmd.__name__!r} not implemented.")
+            return (types.TryCommandResult.XCP_ERROR, e)
+        except Exception as e:
+            return (types.TryCommandResult.OTHER_ERROR, e)
+        else:
+            return (types.TryCommandResult.OK, res)
+
 
 def ticks_to_seconds(ticks, resolution):
     """Convert DAQ timestamp/tick value to seconds.

pyxcp-0.21.11/pyxcp/scripts/xcp_info.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+"""XCP info/exploration tool.
+"""
+from pprint import pprint
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.types import TryCommandResult
+
+
+ap = ArgumentParser(description="XCP info/exploration tool.")
+
+with ap.run() as x:
+    x.connect()
+    if x.slaveProperties.optionalCommMode:
+        x.try_command(x.getCommModeInfo, extra_msg="availability signaled by CONNECT, this may be a slave configuration error.")
+    print("\nSlave Properties:")
+    print("=================")
+    pprint(x.slaveProperties)
+
+    # result = x.id_scanner()
+    # print("\n")
+    # print("Implemented IDs:")
+    # print("================")
+    # for key, value in result.items():
+    #     print(f"{key}: {value}", end="\n\n")
+    cps = x.getCurrentProtectionStatus()
+    print("\nProtection Status")
+    print("=================")
+    for k, v in cps.items():
+        print(f"    {k:6s}: {v}")
+    x.cond_unlock()
+    print("\nDAQ Info:")
+    print("=========")
+    daq_info = x.getDaqInfo()
+    pprint(daq_info)
+
+    daq_pro = daq_info["processor"]
+    daq_properties = daq_pro["properties"]
+    if x.slaveProperties.transport_layer == "CAN":
+        print("")
+        if daq_properties["pidOffSupported"]:
+            print("*** pidOffSupported -- i.e. one CAN-ID per DAQ-list.")
+        else:
+            print("*** NO support for PID_OFF")
+    num_predefined = daq_pro["minDaq"]
+    print("\nPredefined DAQ-Lists")
+    print("====================")
+    if num_predefined > 0:
+        print(f"There are {num_predefined} predefined DAQ-lists")
+        for idx in range(num_predefined):
+            print(f"DAQ-List #{idx}\n____________\n")
+            status, dm = x.try_command(x.getDaqListMode, idx)
+            if status == TryCommandResult.OK:
+                print(dm)
+            status, di = x.try_command(x.getDaqListInfo, idx)
+            if status == TryCommandResult.OK:
+                print(di)
+    else:
+        print("*** NO Predefined DAQ-Lists")
+    print("\nPAG Info:")
+    print("=========")
+    if x.slaveProperties.supportsCalpag:
+        status, pag = x.try_command(x.getPagProcessorInfo)
+        if status == TryCommandResult.OK:
+            print(pag)
+            # for idx in range(pag.maxSegments):
+            #     x.getSegmentInfo(0x01, idx, 0, 0)
+    else:
+        print("*** PAGING IS NOT SUPPORTED.")
+
+    print("\nPGM Info:")
+    print("=========")
+    if x.slaveProperties.supportsPgm:
+        status, pgm = x.try_command(x.getPgmProcessorInfo)
+        if status == TryCommandResult.OK:
+            print(pgm)
+    else:
+        print("*** FLASH PROGRAMMING IS NOT SUPPORTED.")
+
+    if x.slaveProperties.transport_layer == "CAN":
+        # print("OK, CAN!!!")
+        for idx in range(num_predefined):
+            status, daq_id = x.try_command(x.getDaqId, idx)
+            if status != TryCommandResult.OK:
+                break
+            print(f"DAQ-ID #{idx}", daq_id)
+    x.disconnect()
+
+    print("\nDone.")

{pyxcp-0.21.9 → pyxcp-0.21.11}/pyxcp/types.py

@@ -942,3 +942,11 @@ class FrameCategory(enum.IntEnum):
     SERV = 5
     DAQ = 6
     STIM = 7
+
+
+class TryCommandResult(enum.IntEnum):
+    """ """
+
+    OK = 0
+    XCP_ERROR = 1
+    OTHER_ERROR = 2

pyxcp-0.21.9/pyxcp/scripts/xcp_info.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""Very basic hello-world example.
-"""
-from pprint import pprint
-
-from pyxcp.cmdline import ArgumentParser
-
-daq_info = False
-
-
-def callout(master, args):
-    global daq_info
-    if args.daq_info:
-        daq_info = True
-
-
-ap = ArgumentParser(description="pyXCP hello world.", callout=callout)
-ap.parser.add_argument(
-    "-d",
-    "--daq-info",
-    dest="daq_info",
-    help="Display DAQ-info",
-    default=False,
-    action="store_true",
-)
-with ap.run() as x:
-    x.connect()
-    if x.slaveProperties.optionalCommMode:
-        x.getCommModeInfo()
-    identifier = x.identifier(0x01)
-    print("\nSlave Properties:")
-    print("=================")
-    print(f"ID: '{identifier}'")
-    pprint(x.slaveProperties)
-    cps = x.getCurrentProtectionStatus()
-    print("\nProtection Status")
-    print("=================")
-    for k, v in cps.items():
-        print(f"    {k:6s}: {v}")
-    if daq_info:
-        dqp = x.getDaqProcessorInfo()
-        print("\nDAQ Processor Info:")
-        print("===================")
-        print(dqp)
-        print("\nDAQ Events:")
-        print("===========")
-        for idx in range(dqp.maxEventChannel):
-            evt = x.getDaqEventInfo(idx)
-            length = evt.eventChannelNameLength
-            name = x.pull(length).decode("utf-8")
-            dq = "DAQ" if evt.daqEventProperties.daq else ""
-            st = "STIM" if evt.daqEventProperties.stim else ""
-            dq_st = dq + " " + st
-            print(f'    [{idx:04}] "{name:s}"')
-            print(f"        dir:            {dq_st}")
-            print(f"        packed:         {evt.daqEventProperties.packed}")
-            PFX_CONS = "CONSISTENCY_"
-            print(f"        consistency:    {evt.daqEventProperties.consistency.strip(PFX_CONS)}")
-            print(f"        max. DAQ lists: {evt.maxDaqList}")
-            PFX_TU = "EVENT_CHANNEL_TIME_UNIT_"
-            print(f"        unit:           {evt.eventChannelTimeUnit.strip(PFX_TU)}")
-            print(f"        cycle:          {evt.eventChannelTimeCycle or 'SPORADIC'}")
-            print(f"        priority        {evt.eventChannelPriority}")
-
-        dqr = x.getDaqResolutionInfo()
-        print("\nDAQ Resolution Info:")
-        print("====================")
-        print(dqr)
-        for idx in range(dqp.maxDaq):
-            print(f"\nDAQ List Info #{idx}")
-            print("=================")
-            print(f"{x.getDaqListInfo(idx)}")
-    x.disconnect()