pyxcp 0.22.23__cp313-cp313-win_amd64.whl

pyxcp/examples/conf_can.toml

@@ -0,0 +1,19 @@
+TRANSPORT = "CAN"
+CAN_DRIVER = "KVaser"
+CAN_USE_DEFAULT_LISTENER = true
+CHANNEL = "0"
+ACCEPT_VIRTUAL = true
+CAN_ID_MASTER = 257
+CAN_ID_SLAVE = 258
+CAN_ID_BROADCAST = 256
+MAX_DLC_REQUIRED = false
+BITRATE = 50000
+DATA_BITRATE = 50000
+FD=false
+BTL_CYCLES = 16
+SAMPLE_RATE = 1
+SAMPLE_POINT = 87.5
+SJW = 2
+TSEG1 = 5
+TSEG2 = 2
+CREATE_DAQ_TIMESTAMPS = false

pyxcp/examples/conf_can_user.toml

@@ -0,0 +1,16 @@
+TRANSPORT = "CAN"
+CAN_DRIVER = "MyCI"
+CAN_USE_DEFAULT_LISTENER = true
+CHANNEL = "0"
+CAN_ID_MASTER = 257
+CAN_ID_SLAVE = 258
+CAN_ID_BROADCAST = 256
+MAX_DLC_REQUIRED = false
+BITRATE = 250000
+BTL_CYCLES = 16
+SAMPLE_RATE = 1
+SAMPLE_POINT = 87.5
+SJW = 2
+TSEG1 = 5
+TSEG2 = 2
+CREATE_DAQ_TIMESTAMPS = false

pyxcp/examples/conf_can_vector.json

@@ -0,0 +1,11 @@
+{
+  "TRANSPORT": "CAN",
+  "CAN_DRIVER": "Vector",
+  "CAN_USE_DEFAULT_LISTENER": true,
+  "CHANNEL": "1",
+  "CAN_ID_MASTER": 2,
+  "CAN_ID_SLAVE": 1,
+  "CAN_ID_BROADCAST": 256,
+  "MAX_DLC_REQUIRED": false,
+  "CREATE_DAQ_TIMESTAMPS": false
+}

pyxcp/examples/conf_can_vector.toml

@@ -0,0 +1,11 @@
+TRANSPORT = "CAN"
+CAN_DRIVER = "Vector"
+CAN_USE_DEFAULT_LISTENER = true
+CHANNEL = "0"
+CAN_ID_MASTER = 2
+CAN_ID_SLAVE = 1
+CAN_ID_BROADCAST = 256
+# MAX_DLC_REQUIRED = true
+CREATE_DAQ_TIMESTAMPS = false
+BITRATE=1000000
+SEED_N_KEY_DLL = "SeedNKeyXcp.dll"

pyxcp/examples/conf_eth.toml

@@ -0,0 +1,9 @@
+TRANSPORT = "ETH"
+#HOST = "192.168.197.40"
+#HOST = "192.168.198.175"
+HOST="localhost"
+PORT = 5555
+PROTOCOL = "UDP"
+IPV6 = false
+CREATE_DAQ_TIMESTAMPS = true
+SEED_N_KEY_DLL="SeedNKeyXcp.dll"

pyxcp/examples/conf_nixnet.json

@@ -0,0 +1,20 @@
+{
+  "TRANSPORT": "CAN",
+  "CAN_DRIVER": "NiXnet",
+  "CAN_USE_DEFAULT_LISTENER": true,
+  "CHANNEL": "CAN4",
+  "ACCEPT_VIRTUAL": true,
+  "BAUDRATE_PRESET": true,
+  "CAN_ID_MASTER": 1911,
+  "CAN_ID_SLAVE": 819,
+  "CAN_ID_BROADCAST": 256,
+  "MAX_DLC_REQUIRED": false,
+  "BITRATE": 500000,
+  "BTL_CYCLES": 16,
+  "SAMPLE_RATE": 1,
+  "SAMPLE_POINT": 87.5,
+  "SJW": 2,
+  "TSEG1": 5,
+  "TSEG2": 2,
+  "CREATE_DAQ_TIMESTAMPS": false
+}

pyxcp/examples/conf_socket_can.toml

@@ -0,0 +1,12 @@
+TRANSPORT = "CAN"
+CAN_DRIVER = "SocketCAN"
+CAN_USE_DEFAULT_LISTENER = true
+CHANNEL = "can0"
+CAN_ID_MASTER = 257
+CAN_ID_SLAVE = 258
+CAN_ID_BROADCAST = 256
+CREATE_DAQ_TIMESTAMPS = false
+FD = false
+MAX_DLC_REQUIRED = true
+MAX_CAN_FD_DLC = 32
+PADDING_VALUE = 0

pyxcp/examples/conf_sxi.json

@@ -0,0 +1,9 @@
+{
+  "TRANSPORT": "SXI",
+  "PORT": "COM10",
+  "BITRATE": 38400,
+  "BYTESIZE": 8,
+  "PARITY": "N",
+  "STOPBITS": 1,
+  "CREATE_DAQ_TIMESTAMPS": false
+}

pyxcp/examples/conf_sxi.toml

@@ -0,0 +1,7 @@
+TRANSPORT = "SXI"
+PORT = "COM10"
+BITRATE = 38400
+PARITY = "N"
+BYTESIZE = 8
+STOPBITS = 1
+CREATE_DAQ_TIMESTAMPS = false

pyxcp/examples/ex_arrow.py

@@ -0,0 +1,109 @@
+import argparse
+import logging
+from array import array
+from dataclasses import dataclass, field
+from typing import Any, List
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from pyxcp.recorder import XcpLogFileDecoder
+
+
+MAP_TO_ARROW = {
+    "U8": pa.uint8(),
+    "I8": pa.int8(),
+    "U16": pa.uint16(),
+    "I16": pa.int16(),
+    "U32": pa.uint32(),
+    "I32": pa.int32(),
+    "U64": pa.uint64(),
+    "I64": pa.int64(),
+    "F32": pa.float32(),
+    "F64": pa.float64(),
+    "F16": pa.float16(),
+    "BF16": pa.float16(),
+}
+
+MAP_TO_ARRAY = {
+    "U8": "B",
+    "I8": "b",
+    "U16": "H",
+    "I16": "h",
+    "U32": "L",
+    "I32": "l",
+    "U64": "Q",
+    "I64": "q",
+    "F32": "f",
+    "F64": "d",
+    "F16": "f",
+    "BF16": "f",
+}
+
+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 initialize(self) -> None:
+        self.arrow_tables = []
+        for dl in self.daq_lists:
+            result = []
+            for name, type_str in dl.headers:
+                array_txpe = MAP_TO_ARRAY[type_str]
+                arrow_type = MAP_TO_ARROW[type_str]
+                sd = Storage(name, arrow_type, array(array_txpe))
+                print(f"\t{name!r} {array_txpe} {arrow_type}", sd)
+                result.append(sd)
+            sc = StorageContainer(dl.name, result)
+            self.arrow_tables.append(sc)
+
+    def finalize(self) -> Any:
+        result = []
+        for arr in self.arrow_tables:
+            timestamp0 = arr.ts0
+            timestamp1 = arr.ts1
+            names = ["timestamp0", "timestamp1"]
+            data = [timestamp0, timestamp1]
+            for sd in arr.arr:
+                adt = pa.array(sd.arr, type=sd.arrow_type)
+                names.append(sd.name)
+                data.append(adt)
+            table = pa.Table.from_arrays(data, names=names)
+            fname = f"{arr.name}.parquet"
+            print("Writing table", fname)
+            pq.write_table(table, fname)
+            print("done.", table.shape)
+            result.append(table)
+        return result
+
+    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
+        sc = self.arrow_tables[daq_list_num]
+        sc.ts0.append(timestamp0)
+        sc.ts1.append(timestamp1)
+        for idx, elem in enumerate(measurements):
+            sto = sc.arr[idx]
+            sto.arr.append(elem)
+
+
+decoder = Decoder(args.xmraw_file)
+res = decoder.run()

pyxcp/examples/ex_csv.py

@@ -0,0 +1,85 @@
+import argparse
+import logging
+import os
+import csv
+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)
+
+    def initialize(self) -> None:
+        self.arrow_tables = []
+        self.csv_writers = []
+        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)
+            writer = csv.writer(open(f"{sc.name}.csv", "w", newline=""), dialect="excel")
+            headers = ["ts0", "ts1"] + [e.name for e in sc.arr]
+            writer.writerow(headers)
+            self.csv_writers.append(writer)
+            self.arrow_tables.append(sc)
+        print("\nInserting data...")
+
+    def finalize(self) -> None:
+        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]
+        writer = self.csv_writers[daq_list_num]
+        data = [timestamp0, timestamp1, *measurements]
+        writer.writerow(data)
+
+decoder = Decoder(args.xmraw_file)
+decoder.run()

pyxcp/examples/ex_excel.py

@@ -0,0 +1,95 @@
+import argparse
+import logging
+import os
+import xlsxwriter
+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.xls_file_name = Path(recording_file_name).with_suffix(".xlsx")
+        try:
+            os.unlink(self.xls_file_name)
+        except Exception as e:
+            print(e)
+
+    def initialize(self) -> None:
+        self.arrow_tables = []
+        self.xls_workbook = xlsxwriter.Workbook(self.xls_file_name)
+        self.xls_sheets = []
+        self.rows = []
+        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)
+            sheet = self.xls_workbook.add_worksheet(sc.name)
+            self.xls_sheets.append(sheet)
+            headers = ["ts0", "ts1"] + [e.name for e in sc.arr]
+            sheet.write_row(0, 0, headers)
+            self.rows.append(1)
+            self.arrow_tables.append(sc)
+        print("\nInserting data...")
+
+    def finalize(self) -> None:
+        self.xls_workbook.close()
+        print("Done.")
+
+    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
+        sheet = self.xls_sheets[daq_list_num]
+        row = self.rows[daq_list_num]
+        data = [timestamp0, timestamp1] + measurements
+        sheet.write_row(row, 0, data)
+        self.rows[daq_list_num] += 1
+
+decoder = Decoder(args.xmraw_file)
+decoder.run()

pyxcp/examples/ex_mdf.py

@@ -0,0 +1,124 @@
+import argparse
+import logging
+from array import array
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, List
+
+import numpy as np
+from asammdf import MDF, Signal
+from asammdf.blocks.v4_blocks import HeaderBlock  # ChannelGroup
+from asammdf.blocks.v4_constants import FLAG_HD_TIME_OFFSET_VALID  # FLAG_HD_LOCAL_TIME,
+
+from pyxcp.recorder import XcpLogFileDecoder
+
+
+MAP_TO_NP = {
+    "U8": np.uint8,
+    "I8": np.int8,
+    "U16": np.uint16,
+    "I16": np.int16,
+    "U32": np.uint32,
+    "I32": np.int32,
+    "U64": np.uint64,
+    "I64": np.int64,
+    "F32": np.float32,
+    "F64": np.float64,
+    "F16": np.float16,
+    "BF16": np.float16,
+}
+
+MAP_TO_ARRAY = {
+    "U8": "B",
+    "I8": "b",
+    "U16": "H",
+    "I16": "h",
+    "U32": "L",
+    "I32": "l",
+    "U64": "Q",
+    "I64": "q",
+    "F32": "f",
+    "F64": "d",
+    "F16": "f",
+    # "BF16"
+}
+
+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.mdf_file_name = Path(recording_file_name).with_suffix(".mf4")
+
+    def initialize(self) -> None:
+        self.tables = []
+        for dl in self.daq_lists:
+            result = []
+            for name, type_str in dl.headers:
+                array_txpe = MAP_TO_ARRAY[type_str]
+                arrow_type = MAP_TO_NP[type_str]
+                sd = Storage(name, arrow_type, array(array_txpe))
+                result.append(sd)
+            sc = StorageContainer(dl.name, result)
+            self.tables.append(sc)
+        print("Extracting DAQ lists...")
+
+    def finalize(self) -> None:
+        print("Creating MDF result...")
+        timestamp_info = self.parameters.timestamp_info
+        hdr = HeaderBlock(
+            abs_time=timestamp_info.timestamp_ns,
+            tz_offset=timestamp_info.utc_offset,
+            daylight_save_time=timestamp_info.dst_offset,
+            time_flags=FLAG_HD_TIME_OFFSET_VALID,
+        )
+        hdr.comment = f"""<HDcomment><TX>Timezone: {timestamp_info.timezone}</TX></HDcomment>"""  # Test-Comment.
+        mdf4 = MDF(version="4.10")
+        mdf4.header = hdr
+        # result = []
+        for idx, arr in enumerate(self.tables):
+            signals = []
+            timestamps = arr.ts0
+            for sd in arr.arr:
+
+                signal = Signal(samples=sd.arr, name=sd.name, timestamps=timestamps)
+                signals.append(signal)
+            print(f"Appending data-group {arr.name!r}")
+            mdf4.append(signals, acq_name=arr.name, comment="Created by pyXCP recorder")
+        print(f"Writing '{self.mdf_file_name!s}'")
+        mdf4.save(self.mdf_file_name, compression=2, overwrite=True)
+        print("Done.")
+        return mdf4
+
+    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
+        sc = self.tables[daq_list_num]
+        sc.ts0.append(timestamp0)
+        sc.ts1.append(timestamp1)
+        for idx, elem in enumerate(measurements):
+            sto = sc.arr[idx]
+            sto.arr.append(elem)
+
+
+decoder = Decoder(args.xmraw_file)
+res = decoder.run()

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()