serial-scale-bench 0.2.0__py3-none-any.whl

serial_scale_bench/__init__.py

@@ -0,0 +1,12 @@
+__author__ = "Lars B. Rollik"
+
+from importlib.metadata import PackageNotFoundError, version
+
+from serial_scale_bench.scale import AutoReconnectSerialScale, Scale, SerialScale
+
+try:
+    __version__ = version("serial-scale-bench")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+__all__ = ["Scale", "SerialScale", "AutoReconnectSerialScale", "__version__"]

serial_scale_bench/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
+
+__commit_id__ = commit_id = None

serial_scale_bench/api.py

@@ -0,0 +1,69 @@
+import socket
+from datetime import datetime
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+from serial_scale_bench.scale import AutoReconnectSerialScale
+
+
+class ScaleStatus(BaseModel):
+    scale_id: str
+    is_connected: bool
+    last_seen: datetime | None = None
+    protocol: str | None = None
+
+
+def create_api(scale: AutoReconnectSerialScale, instance_info: dict) -> FastAPI:
+    """"""
+    app = FastAPI()
+    app.state.scale = scale
+    app.state.instance_info = (
+        instance_info  # TODO: instance id/name, api host/port, serial port/baud rate
+    )
+
+    @app.get("/status", response_model=ScaleStatus)
+    def get_scale_info():
+        return ScaleStatus(
+            scale_id=app.state.instance_info["scale_id"],
+            is_connected=app.state.scale.is_connected(),
+            last_seen=app.state.scale.last_response_time,
+            protocol=app.state.scale.protocol,
+        )
+
+    @app.get("/ping")
+    def ping_scale():
+        return {"responsive": app.state.scale.is_responsive()}
+
+    @app.get("/info")
+    def get_info():
+        return {
+            "scale_id": app.state.instance_info,
+            "hostname": socket.gethostname(),
+            "port": app.state.instance_info["port"],
+        }
+
+    @app.get("/weight")
+    def read_weight():
+        if not app.state.scale.is_responsive():
+            raise HTTPException(status_code=503, detail="Scale not responsive")
+        weight = app.state.scale.get_weight()
+        if weight is None:
+            raise HTTPException(status_code=204, detail="No weight read")
+        return {"scale_id": instance_info["id"], "weight": weight}
+
+    @app.post("/tare")
+    def tare_scale():
+        if not app.state.scale.is_responsive():
+            raise HTTPException(status_code=503, detail="Scale not responsive")
+        app.state.scale.tare()
+        return {"scale_id": instance_info["id"], "action": "tared"}
+
+    @app.post("/zero")
+    def zero_scale():
+        if not app.state.scale.is_responsive():
+            raise HTTPException(status_code=503, detail="Scale not responsive")
+        app.state.scale.zero()
+        return {"scale_id": instance_info["id"], "action": "zeroed"}
+
+    return app

serial_scale_bench/cli.py

@@ -0,0 +1,20 @@
+import argparse
+import os
+
+
+def cli_parser():
+    parser = argparse.ArgumentParser(description="Start a SerialScale FastAPI service")
+    parser.add_argument("--port", type=int, default=8000, help="Port to run FastAPI server on")
+    parser.add_argument(
+        "--device",
+        type=str,
+        default=os.environ.get("SERIAL_DEVICE"),
+        help="Serial port (e.g., /dev/ttyUSB0)",
+    )
+    parser.add_argument(
+        "--scale-id", type=str, default=os.environ.get("SCALE_ID"), help="Unique scale ID or name"
+    )
+    parser.add_argument("--baudrate", type=int, default=4800, help="Serial baud rate")
+    parser.add_argument("--timeout", type=float, default=1.0, help="Serial read timeout")
+    args = parser.parse_args()
+    return args

serial_scale_bench/entrypoint.py

@@ -0,0 +1,23 @@
+import uvicorn
+
+from serial_scale_bench.cli import cli_parser
+from serial_scale_bench.scale import AutoReconnectSerialScale
+
+
+def entrypoint():
+    args = cli_parser()
+
+    scale_id = args.scale_id
+
+    _scale = AutoReconnectSerialScale(
+        port=args.device,
+        baudrate=args.baudrate,
+        timeout=args.timeout,
+    )
+
+    print(f"Running FastAPI server for scale '{scale_id}' on port {args.port}")
+    uvicorn.run("serial_scale_bench.api:app", host="0.0.0.0", port=args.port, reload=False)
+
+
+if __name__ == "__main__":
+    entrypoint()

serial_scale_bench/scale.py

@@ -0,0 +1,303 @@
+import logging
+import re
+import statistics
+import time
+from collections.abc import Callable
+from datetime import datetime
+from enum import Enum
+
+import serial
+from serial import SerialException
+
+
+class ScaleProtocols(Enum):
+    Protocol1 = {"id": 1, "format": ""}
+
+
+class SerialScale:
+    def __init__(
+        self,
+        port: str,
+        baudrate: int = 9600,
+        timeout: float = 1,
+        protocol: int = 2,
+    ):
+        self.ser = serial.Serial(
+            port=port,
+            baudrate=baudrate,
+            bytesize=serial.EIGHTBITS,
+            parity=serial.PARITY_NONE,
+            stopbits=serial.STOPBITS_ONE,
+            timeout=timeout,
+        )
+        self.protocol: int | None = protocol
+        self.last_response_time: datetime | None = None
+
+        self.ser.reset_input_buffer()
+        self.ser.reset_output_buffer()
+
+        self._infer_protocol()
+
+    def _send_command(self, command: str):
+        if not self.ser.is_open:
+            raise serial.SerialException("Serial port is not open.")
+
+        if self.ser.in_waiting:
+            self.ser.reset_input_buffer()
+
+        full_command = f"{command}\r\n".encode("ascii")
+        self.ser.write(full_command)
+        logging.debug(f"Sending command: {command}")
+
+    def _read_lines(self) -> list[str]:
+        lines = []
+
+        if self.protocol == 1:
+            max_lines = 5
+        elif self.protocol == 2:
+            max_lines = 1
+        else:
+            raise NotImplementedError(f"Protocol {self.protocol} is not supported.")
+
+        for _ in range(max_lines):
+            line = self.ser.readline().decode("ascii", errors="ignore").strip()
+            if line:
+                lines.append(line)
+        return lines
+
+    def _infer_protocol(self):
+        if self.protocol:
+            return
+
+        self._send_command("P")
+        lines = self._read_lines()
+
+        if not lines:
+            raise RuntimeError("No response from scale.")
+
+        joined = " ".join(lines)
+        if any(h in joined for h in ["GS", "No.", "Total"]):
+            self.protocol = 1
+
+        match = re.search(r"[-+]? *([\d.]+)\s*([a-zA-Z]+)", lines[0])
+        if match:
+            self.protocol = 2
+
+        if self.protocol is None:
+            raise RuntimeError(f"Unrecognized scale output: {lines}")
+
+    def get_weight(self) -> float | None:
+        """"""
+        self._send_command("P")
+        lines = self._read_lines()
+
+        if not lines:
+            return None
+
+        if self.protocol == 1:
+            for line in lines:
+                if line.startswith(("GS", "NT", "GT")):
+                    return self._parse_weight_line(line)
+        elif self.protocol == 2:
+            return self._parse_weight_line(lines[0])
+
+        return None
+
+    def tare(self):
+        self._send_command("T")
+
+    def zero(self):
+        self._send_command("Z")
+
+    def set_tare_value(self, value: float):
+        self._send_command(f"T{value:.3f}")
+
+    def _parse_weight_line(self, line: str) -> float | None:
+        line = re.sub(r"^(GS|NT|GT|ST|US)?\s*", "", line)
+        match = re.search(r"[-+]?\d+\.\d+", line)
+        if match:
+            return float(match.group(0))
+        return None
+
+    def is_connected(self) -> bool:
+        return self.ser and self.ser.is_open
+
+    def is_responsive(self) -> bool:
+        try:
+            self.ser.write(b"P\r\n")
+            line = self.ser.readline()
+            if line:
+                self.last_response_time = datetime.utcnow()
+                return True
+        except serial.SerialException:
+            pass
+        return False
+
+    def close(self):
+        if self.ser.is_open:
+            self.ser.close()
+
+
+class AutoReconnectSerialScale:
+    def __init__(self, *args, retry_delay=2.0, **kwargs):
+        self._args = args
+        self._kwargs = kwargs
+        self._retry_delay = retry_delay
+        self._scale: SerialScale | None = None
+        self._connect()
+
+    def _connect(self):
+        while True:
+            try:
+                self._scale = SerialScale(*self._args, **self._kwargs)
+                print("SerialScale connected.")
+                return
+            except SerialException as e:
+                print(f"Serial connection failed: {e}. Retrying...")
+                time.sleep(self._retry_delay)
+
+    def _ensure_connection(self):
+        if self._scale is None or not self._scale.is_connected():
+            print("Lost connection. Attempting reconnect...")
+            self._connect()
+
+    def __getattr__(self, name):
+        """Forward method calls to internal SerialScale, with reconnection if needed."""
+
+        def method(*args, **kwargs):
+            self._ensure_connection()
+            try:
+                return getattr(self._scale, name)(*args, **kwargs)
+            except SerialException:
+                print("Serial error during operation. Reconnecting...")
+                self._connect()
+                return getattr(self._scale, name)(*args, **kwargs)
+
+        return method
+
+
+class Scale:
+    """High-level bench-scale driver with the same interface as serial-scale-hx711.
+
+    Construction is lightweight; call start() to open the port and infer protocol.
+    This allows the same WeighingScaleBase adapter pattern used for the HX711 scale.
+    """
+
+    def __init__(
+        self,
+        serial_port: str,
+        baudrate: int = 4800,
+        timeout: float = 1.0,
+        protocol: int | None = None,
+    ) -> None:
+        self.serial_port = serial_port
+        self.baudrate = baudrate
+        self.timeout = timeout
+        self.protocol = protocol
+        self._scale: SerialScale | None = None
+
+    def start(self, timeout: float = 10.0) -> None:
+        """Open the serial port, infer protocol, and verify the scale is responsive."""
+        deadline = time.time() + timeout
+        last_exc: Exception | None = None
+        while time.time() < deadline:
+            try:
+                if self._scale is not None:
+                    self._scale.close()
+                    self._scale = None
+                self._scale = SerialScale(
+                    port=self.serial_port,
+                    baudrate=self.baudrate,
+                    timeout=self.timeout,
+                    protocol=self.protocol or 2,
+                )
+                if self._scale.is_responsive():
+                    logging.info(f"Bench scale ready on {self.serial_port}")
+                    return
+            except (SerialException, Exception) as exc:
+                last_exc = exc
+            time.sleep(0.2)
+        raise TimeoutError(
+            f"Bench scale on {self.serial_port} did not respond within {timeout}s. "
+            f"Last error: {last_exc}"
+        )
+
+    def tare(self) -> None:
+        assert self._scale is not None
+        self._scale.tare()
+        time.sleep(0.3)
+
+    def read_weight(self) -> float | None:
+        assert self._scale is not None
+        return self._scale.get_weight()
+
+    def read_weight_repeated(
+        self,
+        n_readings: int = 5,
+        inter_read_delay: float = 0.1,
+    ) -> list[float]:
+        readings = []
+        for _ in range(n_readings):
+            r = self.read_weight()
+            if r is not None:
+                readings.append(r)
+            time.sleep(inter_read_delay)
+        return readings
+
+    def read_weight_reliable(
+        self,
+        n_readings: int = 5,
+        inter_read_delay: float = 0.1,
+        measure: Callable = statistics.median,
+    ) -> float:
+        readings = self.read_weight_repeated(n_readings, inter_read_delay)
+        if not readings:
+            raise RuntimeError(
+                f"Bench scale on {self.serial_port} returned no valid readings "
+                f"after {n_readings} attempts."
+            )
+        return measure(readings)
+
+    def read_weight_blocking(
+        self,
+        n_valid: int = 3,
+        inter_read_delay: float = 0.2,
+        timeout: float = 30.0,
+    ) -> float:
+        readings = []
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            r = self.read_weight()
+            if r is not None:
+                readings.append(r)
+                if len(readings) >= n_valid:
+                    return statistics.median(readings)
+            time.sleep(inter_read_delay)
+        raise TimeoutError(
+            f"Bench scale on {self.serial_port} could not produce {n_valid} valid "
+            f"readings within {timeout}s."
+        )
+
+    def disconnect(self) -> None:
+        if self._scale is not None:
+            self._scale.close()
+            self._scale = None
+
+    def __del__(self) -> None:
+        self.disconnect()
+
+
+if __name__ == "__main__":
+    scale = SerialScale("/dev/ttyUSB0", protocol=2)
+
+    if scale.is_connected():
+        print("Scale is connected.")
+        if scale.is_responsive():
+            print("Scale is responsive.")
+            print("Current weight:", scale.get_weight())
+        else:
+            print("Scale is unresponsive.")
+    else:
+        print("Scale not connected.")
+
+    scale.close()

serial_scale_bench-0.2.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: serial-scale-bench
+Version: 0.2.0
+Summary: Python driver for RS-232/USB bench scales (Kern, Mettler-Toledo, etc.).
+Project-URL: Homepage, https://github.com/MurineShiftWork/serial-scale-bench
+Project-URL: Documentation, https://larsrollik.github.io/serial-scale-bench/
+Project-URL: Issue Tracker, https://github.com/MurineShiftWork/serial-scale-bench/issues
+Author-email: "Lars B. Rollik" <L.B.Rollik@protonmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2021, Lars B. Rollik
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: pyserial
+Provides-Extra: api
+Requires-Dist: fastapi; extra == 'api'
+Requires-Dist: pydantic; extra == 'api'
+Requires-Dist: uvicorn[standard]; extra == 'api'
+Provides-Extra: dev
+Requires-Dist: commitizen; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# serial-scale-bench
+
+Python driver for RS-232/USB commercial bench scales (Kern, Mettler-Toledo, etc.).
+
+Supports two ASCII response protocols:
+- **Protocol 1** — multi-line header responses (`GS`, `NT`, `GT` prefixes); typical of
+  Kern and similar label-printing scales
+- **Protocol 2** — single float line; minimal scales and simpler firmware
+
+Protocol is auto-detected on first connection. A FastAPI HTTP server is included for
+running the scale as a networked service (e.g. LabWatch integration).
+
+## Install
+
+Base (serial only):
+
+```bash
+pip install serial-scale-bench
+```
+
+With HTTP API server:
+
+```bash
+pip install "serial-scale-bench[api]"
+```
+
+Or editable from this repo:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from serial_scale_bench import SerialScale
+
+scale = SerialScale(port="/dev/ttyUSB0", baudrate=9600)
+scale.tare()
+weight = scale.get_weight()   # float grams or None
+scale.close()
+```
+
+### Auto-reconnect wrapper
+
+```python
+from serial_scale_bench import AutoReconnectSerialScale
+
+scale = AutoReconnectSerialScale(port="/dev/ttyUSB0")
+weight = scale.get_weight()   # reconnects automatically on error
+```
+
+## HTTP API server
+
+Start a local REST server exposing the scale over HTTP:
+
+```bash
+python -m serial_scale_bench.entrypoint --device /dev/ttyUSB0 --port 8080 --scale-id bench1
+```
+
+Endpoints: `GET /weight`, `POST /tare`, `POST /zero`, `GET /status`, `GET /ping`.
+
+## API reference
+
+| Method | Description |
+|---|---|
+| `get_weight()` | Poll current weight (float or None) |
+| `tare()` | Send tare command |
+| `zero()` | Send zero command |
+| `set_tare_value(value)` | Set absolute tare |
+| `is_connected()` | True if serial port is open |
+| `is_responsive()` | True if scale responds to ping |
+| `close()` | Close serial connection |
+
+## murineshiftwork integration
+
+Planned: `BenchScaleAdapter` in `murineshiftwork.logic.scale`. Install with:
+
+```bash
+pip install "murineshiftwork[calibration]"
+```

serial_scale_bench-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+serial_scale_bench/__init__.py,sha256=_N0FPvq7LRcS8xmlpGVaKDiARURVmAx_Mhm3EoTn8V0,365
+serial_scale_bench/_version.py,sha256=s9U3X54Pdr-Jlh9GP6LBaa_VRos7qs_wtrVefUHHNIA,520
+serial_scale_bench/api.py,sha256=hDVKtgUrOnMbo0oAeEni7VQRtqwR_LnDzT9Z8ORBsBs,2207
+serial_scale_bench/cli.py,sha256=8CN3UdAyNm0d5iyV3uREU88xt52S7IojTKTNPmqlKBg,751
+serial_scale_bench/entrypoint.py,sha256=vYBBCGV9JrikpgvqpmmNmVhEKCEP8sqQAjSGjKEQGt4,551
+serial_scale_bench/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+serial_scale_bench/scale.py,sha256=qZQUb_EQOn1NqN76M9YOT7Q0wQhAjOsWH-xzVEMo_K4,9040
+serial_scale_bench-0.2.0.dist-info/METADATA,sha256=p6S5epnusgkH2jQBepgHMdo17jx3Cl6mlPJKVpM7tWY,4655
+serial_scale_bench-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+serial_scale_bench-0.2.0.dist-info/licenses/LICENSE,sha256=Ew8cEKZj5F51f1JVCmPZAESmeIe0HCdWdlo_NVKD-8s,1522
+serial_scale_bench-0.2.0.dist-info/RECORD,,

serial_scale_bench-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

serial_scale_bench-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2021, Lars B. Rollik
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.