serial-scale-hx711 2.1.0__tar.gz

serial_scale_hx711-2.1.0/.gitignore

@@ -0,0 +1,142 @@
+# IDE files
+.idea/
+.vscode/
+
+# Ignored file types
+.DS_Store
+
+# Custom config files
+*.conf.custom
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Build artifacts (hatch-vcs generated)
+src/*/_version.py
+
+# Pyre type checker
+.pyre/

serial_scale_hx711-2.1.0/CITATION.cff

@@ -0,0 +1,20 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+type: software
+title: "serial-scale-hx711: Python driver for Arduino+HX711 serial weighing scales"
+version: "2.0.4"
+repository-code: https://github.com/MurineShiftWork/serial-scale-hx711
+license: GPL-3.0
+authors:
+  - family-names: Rollik
+    given-names: Lars B.
+    orcid: https://orcid.org/0000-0003-0160-6971
+
+# Zenodo integration (optional):
+# 1. Enable the Zenodo webhook at zenodo.org/account/settings/github
+# 2. After first tag release, copy the concept DOI from Zenodo and add:
+#
+# identifiers:
+#   - type: doi
+#     value: 10.5281/zenodo.XXXXXXX
+#     description: Zenodo concept DOI (resolves to latest version)

serial_scale_hx711-2.1.0/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.

serial_scale_hx711-2.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: serial-scale-hx711
+Version: 2.1.0
+Summary: Python driver for Arduino+HX711 serial weighing scales.
+Project-URL: Homepage, https://github.com/MurineShiftWork/serial-scale-hx711
+Project-URL: Documentation, https://larsrollik.github.io/serial-scale-hx711/
+Project-URL: Issue Tracker, https://github.com/MurineShiftWork/serial-scale-hx711/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: 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-hx711
+
+Python driver for Arduino+HX711 serial weighing scales.
+
+> **Renamed from `serial-weighing-scale`** (PyPI: `serial-weighing-scale` ≤ 2.0.4).
+> New releases publish under `serial-scale-hx711`. A deprecation stub remains on PyPI
+> under the old name pointing here.
+
+## Hardware
+
+- Arduino Uno (USB-A to USB-B cable)
+- HX711 load cell amplifier (e.g. SparkFun SEN-13879)
+- Load cell 100 g or 500 g (e.g. SEN-14727 / SEN-14728)
+- Firmware: see `scale_firmware/` (uses [olkal/HX711_ADC](https://github.com/olkal/HX711_ADC))
+
+The scale identifies itself as `<SerialWeighingScale>` over 115200 baud.
+
+## Install
+
+```bash
+pip install serial-scale-hx711
+```
+
+Or editable from this repo:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from serial_scale_hx711 import Scale
+
+scale = Scale(serial_port="/dev/ttyACM1")
+scale.start()          # connect and wait for firmware init
+scale.tare()
+weight = scale.read_weight_blocking()   # grams, blocks until stable
+scale.disconnect()
+```
+
+### Auto-detect port
+
+```python
+from serial_scale_hx711 import connect_serial_scale
+
+scale = connect_serial_scale(["/dev/ttyACM0", "/dev/ttyACM1", "/dev/ttyACM2"])
+```
+
+## API
+
+| Method | Description |
+|---|---|
+| `start(timeout=10)` | Connect and wait for firmware ready |
+| `tare()` | Zero the scale |
+| `read_weight()` | Single reading (float or None) |
+| `read_weight_blocking(n_valid, timeout)` | Block until N valid readings, return median |
+| `read_weight_reliable(n_readings, measure)` | Repeated reads with custom aggregation |
+| `identify()` | True if firmware responds with identity string |
+| `get_calibration_factor()` | Read calibration factor from firmware |
+| `disconnect()` | Close serial connection |
+
+## murineshiftwork integration
+
+Used via `murineshiftwork.logic.scale.SerialWeighingScaleAdapter`. Install with:
+
+```bash
+pip install "murineshiftwork[calibration]"
+```

serial_scale_hx711-2.1.0/README.md

@@ -0,0 +1,69 @@
+# serial-scale-hx711
+
+Python driver for Arduino+HX711 serial weighing scales.
+
+> **Renamed from `serial-weighing-scale`** (PyPI: `serial-weighing-scale` ≤ 2.0.4).
+> New releases publish under `serial-scale-hx711`. A deprecation stub remains on PyPI
+> under the old name pointing here.
+
+## Hardware
+
+- Arduino Uno (USB-A to USB-B cable)
+- HX711 load cell amplifier (e.g. SparkFun SEN-13879)
+- Load cell 100 g or 500 g (e.g. SEN-14727 / SEN-14728)
+- Firmware: see `scale_firmware/` (uses [olkal/HX711_ADC](https://github.com/olkal/HX711_ADC))
+
+The scale identifies itself as `<SerialWeighingScale>` over 115200 baud.
+
+## Install
+
+```bash
+pip install serial-scale-hx711
+```
+
+Or editable from this repo:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from serial_scale_hx711 import Scale
+
+scale = Scale(serial_port="/dev/ttyACM1")
+scale.start()          # connect and wait for firmware init
+scale.tare()
+weight = scale.read_weight_blocking()   # grams, blocks until stable
+scale.disconnect()
+```
+
+### Auto-detect port
+
+```python
+from serial_scale_hx711 import connect_serial_scale
+
+scale = connect_serial_scale(["/dev/ttyACM0", "/dev/ttyACM1", "/dev/ttyACM2"])
+```
+
+## API
+
+| Method | Description |
+|---|---|
+| `start(timeout=10)` | Connect and wait for firmware ready |
+| `tare()` | Zero the scale |
+| `read_weight()` | Single reading (float or None) |
+| `read_weight_blocking(n_valid, timeout)` | Block until N valid readings, return median |
+| `read_weight_reliable(n_readings, measure)` | Repeated reads with custom aggregation |
+| `identify()` | True if firmware responds with identity string |
+| `get_calibration_factor()` | Read calibration factor from firmware |
+| `disconnect()` | Close serial connection |
+
+## murineshiftwork integration
+
+Used via `murineshiftwork.logic.scale.SerialWeighingScaleAdapter`. Install with:
+
+```bash
+pip install "murineshiftwork[calibration]"
+```

serial_scale_hx711-2.1.0/VERSION

@@ -0,0 +1 @@
+2.1.0

serial_scale_hx711-2.1.0/pyproject.toml

@@ -0,0 +1,106 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "serial-scale-hx711"
+dynamic = ["version"]
+description = "Python driver for Arduino+HX711 serial weighing scales."
+readme = { file = "README.md", content-type = "text/markdown" }
+license = { file = "LICENSE" }
+authors = [
+    { name = "Lars B. Rollik", email = "L.B.Rollik@protonmail.com" },
+]
+requires-python = ">=3.10"
+dependencies = [
+    "pyserial",
+]
+
+[project.urls]
+Homepage = "https://github.com/MurineShiftWork/serial-scale-hx711"
+Documentation = "https://larsrollik.github.io/serial-scale-hx711/"
+"Issue Tracker" = "https://github.com/MurineShiftWork/serial-scale-hx711/issues"
+
+[project.optional-dependencies]
+dev = [
+    "commitizen",
+    "pytest",
+    "pytest-cov",
+    "pre-commit",
+]
+docs = [
+    "mkdocs-material",
+]
+
+# ---------------------------------------------------------------------------
+# Build
+# ---------------------------------------------------------------------------
+
+[tool.hatch.version]
+source = "vcs"
+fallback-version = "2.0.4"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/serial_scale_hx711/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/serial_scale_hx711"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src/serial_scale_hx711",
+    "/tests",
+    "/README.md",
+    "/LICENSE",
+    "/pyproject.toml",
+    "/CITATION.cff",
+    "/VERSION",
+]
+
+# ---------------------------------------------------------------------------
+# Commitizen
+# ---------------------------------------------------------------------------
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version_provider = "commitizen"
+version = "2.1.0"
+tag_format = "v$version"
+update_changelog_on_bump = false
+version_files = ["VERSION"]
+
+# ---------------------------------------------------------------------------
+# Pytest
+# ---------------------------------------------------------------------------
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=serial_scale_hx711 --durations=0"
+
+# ---------------------------------------------------------------------------
+# Ruff
+# ---------------------------------------------------------------------------
+
+[tool.ruff]
+line-length = 99
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "W"]
+ignore = ["E501"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "auto"
+
+# ---------------------------------------------------------------------------
+# Mypy
+# ---------------------------------------------------------------------------
+
+[tool.mypy]
+mypy_path = "src"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "toml"
+ignore_missing_imports = true

serial_scale_hx711-2.1.0/src/serial_scale_hx711/__init__.py

@@ -0,0 +1,35 @@
+__author__ = "Lars B. Rollik"
+
+from importlib.metadata import PackageNotFoundError, version
+
+from serial_scale_hx711.scale import Scale
+
+try:
+    __version__ = version("serial-scale-hx711")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+DEFAULT_TEST_PORTS = [f"/dev/ttyACM{x}" for x in range(5)]
+
+# Backwards-compatibility alias for code that imported SerialWeighingScale
+SerialWeighingScale = Scale
+
+
+def connect_serial_scale(
+    serial_port_list: list = DEFAULT_TEST_PORTS,
+) -> Scale | None:
+    """Connect to the first available serial scale from the provided list of ports."""
+    from serial import SerialException
+
+    for serial_port in serial_port_list:
+        try:
+            scale = Scale(serial_port=serial_port)
+            scale.start()
+            return scale
+        except SerialException:
+            pass
+
+    return None
+
+
+__all__ = ["Scale", "SerialWeighingScale", "connect_serial_scale", "__version__"]

serial_scale_hx711-2.1.0/src/serial_scale_hx711/_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 = '2.1.0'
+__version_tuple__ = version_tuple = (2, 1, 0)
+
+__commit_id__ = commit_id = None

serial_scale_hx711-2.1.0/src/serial_scale_hx711/connection.py

@@ -0,0 +1,167 @@
+import logging
+import struct
+from typing import Any
+
+from serial import Serial
+
+
+class SerialConnection:
+    serial_port: str = ""
+    baudrate: int
+    timeout: float
+    connection: Serial
+    _connected = False
+
+    def __init__(
+        self,
+        serial_port: str = "",
+        baudrate: int = 115200,
+        timeout: float = 1,
+        **kwargs: Any,
+    ) -> None:
+        self.serial_port = serial_port
+        self.baudrate = baudrate or 115200
+        self.timeout = timeout or 0.1
+        self.connection = None
+
+    def dict(self) -> dict:
+        class_data = {
+            "serial_port": self.serial_port,
+            "baudrate": self.baudrate,
+            "timeout": self.timeout,
+        }
+        return class_data
+
+    def __repr__(self) -> str:
+        return (
+            f"SerialConnection(serial_port={self.serial_port}, "
+            f"baudrate={self.baudrate}, "
+            f"timeout={self.timeout})"
+        )
+
+    def __str__(self) -> str:
+        return (
+            f"SerialConnection: {self.serial_port} @ {self.baudrate} baud, timeout={self.timeout}"
+        )
+
+    def __del__(self) -> None:
+        self.disconnect()
+
+    @property
+    def connected(self) -> bool:
+        return self._connected
+
+    def connect(self) -> "SerialConnection":
+        if not self.connected:
+            self.connection = Serial(
+                port=self.serial_port,
+                baudrate=self.baudrate,
+                timeout=self.timeout,
+                dsrdtr=False,  # prevent DTR toggle from resetting the Arduino on open
+                rtscts=False,
+            )
+            # is open?
+            if self.connection.is_open:
+                logging.info(f"Connected to {self.serial_port} at {self.baudrate} baud.")
+            else:
+                logging.error(f"Failed to open serial port {self.serial_port}.")
+
+        # finalize connection
+        self._connected = True
+        self._clear_buffer()
+
+        return self
+
+    def disconnect(self) -> None:
+        if self.connection is not None:
+            self.connection.close()
+            self.connection = None
+            self._connected = False
+            logging.info(f"Disconnected from {self.serial_port}.")
+
+    def _encode(self, data: Any, order: str) -> bytes:
+        """Encode & pack as byte struct & flank by start/stop bytes."""
+        # check that data is list
+        if not isinstance(data, list):
+            data = [data]
+
+        # encode str to bytes
+        data_encoded = [item.encode() if isinstance(item, str) else item for item in data]
+
+        # pack the data
+        data_packed = struct.pack(order, *data_encoded)
+
+        # flank the packed data with start/stop bytes </>
+        message = b"<" + data_packed + b">"
+
+        logging.debug(f"Encoded message: '{str(message)}'")
+        return message
+
+    def _clear_buffer(self):
+        self.connection.read(self.connection.in_waiting)
+        return not self.connection.in_waiting
+
+    def send(
+        self,
+        command: str,
+        data: list | int | str | None = None,
+        order: str = "",
+    ) -> None:
+        """"""
+        assert isinstance(command, str)
+        assert isinstance(data, list | int | str | type(None))
+        assert isinstance(order, str)
+
+        # fix data type
+        if data is not None and not isinstance(data, list):
+            data = [data]
+
+        raw_data = [command] + data if data is not None else command
+
+        # encode/pack
+        data_to_send = self._encode(raw_data, order=order)
+
+        # send data
+        if self.connected:
+            self._clear_buffer()
+            self.connection.write(data_to_send)
+            self.connection.flush()
+            logging.debug(f"Sent data: {str(data_to_send)}")
+
+    def read_bytes(self, n_bytes: int, unpack_order: str) -> tuple[Any, ...]:
+        """
+        Read n_bytes from the serial port and unpack them according to the
+        specified unpack_order.
+        The unpack_order should be a format string compatible with the
+        struct module.
+
+        Parameters
+        ----------
+        n_bytes : int
+        unpack_order : str
+
+        Returns
+        -------
+        tuple
+            Unpacked data as a tuple of values.
+
+        """
+        raw_data = self.connection.read(n_bytes)
+
+        # Check if the correct amount of data was read
+        if len(raw_data) != n_bytes:
+            raise ValueError(f"Did not receive {n_bytes} bytes from serial port")
+
+        # Unpack the data as separate variables
+        unpacked_bytes = struct.unpack(unpack_order, raw_data)
+
+        logging.debug(f"Unpacked bytes: {unpacked_bytes}")
+        return unpacked_bytes
+
+    def read_line(self) -> str:
+        """
+        Read a line from the serial port and decode it to a string.
+        """
+        line = self.connection.readline().decode("utf-8").strip()
+        logging.debug(f"Received line: {line}")
+        return line

serial_scale_hx711-2.1.0/src/serial_scale_hx711/scale.py

@@ -0,0 +1,154 @@
+import logging
+import statistics
+import time
+from collections.abc import Callable
+
+from serial_scale_hx711.connection import SerialConnection
+
+
+class Scale(SerialConnection):
+    _identity_response = "<SerialWeighingScale>"
+
+    def __init__(self, serial_port: str, baudrate: int = 115200, timeout: float = 1) -> None:
+        # init serial connection
+        super().__init__(serial_port=serial_port, baudrate=baudrate, timeout=timeout)
+
+    def start(self, timeout=10) -> None:
+        """Connect and wait for the scale firmware to finish initialising.
+
+        Firmware only responds to <i> (identify) once the HX711 tare is complete,
+        so polling identify() is sufficient — no need to hammer read_weight().
+        """
+        self.connect()
+
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            try:
+                if self.identify():
+                    elapsed = time.time() - start_time
+                    logging.info(f"Scale ready: {self.serial_port} (after {elapsed:.2f}s)")
+                    return
+            except (UnicodeDecodeError, Exception):
+                pass
+            time.sleep(0.1)
+
+        raise TimeoutError(
+            f"Scale did not respond within {timeout}s on {self.serial_port}. "
+            f"Check wiring and that firmware is loaded."
+        )
+
+    @property
+    def is_ready(self) -> bool:
+        """True if the firmware is initialised and responding to identity queries."""
+        return self.identify()
+
+    def read_weight(self) -> float | None:
+        """
+        Get the weight from the scale.
+        """
+        self.send(command="w", order="c")
+        weight_result = self.read_line()
+
+        # Convert to float
+        try:
+            weight = round(float(weight_result), 2)
+            return weight
+        except ValueError:
+            logging.error(f"Failed to convert weight result to float: {weight_result}")
+            return None
+
+    def tare(self) -> None:
+        """
+        Tare the scale.
+        """
+        self.send(command="t", order="c")
+        # LoadCell.tare() on firmware is blocking (~100 ms at 10 Hz / 1 sample).
+        # The rolling-average buffer also needs time to flush old pre-tare values.
+        # Wait 0.5 s so the next read sees fully tared samples.
+        time.sleep(0.5)
+
+    def identify(self) -> bool:
+        """
+        Identify the device connected to the serial port.
+        This method sends a command to the device and waits for a response.
+        """
+        self.send(command="i", order="c")
+        response = self.read_line()
+        return response == self._identity_response
+
+    def get_calibration_factor(self) -> float | None:
+        """
+        Get the calibration factor from the scale.
+        """
+        self.send(command="f", order="c")
+
+        calibration_result = self.read_line()
+
+        # Convert to float
+        try:
+            calibration_factor = float(calibration_result)
+            return calibration_factor
+        except ValueError:
+            logging.error(f"Failed to convert calibration result to float: {calibration_result}")
+            return None
+
+    def read_weight_repeated(self, n_readings: int = 5, inter_read_delay: float = 0.1) -> list:
+        """Read weight n times, return list of valid (non-None) readings."""
+        readings = []
+        for _ in range(n_readings):
+            reading = self.read_weight()
+            if reading is not None:
+                readings.append(reading)
+            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:
+        """Repeated reads with statistical measure. Raises if no valid readings."""
+        readings = self.read_weight_repeated(
+            n_readings=n_readings, inter_read_delay=inter_read_delay
+        )
+        if not readings:
+            raise RuntimeError(
+                f"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,
+    ) -> float:
+        """Block until n_valid successful weight readings are collected, return their median.
+
+        Use this at every point in the calibration where the task must not proceed
+        until the scale has returned a trustworthy value.  Raises TimeoutError if
+        the scale does not produce enough valid readings within `timeout` seconds.
+        """
+        readings = []
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            reading = self.read_weight()
+            if reading is not None:
+                readings.append(reading)
+                if len(readings) >= n_valid:
+                    return statistics.median(readings)
+            time.sleep(inter_read_delay)
+        raise TimeoutError(
+            f"Scale on {self.serial_port} could not produce {n_valid} valid readings "
+            f"within {timeout}s.  Check connection and sensor."
+        )
+
+
+if __name__ == "__main__":
+    print("TEST")
+
+    s = Scale(serial_port="/dev/ttyACM1", baudrate=115200, timeout=1)
+    s.connect()
+    s.read_weight()

serial_scale_hx711-2.1.0/tests/minimal_usage.py

@@ -0,0 +1,55 @@
+import logging
+from typing import TypedDict
+
+from serial_weighing_scale import SerialWeighingScale
+
+
+class ScaleConfig(TypedDict):
+    serial_port: str
+    baudrate: int
+    timeout: float
+
+
+if __name__ == "__main__":
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+
+    serial_param: ScaleConfig = {
+        "serial_port": "/dev/ttyACM3",
+        "baudrate": 115200,
+        "timeout": 1,
+    }
+
+    # scale = connect_serial_scale()
+    scale = SerialWeighingScale(**serial_param)
+    scale.start()
+
+    # # measure time until scale is ready
+    # start_time = time.time()
+    # while not scale.is_ready:
+    #     time.sleep(0.1)
+    #
+    # elapsed_time = time.time() - start_time
+    #
+    # print("Scale ready", elapsed_time)
+    # scale.read_weight()
+    # scale.tare()
+    #
+    # # query every .25 seconds and print the weight, continue until interrupted
+    # try:
+    #     while True:
+    #         weight = scale.read_weight()
+    #         print("Weight:", weight)
+    #         time.sleep(0.25)
+    # except KeyboardInterrupt:
+    #     pass
+    print("")
+    print("NEXT")
+    print("")
+
+    scale = SerialWeighingScale(**serial_param)
+    scale.start()
+    scale.identify()
+    scale.read_weight()
+
+    print("Scale:", scale.is_ready)

serial_scale_hx711-2.1.0/tests/tests/test_integration/test_placeholder.py

@@ -0,0 +1,30 @@
+import subprocess
+
+import toml
+
+
+def get_package_name() -> str:
+    """Retrieve package name from pyproject.toml."""
+    project_data = toml.load("pyproject.toml")
+    return str(project_data["project"]["name"])
+
+
+def test_package_functionality() -> None:
+    """Test the package dynamically after installation."""
+    package_name = get_package_name()
+    # Replace hyphens with underscores for import compatibility
+    package_name = package_name.replace("-", "_")
+
+    # Install the package
+    subprocess.run(["pip", "install", "."], check=True)
+
+    # Dynamically import the package
+    result = subprocess.run(
+        ["python", "-c", f"import {package_name}"],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, f"Dynamic package import failed: {result.stderr}"
+
+    # Cleanup: Uninstall the package
+    subprocess.run(["pip", "uninstall", "-y", package_name], check=True)

serial_scale_hx711-2.1.0/tests/tests/test_unit/test_unit.py

@@ -0,0 +1,52 @@
+import subprocess
+import sys
+
+
+def ensure_toml_installed() -> None:
+    """Ensure toml is installed in the current environment."""
+    try:
+        __import__("toml")
+    except ImportError:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "toml"],
+            check=True,
+        )
+
+
+def test_python_version() -> None:
+    """Test that Python version is compatible with the environment."""
+    assert sys.version_info >= (3, 8), "Python version must be 3.8 or higher"
+
+
+def test_package_installation() -> None:
+    """Test dynamic installation and uninstallation of the package."""
+    ensure_toml_installed()
+    import toml
+
+    # Dynamically read the package name
+    package_name = toml.load("pyproject.toml")["project"]["name"]
+
+    # Install the package
+    subprocess.run([sys.executable, "-m", "pip", "install", "."], check=True)
+
+    # Check that the package is installed
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "show", package_name],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, "Package installation failed"
+
+    # Uninstall the package
+    subprocess.run(
+        [sys.executable, "-m", "pip", "uninstall", "-y", package_name],
+        check=True,
+    )
+
+    # Verify the package is uninstalled
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "show", package_name],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode != 0, "Package uninstallation failed"