pyxcp 0.21.9__cp39-cp39-win_amd64.whl → 0.22.23__cp39-cp39-win_amd64.whl

pyxcp/examples/ex_sqlite.py

@@ -0,0 +1,128 @@
+import argparse
+import logging
+import os
+import sqlite3
+from array import array
+from dataclasses import dataclass, field
+from mmap import PAGESIZE
+from pathlib import Path
+from typing import Any, List
+
+from pyxcp.recorder import XcpLogFileDecoder
+from pyxcp.recorder.converter import MAP_TO_ARRAY
+
+
+MAP_TO_SQL = {
+    "U8": "INTEGER",
+    "I8": "INTEGER",
+    "U16": "INTEGER",
+    "I16": "INTEGER",
+    "U32": "INTEGER",
+    "I32": "INTEGER",
+    "U64": "INTEGER",
+    "I64": "INTEGER",
+    "F32": "FLOAT",
+    "F64": "FLOAT",
+    "F16": "FLOAT",
+    "BF16": "FLOAT",
+}
+
+logger = logging.getLogger("PyXCP")
+
+parser = argparse.ArgumentParser(description="Use .xmraw files in an Apache Arrow application.")
+parser.add_argument("xmraw_file", help=".xmraw file")
+args = parser.parse_args()
+
+
+@dataclass
+class Storage:
+    name: str
+    arrow_type: Any
+    arr: array
+
+
+@dataclass
+class StorageContainer:
+    name: str
+    arr: List[Storage] = field(default_factory=[])
+    ts0: List[int] = field(default_factory=lambda: array("Q"))
+    ts1: List[int] = field(default_factory=lambda: array("Q"))
+
+
+class Decoder(XcpLogFileDecoder):
+
+    def __init__(self, recording_file_name: str):
+        super().__init__(recording_file_name)
+        self.sq3_file_name = Path(recording_file_name).with_suffix(".sq3")
+        try:
+            os.unlink(self.sq3_file_name)
+        except Exception as e:
+            print(e)
+
+    def initialize(self) -> None:
+        self.create_database(self.sq3_file_name)
+        self.arrow_tables = []
+        self.insert_stmt = {}
+        for dl in self.daq_lists:
+            result = []
+            for name, type_str in dl.headers:
+                array_txpe = MAP_TO_ARRAY[type_str]
+                sql_type = MAP_TO_SQL[type_str]
+                sd = Storage(name, sql_type, array(array_txpe))
+                result.append(sd)
+            sc = StorageContainer(dl.name, result)
+            print(f"Creating table {sc.name!r}.")
+            self.create_table(sc)
+            self.insert_stmt[sc.name] = (
+                f"""INSERT INTO {sc.name}({', '.join(['ts0', 'ts1'] + [r.name for r in sc.arr])}) VALUES({', '.join(["?" for _ in range(len(sc.arr) + 2)])})"""
+            )
+            self.arrow_tables.append(sc)
+        print("\nInserting data...")
+
+    def create_database(self, db_name: str) -> None:
+        self.conn = sqlite3.Connection(db_name)
+        self.cursor = self.conn.cursor()
+        self.execute("PRAGMA FOREIGN_KEYS=ON")
+        self.execute(f"PRAGMA PAGE_SIZE={PAGESIZE}")
+        self.execute("PRAGMA SYNCHRONOUS=OFF")
+        self.execute("PRAGMA LOCKING_MODE=EXCLUSIVE")
+        self.execute("PRAGMA TEMP_STORE=MEMORY")
+
+        timestamp_info = self.parameters.timestamp_info
+        self.execute(
+            "CREATE TABLE timestamp_info(timestamp_ns INTEGER, utc_offset INTEGER, dst_offset INTEGER, timezone VARCHAR(255))"
+        )
+        self.execute("CREATE TABLE table_names(name VARCHAR(255))")
+        self.execute(
+            "INSERT INTO timestamp_info VALUES(?, ?, ?, ?)",
+            [timestamp_info.timestamp_ns, timestamp_info.utc_offset, timestamp_info.dst_offset, timestamp_info.timezone],
+        )
+
+    def create_table(self, sc: StorageContainer) -> None:
+        columns = ["ts0 INTEGER", "ts1 INTEGER"]
+        for elem in sc.arr:
+            columns.append(f"{elem.name} {elem.arrow_type}")
+        ddl = f"CREATE TABLE {sc.name}({', '.join(columns)})"
+        self.execute(ddl)
+        self.execute("INSERT INTO table_names VALUES(?)", [sc.name])
+
+    def execute(self, *args: List[str]) -> None:
+        try:
+            self.cursor.execute(*args)
+        except Exception as e:
+            print(e)
+
+    def finalize(self) -> None:
+        self.conn.commit()
+        self.conn.close()
+        print("Done.")
+
+    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
+        sc = self.arrow_tables[daq_list_num]
+        insert_stmt = self.insert_stmt[sc.name]
+        data = [timestamp0, timestamp1, *measurements]
+        self.execute(insert_stmt, data)
+
+
+decoder = Decoder(args.xmraw_file)
+decoder.run()

pyxcp/examples/run_daq.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+
+import time
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.daq_stim import DaqList, DaqRecorder, DaqToCsv  # noqa: F401
+
+
+ap = ArgumentParser(description="DAQ test")
+
+XCP_LITE = True
+
+#
+# NOTE: UPDATE TO CORRECT ADDRESSES BEFORE RUNNING!!!
+#
+if XCP_LITE:
+    # Vectorgrp XCPlite.
+    DAQ_LISTS = [
+        DaqList(
+            "part_1",
+            0,
+            False,
+            False,
+            [
+                ("byteCounter", 0x00023648, 0, "U8"),
+                ("wordCounter", 0x0002364C, 0, "U16"),
+                ("dwordCounter", 0x00023650, 0, "U32"),
+                ("sbyteCounter", 0x00023649, 0, "I8"),
+            ],
+        ),
+        DaqList(
+            "part_2",
+            7,
+            False,
+            False,
+            [
+                ("swordCounter", 0x00023654, 0, "I16"),
+                ("sdwordCounter", 0x00023658, 0, "I32"),
+                ("channel1", 0x00023630, 0, "F64"),
+                ("channel2", 0x00023638, 0, "F64"),
+                ("channel3", 0x00023640, 0, "F64"),
+            ],
+        ),
+    ]
+else:
+    # XCPsim from CANape.
+    DAQ_LISTS = [
+        DaqList(
+            "pwm_stuff",
+            2,
+            False,
+            True,
+            [
+                ("channel1", 0x1BD004, 0, "F32"),
+                ("period", 0x001C0028, 0, "F32"),
+                ("channel2", 0x1BD008, 0, "F32"),
+                ("PWMFiltered", 0x1BDDE2, 0, "U8"),
+                ("PWM", 0x1BDDDF, 0, "U8"),
+                ("Triangle", 0x1BDDDE, 0, "I8"),
+            ],
+        ),
+        DaqList(
+            "bytes",
+            1,
+            False,
+            True,
+            [
+                ("TestByte_000", 0x1BE11C, 0, "U8"),
+                ("TestByte_015", 0x1BE158, 0, "U8"),
+                ("TestByte_016", 0x1BE15C, 0, "U8"),
+                ("TestByte_023", 0x1BE178, 0, "U8"),
+                ("TestByte_024", 0x1BE17C, 0, "U8"),
+                ("TestByte_034", 0x1BE1A4, 0, "U8"),
+                ("TestByte_059", 0x1BE208, 0, "U8"),
+                ("TestByte_061", 0x1BE210, 0, "U8"),
+                ("TestByte_063", 0x1BE218, 0, "U8"),
+                ("TestByte_064", 0x1BE21C, 0, "U8"),
+                ("TestByte_097", 0x1BE2A0, 0, "U8"),
+                ("TestByte_107", 0x1BE2C8, 0, "U8"),
+                ("TestByte_131", 0x1BE328, 0, "U8"),
+                ("TestByte_156", 0x1BE38C, 0, "U8"),
+                ("TestByte_159", 0x1BE398, 0, "U8"),
+                ("TestByte_182", 0x1BE3F4, 0, "U8"),
+                ("TestByte_183", 0x1BE3F8, 0, "U8"),
+                ("TestByte_189", 0x1BE410, 0, "U8"),
+                ("TestByte_195", 0x1BE428, 0, "U8"),
+                ("TestByte_216", 0x1BE47C, 0, "U8"),
+                ("TestByte_218", 0x1BE484, 0, "U8"),
+                ("TestByte_221", 0x1BE490, 0, "U8"),
+                ("TestByte_251", 0x1BE508, 0, "U8"),
+                ("TestByte_263", 0x1BE538, 0, "U8"),
+                ("TestByte_276", 0x1BE56C, 0, "U8"),
+                ("TestByte_277", 0x1BE570, 0, "U8"),
+                ("TestByte_297", 0x1BE5C0, 0, "U8"),
+                ("TestByte_302", 0x1BE5D4, 0, "U8"),
+                ("TestByte_324", 0x1BE62C, 0, "U8"),
+                ("TestByte_344", 0x1BE67C, 0, "U8"),
+                ("TestByte_346", 0x1BE684, 0, "U8"),
+            ],
+        ),
+        DaqList(
+            "words",
+            3,
+            False,
+            True,
+            [
+                ("TestWord_001", 0x1BE120, 0, "U16"),
+                ("TestWord_003", 0x1BE128, 0, "U16"),
+                ("TestWord_004", 0x1BE12C, 0, "U16"),
+                ("TestWord_005", 0x1BE134, 0, "U16"),
+                ("TestWord_006", 0x1BE134, 0, "U16"),
+                ("TestWord_007", 0x1BE138, 0, "U16"),
+                ("TestWord_008", 0x1BE13C, 0, "U16"),
+                ("TestWord_009", 0x1BE140, 0, "U16"),
+                ("TestWord_011", 0x1BE148, 0, "U16"),
+            ],
+        ),
+    ]
+
+daq_parser = DaqToCsv(DAQ_LISTS)  # Record to CSV file(s).
+# daq_parser = DaqRecorder(DAQ_LISTS, "run_daq", 2)  # Record to ".xmraw" file.
+
+with ap.run(policy=daq_parser) as x:
+    x.connect()
+    if x.slaveProperties.optionalCommMode:
+        x.getCommModeInfo()
+
+    x.cond_unlock("DAQ")  # DAQ resource is locked in many cases.
+
+    DAQ_LISTS[1].event_num = 0
+
+    print("setup DAQ lists.")
+    daq_parser.setup()  # Execute setup procedures.
+    print("start DAQ lists.")
+    daq_parser.start()  # Start DAQ lists.
+
+    time.sleep(5.0 * 60.0)  # Run for 15 minutes.
+
+    print("Stop DAQ....")
+    daq_parser.stop()  # Stop DAQ lists.
+    print("finalize DAQ lists.\n")
+    x.disconnect()
+
+if hasattr(daq_parser, "files"):  # `files` attribute is specific to `DaqToCsv`.
+    print("Data written to:")
+    print("================")
+    for fl in daq_parser.files.values():
+        print(fl.name)

pyxcp/examples/xcp_policy.py

@@ -1,18 +1,17 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""Demostrates how to use frame recording policies.
+"""Demostrates how to use frame recording policies including recorder extension.
 """
 from pprint import pprint
 
 from pyxcp.cmdline import ArgumentParser
-from pyxcp.transport.base import FrameRecorderAcquisitionPolicy
-from pyxcp.transport.base import StdoutPolicy
+from pyxcp.transport.base import FrameRecorderPolicy, StdoutPolicy  # noqa: F401
+
 
 ap = ArgumentParser(description="pyXCP frame recording policy example.")
 
 LOG_FILE = "pyxcp"
 
-policy = FrameRecorderAcquisitionPolicy(LOG_FILE)
+policy = FrameRecorderPolicy(LOG_FILE)
 use_recorder = True
 
 # policy = StdoutPolicy()  # You may also try this one.
@@ -25,7 +24,7 @@ with ap.run(policy=policy) as x:
     identifier = x.identifier(0x01)
     print("\nSlave Properties:")
     print("=================")
-    print(f"ID: '{identifier}'")
+    print(f"ID: {identifier!r}")
     pprint(x.slaveProperties)
     x.disconnect()
 
@@ -34,7 +33,7 @@ if use_recorder:
     from pyxcp.utils import hexDump
 
     try:
-        import pandas
+        import pandas  # noqa: F401
     except ImportError:
         has_pandas = False
     else:

pyxcp/examples/xcp_read_benchmark.py

@@ -1,14 +1,15 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Very basic hello-world example.
 """
 import time
-from pyxcp.cmdline import ArgumentParser
 
 import matplotlib.pyplot as plt
-import numpy as np
 import seaborn as sns
 
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.transport import FrameRecorderPolicy
+
+
 sns.set()
 
 
@@ -16,13 +17,14 @@ ADDR = 0x4000
 LENGTH = 0x1000
 ITERATIONS = 100
 
-ap = ArgumentParser(description="pyXCP hello world.")
+recorder_policy = FrameRecorderPolicy()  # Create frame recorder.
+ap = ArgumentParser(description="pyXCP hello world.", policy=recorder_policy)
 with ap.run() as x:
     xs = []
     ys = []
     x.connect()
     for ctoSize in range(8, 64 + 4, 4):
-        print("CTO-Size: {}".format(ctoSize))
+        print(f"CTO-Size: {ctoSize}")
         xs.append(ctoSize)
         start = time.perf_counter()
         for _ in range(ITERATIONS):
@@ -30,7 +32,7 @@ with ap.run() as x:
             data = x.fetch(LENGTH, ctoSize)
         et = time.perf_counter() - start
         ys.append(et)
-        print("CTO size: {:-3} -- elapsed time {:-3.04}".format(ctoSize, et))
+        print(f"CTO size: {ctoSize:-3} -- elapsed time {et:-3.04}")
     x.disconnect()
     plt.plot(xs, ys)
     plt.show()

pyxcp/examples/xcp_skel.py

@@ -1,8 +1,6 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Use this as a copy-and-paste template for your own scripts.
 """
-from pprint import pprint
 
 from pyxcp.cmdline import ArgumentParser
 

pyxcp/examples/xcp_unlock.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Very basic hello-world example.
 """
 from pyxcp.cmdline import ArgumentParser
 
+
 """
 """
 

pyxcp/examples/xcp_user_supplied_driver.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """User supplied CAN driver.
 
 Run as:
@@ -31,7 +30,7 @@ class MyCI(CanInterfaceBase):
     def close(self):
         pass
 
-    def getTimestampResolution(self):
+    def get_timestamp_resolution(self):
         pass
 
     def read(self):

pyxcp/examples/xcphello.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Very basic hello-world example.
 """
 from pprint import pprint
@@ -7,6 +6,7 @@ from pprint import pprint
 from pyxcp.cmdline import ArgumentParser
 from pyxcp.utils import decode_bytes
 
+
 daq_info = False
 
 
@@ -33,13 +33,16 @@ with ap.run() as x:
     identifier = x.identifier(0x01)
     print("\nSlave Properties:")
     print("=================")
-    print(f"ID: '{identifier}'")
+    print(f"ID: {identifier!r}")
     pprint(x.slaveProperties)
+    x.cond_unlock()
     cps = x.getCurrentProtectionStatus()
     print("\nProtection Status")
     print("=================")
     for k, v in cps.items():
         print(f"    {k:6s}: {v}")
+    daq = x.getDaqInfo()
+    pprint(daq)
     if daq_info:
         dqp = x.getDaqProcessorInfo()
         print("\nDAQ Processor Info:")
@@ -54,7 +57,7 @@ with ap.run() as x:
             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"    [{idx:04}] {name:r}")
             print(f"        dir:            {dq_st}")
             print(f"        packed:         {evt.daqEventProperties.packed}")
             PFX_CONS = "CONSISTENCY_"

pyxcp/examples/xcphello_recorder.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Very basic hello-world example.
 """
 from pprint import pprint
@@ -9,6 +8,7 @@ from pyxcp.recorder import XcpLogFileReader
 from pyxcp.transport import FrameRecorderPolicy
 from pyxcp.utils import decode_bytes
 
+
 daq_info = False
 
 
@@ -39,7 +39,7 @@ with ap.run(recorder_policy) as x:  # parameter policy is new.
     identifier = x.identifier(0x01)
     print("\nSlave Properties:")
     print("=================")
-    print(f"ID: '{identifier}'")
+    print(f"ID: {identifier!r}")
     pprint(x.slaveProperties)
     cps = x.getCurrentProtectionStatus()
     print("\nProtection Status")
@@ -60,7 +60,7 @@ with ap.run(recorder_policy) as x:  # parameter policy is new.
             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"    [{idx:04}] {name:r}")
             print(f"        dir:            {dq_st}")
             print(f"        packed:         {evt.daqEventProperties.packed}")
             PFX_CONS = "CONSISTENCY_"
@@ -80,7 +80,7 @@ with ap.run(recorder_policy) as x:  # parameter policy is new.
             print("=================")
             print(f"{x.getDaqListInfo(idx)}")
     x.disconnect()
-
+print("After recording...")
 ##
 ## Now read and dump recorded frames.
 ##

pyxcp/master/__init__.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Lowlevel API reflecting available XCP services
 
 .. note:: For technical reasons the API is split into two parts;
@@ -7,4 +6,4 @@
 
 .. [1] XCP Specification, Part 2 - Protocol Layer Specification
 """
-from .master import Master
+from .master import Master  # noqa: F401