scietex.hal.adc 0.0.1__tar.gz

scietex_hal_adc-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anton Bondarenko
+
+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.

scietex_hal_adc-0.0.1/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: scietex.hal.adc
+Version: 0.0.1
+Summary: Scietex ADC HAL package
+Author-email: Anton Bondarenko <bond.anton@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Anton Bondarenko
+        
+        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.
+Project-URL: Homepage, https://github.com/bond-anton/scietex.hal.adc
+Project-URL: Bug Tracker, https://github.com/bond-anton/scietex.hal.adc/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msgspec[yaml]>=0.20.0
+Requires-Dist: scietex.hal.serial<2.0.0,>=1.3.0
+Provides-Extra: dev
+Requires-Dist: tox>=4.45.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Provides-Extra: lint
+Requires-Dist: ruff; extra == "lint"
+Dynamic: license-file
+
+# scietex.hal.adc
+
+The `scietex.hal.adc` package is a Python library for interfacing with ADC.
+It provides an abstract class `ADC`, and a base class for ADCs with RS485 communication
+interface, which in its turn inherits `scietex.hal.serial.RS485Client`.
+The concrete implementation for the ADC manufactured by Scietex is provided.
+
+
+## License
+
+This project is licensed under the **MIT License** - see the LICENSE file for details.

scietex_hal_adc-0.0.1/README.md

@@ -0,0 +1,11 @@
+# scietex.hal.adc
+
+The `scietex.hal.adc` package is a Python library for interfacing with ADC.
+It provides an abstract class `ADC`, and a base class for ADCs with RS485 communication
+interface, which in its turn inherits `scietex.hal.serial.RS485Client`.
+The concrete implementation for the ADC manufactured by Scietex is provided.
+
+
+## License
+
+This project is licensed under the **MIT License** - see the LICENSE file for details.

scietex_hal_adc-0.0.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scietex.hal.adc"
+dynamic = ["version"]
+description = "Scietex ADC HAL package"
+authors = [{ name = "Anton Bondarenko", email = "bond.anton@gmail.com" }]
+license = { file = "LICENSE" }
+readme = "README.md"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+requires-python = ">=3.10"
+dependencies = [
+  "msgspec[yaml] >= 0.20.0",
+  "scietex.hal.serial >= 1.3.0, < 2.0.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/bond-anton/scietex.hal.adc"
+"Bug Tracker" = "https://github.com/bond-anton/scietex.hal.adc/issues"
+
+[project.optional-dependencies]
+dev = ["tox>=4.45.0"]
+test = ["pytest", "pytest-asyncio"]
+lint = ["ruff"]
+
+[tool.setuptools.dynamic]
+version = { attr = "scietex.hal.adc.version.__version__" }
+
+[tool.setuptools.package-data]
+"scietex.hal.adc" = ["py.typed"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

scietex_hal_adc-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

scietex_hal_adc-0.0.1/src/scietex/hal/adc/__init__.py

@@ -0,0 +1,6 @@
+"""ADC HAL module"""
+
+from .base import ADC
+from .version import __version__
+
+__all__ = ["__version__", "ADC"]

scietex_hal_adc-0.0.1/src/scietex/hal/adc/base/__init__.py

@@ -0,0 +1,5 @@
+"""Base ADC classes to be inherited in particular device implementation."""
+
+from .adc import ADC
+
+__all__ = ["ADC"]

scietex_hal_adc-0.0.1/src/scietex/hal/adc/base/adc.py

@@ -0,0 +1,88 @@
+"""ADC abstract interface."""
+
+from abc import ABC, abstractmethod
+
+from .data import ADCError, ADCParameters, VoltageTuple
+
+
+class ADC(ABC):
+    """ADC interface class."""
+
+    channels_number: int = 1
+
+    error_codes: dict[int, ADCError] = {0: ADCError(code=0, message="No error")}
+    error_codes_com: dict[int, ADCError] = {0: ADCError(code=0, message="No error")}
+
+    # Error processing methods
+    @abstractmethod
+    async def get_error_code(self, comm: bool = False) -> int:
+        """Read error code from the device"""
+
+    def parse_error_code(self, code: int, comm: bool = False) -> ADCError:
+        """Parse error code from the device"""
+        if comm:
+            if code in self.error_codes_com:
+                return self.error_codes_com[code]
+        else:
+            if code in self.error_codes:
+                return self.error_codes[code]
+        return ADCError(code=code, message="Unknown error")
+
+    @abstractmethod
+    async def clear_error(self, comm: bool = False) -> int:
+        """Clear error from the device."""
+
+    # Device information methods
+    @abstractmethod
+    async def get_vendor(self) -> str:
+        """Get device vendor name."""
+
+    @abstractmethod
+    async def get_product_name(self) -> str:
+        """Get device product name."""
+
+    @abstractmethod
+    async def get_serial_number(self) -> str:
+        """Get device serial number."""
+
+    @abstractmethod
+    async def get_version(self) -> str:
+        """get device firmware version."""
+
+    # ADC measurement setup
+
+    # @abstractmethod
+    # async def get_mcu_frequency(self) -> int:
+    #     """GET MCU frequency."""
+
+    # @abstractmethod
+    # async def get_gate_time(self) -> float:
+    #     """Get gate time in ms"""
+
+    # @abstractmethod
+    # async def set_gate_time(self, gate_time_ms: float) -> float:
+    #     """Set gate time in ms"""
+
+    # @abstractmethod
+    # async def get_averaging(self) -> int:
+    #     """Get averaging window"""
+
+    # @abstractmethod
+    # async def set_averaging(self, averaging_window: int) -> int:
+    #     """Set averaging window."""
+
+    # Voltage measurement methods
+
+    @abstractmethod
+    async def get_voltage(self) -> VoltageTuple:
+        """Get all channels voltages."""
+
+    @abstractmethod
+    async def get_channel_voltage(self, channel: int) -> float | None:
+        """Get voltage value for a specific channel."""
+
+    # Read ADC parameters in single call
+
+    @abstractmethod
+    async def read_parameters(self) -> ADCParameters:
+        """Read ADC Parameters"""

scietex_hal_adc-0.0.1/src/scietex/hal/adc/base/data.py

@@ -0,0 +1,69 @@
+"""Data models for the ADC."""
+
+# from enum import Enum
+
+import msgspec
+
+# class OutCTRLMode(Enum):
+#     """Modes of the control output."""
+
+#     HIGH = 1
+#     LOW = 2
+#     MANUAL = 3
+#     DISABLED = 4
+
+
+# class PwmCTRLMode(Enum):
+#     """Modes of the PWM output."""
+
+#     ABSOLUTE = 1
+#     RELATIVE = 2
+#     MANUAL = 3
+#     DISABLED = 4
+
+
+class ADCError(msgspec.Struct, frozen=True):
+    """Model of an ADC error with code and message."""
+
+    code: int
+    message: str = "Unknown error"
+
+    def __str__(self) -> str:
+        return f"ADCError(code={self.code}, message='{self.message}')"
+
+
+VoltageTuple = tuple[float | None, ...]
+
+
+class ADCParameters(msgspec.Struct, frozen=True):
+    """ADC parameters schema."""
+
+    connected: bool = False  # ADC connection status
+    channels_number: int | None = None  # Number of ADC channels
+    voltage: VoltageTuple | None = None  # Channel voltages
+
+    def __str__(self) -> str:
+        """Human-readable representation."""
+        if self.voltage is None:
+            voltage_str = "None"
+        elif not self.voltage:
+            voltage_str = "[]"
+        else:
+            voltage_strs = [f"{v:.2f} V" if v is not None else "N/A" for v in self.voltage]
+            voltage_str = f"[{', '.join(voltage_strs)}]"
+
+        return (
+            f"ADCParameters("
+            f"channels_number={self.channels_number}, "
+            f"voltage={voltage_str}, "
+            f"connected={self.connected})"
+        )
+
+    def __repr__(self) -> str:
+        """Official string representation (used in debugging)."""
+        return (
+            f"ADCParameters("
+            f"connected={self.connected!r}, "
+            f"channels_number={self.channels_number!r}, "
+            f"voltage={self.voltage!r})"
+        )

scietex_hal_adc-0.0.1/src/scietex/hal/adc/base/rs485/__init__.py

@@ -0,0 +1,5 @@
+"""RS485 devices."""
+
+from .adc import RS485ADC
+
+__all__ = ["RS485ADC"]

scietex_hal_adc-0.0.1/src/scietex/hal/adc/base/rs485/adc.py

@@ -0,0 +1,152 @@
+"""Lock-in amplifier with RS485 communication interface."""
+
+from logging import Logger
+from typing import Any
+
+from pymodbus.framer import FramerBase
+from pymodbus.pdu import DecodePDU, ModbusPDU
+from scietex.hal.serial import (
+    ModbusSerialConnectionConfig,
+    RS485Client,
+    SerialConnectionConfig,
+)
+
+from ...version import __version__
+from .. import ADC
+from ..data import ADCParameters, VoltageTuple
+
+
+class RS485ADC(ADC, RS485Client):
+    """ADC with RS485 communication interface."""
+
+    def __init__(
+        self,
+        channels_number: int,
+        con_params: SerialConnectionConfig | ModbusSerialConnectionConfig,
+        address: int = 1,
+        label: str = "RS485 ADC",
+        custom_framer: type[FramerBase] | None = None,
+        custom_decoder: type[DecodePDU] | None = None,
+        custom_response: list[type[ModbusPDU]] | None = None,
+        chunk_size: int | None = None,
+        write_chunk_size: int | None = None,
+        logger: Logger | None = None,
+        **kwargs,
+    ):
+        RS485Client.__init__(
+            self,
+            con_params=con_params,
+            address=address,
+            custom_framer=custom_framer,
+            custom_decoder=custom_decoder,
+            custom_response=custom_response,
+            chunk_size=chunk_size,
+            write_chunk_size=write_chunk_size,
+            logger=logger,
+        )
+        self.channels_number = channels_number
+
+    # Error processing methods
+
+    async def get_error_code(self, comm: bool = False) -> int:
+        """Read error code from the ADC."""
+        code = 0
+        if comm:
+            self.logger.debug("%s: Communication error code %d.", self.label, code)
+        else:
+            self.logger.debug("%s: Error code %d.", self.label, code)
+        return code
+
+    async def clear_error(self, comm: bool = False) -> int:
+        """Clear error from the ADC."""
+        if comm:
+            self.logger.debug("%s: Clear communication error.", self.label)
+        else:
+            self.logger.debug("%s: Clear error.", self.label)
+        return await self.get_error_code()
+
+    # Device information methods
+
+    async def get_vendor(self) -> str:
+        """Get ADC vendor name."""
+        vendor: str = "n/d"
+        self.logger.debug("%s vendor: %s", self.label, vendor)
+        return vendor
+
+    async def get_product_name(self) -> str:
+        """Get ADC product name."""
+        self.logger.debug("%s prod. name: %s", self.label, self.label)
+        return self.label
+
+    async def get_serial_number(self) -> str:
+        """Get ADC serial number."""
+        sn = "n/d"
+        self.logger.debug("%s SN: %s", self.label, sn)
+        return sn
+
+    async def get_version(self) -> str:
+        """Get ADC firmware version."""
+        self.logger.debug("%s version: %s.", self.label, __version__)
+        return __version__
+
+    # Voltage measurement methods
+
+    async def get_voltage(self) -> VoltageTuple:
+        """Get all channels voltages."""
+        self.logger.debug("%s: get_voltage call", self.label)
+        voltage: VoltageTuple = (None,) * self.channels_number
+        return voltage
+
+    async def get_channel_voltage(self, channel: int) -> float | None:
+        """Get X channel voltage value."""
+        self.logger.debug("%s: get_channel_voltage[%d] call", self.label, channel)
+        return None
+
+    # RS485 address and baudrate
+
+    async def get_address(self) -> int:
+        """Get RS-485 address."""
+        self.logger.debug("%s: get_address call", self.label)
+        return 1
+
+    async def set_address(self, address: int) -> int:
+        """Set RS-485 address."""
+        self.logger.debug("%s: set_address(%d) call", self.label, address)
+        return await self.get_address()
+
+    async def get_baudrate(self) -> int:
+        """Get RS-485 baudrate value."""
+        self.logger.debug("%s: get_baudrate call", self.label)
+        return 9600
+
+    async def set_baudrate(self, baudrate: int) -> int:
+        """Set RS-485 baudrate."""
+        self.logger.debug("%s: set_baudrate(%d) call", self.label, baudrate)
+        return await self.get_baudrate()
+
+    async def check_connection(self) -> bool:
+        """Set RS-485 baudrate."""
+        self.logger.debug("%s: check_connection call", self.label)
+        return False
+
+    # Read Lock-in state in a single request
+
+    async def read_parameters(self) -> ADCParameters:
+        """Read ADC Parameters."""
+        self.logger.debug("%s: read_parameters call", self.label)
+        voltage: VoltageTuple = await self.get_voltage()
+        connected: bool = await self.check_connection()
+        parameters = ADCParameters(
+            channels_number=self.channels_number,
+            voltage=voltage,
+            connected=connected,
+        )
+        return parameters
+
+    async def read_data(self) -> dict[str, int | float | list[int | float]]:
+        """Read Lockin data in a single request."""
+        parameters = await self.read_parameters()
+        return {f: getattr(parameters, f) for f in parameters.__struct_fields__}
+
+    async def process_message(self, message: dict[str, Any]) -> None:
+        await super().process_message(message)

scietex_hal_adc-0.0.1/src/scietex/hal/adc/scietex/__init__.py

@@ -0,0 +1,5 @@
+"""Scietex drivers."""
+
+from .vdp_adc import VdpADC
+
+__all__ = ["VdpADC"]

scietex_hal_adc-0.0.1/src/scietex/hal/adc/scietex/utils.py

@@ -0,0 +1,21 @@
+"""Scietex-related utilities."""
+
+
+def baudrate_check(baudrate: int) -> int:
+    """Adjust baudrate to the supported values."""
+    if baudrate <= 9600:
+        return 9600
+    if baudrate <= 14400:
+        return 14400
+    if baudrate <= 19200:
+        return 19200
+    if baudrate <= 38400:
+        return 38400
+    if baudrate <= 57600:
+        return 57600
+    return 115200
+
+
+def address_check(address: int) -> int:
+    """Adjust address to the supported values."""
+    return max(1, min(address, 247))

scietex_hal_adc-0.0.1/src/scietex/hal/adc/scietex/vdp_adc.py

@@ -0,0 +1,149 @@
+"""Scietex VdpADC."""
+
+from logging import Logger
+
+from scietex.hal.serial import ModbusSerialConnectionConfig
+from scietex.hal.serial.utilities.numeric import ByteOrder, combine_32bit, float_from_int
+
+from ..base.data import ADCParameters, VoltageTuple
+from ..base.rs485 import RS485ADC
+
+VOLTAGE_SCALE = 100
+
+
+class VdpADC(RS485ADC):
+    """Scietex Van der Pauw ADC RS485 driver."""
+
+    def __init__(
+        self,
+        con_params: ModbusSerialConnectionConfig,
+        address: int = 1,
+        label: str = "Scietex Van der Pauw ADC",
+        logger: Logger | None = None,
+        chunk_size: int | None = 8,
+        write_chunk_size: int | None = 8,
+        **kwargs,
+    ):
+
+        con_params.framer = "RTU"
+        super().__init__(
+            channels_number=4,
+            con_params=con_params,
+            address=address,
+            label=label,
+            logger=logger,
+            chunk_size=chunk_size,
+            write_chunk_size=write_chunk_size,
+            **kwargs,
+        )
+
+    async def get_vendor(self) -> str:
+        response = await self.read_registers(0, 10, holding=False)
+        if response is not None:
+            return bytes(response).decode()
+        return ""
+
+    async def get_product_name(self) -> str:
+        response = await self.read_registers(10, 10, holding=False)
+        if response is not None:
+            return bytes(response).decode()
+        return ""
+
+    async def get_version(self) -> str:
+        response = await self.read_registers(20, 3, holding=False)
+        if response is not None:
+            return f"{response[0]:d}.{response[1]:d}.{response[2]:d}"
+        return ""
+
+    async def get_serial_number(self) -> str:
+        response = await self.read_two_registers_int(
+            10, holding=True, byteorder=ByteOrder.BIG_ENDIAN
+        )
+        if response is not None:
+            return f"{response:d}"
+        return ""
+
+    async def get_channel_voltage(self, channel: int) -> float | None:
+        ch_idx = max(0, min(channel, self.channels_number - 1))
+        start_register = 36 + ch_idx * 2
+        response = await self.read_two_registers_float(
+            start_register, holding=False, factor=VOLTAGE_SCALE, byteorder=ByteOrder.BIG_ENDIAN
+        )
+        if response is not None:
+            return float(response)
+        return None
+
+    async def get_voltage(self) -> VoltageTuple:
+        response = await self.read_registers(36, self.channels_number * 2, holding=False)
+        if response is not None and len(response) == self.channels_number * 2:
+            voltage = tuple(
+                float_from_int(combine_32bit(a, b, byteorder=ByteOrder.BIG_ENDIAN), VOLTAGE_SCALE)
+                if a is not None and b is not None
+                else None
+                for a, b in zip(response[::2], response[1::2])
+            )
+            return voltage
+        return (None,) * self.channels_number
+
+    async def get_address(self) -> int:
+        response = await self.read_register(0, holding=True)
+        if response is not None:
+            return response
+        return 0
+
+    async def set_address(self, address: int) -> int:
+        new_address = max(1, min(address, 247))
+        await self.write_register(0, new_address)
+        self.address = new_address
+        response = await self.get_address()
+        if response is not None and response > 0:
+            self.address = response
+            return response
+        return 0
+
+    async def get_baudrate(self) -> int:
+        response = await self.read_register(1, holding=True)
+        if response is not None:
+            if response == 0:
+                return 9600
+            elif response == 1:
+                return 19200
+            elif response == 2:
+                return 115200
+        return 0
+
+    async def set_baudrate(self, baudrate: int) -> int:
+        if baudrate <= 9600:
+            new_baudrate = 9600
+            baudrate_code = 0
+        elif baudrate <= 19200:
+            new_baudrate = 19200
+            baudrate_code = 1
+        else:
+            new_baudrate = 115200
+            baudrate_code = 5
+        response = await self.write_register(1, baudrate_code)
+        new_con_params = self.con_params
+        new_con_params.baudrate = new_baudrate
+        self.con_params = new_con_params
+        if response is not None:
+            return response
+        response = await self.read_register(1, holding=True)
+        if response is not None:
+            return response
+        return 0
+
+    async def check_connection(self):
+        vendor = await self.get_vendor()
+        if vendor:
+            return True
+        return False
+
+    async def read_parameters(self) -> ADCParameters:
+        voltage = await self.get_voltage()
+        parameters = ADCParameters(
+            connected=True,
+            channels_number=self.channels_number,
+            voltage=voltage,
+        )
+        return parameters

scietex_hal_adc-0.0.1/src/scietex/hal/adc/version.py

@@ -0,0 +1,8 @@
+"""
+Module containing the package version information.
+
+Attributes:
+    __version__ (str): The current version of the package.
+"""
+
+__version__ = "0.0.1"

scietex_hal_adc-0.0.1/src/scietex.hal.adc.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: scietex.hal.adc
+Version: 0.0.1
+Summary: Scietex ADC HAL package
+Author-email: Anton Bondarenko <bond.anton@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Anton Bondarenko
+        
+        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.
+Project-URL: Homepage, https://github.com/bond-anton/scietex.hal.adc
+Project-URL: Bug Tracker, https://github.com/bond-anton/scietex.hal.adc/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msgspec[yaml]>=0.20.0
+Requires-Dist: scietex.hal.serial<2.0.0,>=1.3.0
+Provides-Extra: dev
+Requires-Dist: tox>=4.45.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Provides-Extra: lint
+Requires-Dist: ruff; extra == "lint"
+Dynamic: license-file
+
+# scietex.hal.adc
+
+The `scietex.hal.adc` package is a Python library for interfacing with ADC.
+It provides an abstract class `ADC`, and a base class for ADCs with RS485 communication
+interface, which in its turn inherits `scietex.hal.serial.RS485Client`.
+The concrete implementation for the ADC manufactured by Scietex is provided.
+
+
+## License
+
+This project is licensed under the **MIT License** - see the LICENSE file for details.

scietex_hal_adc-0.0.1/src/scietex.hal.adc.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+src/scietex.hal.adc.egg-info/PKG-INFO
+src/scietex.hal.adc.egg-info/SOURCES.txt
+src/scietex.hal.adc.egg-info/dependency_links.txt
+src/scietex.hal.adc.egg-info/requires.txt
+src/scietex.hal.adc.egg-info/top_level.txt
+src/scietex/hal/adc/__init__.py
+src/scietex/hal/adc/py.typed
+src/scietex/hal/adc/version.py
+src/scietex/hal/adc/base/__init__.py
+src/scietex/hal/adc/base/adc.py
+src/scietex/hal/adc/base/data.py
+src/scietex/hal/adc/base/rs485/__init__.py
+src/scietex/hal/adc/base/rs485/adc.py
+src/scietex/hal/adc/scietex/__init__.py
+src/scietex/hal/adc/scietex/utils.py
+src/scietex/hal/adc/scietex/vdp_adc.py
+tests/test_version.py

scietex_hal_adc-0.0.1/src/scietex.hal.adc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

scietex_hal_adc-0.0.1/src/scietex.hal.adc.egg-info/requires.txt

@@ -0,0 +1,12 @@
+msgspec[yaml]>=0.20.0
+scietex.hal.serial<2.0.0,>=1.3.0
+
+[dev]
+tox>=4.45.0
+
+[lint]
+ruff
+
+[test]
+pytest
+pytest-asyncio

scietex_hal_adc-0.0.1/src/scietex.hal.adc.egg-info/top_level.txt

@@ -0,0 +1 @@
+scietex

scietex_hal_adc-0.0.1/tests/test_version.py

@@ -0,0 +1,47 @@
+"""Test package version is correctly set"""
+
+import pytest
+
+try:
+    from src.scietex.hal.adc import __version__ as version
+except ModuleNotFoundError:
+    from scietex.hal.adc import __version__ as version
+
+
+def test_check_version_numbering():
+    """
+    Version must be a string with the three integers separated by a dot.
+    Example: `0.1.4` or `2.0.0`.
+    All three digits must not negative and must not be equal to zero at the same time.
+    """
+    # Assert version is a string.
+    assert isinstance(version, str)
+
+    # Assert no extra space present. Example: " 0.1.1  " is not correct, "0.1.1" is correct.
+    assert len(version) == len(version.strip())
+
+    # Assert all three parts are present
+    v_l = version.split(".")
+    assert len(v_l) == 3
+
+    # Assert no extra space present in each part.
+    # Example: "0. 1 .1" is not correct, "0.1.1" is correct
+    for i in range(3):
+        assert len(v_l[i]) == len(v_l[i].strip())
+
+    # Convert all parts of the version to int values
+    v_maj = int(v_l[0])
+    v_min = int(v_l[1])
+    v_patch = int(v_l[2])
+
+    # Assert all version numbers are not negative
+    assert v_maj >= 0
+    assert v_min >= 0
+    assert v_patch >= 0
+
+    # Assert all version numbers are not equal to zero at the same time
+    assert v_maj + v_min + v_patch > 0
+
+
+if __name__ == "__main__":
+    pytest.main()