riden 0.1.0__py3-none-any.whl

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/bt/__init__.py

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

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

riden/bt/protocol_bt.py

@@ -0,0 +1,48 @@
+
+import typing
+from functools import partial
+from urllib.parse import parse_qs, urlsplit
+
+from .bt_serial import BtSerial
+
+
+def parse_bt_url(url: str):
+    parsed = urlsplit(url)
+    if parsed.scheme.lower() != "bt":
+        raise ValueError(f"not a bt:// URL: {url!r}")
+
+    mac = parsed.netloc
+    if not mac:
+        raise ValueError(f"no MAC in bt URL: {url!r}")
+    if parsed.path not in ("", "/"):
+        raise ValueError(
+            "channel must be a query parameter, e.g. bt://MAC?channel=1"
+        )
+
+    query = parse_qs(parsed.query)
+
+    def qs(name: str, type: type):
+        values = query.get(name)
+        if values is None:
+            return None
+        try:
+            return type(values[0])
+        except (TypeError, ValueError) as exc:
+            raise ValueError(f"invalid {name} in URL: {values[0]!r}") from exc
+
+    kwargs: dict[str, typing.Any] = {
+        "channel": qs("channel", int) or 1,
+        "timeout": qs("timeout", float),
+        "connect_timeout": qs("connect_timeout", float)
+    }
+
+    return mac, kwargs
+
+def serial_class_for_url(url: str):
+    """Return (MAC, partial(BtSerial, channel=..., timeout=...)).
+
+    pyserial calls this hook, then constructs the class with port=None, sets
+    instance.port to the returned MAC, and calls open() unless do_not_open.
+    """
+    mac, kwargs = parse_bt_url(url)
+    return mac, partial(BtSerial, **kwargs)

riden/enums.py

@@ -0,0 +1,11 @@
+from enum import IntEnum
+
+
+class Protection(IntEnum):
+    NONE = 0
+    OVP = 1
+    OCP = 2
+
+class Mode(IntEnum):
+    CV = 0
+    CC = 1

riden/field.py

@@ -0,0 +1,204 @@
+from collections.abc import Callable, Sequence
+from enum import Enum
+from functools import partial
+from typing import Any, override
+
+from .enums import Mode, Protection
+from .model import Model
+
+type RegRead = Callable[[tuple[int, ...], Model], Any]
+type RegWrite = Callable[[Any, Model], tuple[int, ...]]
+
+def compose(*funcs):
+    def composed_fn(arg: Any, *others):
+        for fn in funcs:
+            arg = fn(arg, *others)
+        return arg
+    return composed_fn
+
+def read_flag(r: tuple[int, ...], _: Model):
+    return bool(r[0])
+
+def read_int(r: tuple[int, ...], _: Model):
+    return r[0]
+
+def write_int(v, _: Model) -> tuple[int, ...]:
+    return (int(v),)
+
+def read_protection(r: tuple[int, ...], _: Model):
+    return Protection(r[0])
+
+def read_mode(r: tuple[int, ...], _: Model):
+    return Mode(r[0])
+
+def read_div(d, r: tuple[int, ...], _: Model):
+    return float(r[0] / d)
+
+def div(d, x, _: Model):
+    return x / d
+
+def read_dw(r: tuple[int, ...], _: Model):
+    return r[0] << 16 | r[1]
+
+def read_temp(r: tuple[int, ...], _: Model):
+    return (-1 if r[0] else 1) * r[1]
+
+def read_v(r: tuple[int, ...], m: Model):
+    return r[0] / m.v_scale
+
+def write_v(v, m: Model, off = 0) -> tuple[int, ...]:
+    return (m.v_clamp(v, off),)
+
+def read_i(r: tuple[int, ...], m: Model):
+    return r[0] / m.i_scale
+
+def write_i(v, m: Model, off = 0) -> tuple[int, ...]:
+    return (m.i_clamp(v, off),)
+
+class Field(Enum):
+    ID = 0, 1, read_int, None
+    SN = 1, 2, read_dw, None
+    FW = 3, 1, partial(read_div, 100), None
+    TEMP_C = 4, 2, read_temp, None
+    TEMP_F = 6, 2, read_temp, None
+    V_SET = 8, 1, read_v, write_v
+    I_SET = 9, 1, read_i, write_i
+    V = 10, 1, read_v, None
+    I = 11, 1, read_i, None
+    P = 12, 2, compose(read_dw, partial(div, 100)), None
+    V_IN = 14, 1, partial(read_div, 100), None
+    LOCK = 15, 1, read_flag, write_int
+    PROTECTION = 16, 1, read_protection, None
+    MODE = 17, 1, read_mode, None
+    EN = 18, 1, read_flag, write_int
+    PRESET = 19, 1, read_int, write_int
+
+    BAT_EN = 32, 1, read_flag, None
+    BAT_V = 33, 1, read_v, None
+    EXT_TEMP_C = 34, 2, read_temp, None
+    EXT_TEMP_F = 36, 2, read_temp, None
+    AH = 38, 2, compose(read_dw, partial(div, 1000)), None
+    WH = 40, 2, compose(read_dw, partial(div, 1000)), None
+
+    YEAR = 48, 1, read_int, write_int
+    MONTH = 49, 1, read_int, write_int
+    DAY = 50, 1, read_int, write_int
+    HOUR = 51, 1, read_int, write_int
+    MINUTE = 52, 1, read_int, write_int
+    SECOND = 53, 1, read_int, write_int
+
+    # Register 54 is a command register, not calibration data: writing 5377
+    # (0x1501) commits the calibration registers 55-62 to NVRAM.  It is not
+    # readable because it carries no meaningful state.
+    CAL_COMMIT = 54, 1, None, write_int
+    CAL_V_ZERO = 55, 1, read_int, write_int
+    CAL_V_SCALE = 56, 1, read_int, write_int
+    CAL_BV_ZERO = 57, 1, read_int, write_int
+    CAL_BV_SCALE = 58, 1, read_int, write_int
+    CAL_I_ZERO = 59, 1, read_int, write_int
+    CAL_I_SCALE = 60, 1, read_int, write_int
+    CAL_BI_ZERO = 61, 1, read_int, write_int
+    CAL_BI_SCALE = 62, 1, read_int, write_int
+
+    TAKE_OK = 66, 1, read_flag, write_int
+    TAKE_OUT = 67, 1, read_flag, write_int
+    BOOT_EN = 68, 1, read_flag, write_int
+    VOLUME = 69, 1, read_flag, write_int
+    LOGO = 70, 1, read_flag, write_int
+    LANG = 71, 1, read_int, write_int
+    BACKLIGHT = 72, 1, read_int, write_int
+
+    M0_V = 80, 1, read_v, write_v
+    M0_A = 81, 1, read_i, write_i
+    M0_OVP = 82, 1, read_v, partial(write_v, off=2)
+    M0_OCP = 83, 1, read_i, write_i
+
+    M1_V = 84, 1, read_v, write_v
+    M1_A = 85, 1, read_i, write_i
+    M1_OVP = 86, 1, read_v, partial(write_v, off=2)
+    M1_OCP = 87, 1, read_i, write_i
+
+    M2_V = 88, 1, read_v, write_v
+    M2_A = 89, 1, read_i, write_i
+    M2_OVP = 90, 1, read_v, partial(write_v, off=2)
+    M2_OCP = 91, 1, read_i, write_i
+
+    M3_V = 92, 1, read_v, write_v
+    M3_A = 93, 1, read_i, write_i
+    M3_OVP = 94, 1, read_v, partial(write_v, off=2)
+    M3_OCP = 95, 1, read_i, write_i
+
+    M4_V = 96, 1, read_v, write_v
+    M4_A = 97, 1, read_i, write_i
+    M4_OVP = 98, 1, read_v, partial(write_v, off=2)
+    M4_OCP = 99, 1, read_i, write_i
+
+    M5_V = 100, 1, read_v, write_v
+    M5_A = 101, 1, read_i, write_i
+    M5_OVP = 102, 1, read_v, partial(write_v, off=2)
+    M5_OCP = 103, 1, read_i, write_i
+
+    M6_V = 104, 1, read_v, write_v
+    M6_A = 105, 1, read_i, write_i
+    M6_OVP = 106, 1, read_v, partial(write_v, off=2)
+    M6_OCP = 107, 1, read_i, write_i
+
+    M7_V = 108, 1, read_v, write_v
+    M7_A = 109, 1, read_i, write_i
+    M7_OVP = 110, 1, read_v, partial(write_v, off=2)
+    M7_OCP = 111, 1, read_i, write_i
+
+    M8_V = 112, 1, read_v, write_v
+    M8_A = 113, 1, read_i, write_i
+    M8_OVP = 114, 1, read_v, partial(write_v, off=2)
+    M8_OCP = 115, 1, read_i, write_i
+
+    M9_V = 116, 1, read_v, write_v
+    M9_A = 117, 1, read_i, write_i
+    M9_OVP = 118, 1, read_v, partial(write_v, off=2)
+    M9_OCP = 119, 1, read_i, write_i
+
+    addr: int
+    count: int
+    read: RegRead | None
+    write: RegWrite | None
+
+    def __new__(cls, addr: int, count: int, read: RegRead | None, write: RegWrite | None):
+        obj = object.__new__(cls)
+        obj._value_ = addr
+        obj.addr = addr
+        obj.count = count
+        obj.read = read
+        obj.write = write
+        return obj
+
+    @override
+    @classmethod
+    def _missing_(cls, value: object) -> Field | None:
+        if isinstance(value, str):
+            return cls.__members__.get(value.upper())
+        return None
+
+    @property
+    def label(self) -> str:
+        return self.name.lower()
+
+    @override
+    def __str__(self) -> str:
+        return self.label
+
+    @property
+    def is_readable(self):
+        return self.read is not None
+
+    @property
+    def is_writable(self):
+        return self.write is not None
+
+
+def flatten_fields(fields: Sequence[str | Field | Sequence[str | Field]]):
+    for field in fields:
+        match field:
+            case Field(): yield field
+            case str(): yield Field(field)
+            case _: yield from flatten_fields(field)

riden/model.py

@@ -0,0 +1,32 @@
+from collections.abc import Sequence
+from enum import Enum
+
+
+class Model(Enum):
+    RD6006 = (range(60060, 60065), 100, 1000, 60, 6)
+    RD6006P = ([60065], 1000, 10000, 60, 6)
+    RK6006 = ([60066], 100, 1000, 60, 6)
+    RD6012 = (range(60120, 60125), 100, 100, 60, 12)
+    RD6012P = (range(60125, 60130), 1000, 100, 60, 12)
+    RD6018 = (range(60180, 60190), 100, 100, 60, 18)
+    RD6024 = (range(60241, 60250), 100, 100, 60, 24)
+
+    def __init__(self, codes: Sequence[int], v_scale: int, i_scale: int, v_max: int, i_max: int):
+        self.codes = codes
+        self.v_scale = v_scale
+        self.i_scale = i_scale
+        self.v_max = v_max
+        self.i_max = i_max
+
+    def v_clamp(self, value: float, offset: float = 0) -> int:
+        return round(max(0, min(self.v_max + offset, value)) * self.v_scale)
+
+    def i_clamp(self, value: float, offset: float = 0) -> int:
+        return round(max(0, min(self.i_max + offset, value)) * self.i_scale)
+
+    @staticmethod
+    def find(code: int) -> Model:
+        for model in Model:
+            if code in model.codes:
+                return model
+        return next(iter(Model))