scietex.hal.adc 0.0.1__py3-none-any.whl

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

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

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

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

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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,16 @@
+scietex/hal/adc/__init__.py,sha256=9GMNW7ZUEc6JsUc4j0ByDQs5QsPKxbCaCZznj3h_cr8,111
+scietex/hal/adc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scietex/hal/adc/version.py,sha256=piE4bIBU9mWny5k8pD8kbdn__ngmBDQS7k2Ja56GK8I,154
+scietex/hal/adc/base/__init__.py,sha256=eys9eDRuyCojmDxfs2q2-9Ml4MAqhrRynewEypnEMbQ,117
+scietex/hal/adc/base/adc.py,sha256=_xqSRkSp3Cyta81CvGFmb4WySgEvVDKrhcH6LHRSFIQ,2541
+scietex/hal/adc/base/data.py,sha256=EQIb0dqcOTWNvC3Snq5j2z0tz-PXLFGDhBhzL5D2D_0,1771
+scietex/hal/adc/base/rs485/__init__.py,sha256=IwKX84855Q9p1-s9WiT6TOeK7qRrhcahZSmxQmuVis4,72
+scietex/hal/adc/base/rs485/adc.py,sha256=1qSCbqSJTF5CcpKtuF3_CuUD3VX7Nxu1QiIwJ4qHOOI,5161
+scietex/hal/adc/scietex/__init__.py,sha256=-70CpKu-Wmx79fKESPtw33CvQZCjkCaILr7wH2Xi8ZA,74
+scietex/hal/adc/scietex/utils.py,sha256=vc-oHUIV8Ut2MBanf536mDwvPwGjxbGCWIsLkNTHw8Q,508
+scietex/hal/adc/scietex/vdp_adc.py,sha256=UXZ8RTT2Z1dWNIT1WqegmRECiSAPUFybRgE2_w4Yh4A,4915
+scietex_hal_adc-0.0.1.dist-info/licenses/LICENSE,sha256=Kv8K8tNh4XWlpCNncypg7EhUWm4drfJp0zCGNsrp6So,1072
+scietex_hal_adc-0.0.1.dist-info/METADATA,sha256=9ZiMVZFuxSj8Rt5wALqgflZ-Wubb6dqYHGPL9qvddqc,2537
+scietex_hal_adc-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+scietex_hal_adc-0.0.1.dist-info/top_level.txt,sha256=AyNTe2f94XrlwxyUGMuitoEj6mqEacwNkt8nU47GjvI,8
+scietex_hal_adc-0.0.1.dist-info/RECORD,,

scietex_hal_adc-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

scietex_hal_adc-0.0.1.dist-info/licenses/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.dist-info/top_level.txt

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