nuotec-sent2usb 0.1.0__tar.gz

nuotec_sent2usb-0.1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nuotec GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nuotec_sent2usb-0.1.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: nuotec-sent2usb
+Version: 0.1.0
+Summary: Driver for Nuotec SENT2USB Converter
+Author: Nuotec GmbH
+License-Expression: MIT
+License-File: LICENSE.txt
+Requires-Dist: cobs>=1.2.2,<2
+Requires-Dist: pyserial>=3.5,<4
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Nuotec SENT2USB Python Driver
+
+This is an alternative Python driver for the
+[SENT (SAE J2716) to USB converter from uCANDevices](https://ucandevices.github.io/sentusb.html).
+
+> [!IMPORTANT]
+> This driver requires the firmware from
+> [nuotec-sent2usb-firmware](https://gitlab.com/nuotec/sent2usb/nuotec-sent2usb-firmware)
+> to be running on the device. See the instructions below to replace the
+> original firmware with this firmware.
+
+> [!NOTE]
+> For more information about the advantages and disadvantages of this
+> alternative firmware and Python driver compared to the original product, see
+> details at
+> [nuotec-sent2usb-firmware](https://gitlab.com/nuotec/sent2usb/nuotec-sent2usb-firmware).
+
+## Installation
+
+Install the package from PyPI:
+
+```bash
+pip install nuotec-sent2usb
+```
+
+## CLI Usage
+
+The easiest way to use this driver is through its command-line interface:
+
+```bash
+$ nuotec-sent2usb --help
+
+usage: nuotec-sent2usb [-h] [-l] [-a] [-b] [-o] [-f] [-u] [-p PORT] [-s SEND] [-i INTERVAL] [-m] [-t TICK_TIME] [-w WIDTH]
+
+options:
+  -h, --help            show this help message and exit
+  -l, --list            List connected devices
+  -a, --all             List all available serial ports
+  -b, --bootloader      Enter DFU bootloader
+  -o, --flash-option-bytes
+                        Flash option bytes with dfu-util
+  -f, --flash           Flash firmware with dfu-util
+  -u, --update          Check & update firmware on device
+  -p, --port PORT       Serial port
+  -s, --send SEND       Send nibbles (e.g. '0abc')
+  -i, --interval INTERVAL
+                        Send data periodically in this interval [s]
+  -m, --monitor         Monitor and print received SENT frames
+  -t, --tick-time TICK_TIME
+                        Clock tick time in microseconds
+  -w, --width WIDTH     Low pulse length in ticks
+```
+
+### Flash Firmware
+
+After you have purchased an original
+[SENTToUSB device from uCANDevices](https://ucandevices.github.io/sentusb.html),
+you need to replace its firmware to make it work with this Python driver.
+
+> [!CAUTION]
+> This step may be risky. After flashing our firmware, your device won't be
+> compatible with the tools from uCANDevices anymore. It is recommended to
+> back up the original firmware on the device first, to allow restoring it
+> at any time.
+
+First, instruct the original firmware to enter the bootloader (adjust
+`/dev/ttyACM0` to match your serial port):
+
+```bash
+python -c "import serial,time; s=serial.Serial('/dev/ttyACM0',115200,timeout=1); s.write(b'boot\r'); time.sleep(0.3); s.close()"
+```
+
+Then flash the new firmware to it. This will require
+[dfu-util](https://dfu-util.sourceforge.net/) to be available in `PATH`:
+
+```bash
+nuotec-sent2usb -f
+```
+
+### Update Firmware
+
+If the device is already running our custom firmware, it can be updated with
+a single command (the firmware binary is contained in the Python driver):
+
+```bash
+nuotec-sent2usb -u
+```
+
+### Example: List Devices
+
+```bash
+$ nuotec-sent2usb -l
+/dev/ttyACM0 Nuotec SENT2USB - CDC Interface 002E002F393043022033344E
+```
+
+### Example: Send Frame (90us Tick Time, Data=123456)
+
+```bash
+$ nuotec-sent2usb -t 90 -s 123456
+Firmware:   1.0.0 (9b287c72ce4c48e7c11475cbb7acde5df17e562a)
+Tick Time:  90 μs
+TX: status=0x1 data=[0x2, 0x3, 0x4, 0x5, 0x6] crc=0x0
+```
+
+### Example: Monitor Received Frames (90us Tick Time)
+
+```bash
+$ nuotec-sent2usb -t 90 -m
+Firmware:   1.0.0 (9b287c72ce4c48e7c11475cbb7acde5df17e562a)
+Tick Time:  90 μs
+RX: status=0x0 data=[0x1, 0x0, 0xC, 0x3, 0xC, 0x0] crc=0xB
+RX: status=0x0 data=[0x1, 0x0, 0xC, 0x3, 0xC, 0x0] crc=0xB
+RX: status=0x0 data=[0x1, 0x0, 0xC, 0x3, 0xC, 0x0] crc=0xB
+RX: status=0x0 data=[0x1, 0x0, 0xC, 0x3, 0xC, 0x0] crc=0xB
+```
+
+Press Ctrl+C to cancel.
+
+## API Usage
+
+The driver can also be used from Python directly:
+
+```python
+import time
+from nuotec_sent2usb import Sent2UsbDevice, SentFrame, SentDecoder
+
+with Sent2UsbDevice() as device:
+    print(f"Firmware: {device.get_version()}")
+
+    # Send frame
+    frame = SentFrame(status=0x0, data=[0x1, 0x2, 0x3, 0x4, 0x5, 0x6])
+    device.send_pulses(frame.to_pulses(5, 90))  # width [ticks] & tick time [us]
+    print(f"TX: {frame}")
+
+    # Receive frames
+    decoder = SentDecoder(90)  # tick time [us]
+    while True:
+        for period, width in device.fetch_pulses():
+            frame = decoder.process(period, width)
+            if frame is not None:
+                print(f"RX: {frame}")
+        time.sleep(0.05)
+```
+
+For more details, see the Python files in this package.
+
+## Disclaimer
+
+This project is provided as-is without any guarantee for correct behavior.
+It was a side project, without the goal of creating a highly reliable
+production device. So far it seems to work fine, but the code is not perfect
+at all and would need some deeper review, rework and more testing to get more
+confidence about the quality and reliability of this product.
+
+## Contributions
+
+Generally, this project has been published just in case it could be useful for
+other people. However, it may or may not fit your use-case. In case you are
+interested in adding more functionality, bugfixing, etc., we are happy to
+receive contributions (though without any guarantee that we find the time to
+review & merge it - it's recommended to contact us in advance about your
+intentions).
+
+## Credits
+
+The development of this project is kindly sponsored by
+[Nuotec GmbH](https://nuotec.ch) and
+[Sensirion Automotive Solutions AG](https://sensirion-automotive.com/).
+
+Many thanks to [uCANDevices](https://ucandevices.github.io/) for developing
+the hardware this firmware runs on, which is available for purchase through
+their website.
+
+## License
+
+Released under MIT, see [LICENSE.txt](LICENSE.txt).

nuotec_sent2usb-0.1.0/README.md

@@ -0,0 +1,176 @@
+# Nuotec SENT2USB Python Driver
+
+This is an alternative Python driver for the
+[SENT (SAE J2716) to USB converter from uCANDevices](https://ucandevices.github.io/sentusb.html).
+
+> [!IMPORTANT]
+> This driver requires the firmware from
+> [nuotec-sent2usb-firmware](https://gitlab.com/nuotec/sent2usb/nuotec-sent2usb-firmware)
+> to be running on the device. See the instructions below to replace the
+> original firmware with this firmware.
+
+> [!NOTE]
+> For more information about the advantages and disadvantages of this
+> alternative firmware and Python driver compared to the original product, see
+> details at
+> [nuotec-sent2usb-firmware](https://gitlab.com/nuotec/sent2usb/nuotec-sent2usb-firmware).
+
+## Installation
+
+Install the package from PyPI:
+
+```bash
+pip install nuotec-sent2usb
+```
+
+## CLI Usage
+
+The easiest way to use this driver is through its command-line interface:
+
+```bash
+$ nuotec-sent2usb --help
+
+usage: nuotec-sent2usb [-h] [-l] [-a] [-b] [-o] [-f] [-u] [-p PORT] [-s SEND] [-i INTERVAL] [-m] [-t TICK_TIME] [-w WIDTH]
+
+options:
+  -h, --help            show this help message and exit
+  -l, --list            List connected devices
+  -a, --all             List all available serial ports
+  -b, --bootloader      Enter DFU bootloader
+  -o, --flash-option-bytes
+                        Flash option bytes with dfu-util
+  -f, --flash           Flash firmware with dfu-util
+  -u, --update          Check & update firmware on device
+  -p, --port PORT       Serial port
+  -s, --send SEND       Send nibbles (e.g. '0abc')
+  -i, --interval INTERVAL
+                        Send data periodically in this interval [s]
+  -m, --monitor         Monitor and print received SENT frames
+  -t, --tick-time TICK_TIME
+                        Clock tick time in microseconds
+  -w, --width WIDTH     Low pulse length in ticks
+```
+
+### Flash Firmware
+
+After you have purchased an original
+[SENTToUSB device from uCANDevices](https://ucandevices.github.io/sentusb.html),
+you need to replace its firmware to make it work with this Python driver.
+
+> [!CAUTION]
+> This step may be risky. After flashing our firmware, your device won't be
+> compatible with the tools from uCANDevices anymore. It is recommended to
+> back up the original firmware on the device first, to allow restoring it
+> at any time.
+
+First, instruct the original firmware to enter the bootloader (adjust
+`/dev/ttyACM0` to match your serial port):
+
+```bash
+python -c "import serial,time; s=serial.Serial('/dev/ttyACM0',115200,timeout=1); s.write(b'boot\r'); time.sleep(0.3); s.close()"
+```
+
+Then flash the new firmware to it. This will require
+[dfu-util](https://dfu-util.sourceforge.net/) to be available in `PATH`:
+
+```bash
+nuotec-sent2usb -f
+```
+
+### Update Firmware
+
+If the device is already running our custom firmware, it can be updated with
+a single command (the firmware binary is contained in the Python driver):
+
+```bash
+nuotec-sent2usb -u
+```
+
+### Example: List Devices
+
+```bash
+$ nuotec-sent2usb -l
+/dev/ttyACM0 Nuotec SENT2USB - CDC Interface 002E002F393043022033344E
+```
+
+### Example: Send Frame (90us Tick Time, Data=123456)
+
+```bash
+$ nuotec-sent2usb -t 90 -s 123456
+Firmware:   1.0.0 (9b287c72ce4c48e7c11475cbb7acde5df17e562a)
+Tick Time:  90 μs
+TX: status=0x1 data=[0x2, 0x3, 0x4, 0x5, 0x6] crc=0x0
+```
+
+### Example: Monitor Received Frames (90us Tick Time)
+
+```bash
+$ nuotec-sent2usb -t 90 -m
+Firmware:   1.0.0 (9b287c72ce4c48e7c11475cbb7acde5df17e562a)
+Tick Time:  90 μs
+RX: status=0x0 data=[0x1, 0x0, 0xC, 0x3, 0xC, 0x0] crc=0xB
+RX: status=0x0 data=[0x1, 0x0, 0xC, 0x3, 0xC, 0x0] crc=0xB
+RX: status=0x0 data=[0x1, 0x0, 0xC, 0x3, 0xC, 0x0] crc=0xB
+RX: status=0x0 data=[0x1, 0x0, 0xC, 0x3, 0xC, 0x0] crc=0xB
+```
+
+Press Ctrl+C to cancel.
+
+## API Usage
+
+The driver can also be used from Python directly:
+
+```python
+import time
+from nuotec_sent2usb import Sent2UsbDevice, SentFrame, SentDecoder
+
+with Sent2UsbDevice() as device:
+    print(f"Firmware: {device.get_version()}")
+
+    # Send frame
+    frame = SentFrame(status=0x0, data=[0x1, 0x2, 0x3, 0x4, 0x5, 0x6])
+    device.send_pulses(frame.to_pulses(5, 90))  # width [ticks] & tick time [us]
+    print(f"TX: {frame}")
+
+    # Receive frames
+    decoder = SentDecoder(90)  # tick time [us]
+    while True:
+        for period, width in device.fetch_pulses():
+            frame = decoder.process(period, width)
+            if frame is not None:
+                print(f"RX: {frame}")
+        time.sleep(0.05)
+```
+
+For more details, see the Python files in this package.
+
+## Disclaimer
+
+This project is provided as-is without any guarantee for correct behavior.
+It was a side project, without the goal of creating a highly reliable
+production device. So far it seems to work fine, but the code is not perfect
+at all and would need some deeper review, rework and more testing to get more
+confidence about the quality and reliability of this product.
+
+## Contributions
+
+Generally, this project has been published just in case it could be useful for
+other people. However, it may or may not fit your use-case. In case you are
+interested in adding more functionality, bugfixing, etc., we are happy to
+receive contributions (though without any guarantee that we find the time to
+review & merge it - it's recommended to contact us in advance about your
+intentions).
+
+## Credits
+
+The development of this project is kindly sponsored by
+[Nuotec GmbH](https://nuotec.ch) and
+[Sensirion Automotive Solutions AG](https://sensirion-automotive.com/).
+
+Many thanks to [uCANDevices](https://ucandevices.github.io/) for developing
+the hardware this firmware runs on, which is available for purchase through
+their website.
+
+## License
+
+Released under MIT, see [LICENSE.txt](LICENSE.txt).

nuotec_sent2usb-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "nuotec-sent2usb"
+version = "0.1.0"
+description = "Driver for Nuotec SENT2USB Converter"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE.txt"]
+requires-python = ">=3.8"
+dependencies = [
+    "cobs>=1.2.2,<2",
+    "pyserial>=3.5,<4",
+]
+
+[[project.authors]]
+name = "Nuotec GmbH"
+
+[project.scripts]
+nuotec-sent2usb = "nuotec_sent2usb.cli:main"
+sent2usb = "nuotec_sent2usb.cli:main"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0,<8.4",
+    "ruff>=0.16.2,<0.17",
+]
+
+[build-system]
+requires = ["uv_build>=0.12.3,<0.13"]
+build-backend = "uv_build"

nuotec_sent2usb-0.1.0/pyproject.toml.orig

@@ -0,0 +1,29 @@
+[project]
+name = "nuotec-sent2usb"
+version = "0.1.0"
+description = "Driver for Nuotec SENT2USB Converter"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE.txt"]
+authors = [
+    { name = "Nuotec GmbH" },
+]
+requires-python = ">=3.8"
+dependencies = [
+    "cobs>=1.2.2,<2",
+    "pyserial>=3.5,<4",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0,<8.4",
+    "ruff>=0.16.2,<0.17",
+]
+
+[project.scripts]
+nuotec-sent2usb = "nuotec_sent2usb.cli:main"
+sent2usb = "nuotec_sent2usb.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.12.3,<0.13"]
+build-backend = "uv_build"

nuotec_sent2usb-0.1.0/src/nuotec_sent2usb/__init__.py

@@ -0,0 +1,19 @@
+from .decoder import SentDecoder
+from .device import Sent2UsbDevice
+from .device_version import Sent2UsbDeviceVersion
+from .exceptions import (
+    Sent2UsbCommunicationError,
+    Sent2UsbDeviceError,
+    Sent2UsbError,
+)
+from .frame import SentFrame
+
+__all__ = [
+    "Sent2UsbCommunicationError",
+    "Sent2UsbDevice",
+    "Sent2UsbDeviceError",
+    "Sent2UsbDeviceVersion",
+    "Sent2UsbError",
+    "SentDecoder",
+    "SentFrame",
+]

nuotec_sent2usb-0.1.0/src/nuotec_sent2usb/cli.py

@@ -0,0 +1,191 @@
+import argparse
+import subprocess
+import sys
+import time
+from importlib import resources
+from struct import unpack
+
+from .decoder import SentDecoder
+from .device import Sent2UsbDevice
+from .device_version import Sent2UsbDeviceVersion
+from .frame import SentFrame
+
+FIRMWARE_RESOURCE = ("nuotec_sent2usb", "nuotec-sent2usb.bin")
+OPTIONBYTES_RESOURCE = ("nuotec_sent2usb", "optionbytes.bin")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-l", "--list", action="store_true", help="List connected devices"
+    )
+    parser.add_argument(
+        "-a", "--all", action="store_true", help="List all available serial ports"
+    )
+    parser.add_argument(
+        "-b", "--bootloader", action="store_true", help="Enter DFU bootloader"
+    )
+    parser.add_argument(
+        "-o",
+        "--flash-option-bytes",
+        action="store_true",
+        help="Flash option bytes with dfu-util",
+    )
+    parser.add_argument(
+        "-f", "--flash", action="store_true", help="Flash firmware with dfu-util"
+    )
+    parser.add_argument(
+        "-u", "--update", action="store_true", help="Check & update firmware on device"
+    )
+    parser.add_argument("-p", "--port", type=str, help="Serial port")
+    parser.add_argument(
+        "-s",
+        "--send",
+        type=str,
+        help="Send nibbles (e.g. '0abc')",
+    )
+    parser.add_argument(
+        "-i",
+        "--interval",
+        type=float,
+        help="Send data periodically in this interval [s]",
+    )
+    parser.add_argument(
+        "-m",
+        "--monitor",
+        action="store_true",
+        help="Monitor and print received SENT frames",
+    )
+    parser.add_argument(
+        "-t", "--tick-time", type=int, default=3, help="Clock tick time in microseconds"
+    )
+    parser.add_argument(
+        "-w", "--width", type=int, default=5, help="Low pulse length in ticks"
+    )
+    args = parser.parse_args()
+
+    # --list
+    if args.list:
+        try:
+            ports = Sent2UsbDevice.list_ports(list_all=args.all, as_objects=True)
+            for p in ports:
+                print(f"{p.device} {p.manufacturer} {p.description} {p.serial_number}")
+            if len(ports) == 0:
+                print(
+                    "No device found. Make sure the nuotec-sent2usb firmware is flashed and running."
+                )
+        except Exception as e:  # noqa: BLE001
+            print(f"ERROR: {e!s}")
+            sys.exit(1)
+
+    # --update
+    if args.update:
+        try:
+            with resources.path(*FIRMWARE_RESOURCE) as p, open(p, "rb") as f:
+                content = f.read()
+            pattern, major, minor, patch, candidate, name_len, desc_len = unpack(
+                "<IBBBBII", content[0x100:0x110]
+            )
+            if pattern != 0x6E758001:
+                raise ValueError("Invalid firmware binary (magic pattern not found).")
+            latest_version = Sent2UsbDeviceVersion(
+                major,
+                minor,
+                patch,
+                candidate,
+                content[0x114 + name_len : 0x114 + name_len + desc_len],
+            )
+            print(f"Latest version: {latest_version}")
+            with Sent2UsbDevice(args.port) as device:
+                version = device.get_version()
+                print(f"Device version: {version}")
+            if latest_version.build_id == version.build_id:
+                print("Firmware is up-to-date.")
+            else:
+                args.bootloader = True
+                args.flash = True
+        except Exception as e:  # noqa: BLE001
+            print(f"ERROR: {e!s}")
+            sys.exit(1)
+
+    # --bootloader
+    if args.bootloader:
+        try:
+            print("Enter bootloader...")
+            with Sent2UsbDevice(args.port) as device:
+                device.enter_bootloader()
+            print("Waiting for reset...")
+            time.sleep(4.0)
+        except Exception as e:  # noqa: BLE001
+            print(f"ERROR: {e!s}")
+            sys.exit(1)
+
+    # --flash-option-bytes
+    if args.flash_option_bytes:
+        try:
+            with resources.path(*OPTIONBYTES_RESOURCE) as p:
+                command = [
+                    "dfu-util",
+                    "-a1",
+                    "-s0x1ffff800",
+                    f"-D{p}",
+                ]
+                print(f"Run command: {' '.join(command)}")
+                subprocess.check_call(command, stdout=sys.stdout, stderr=sys.stderr)
+                time.sleep(2.0)
+        except Exception as e:  # noqa: BLE001
+            print(f"ERROR: {e!s}")
+            sys.exit(1)
+
+    # --flash
+    if args.flash:
+        try:
+            with resources.path(*FIRMWARE_RESOURCE) as p:
+                command = [
+                    "dfu-util",
+                    "-a0",
+                    "-s0x08000000:leave",
+                    f"-D{p}",
+                ]
+                print(f"Run command: {' '.join(command)}")
+                subprocess.check_call(command, stdout=sys.stdout, stderr=sys.stderr)
+                time.sleep(2.0)
+        except Exception as e:  # noqa: BLE001
+            print(f"ERROR: {e!s}")
+            sys.exit(1)
+
+    if args.send or args.monitor:
+        with Sent2UsbDevice(args.port) as device:
+            print(f"Firmware:   {device.get_version()}")
+            print(f"Tick Time:  {args.tick_time} μs")
+
+            last_tx_time = None
+            decoder = SentDecoder(args.tick_time)
+            while True:
+                if args.send and (
+                    last_tx_time is None
+                    or (
+                        args.interval is not None
+                        and (time.time() - last_tx_time > args.interval)
+                    )
+                ):
+                    last_tx_time = time.time()
+                    nibbles = [int(c, 16) for c in args.send]
+                    frame = SentFrame(status=nibbles[0], data=nibbles[1:])
+                    print(f"TX: {frame}")
+                    device.send_pulses(frame.to_pulses(args.width, args.tick_time))
+
+                if args.monitor:
+                    for period, width in device.fetch_pulses():
+                        frame = decoder.process(period, width)
+                        if frame is not None:
+                            print(f"RX: {frame}")
+
+                if not args.monitor and args.interval is None:
+                    break
+
+                time.sleep(0.05)
+
+
+if __name__ == "__main__":
+    main()

nuotec_sent2usb-0.1.0/src/nuotec_sent2usb/decoder.py

@@ -0,0 +1,61 @@
+from .frame import SentFrame
+
+
+class SentDecoder:
+    """Decodes SENT pulse pairs into frames."""
+
+    def __init__(self, tick_time_us: int, max_deviation: float = 0.25):
+        """Initialize the decoder.
+
+        Args:
+            tick_time_us: SENT clock tick time [microseconds].
+            max_deviation: Allowed calibration pulse deviation [1].
+        """
+        self._time_base_ticks = 48 * tick_time_us
+        self._min_calib_ticks = 56 * (1 - max_deviation)
+        self._max_calib_ticks = 56 * (1 + max_deviation)
+        self._calib_factor = None
+        self._received_nibbles = []
+
+    def process(self, period: int, width: int):
+        """Process a received pulse pair.
+
+        Args:
+            period: Pulse period in device ticks.
+            width: Pulse low time in device ticks.
+
+        Returns:
+            A decoded frame, or `None` until one is complete.
+        """
+        period_ticks = period / self._time_base_ticks
+
+        is_complete = width != 0
+        is_calib_pulse = (
+            is_complete
+            and (period_ticks >= self._min_calib_ticks)
+            and (period_ticks <= self._max_calib_ticks)
+        )
+        is_timeout = period_ticks > self._max_calib_ticks
+
+        result = None
+        if (
+            self._calib_factor is not None
+            and len(self._received_nibbles) > 2
+            and (is_calib_pulse or is_timeout)
+        ):
+            result = SentFrame(
+                self._received_nibbles[0],
+                self._received_nibbles[1:-1],
+                self._received_nibbles[-1],
+            )
+            self._calib_factor = None
+        if is_calib_pulse:
+            self._calib_factor = period_ticks / 56
+            self._received_nibbles = []
+        elif is_complete and self._calib_factor is not None:
+            value = round((period_ticks / self._calib_factor) - 12)
+            if (value >= 0) and (value <= 15):
+                self._received_nibbles.append(value)
+            else:
+                self._calib_factor = None
+        return result

nuotec_sent2usb-0.1.0/src/nuotec_sent2usb/device.py

@@ -0,0 +1,192 @@
+from struct import pack, unpack
+
+from cobs import cobs
+from serial import Serial
+from serial.tools import list_ports
+
+from .device_version import Sent2UsbDeviceVersion
+from .exceptions import Sent2UsbCommunicationError, Sent2UsbDeviceError, Sent2UsbError
+
+
+class Sent2UsbDevice:
+    """Represents a SENT2USB device."""
+
+    USB_VID = 0x0483
+    USB_PID = 0x5740
+
+    def __init__(self, port=None):
+        """Initialize the device (not connecting yet).
+
+        Args:
+            port: Serial port. Detected automatically when omitted.
+        """
+        self._port = port or Sent2UsbDevice.find_port()
+        self._serial = None
+
+    def __enter__(self):
+        """Connect to and return the device."""
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Disconnect from the device."""
+        self.disconnect()
+
+    def connect(self):
+        """Open the serial connection."""
+        self._serial = Serial(port=self._port, timeout=1)
+
+    def disconnect(self):
+        """Close the serial connection."""
+        if self._serial and self._serial.is_open:
+            self._serial.close()
+        self._serial = None
+
+    def get_version(self) -> Sent2UsbDeviceVersion:
+        """Read the firmware version.
+
+        Returns:
+            The device firmware version.
+        """
+        rx_data = self._transceive(0x00, min_len=4, max_len=None)
+        return Sent2UsbDeviceVersion.from_raw(rx_data)
+
+    def send_pulses(self, pattern):
+        """Send SENT pulse pairs.
+
+        Args:
+            pattern: `(period, low_time)` pairs ending with period `0xFFFF`.
+
+        Raises:
+            ValueError: If the pattern is invalid.
+        """
+        if len(pattern) < 1:
+            raise ValueError("Pattern must contain minimum 1 pulse.")
+        if any(x[0] < 2 or x[0] > 0xFFFF for x in pattern):
+            raise ValueError("Period must be in range 2..0xFFFF.")
+        if any(x[1] < 1 or x[1] >= x[0] for x in pattern):
+            raise ValueError("Low-time must be in range 1..period-1.")
+        if pattern[-1][0] != 0xFFFF:
+            raise ValueError("The last period must be 0xFFFF.")
+        data = pack(f">{len(pattern) * 2}H", *[v for pair in pattern for v in pair])
+        self._transceive(0x10, data)
+
+    def fetch_pulses(self):
+        """Fetch received SENT pulse pairs.
+
+        Returns:
+            A list of `(period, low_time)` pairs.
+        """
+        data = self._transceive(0x20, max_len=None)
+        values = unpack(f">{len(data) // 4}I", data)
+        return [(values[i * 2], values[i * 2 + 1]) for i in range(len(values) // 2)]
+
+    def enter_bootloader(self):
+        """Instruct the device to enter its bootloader."""
+        self._transceive(0xFF)
+
+    def _transceive(self, cmd, data=None, min_len=0, max_len=-1):
+        if max_len is not None and max_len < 0:
+            max_len = min_len
+        self._transmit(cmd, data)
+        rx_cmd, rx_result, rx_data = self._receive()
+        if rx_cmd != cmd:
+            raise Sent2UsbCommunicationError(
+                f"Received command '0x{rx_cmd:02X}', expected '0x{cmd:02X}'."
+            )
+        if rx_result != 0x00:
+            raise Sent2UsbDeviceError(
+                f"Command '0x{cmd:02X}' failed with error '0x{rx_result:02X}'."
+            )
+        rx_len = len(rx_data)
+        if rx_len < min_len or (max_len is not None and rx_len > max_len):
+            raise Sent2UsbCommunicationError(
+                f"Received {rx_len} bytes, expected {min_len}..{max_len}."
+            )
+        return rx_data
+
+    def _transmit(self, cmd, data=None):
+        frame = bytearray()
+        frame.append(cmd)
+        if data is not None:
+            frame.extend(data)
+        frame.extend(pack(">H", self._calc_crc(frame)))
+        self._serial.reset_input_buffer()
+        self._serial.write(cobs.encode(frame) + b"\x00")
+
+    def _receive(self):
+        frame = self._serial.read_until(expected=b"\x00")
+        if not frame.endswith(b"\x00"):
+            raise TimeoutError()
+        frame = cobs.decode(frame[:-1])
+        if len(frame) < 4:
+            raise Sent2UsbCommunicationError(
+                f"Received too short response frame: {frame}"
+            )
+        cmd = frame[0]
+        result = frame[1]
+        payload = frame[2:-2]
+        crc = unpack(">H", frame[-2:])[0]
+        if crc != self._calc_crc(frame[:-2]):
+            raise Sent2UsbCommunicationError(f"Received invalid CRC: {frame}")
+        return cmd, result, payload
+
+    def _calc_crc(self, data: bytes) -> int:
+        crc = 0xFFFF
+        for byte in data:
+            crc ^= byte << 8
+            for _ in range(8):
+                if crc & 0x8000:
+                    crc = ((crc << 1) ^ 0x1021) & 0xFFFF
+                else:
+                    crc = (crc << 1) & 0xFFFF
+        return crc
+
+    @staticmethod
+    def list_ports(list_all: bool = False, as_objects: bool = False):
+        """List serial ports.
+
+        Args:
+            list_all: Include ports not matching the SENT2USB identifiers.
+            as_objects: Return pyserial port objects instead of device names.
+
+        Returns:
+            Available serial ports.
+        """
+        ports = list_ports.comports()
+        if not list_all:
+            # Filter by VID/PID
+            ports = [
+                p
+                for p in ports
+                if p.vid == Sent2UsbDevice.USB_VID and p.pid == Sent2UsbDevice.USB_PID
+            ]
+            # Try to find only devices which match the manufacturer & description.
+            # However, this does not seem to work on Windows so this is optional.
+            ports = [
+                p
+                for p in ports
+                if "nuotec" in (p.manufacturer or "").lower()
+                and "sent2usb" in (p.description or "").lower()
+            ] or ports
+        return ports if as_objects else [p.device for p in ports]
+
+    @staticmethod
+    def find_port():
+        """Find the only connected SENT2USB device.
+
+        Returns:
+            The device serial port.
+
+        Raises:
+            Sent2UsbError: If no device or multiple devices are found.
+        """
+        ports = Sent2UsbDevice.list_ports()
+        if len(ports) == 0:
+            raise Sent2UsbError("No device found, check USB connection.")
+        elif len(ports) > 1:
+            raise Sent2UsbError(
+                f"Multiple devices found, specify serial port manually: {ports}"
+            )
+        else:
+            return ports[0]

nuotec_sent2usb-0.1.0/src/nuotec_sent2usb/device_version.py

@@ -0,0 +1,40 @@
+class Sent2UsbDeviceVersion:
+    """Represents a SENT2USB firmware version."""
+
+    def __init__(
+        self, major: int, minor: int, patch: int, candidate: int, build_id: str
+    ):
+        """Initialize a firmware version.
+
+        Args:
+            major: Major version number.
+            minor: Minor version number.
+            patch: Patch version number.
+            candidate: Release candidate number.
+            build_id: Firmware build identifier.
+        """
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+        self.candidate = candidate
+        self.build_id = build_id
+
+    @staticmethod
+    def from_raw(data: bytes) -> "Sent2UsbDeviceVersion":
+        """Parse a raw version response.
+
+        Args:
+            data: Raw version response bytes.
+
+        Returns:
+            The parsed firmware version.
+        """
+        return Sent2UsbDeviceVersion(data[0], data[1], data[2], data[3], data[4:])
+
+    def __str__(self) -> str:
+        s = f"{self.major}.{self.minor}.{self.patch}"
+        if self.candidate != 0:
+            s += f"-rc{self.candidate}"
+        if len(self.build_id) > 0:
+            s += f" ({self.build_id.hex()})"
+        return s

nuotec_sent2usb-0.1.0/src/nuotec_sent2usb/exceptions.py

@@ -0,0 +1,10 @@
+class Sent2UsbError(Exception):
+    """Base class for errors raised by this driver."""
+
+
+class Sent2UsbCommunicationError(Sent2UsbError):
+    """An invalid or unexpected response received from the device."""
+
+
+class Sent2UsbDeviceError(Sent2UsbError):
+    """A non-success result returned from the device."""

nuotec_sent2usb-0.1.0/src/nuotec_sent2usb/frame.py

@@ -0,0 +1,65 @@
+class SentFrame:
+    """Represents a SENT frame."""
+
+    def __init__(self, status: int, data: list, crc=None):
+        """Initialize a SENT frame.
+
+        Args:
+            status: Status nibble.
+            data: Frame data nibbles.
+            crc: CRC nibble. Calculated from data when omitted.
+        """
+        self.status = status
+        self.data = data
+        self.crc = SentFrame.calc_crc(self.data) if crc is None else crc
+
+    @property
+    def valid(self) -> bool:
+        """Whether the frame CRC is valid."""
+        return self.crc == SentFrame.calc_crc(self.data)
+
+    def to_pulses(self, low_time: int, tick_time_us: int):
+        """Convert the frame to SENT pulse pairs.
+
+        Args:
+            low_time: Pulse low time [clock ticks].
+            tick_time_us: Clock tick time [microseconds].
+
+        Returns:
+            A list of `(period, low_time)` pairs.
+        """
+        pulses = []
+        pulses.append(56)  # calibration pulse
+        pulses.append(self.status + 12)
+        pulses.extend([data + 12 for data in self.data])
+        pulses.append(self.crc + 12)
+        return [(p * tick_time_us, low_time * tick_time_us) for p in pulses] + [
+            (0xFFFF, low_time * tick_time_us)
+        ]
+
+    def __str__(self) -> str:
+        data = ", ".join([f"0x{d:X}" for d in self.data])
+        s = f"status=0x{self.status:X} data=[{data}] crc=0x{self.crc:X}"
+        if not self.valid:
+            s += " [CRC ERROR]"
+        return s
+
+    @staticmethod
+    def calc_crc(data: bytes) -> int:
+        """Calculate the SENT CRC nibble.
+
+        Args:
+            data: Frame data nibbles.
+
+        Returns:
+            The CRC nibble.
+        """
+        crc = 0x03
+        for byte in data:
+            crc ^= byte
+            for _ in range(4):
+                if crc & 0x08:
+                    crc = ((crc << 1) ^ 0x0D) & 0x0F
+                else:
+                    crc = (crc << 1) & 0x0F
+        return crc

nuotec_sent2usb-0.1.0/src/nuotec_sent2usb/optionbytes.bin

@@ -0,0 +1 @@
+�U�������������