pyxcp 0.21.11__cp38-cp38-win_amd64.whl → 0.22.2__cp38-cp38-win_amd64.whl

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

@@ -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