riden 0.1.0__tar.gz

riden-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vyacheslav Mayorov
+
+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.

riden-0.1.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: riden
+Version: 0.1.0
+Summary: Synchronous Python client for Riden RD60xx power supplies (USB serial and Bluetooth)
+Keywords: riden,rd6006,rd6012,rd6018,rk6006,rk6012,rk6018,power-supply,modbus,bluetooth,serial
+Author: Vyacheslav Mayorov
+Author-email: Vyacheslav Mayorov <vyacheslav.mayorov@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: System :: Hardware
+Classifier: Typing :: Typed
+Requires-Dist: minimalmodbus>=2.1.1
+Requires-Dist: pyserial>=3.5
+Requires-Python: >=3.14
+Project-URL: Homepage, https://github.com/acc15/riden
+Project-URL: Repository, https://github.com/acc15/riden
+Project-URL: Issues, https://github.com/acc15/riden/issues
+Description-Content-Type: text/markdown
+
+# riden
+
+A simple synchronous, single-threaded client for Riden laboratory power
+supplies (RD6006, RD6006P, RD6012, RD6012P, RD6018, RD6024, RK6006).
+
+It speaks Modbus RTU over a regular serial port or Bluetooth SPP (RFCOMM) on
+Linux.
+
+## Features
+
+- synchronous API with no background event loop:
+  `with Riden.connect(...) as rd: ...`;
+- Bluetooth on Linux via `bt://` URLs (`AF_BLUETOOTH` + RFCOMM);
+- batched I/O: fields are read and written in one Modbus transaction per
+  contiguous register block, not one transaction per field;
+- automatic model and voltage/current scale detection on connect;
+- ready-made transport stack: transaction pacing, keepalive, reconnect, and
+  logging.
+
+## Requirements
+
+- Python 3.14 or newer;
+- Linux with BlueZ for Bluetooth SPP;
+- any OS supported by pyserial for USB serial.
+
+## Install
+
+```sh
+uv add riden
+```
+
+or with pip:
+
+```sh
+pip install riden
+```
+
+From source:
+
+```sh
+git clone https://github.com/acc15/riden
+cd riden
+uv sync
+```
+
+## Quick start
+
+```python
+from riden import Riden
+
+with Riden.connect("bt://E2:F9:C6:24:71:C8?channel=1&timeout=0.5") as rd:
+    print(rd.status())
+
+    # Several fields — a single device transaction.
+    v, i, p = rd.read("v", "i", "p").values()
+    print(v, i, p)
+
+    # Several fields — a single write transaction.
+    rd.write(v_set=5.0, i_set=0.1, en=True)
+```
+
+For USB serial, pass the device path:
+
+```python
+with Riden.connect("/dev/ttyUSB0") as rd:
+    ...
+```
+
+Field names are case-insensitive, so `"V"` and `"v"` refer to the same field.
+
+## Example: voltage sweep + status
+
+```python
+import time
+
+from riden import Riden
+
+with Riden.connect("bt://E2:F9:C6:24:71:C8?channel=1&timeout=0.5") as rd:
+    try:
+        rd.write(v_set=0.0, i_set=0.1, en=True)
+
+        for voltage in range(0, 60, 5):
+            rd.write(v_set=float(voltage))
+            time.sleep(2)
+            print(rd.status())
+    finally:
+        rd.write(v_set=0.0, en=False)
+```
+
+## Bluetooth on Linux
+
+Pair and trust the device first (`bluetoothctl pair/trust`); the RFCOMM
+channel is usually `1`. URL format:
+
+```text
+bt://AA:BB:CC:DD:EE:FF?channel=1&timeout=0.5
+```
+
+`timeout` and `connect_timeout` are specified in seconds as query parameters.
+`BtSerial` is registered as a pyserial URL handler, so `bt://` works anywhere a
+regular serial port is accepted.
+
+## Performance
+
+`read()` selects the requested fields, computes their overall address range,
+and issues **one** `read_registers` call for the whole range, then decodes the
+raw registers into fields. `write()` encodes and validates all values first,
+merges adjacent fields into contiguous blocks, and sends one transaction per
+block.
+
+Therefore:
+
+```python
+# 1 transaction instead of 3
+v, i, p = rd.read("v", "i", "p").values()
+
+# 1 transaction instead of 3
+rd.write(v_set=5.0, i_set=0.1, en=True)
+```
+
+Sparse fields are still read in one transaction spanning the whole range
+between them, so grouping nearby fields is preferable.
+
+## Development
+
+```sh
+uv sync
+uv build          # sdist + wheel in dist/
+just check        # ty + ruff + pytest
+```
+
+Scripts in `scripts/` are run through `uv run`:
+
+```sh
+uv run scripts/v_sweep.py
+uv run scripts/link_test.py "bt://E2:F9:C6:24:71:C8?channel=1&timeout=0.5"
+```
+
+`just --list` shows the remaining tasks.
+
+## License
+
+MIT — see [LICENSE](https://github.com/acc15/riden/blob/master/LICENSE).

riden-0.1.0/README.md

@@ -0,0 +1,143 @@
+# riden
+
+A simple synchronous, single-threaded client for Riden laboratory power
+supplies (RD6006, RD6006P, RD6012, RD6012P, RD6018, RD6024, RK6006).
+
+It speaks Modbus RTU over a regular serial port or Bluetooth SPP (RFCOMM) on
+Linux.
+
+## Features
+
+- synchronous API with no background event loop:
+  `with Riden.connect(...) as rd: ...`;
+- Bluetooth on Linux via `bt://` URLs (`AF_BLUETOOTH` + RFCOMM);
+- batched I/O: fields are read and written in one Modbus transaction per
+  contiguous register block, not one transaction per field;
+- automatic model and voltage/current scale detection on connect;
+- ready-made transport stack: transaction pacing, keepalive, reconnect, and
+  logging.
+
+## Requirements
+
+- Python 3.14 or newer;
+- Linux with BlueZ for Bluetooth SPP;
+- any OS supported by pyserial for USB serial.
+
+## Install
+
+```sh
+uv add riden
+```
+
+or with pip:
+
+```sh
+pip install riden
+```
+
+From source:
+
+```sh
+git clone https://github.com/acc15/riden
+cd riden
+uv sync
+```
+
+## Quick start
+
+```python
+from riden import Riden
+
+with Riden.connect("bt://E2:F9:C6:24:71:C8?channel=1&timeout=0.5") as rd:
+    print(rd.status())
+
+    # Several fields — a single device transaction.
+    v, i, p = rd.read("v", "i", "p").values()
+    print(v, i, p)
+
+    # Several fields — a single write transaction.
+    rd.write(v_set=5.0, i_set=0.1, en=True)
+```
+
+For USB serial, pass the device path:
+
+```python
+with Riden.connect("/dev/ttyUSB0") as rd:
+    ...
+```
+
+Field names are case-insensitive, so `"V"` and `"v"` refer to the same field.
+
+## Example: voltage sweep + status
+
+```python
+import time
+
+from riden import Riden
+
+with Riden.connect("bt://E2:F9:C6:24:71:C8?channel=1&timeout=0.5") as rd:
+    try:
+        rd.write(v_set=0.0, i_set=0.1, en=True)
+
+        for voltage in range(0, 60, 5):
+            rd.write(v_set=float(voltage))
+            time.sleep(2)
+            print(rd.status())
+    finally:
+        rd.write(v_set=0.0, en=False)
+```
+
+## Bluetooth on Linux
+
+Pair and trust the device first (`bluetoothctl pair/trust`); the RFCOMM
+channel is usually `1`. URL format:
+
+```text
+bt://AA:BB:CC:DD:EE:FF?channel=1&timeout=0.5
+```
+
+`timeout` and `connect_timeout` are specified in seconds as query parameters.
+`BtSerial` is registered as a pyserial URL handler, so `bt://` works anywhere a
+regular serial port is accepted.
+
+## Performance
+
+`read()` selects the requested fields, computes their overall address range,
+and issues **one** `read_registers` call for the whole range, then decodes the
+raw registers into fields. `write()` encodes and validates all values first,
+merges adjacent fields into contiguous blocks, and sends one transaction per
+block.
+
+Therefore:
+
+```python
+# 1 transaction instead of 3
+v, i, p = rd.read("v", "i", "p").values()
+
+# 1 transaction instead of 3
+rd.write(v_set=5.0, i_set=0.1, en=True)
+```
+
+Sparse fields are still read in one transaction spanning the whole range
+between them, so grouping nearby fields is preferable.
+
+## Development
+
+```sh
+uv sync
+uv build          # sdist + wheel in dist/
+just check        # ty + ruff + pytest
+```
+
+Scripts in `scripts/` are run through `uv run`:
+
+```sh
+uv run scripts/v_sweep.py
+uv run scripts/link_test.py "bt://E2:F9:C6:24:71:C8?channel=1&timeout=0.5"
+```
+
+`just --list` shows the remaining tasks.
+
+## License
+
+MIT — see [LICENSE](https://github.com/acc15/riden/blob/master/LICENSE).

riden-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[project]
+name = "riden"
+version = "0.1.0"
+description = "Synchronous Python client for Riden RD60xx power supplies (USB serial and Bluetooth)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+keywords = [
+    "riden",
+    "rd6006",
+    "rd6012",
+    "rd6018",
+    "rk6006",
+    "rk6012",
+    "rk6018",
+    "power-supply",
+    "modbus",
+    "bluetooth",
+    "serial",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: System :: Hardware",
+    "Typing :: Typed",
+]
+dependencies = [
+    "minimalmodbus>=2.1.1",
+    "pyserial>=3.5",
+]
+
+[[project.authors]]
+name = "Vyacheslav Mayorov"
+email = "vyacheslav.mayorov@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/acc15/riden"
+Repository = "https://github.com/acc15/riden"
+Issues = "https://github.com/acc15/riden/issues"
+
+[tool.ruff]
+src = ["src"]
+target-version = "py314"
+
+[tool.ty.rules]
+all = "error"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[build-system]
+requires = ["uv_build>=0.13.7,<0.14.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.2.0",
+    "ruff>=0.17.4",
+    "ty>=0.0.100",
+]

riden-0.1.0/pyproject.toml.orig

@@ -0,0 +1,64 @@
+[project]
+name = "riden"
+version = "0.1.0"
+description = "Synchronous Python client for Riden RD60xx power supplies (USB serial and Bluetooth)"
+readme = "README.md"
+authors = [
+    { name = "Vyacheslav Mayorov", email = "vyacheslav.mayorov@gmail.com" }
+]
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+keywords = [
+    "riden",
+    "rd6006",
+    "rd6012",
+    "rd6018",
+    "rk6006",
+    "rk6012",
+    "rk6018",
+    "power-supply",
+    "modbus",
+    "bluetooth",
+    "serial",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: System :: Hardware",
+    "Typing :: Typed",
+]
+dependencies = [
+    "minimalmodbus>=2.1.1",
+    "pyserial>=3.5",
+]
+
+[project.urls]
+Homepage = "https://github.com/acc15/riden"
+Repository = "https://github.com/acc15/riden"
+Issues = "https://github.com/acc15/riden/issues"
+
+[tool.ruff]
+src = ["src"]
+target-version = "py314"
+
+[tool.ty.rules]
+all = "error"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[build-system]
+requires = ["uv_build>=0.13.7,<0.14.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.2.0",
+    "ruff>=0.17.4",
+    "ty>=0.0.100",
+]

riden-0.1.0/src/riden/__init__.py

@@ -0,0 +1,26 @@
+import serial
+
+from .bt import BtSerial
+from .enums import Mode, Protection
+from .field import Field
+from .riden import Riden
+from .transport import Delayed, KeepAlive, Logging, Modbus, Reconnectable, Transport
+
+HANDLER_PACKAGE = "riden.bt"
+
+if HANDLER_PACKAGE not in serial.protocol_handler_packages:
+    serial.protocol_handler_packages.append(HANDLER_PACKAGE)
+
+__all__ = [
+    "BtSerial",
+    "Delayed",
+    "Field",
+    "KeepAlive",
+    "Logging",
+    "Modbus",
+    "Mode",
+    "Protection",
+    "Reconnectable",
+    "Riden",
+    "Transport",
+]

riden-0.1.0/src/riden/bt/__init__.py

@@ -0,0 +1,5 @@
+from .bt_serial import BtSerial
+
+__all__ = [
+    "BtSerial"
+]

riden-0.1.0/src/riden/bt/bt_serial.py

@@ -0,0 +1,204 @@
+"""Bluetooth SPP transport shaped like a pyserial port.
+
+BtSerial.port is always a Bluetooth MAC, just as serial.Serial.port is a
+device path.  URL parsing lives only in serial_urlhandler/protocol_bt.py,
+which pyserial uses via serial_for_url():
+
+    serial.serial_for_url("bt://E2:F9:C6:24:71:C8?channel=1&timeout=0.5")
+
+Direct construction uses the MAC:
+
+    BtSerial("E2:F9:C6:24:71:C8", channel=1, timeout=0.5)
+
+The connect timeout is an internal constant (CONNECT_TIMEOUT), not part of the
+serial interface.  For a configured but closed object use
+serial_for_url(..., do_not_open=True), or BtSerial(None) and set .port before
+open().
+"""
+import contextlib
+import re
+import select
+import socket
+import time
+from typing import override
+
+import serial
+
+# Fixed for minimalmodbus; RFCOMM has no real baudrate.
+BAUDRATE = 115200
+
+_MAC_RE = re.compile(r"^(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$")
+
+def parse_mac(value: str) -> str:
+    value = value.strip()
+    if not _MAC_RE.match(value):
+        raise ValueError(f"invalid Bluetooth MAC: {value!r}")
+    return value.replace("-", ":").upper()
+
+
+class BtSerial(contextlib.AbstractContextManager["BtSerial"]):
+
+    def __init__(self, 
+        port: str | None = None, 
+        channel: int = 1,
+        timeout: float | None = 0.5,
+        connect_timeout: float | None = 10
+    ):
+        self.port = port
+        self.channel = channel
+        self.sock: socket.socket | None = None
+        self._buf = bytearray()
+        self.timeout = timeout
+        self.connect_timeout = connect_timeout
+        if port is not None:
+            self.open()
+
+    @property
+    def timeout(self) -> float | None:
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, value: float | None) -> None:
+        if value is not None:
+            try:
+                value + 1  # numeric check, like pyserial
+            except TypeError:
+                raise ValueError(f"Not a valid timeout: {value!r}") from None
+            if value < 0:
+                raise ValueError(f"Not a valid timeout: {value!r}")
+        self._timeout = value
+        if self.sock is not None:
+            self.sock.settimeout(value)
+
+    @property
+    def baudrate(self) -> int:
+        # minimalmodbus reads this to calculate the 3.5-character silent
+        # period; RFCOMM itself has no baudrate setting.
+        return BAUDRATE
+
+    @property
+    def is_open(self) -> bool:
+        return self.sock is not None
+
+    # -- pyserial-compatible lifecycle ------------------------------------
+    def ensure_opened(self) -> socket.socket:
+        sock = self.sock
+        if sock is None:
+            raise serial.SerialException("Bluetooth socket is closed")
+        return sock
+
+    def open(self) -> None:
+        if self.is_open:
+            raise serial.SerialException("Port is already open.")
+        if self.port is None:
+            raise serial.SerialException("Port must be configured before it can be used.")
+
+        try:
+            mac = parse_mac(str(self.port))
+        except ValueError as exc:
+            raise serial.SerialException(str(exc)) from exc
+        channel = int(self.channel)
+        if not 1 <= channel <= 30:
+            raise ValueError(f"Bluetooth channel must be 1..30, got {channel}")
+
+        sock = socket.socket(
+            socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM
+        )
+        try:
+            sock.settimeout(self.connect_timeout)
+            sock.connect((mac, channel))
+            sock.settimeout(self.timeout)
+        except Exception:
+            sock.close()
+            raise
+
+        self.sock = sock
+        self.mac = mac
+        self.channel = channel
+        self._buf.clear()
+
+    def close(self) -> None:
+        sock = self.sock
+        self.sock = None
+        if sock is not None:
+            sock.close()
+
+    def __del__(self):
+        with contextlib.suppress(Exception):
+            self.close()
+
+    @override
+    def __exit__(self, *_):
+        self.close()
+
+    # -- pyserial-like I/O ------------------------------------------------
+    def write(self, data: bytes) -> int:
+        sock = self.ensure_opened()
+        sock.sendall(bytes(data))
+        return len(data)
+
+    def read(self, size: int = 1) -> bytes:
+        sock = self.ensure_opened()
+        if size <= 0:
+            return b""
+
+        if self.timeout is None:
+            # pyserial semantics: None means blocking until size bytes or EOF.
+            while len(self._buf) < size:
+                chunk = sock.recv(size - len(self._buf))
+                if not chunk:
+                    raise serial.SerialException("Bluetooth peer closed the link")
+                self._buf.extend(chunk)
+            out = bytes(self._buf[:size])
+            del self._buf[:size]
+            return out
+
+        if self.timeout == 0:
+            # pyserial semantics: return immediately with what is available.
+            try:
+                chunk = sock.recv(size - len(self._buf), socket.MSG_DONTWAIT)
+                if chunk:
+                    self._buf.extend(chunk)
+            except BlockingIOError:
+                pass
+            except OSError as exc:
+                raise serial.SerialException(str(exc)) from exc
+            out = bytes(self._buf[:size])
+            del self._buf[:size]
+            return out
+
+        # timeout > 0: the timeout is for the whole call (pyserial semantics).
+        # select() waits for readability with the time left, so the socket
+        # timeout is never touched and recv() cannot block past the deadline.
+        deadline = time.monotonic() + self.timeout
+        while len(self._buf) < size:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                break
+            if not select.select([sock], [], [], remaining)[0]:
+                break
+            chunk = sock.recv(size - len(self._buf))
+            if not chunk:
+                raise serial.SerialException("Bluetooth peer closed the link")
+            self._buf.extend(chunk)
+
+        out = bytes(self._buf[:size])
+        del self._buf[:size]
+        return out
+
+    def reset_input_buffer(self) -> None:
+        sock = self.ensure_opened()
+        self._buf.clear()
+        # Zero-timeout poll: recv() after a readable select() returns at once,
+        # so the socket timeout is never touched.
+        while select.select([sock], [], [], 0)[0]:
+            if not sock.recv(4096):
+                break
+
+    def reset_output_buffer(self) -> None:
+        pass
+
+    def flush(self) -> None:
+        pass
+
+