pyxcp 0.21.9__cp38-cp38-win_amd64.whl → 0.22.23__cp38-cp38-win_amd64.whl

pyxcp/dllif.py

@@ -1,11 +1,10 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 import binascii
 import ctypes
 import enum
 import platform
 import re
-import subprocess
+import subprocess  # nosec
 import sys
 from pathlib import Path
 
@@ -24,31 +23,30 @@ class SeedNKeyError(Exception):
     """"""
 
 
-LOADER = Path(sys.modules["pyxcp"].__file__).parent / "asamkeydll"  # Absolute path to DLL loader.
+LOADER = Path(str(sys.modules["pyxcp"].__file__)).parent / "asamkeydll"  # Absolute path to DLL loader.
 
 bwidth, _ = platform.architecture()
 
-if sys.platform in ("win32", "linux"):
+if sys.platform in ("win32", "linux", "darwin"):
     if bwidth == "64bit":
         use_ctypes = False
     elif bwidth == "32bit":
         use_ctypes = True
 else:
-    raise RuntimeError("Platform '{}' currently not supported.".format(sys.platform))
+    raise RuntimeError(f"Platform {sys.platform!r} currently not supported.")
 
 
-def getKey(logger, dllName: str, privilege: int, seed: str, assume_same_bit_width: bool):
-
+def getKey(logger, dllName: str, privilege: int, seed: bytes, assume_same_bit_width: bool):
     dllName = str(Path(dllName).absolute())  # Fix loader issues.
 
-    use_ctypes = False
+    use_ctypes: bool = False
     if assume_same_bit_width:
         use_ctypes = True
     if use_ctypes:
         try:
-            lib = ctypes.cdll.LoadLibrary(dllName)
+            lib: ctypes.CDLL = ctypes.cdll.LoadLibrary(dllName)
         except OSError:
-            logger.error(f"Could not load DLL '{dllName}' -- Probably an 64bit vs 32bit issue?")
+            logger.error(f"Could not load DLL {dllName!r} -- Probably an 64bit vs 32bit issue?")
             return (SeedNKeyResult.ERR_COULD_NOT_LOAD_DLL, None)
         func = lib.XCP_ComputeKeyFromSeed
         func.restype = ctypes.c_uint32
@@ -59,9 +57,9 @@ def getKey(logger, dllName: str, privilege: int, seed: str, assume_same_bit_widt
             ctypes.POINTER(ctypes.c_uint8),
             ctypes.c_char_p,
         ]
-        key_buffer = ctypes.create_string_buffer(b"\000" * 128)
-        key_length = ctypes.c_uint8(128)
-        ret_code = func(
+        key_buffer: ctypes.Array[ctypes.c_char] = ctypes.create_string_buffer(b"\000" * 128)
+        key_length: ctypes.c_uint8 = ctypes.c_uint8(128)
+        ret_code: int = func(
             privilege,
             len(seed),
             ctypes.c_char_p(seed),
@@ -75,16 +73,21 @@ def getKey(logger, dllName: str, privilege: int, seed: str, assume_same_bit_widt
                 [LOADER, dllName, str(privilege), binascii.hexlify(seed).decode("ascii")],
                 stdout=subprocess.PIPE,
                 shell=False,
-            )
+            )  # nosec
         except FileNotFoundError as exc:
-            logger.error(f"Could not find executable '{LOADER}' -- {exc}")
+            logger.error(f"Could not find executable {LOADER!r} -- {exc}")
             return (SeedNKeyResult.ERR_COULD_NOT_LOAD_DLL, None)
         except OSError as exc:
-            logger.error(f"Cannot execute {LOADER} -- {exc}")
+            logger.error(f"Cannot execute {LOADER!r} -- {exc}")
             return (SeedNKeyResult.ERR_COULD_NOT_LOAD_DLL, None)
-        key = p0.stdout.read()
+        key: bytes = b""
+        if p0.stdout:
+            key = p0.stdout.read()
+            p0.stdout.close()
+        p0.kill()
+        p0.wait()
         if not key:
-            logger.error(f"Something went wrong while calling seed-and-key-DLL '{dllName}'")
+            logger.error(f"Something went wrong while calling seed-and-key-DLL {dllName!r}")
             return (SeedNKeyResult.ERR_COULD_NOT_LOAD_DLL, None)
         res = re.split(b"\r?\n", key)
         returnCode = int(res[0])

pyxcp/errormatrix.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Types and structures to support error-handling as specified by XCP.
 """
 import enum
 from collections import namedtuple
-from pyxcp.types import Command
-from pyxcp.types import XcpError
+
+from pyxcp.types import Command, XcpError
+
 
 Handler = namedtuple("Handler", "preAction  action")
 
@@ -257,6 +257,7 @@ ERROR_MATRIX = {
         ),
     },
     Command.TRANSPORT_LAYER_CMD: {
+        XcpError.ERR_CMD_UNKNOWN: ((PreAction.NONE), Action.DISPLAY_ERROR),
         XcpError.ERR_TIMEOUT: ((PreAction.SYNCH,), Action.REPEAT_2_TIMES),
         XcpError.ERR_CMD_BUSY: ((PreAction.WAIT_T7), Action.REPEAT_INF_TIMES),
         XcpError.ERR_PGM_ACTIVE: ((PreAction.WAIT_T7), Action.REPEAT_INF_TIMES),
@@ -268,6 +269,7 @@ ERROR_MATRIX = {
         ),
     },
     Command.USER_CMD: {
+        XcpError.ERR_CMD_UNKNOWN: ((PreAction.NONE), Action.DISPLAY_ERROR),
         XcpError.ERR_TIMEOUT: ((PreAction.SYNCH,), Action.REPEAT_2_TIMES),
         XcpError.ERR_CMD_BUSY: ((PreAction.WAIT_T7), Action.REPEAT_INF_TIMES),
         XcpError.ERR_PGM_ACTIVE: ((PreAction.WAIT_T7), Action.REPEAT_INF_TIMES),

pyxcp/examples/conf_can.toml

@@ -1,5 +1,5 @@
 TRANSPORT = "CAN"
-CAN_DRIVER = "Kvaser"
+CAN_DRIVER = "KVaser"
 CAN_USE_DEFAULT_LISTENER = true
 CHANNEL = "0"
 ACCEPT_VIRTUAL = true
@@ -7,7 +7,9 @@ CAN_ID_MASTER = 257
 CAN_ID_SLAVE = 258
 CAN_ID_BROADCAST = 256
 MAX_DLC_REQUIRED = false
-BITRATE = 250000
+BITRATE = 50000
+DATA_BITRATE = 50000
+FD=false
 BTL_CYCLES = 16
 SAMPLE_RATE = 1
 SAMPLE_POINT = 87.5

pyxcp/examples/conf_can_vector.json

@@ -1,11 +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
+  "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

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

pyxcp/examples/conf_eth.toml

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

pyxcp/examples/conf_nixnet.json

@@ -1,20 +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
+  "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_sxi.json

@@ -1,9 +1,9 @@
 {
-    "TRANSPORT": "SXI",
-    "PORT": "COM10",
-    "BITRATE": 38400,
-    "BYTESIZE": 8,
-    "PARITY": "N",
-    "STOPBITS": 1,
-    "CREATE_DAQ_TIMESTAMPS": false
+  "TRANSPORT": "SXI",
+  "PORT": "COM10",
+  "BITRATE": 38400,
+  "BYTESIZE": 8,
+  "PARITY": "N",
+  "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()