pyxcp 0.22.1__cp39-cp39-macosx_13_0_x86_64.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_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()

pyxcp/examples/run_daq.py

@@ -0,0 +1,146 @@
+#!/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", 0x203EA, 0, "U8"),
+                ("wordCounter", 0x203EC, 0, "U16"),
+                ("dwordCounter", 0x20410, 0, "U32"),
+                ("sbyteCounter", 0x203EB, 0, "I8"),
+            ],
+        ),
+        DaqList(
+            "part_2",
+            0,
+            False,
+            False,
+            [
+                ("swordCounter", 0x20414, 0, "I16"),
+                ("sdwordCounter", 0x20418, 0, "I32"),
+                ("channel1", 0x203F8, 0, "F64"),
+                ("channel2", 0x20400, 0, "F64"),
+                ("channel3", 0x20408, 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.
+
+    print("setup DAQ lists.")
+    daq_parser.setup()  # Execute setup procedures.
+    print("start DAQ lists.")
+    daq_parser.start()  # Start DAQ lists.
+
+    time.sleep(15.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

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+"""Demostrates how to use frame recording policies including recorder extension.
+"""
+from pprint import pprint
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.transport.base import FrameRecorderPolicy, StdoutPolicy  # noqa: F401
+
+
+ap = ArgumentParser(description="pyXCP frame recording policy example.")
+
+LOG_FILE = "pyxcp"
+
+policy = FrameRecorderPolicy(LOG_FILE)
+use_recorder = True
+
+# policy = StdoutPolicy()  # You may also try this one.
+# use_recorder = False
+
+with ap.run(policy=policy) as x:
+    x.connect()
+    if x.slaveProperties.optionalCommMode:
+        x.getCommModeInfo()
+    identifier = x.identifier(0x01)
+    print("\nSlave Properties:")
+    print("=================")
+    print(f"ID: {identifier!r}")
+    pprint(x.slaveProperties)
+    x.disconnect()
+
+if use_recorder:
+    from pyxcp.recorder import XcpLogFileReader
+    from pyxcp.utils import hexDump
+
+    try:
+        import pandas  # noqa: F401
+    except ImportError:
+        has_pandas = False
+    else:
+        has_pandas = True
+
+    reader = XcpLogFileReader(LOG_FILE)
+    hdr = reader.get_header()  # Get file information.
+    print("\nRecording file header")
+    print("=====================\n")
+    print(hdr)
+    print("\nRecorded frames")
+    print("===============\n")
+    print("CAT         CTR  TS             PAYLOAD")
+    print("-" * 80)
+    for category, counter, timestamp, payload in reader:
+        print(f"{category.name:8} {counter:6}  {timestamp:7.7f} {hexDump(payload)}")
+    print("-" * 80)
+    reader.reset_iter()  # reader acts as an Python iterator -- can be reseted with this non-standard method.
+    if has_pandas:
+        print("\nRecordings as Pandas stuff")
+        print("==========================\n")
+        df = reader.as_dataframe()  # Return recordings as Pandas DataFrame.
+        print(df.info())
+        print(df.head(60))