pyxcp 0.25.1__cp314-cp314-macosx_11_0_arm64.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/run_daq.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python
+
+import sys
+import time
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.daq_stim import DaqList, DaqRecorder, DaqToCsv  # noqa: F401
+from pyxcp.types import XcpTimeoutError
+
+
+ap = ArgumentParser(description="DAQ test")
+
+XCP_LITE = False
+
+#
+# NOTE: UPDATE TO CORRECT ADDRESSES BEFORE RUNNING!!!
+#
+if XCP_LITE:
+    # Vectorgrp XCPlite.
+    DAQ_LISTS = [
+        DaqList(
+            name="part_1",
+            event_num=0,
+            stim=False,
+            enable_timestamps=False,
+            measurements=[
+                ("byteCounter", 0x00023648, 0, "U8"),
+                ("wordCounter", 0x0002364C, 0, "U16"),
+                ("dwordCounter", 0x00023650, 0, "U32"),
+                ("sbyteCounter", 0x00023649, 0, "I8"),
+            ],
+            priority=0,
+            prescaler=1,
+        ),
+        DaqList(
+            name="part_2",
+            event_num=7,
+            stim=False,
+            enable_timestamps=False,
+            measurements=[
+                ("swordCounter", 0x00023654, 0, "I16"),
+                ("sdwordCounter", 0x00023658, 0, "I32"),
+                ("channel1", 0x00023630, 0, "F64"),
+                ("channel2", 0x00023638, 0, "F64"),
+                ("channel3", 0x00023640, 0, "F64"),
+            ],
+            priority=0,
+            prescaler=1,
+        ),
+    ]
+else:
+    # XCPsim from CANape.
+    DAQ_LISTS = [
+        DaqList(
+            name="pwm_stuff",
+            event_num=2,
+            stim=False,
+            enable_timestamps=True,
+            measurements=[
+                ("channel1", 0x1BD004, 0, "F32"),
+                ("period", 0x001C0028, 0, "F32"),
+                ("channel2", 0x1BD008, 0, "F32"),
+                ("PWMFiltered", 0x1BDDE2, 0, "U8"),
+                ("PWM", 0x1BDDDF, 0, "U8"),
+                ("Triangle", 0x1BDDDE, 0, "I8"),
+            ],
+            priority=0,
+            prescaler=1,
+        ),
+        DaqList(
+            name="bytes",
+            event_num=1,
+            stim=False,
+            enable_timestamps=True,
+            measurements=[
+                ("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"),
+            ],
+            priority=0,
+            prescaler=1,
+        ),
+        DaqList(
+            name="words",
+            event_num=3,
+            stim=False,
+            enable_timestamps=True,
+            measurements=[
+                ("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"),
+            ],
+            priority=0,
+            prescaler=1,
+        ),
+    ]
+
+
+# daq_parser = DaqToCsv(DAQ_LISTS)  # Record to CSV file(s).
+daq_parser = DaqRecorder(DAQ_LISTS, "run_daq_21092025_01", 8)  # Record to ".xmraw" file.
+
+with ap.run(policy=daq_parser) as x:
+    try:
+        x.connect()
+    except XcpTimeoutError:
+        print("TO")
+        sys.exit(2)
+
+    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(2.0 * 60.0)
+    time.sleep(0.25 * 60.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))

pyxcp/examples/xcp_read_benchmark.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+"""Very basic hello-world example.
+"""
+import time
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.transport import FrameRecorderPolicy
+
+
+sns.set()
+
+
+ADDR = 0x4000
+LENGTH = 0x1000
+ITERATIONS = 100
+
+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(f"CTO-Size: {ctoSize}")
+        xs.append(ctoSize)
+        start = time.perf_counter()
+        for _ in range(ITERATIONS):
+            x.setMta(ADDR)
+            data = x.fetch(LENGTH, ctoSize)
+        et = time.perf_counter() - start
+        ys.append(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

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+"""Use this as a copy-and-paste template for your own scripts.
+"""
+
+from pyxcp.cmdline import ArgumentParser
+
+
+def callout(master, args):
+    if args.sk_dll:
+        master.seedNKeyDLL = args.sk_dll
+
+
+ap = ArgumentParser(description="pyXCP skeleton.", callout=callout)
+
+# Add command-line option for seed-and-key DLL.
+ap.parser.add_argument(
+    "-s",
+    "--sk-dll",
+    dest="sk_dll",
+    help="Seed-and-Key .DLL name",
+    type=str,
+    default=None,
+)
+
+with ap.run() as x:
+    x.connect()
+    if x.slaveProperties.optionalCommMode:
+        # Collect additional properties.
+        x.getCommModeInfo()
+
+    # getId() is not strictly required.
+    slave_name = x.identifier(0x01)
+
+    # Unlock resources, if necessary.
+    # Could be more specific, like cond_unlock("DAQ")
+    # Note: Unlocking requires a seed-and-key DLL.
+    x.cond_unlock()
+
+    ##
+    # Your own code goes here.
+    ##
+
+    x.disconnect()
+
+# Print some useful information.
+# print("\nSlave properties:")
+# print("=================")
+# print("ID: '{}'".format(slave_name.decode("utf8")))
+# pprint(x.slaveProperties)

pyxcp/examples/xcp_unlock.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+"""Very basic hello-world example.
+"""
+from pyxcp.cmdline import ArgumentParser
+
+
+"""
+"""
+
+
+def callout(master, args):
+    if args.sk_dll:
+        master.seedNKeyDLL = args.sk_dll
+
+
+ap = ArgumentParser(callout)
+ap.parser.add_argument(
+    "-s",
+    "--sk-dll",
+    dest="sk_dll",
+    help="Seed-and-Key .DLL name",
+    type=str,
+    default=None,
+)
+
+with ap.run() as x:
+    x.connect()
+
+    print("")
+    rps = x.getCurrentProtectionStatus()
+    print("Protection before unlocking:", rps, end="\n\n")
+
+    x.cond_unlock()
+
+    rps = x.getCurrentProtectionStatus()
+    print("Protection after unlocking:", rps)
+
+    x.disconnect()

pyxcp/examples/xcp_user_supplied_driver.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+from typing import Dict, List, Optional
+
+import can
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.transport.can import CanInterfaceBase
+
+
+class CustomCANInterface(CanInterfaceBase):
+
+    def init(self):
+        """Initialize the CAN interface here."""
+
+    def set_filters(self, filters):
+        print(f"set_filters({filters})")
+        self._filters = filters
+
+    def recv(self, timeout: Optional[float] = None) -> Optional[can.message.Message]:
+        """Receive CAN frames."""
+        return can.message.Message()
+
+    def send(self, msg: can.message.Message):
+        """Send CAN frames."""
+        print(f"send({msg})")
+
+    @property
+    def filters(self):
+        """Return the current CAN filters."""
+        return self._filters
+
+    @property
+    def state(self):
+        """Return the current state of the CAN interface."""
+        return can.BusState.ACTIVE
+
+
+custom_interface = CustomCANInterface()
+
+ap = ArgumentParser(description="User supplied CAN driver.")
+with ap.run(transport_layer_interface=custom_interface) as x:
+    x.connect()
+    x.disconnect()

pyxcp/examples/xcphello.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+"""Very basic hello-world example."""
+from pprint import pprint
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.utils import decode_bytes
+
+
+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!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:")
+        print("===================")
+        print(dqp)
+        print("\nDAQ Events:")
+        print("===========")
+        for idx in range(dqp.maxEventChannel):
+            evt = x.getDaqEventInfo(idx)
+            length = evt.eventChannelNameLength
+            name = decode_bytes(x.pull(length))
+            dq = "DAQ" if evt.daqEventProperties.daq else ""
+            st = "STIM" if evt.daqEventProperties.stim else ""
+            dq_st = dq + " " + st
+            print(f"    [{idx:04}] {name:r}")
+            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()

pyxcp/examples/xcphello_recorder.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python
+"""Very basic hello-world example.
+"""
+from pprint import pprint
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.recorder import XcpLogFileReader
+from pyxcp.transport import FrameRecorderPolicy
+from pyxcp.utils import decode_bytes
+
+
+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",
+)
+
+RECORDER_FILE_NAME = "xcphello"
+
+recorder_policy = FrameRecorderPolicy(RECORDER_FILE_NAME)  # Create frame recorder.
+
+with ap.run(recorder_policy) as x:  # parameter policy is new.
+    x.connect()
+    if x.slaveProperties.optionalCommMode:
+        x.getCommModeInfo()
+    identifier = x.identifier(0x01)
+    print("\nSlave Properties:")
+    print("=================")
+    print(f"ID: {identifier!r}")
+    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 = decode_bytes(x.pull(length))
+            dq = "DAQ" if evt.daqEventProperties.daq else ""
+            st = "STIM" if evt.daqEventProperties.stim else ""
+            dq_st = dq + " " + st
+            print(f"    [{idx:04}] {name:r}")
+            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()
+print("After recording...")
+##
+## Now read and dump recorded frames.
+##
+reader = XcpLogFileReader(RECORDER_FILE_NAME)
+
+hdr = reader.get_header()  # Get file information.
+print("\n\n")
+print("=" * 82)
+pprint(hdr)
+print("=" * 82)
+
+print("\nIterating over frames")
+print("=" * 82)
+for _frame in reader:
+    print(_frame)
+print("---")
+
+reader.reset_iter()  # Non-standard method to restart iteration.
+
+df = reader.as_dataframe()  # Return recordings as Pandas DataFrame.
+print("\nRecording as Pandas DataFrame")
+print("=" * 82)
+print(df.head(24))
+print("=" * 82)