scietex.hal.qcm 1.0.0__tar.gz

scietex_hal_qcm-1.0.0/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_qcm-1.0.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: scietex.hal.qcm
+Version: 1.0.0
+Summary: Scietex Quatz Microbalance 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.qcm
+Project-URL: Bug Tracker, https://github.com/bond-anton/scietex.hal.qcm/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msgspec[yaml]~=0.19.0
+Requires-Dist: scietex.hal.serial<2.0.0,>=1.0.5
+Provides-Extra: dev
+Provides-Extra: test
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Provides-Extra: lint
+Requires-Dist: pylint; extra == "lint"
+Dynamic: license-file
+
+# scietex.hal.qcm
+
+The `scietex.hal.qcm` package is a Python library for interfacing with Quartz Microbalance (QCM).
+It provides an abstract base class (`QCM`), which in its turn inherits `scietex.hal.serial.RS485Client`.
+The concrete implementations for two models of QCM manufactured by Scietex and CYKY are provided.
+
+## Features
+- Abstract base class (`VFD`) for consistent VFD implementations.
+- Implemented VFD models:
+  - `Scietex ftmONE`.
+  - `CYKY TM106B`.
+
+## Installation
+Install the package via pip (assuming it’s published to PyPI):
+```bash
+pip install scietex.hal.qcm
+```
+
+Alternatively, clone the repository and install locally:
+```bash
+git clone https://github.com/bond-anton/scietex.hal.qcm.git
+cd scietex.hal.qcm
+pip install .
+```
+
+## Requirements
+
+ - Python 3.9 or higher.
+ - `scietex.hal.serial` (For RS485 communication support).
+
+## Contributing
+
+Contributions are welcome! To contribute:
+
+1. Fork the repository.
+2. Create a feature branch (`git checkout -b feature/YourFeature`).
+3. Commit your changes (`git commit -m "Add your message"`).
+4. Push to the branch (`git push origin feature/YourFeature`).
+5. Open a Pull Request.
+
+Please include tests (if applicable) and follow PEP 8 style guidelines.
+
+## License
+
+This project is licensed under the **MIT License** - see the LICENSE file for details.

scietex_hal_qcm-1.0.0/README.md

@@ -0,0 +1,45 @@
+# scietex.hal.qcm
+
+The `scietex.hal.qcm` package is a Python library for interfacing with Quartz Microbalance (QCM).
+It provides an abstract base class (`QCM`), which in its turn inherits `scietex.hal.serial.RS485Client`.
+The concrete implementations for two models of QCM manufactured by Scietex and CYKY are provided.
+
+## Features
+- Abstract base class (`VFD`) for consistent VFD implementations.
+- Implemented VFD models:
+  - `Scietex ftmONE`.
+  - `CYKY TM106B`.
+
+## Installation
+Install the package via pip (assuming it’s published to PyPI):
+```bash
+pip install scietex.hal.qcm
+```
+
+Alternatively, clone the repository and install locally:
+```bash
+git clone https://github.com/bond-anton/scietex.hal.qcm.git
+cd scietex.hal.qcm
+pip install .
+```
+
+## Requirements
+
+ - Python 3.9 or higher.
+ - `scietex.hal.serial` (For RS485 communication support).
+
+## Contributing
+
+Contributions are welcome! To contribute:
+
+1. Fork the repository.
+2. Create a feature branch (`git checkout -b feature/YourFeature`).
+3. Commit your changes (`git commit -m "Add your message"`).
+4. Push to the branch (`git push origin feature/YourFeature`).
+5. Open a Pull Request.
+
+Please include tests (if applicable) and follow PEP 8 style guidelines.
+
+## License
+
+This project is licensed under the **MIT License** - see the LICENSE file for details.

scietex_hal_qcm-1.0.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scietex.hal.qcm"
+dynamic = ["version"]
+description = "Scietex Quatz Microbalance 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.9"
+dependencies = [
+    "msgspec[yaml] ~= 0.19.0",
+    "scietex.hal.serial >= 1.0.5, < 2.0.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/bond-anton/scietex.hal.qcm"
+"Bug Tracker" = "https://github.com/bond-anton/scietex.hal.qcm/issues"
+
+[project.optional-dependencies]
+dev = []
+test = ["flake8", "pytest", "pytest-asyncio"]
+lint = ["pylint"]
+
+[tool.setuptools.dynamic]
+version = {attr = "scietex.hal.qcm.version.__version__"}
+
+[tool.setuptools.package-data]
+"scietex.hal.qcm" = ["py.typed"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.black]
+line-length = 100
+
+[tool.mypy]
+python_version = "3.9"
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "src"
+]

scietex_hal_qcm-1.0.0/setup.cfg

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

scietex_hal_qcm-1.0.0/src/scietex/hal/qcm/__init__.py

@@ -0,0 +1,4 @@
+"""QCM HAL module"""
+
+from .version import __version__
+from .base import GatedFTM

scietex_hal_qcm-1.0.0/src/scietex/hal/qcm/base/__init__.py

@@ -0,0 +1,3 @@
+"""Base QCM classes to be inherited in particular device implementation."""
+
+from .gated_ftm import GatedFTM

scietex_hal_qcm-1.0.0/src/scietex/hal/qcm/base/data.py

@@ -0,0 +1,84 @@
+"""Data models for the QCM."""
+
+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
+
+
+# pylint: disable=too-few-public-methods
+class QCMError(msgspec.Struct, frozen=True):
+    """Model of a QCM error with code and message."""
+
+    code: int
+    message: str = "Unknown error"
+
+    def __str__(self) -> str:
+        return f"QCMError(code={self.code}, message='{self.message}')"
+
+
+# pylint: disable=too-few-public-methods
+class FTMParameters(msgspec.Struct, frozen=True):
+    """Model for FTM operational parameters."""
+
+    frequency: float = 0.0  # Sensor frequency
+    frequency_std: float = 0.0  # Sensor frequency standard deviation
+    averaging_window: int = 1  # Averaging window size
+    averaging_progress: int = 1  # Averaging accumulation progress
+    rate: float = 0.0  # Deposition rate A/s
+    thickness: float = 0.0  # Film thickness A
+    thickness_std: float = 0.0  # Film thickness standard deviation A
+    target: float = 0.0  # Film target thickness A
+    material_density: float = 0.0  # Material density g/cm^3
+    material_z_ratio: float = 0.0  # Material Z-ratio
+    running: bool = False  # Current FTM measurement running state
+    scale: float = 1.0  # Scale (tooling) factor
+
+    def __str__(self) -> str:
+        return (
+            f"FTMParameters(frequency={self.frequency:g} +- {self.frequency_std:g} Hz, "
+            f"averaging={self.averaging_progress}/{self.averaging_window}, "
+            f"deposition rate={self.rate} A/s, "
+            f"film thickness={self.thickness} +- {self.thickness_std} A, "
+            f"target thickness={self.target} A, "
+            f"material density={self.material_density} g/cm^3, "
+            f"material Z-ratio={self.material_z_ratio}, "
+            f"running={self.running})"
+        )
+
+
+# pylint: disable=too-few-public-methods
+class FTMStartCMD(msgspec.Struct, frozen=True):
+    """FTM start command with parameters."""
+
+    reset: bool = True  # Reset thickness at start
+
+    def __str__(self) -> str:
+        return f"FTMStartCMD(reset={self.reset})"
+
+
+# pylint: disable=too-few-public-methods
+class Material(msgspec.Struct, frozen=True):
+    """Material parameters."""
+
+    density: float  # Density g/cm^3
+    z_ratio: float  # Z-ratio
+
+    def __str__(self) -> str:
+        return f"Material(density={self.density}, Z-ratio={self.z_ratio})"

scietex_hal_qcm-1.0.0/src/scietex/hal/qcm/base/ftm_calculation.py

@@ -0,0 +1,21 @@
+"""Functions for film thickness calculation"""
+
+import math as m
+
+
+NQ = 1.668e5  # Hz*cm  Frequency const of AT-cut quartz
+RQ = 2.648  # g/cm^3 Density of quartz
+MQ = 2.947e11  # g/(cm*s^2) Shear modulus of quartz
+
+NRQ = 140593.14771292824  # NQ * RQ / m.pi [Hz * g / cm^2]
+
+
+def freq_change_to_mass_per_cm2(f0, f1, z):
+    """Calculate film mass per cm2 (g / cm^2)"""
+    return NRQ / (z * f1) * m.atan(z * m.tan(m.pi * (f0 - f1) / f0))  # g / cm^2
+
+
+def freq_change_to_thickness(f0, f1, rho, z):
+    """Calculate film thickness (A)"""
+    m_per_cm2 = freq_change_to_mass_per_cm2(f0, f1, z)
+    return m_per_cm2 / rho * 1e8  # Angstrom

scietex_hal_qcm-1.0.0/src/scietex/hal/qcm/base/ftm_materials_data.py

@@ -0,0 +1,63 @@
+"""
+Reference dict for different materials.
+Density is given in g/cm^3.
+"""
+
+materials = {
+    "Ag": {
+        "density": 10.5,
+        "z_ratio": 0.53,
+    },
+    "Al": {
+        "density": 2.7,
+        "z_ratio": 1.08,
+    },
+    "Au": {
+        "density": 19.3,
+        "z_ratio": 0.38,
+    },
+    "C": {
+        "density": 2.25,
+        "z_ratio": 3.26,
+    },
+    "Cr": {
+        "density": 7.2,
+        "z_ratio": 0.31,
+    },
+    "Cu": {
+        "density": 8.93,
+        "z_ratio": 0.44,
+    },
+    "Mo": {
+        "density": 10.2,
+        "z_ratio": 0.26,
+    },
+    "Ni": {
+        "density": 8.91,
+        "z_ratio": 0.33,
+    },
+    "Pd": {
+        "density": 12.04,
+        "z_ratio": 0.36,
+    },
+    "Pt": {
+        "density": 21.4,
+        "z_ratio": 0.25,
+    },
+    "Ti": {
+        "density": 4.5,
+        "z_ratio": 0.63,
+    },
+    "V": {
+        "density": 5.96,
+        "z_ratio": 0.53,
+    },
+    "W": {
+        "density": 19.3,
+        "z_ratio": 0.16,
+    },
+    "Zn": {
+        "density": 7.04,
+        "z_ratio": 0.51,
+    },
+}

scietex_hal_qcm-1.0.0/src/scietex/hal/qcm/base/gated_ftm.py

@@ -0,0 +1,235 @@
+"""Gated FTM abstract interface."""
+
+from abc import ABC, abstractmethod
+
+from .data import QCMError, PwmCTRLMode, OutCTRLMode, FTMParameters, Material
+
+
+# pylint: disable=too-many-public-methods
+class GatedFTM(ABC):
+    """Gated Film Thickness Monitor interface class."""
+
+    error_codes: dict[int, QCMError] = {0: QCMError(code=0, message="No error")}
+    error_codes_com: dict[int, QCMError] = {0: QCMError(code=0, message="No error")}
+
+    # Error processing methods
+    @abstractmethod
+    async def get_error_code(self, comm: bool = False) -> int:
+        """Read error code from the FTM"""
+
+    def parse_error_code(self, code: int, comm: bool = False) -> QCMError:
+        """Parse error code from the FTM"""
+        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 QCMError(code=code, message="Unknown error")
+
+    @abstractmethod
+    async def clear_error(self, comm: bool = False) -> int:
+        """Clear error from the FTM"""
+
+    # Device information methods
+    @abstractmethod
+    async def get_vendor(self) -> str:
+        """Get QCM vendor name."""
+
+    @abstractmethod
+    async def get_product_name(self) -> str:
+        """Get QCM product name."""
+
+    @abstractmethod
+    async def get_serial_number(self) -> str:
+        """Get QCM serial number."""
+
+    @abstractmethod
+    async def get_version(self) -> str:
+        """get QCM firmware version"""
+
+    # FTM 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."""
+
+    # FTM frequency measurement data access methods
+
+    @abstractmethod
+    async def get_counter(self) -> int:
+        """Get FTM raw counts."""
+
+    @abstractmethod
+    async def get_frequency_instant(self) -> float:
+        """Get instant frequency."""
+
+    @abstractmethod
+    async def get_averaging_progress(self) -> int:
+        """Get averaging accumulation progress."""
+
+    @abstractmethod
+    async def get_frequency(self) -> float:
+        """Get frequency."""
+
+    @abstractmethod
+    async def get_frequency_std(self) -> float:
+        """Get frequency standard deviation."""
+
+    # Thickness measurement methods
+
+    @abstractmethod
+    async def get_thickness(self) -> float:
+        """Get thickness (Angstrom) value."""
+
+    @abstractmethod
+    async def get_thickness_std(self) -> float:
+        """Parse thickness (Angstrom) standard deviation."""
+
+    @abstractmethod
+    async def get_rate(self) -> float:
+        """Parse rate (Angstrom/s) value from register data"""
+
+    @abstractmethod
+    async def get_material_density(self) -> float:
+        """Get material density g/cm3"""
+
+    @abstractmethod
+    async def set_material_density(self, density: float) -> float:
+        """Set material density g/cm3."""
+
+    @abstractmethod
+    async def get_material_z_ratio(self) -> float:
+        """Get material Z-ratio."""
+
+    @abstractmethod
+    async def set_material_z_ratio(self, z_ratio: float) -> float:
+        """Set material Z-ratio."""
+
+    @abstractmethod
+    async def get_material(self) -> Material:
+        """Get deposition material density and Z-ratio"""
+
+    @abstractmethod
+    async def set_material(self, material: Material) -> Material:
+        """Set deposition material density and Z-ratio"""
+
+    @abstractmethod
+    async def get_ftm_scale(self) -> float:
+        """Get FTM scale factor."""
+
+    @abstractmethod
+    async def set_ftm_scale(self, scale: float) -> float:
+        """Set FTM scale factor."""
+
+    @abstractmethod
+    async def get_target_thickness(self) -> float:
+        """Get target thickness (Angstrom)."""
+
+    @abstractmethod
+    async def set_target_thickness(self, target: float) -> float:
+        """Set target thickness (Angstrom)."""
+
+    async def get_target_nm(self) -> float:
+        """Get target thickness (nm)."""
+        return await self.get_target_thickness() / 10
+
+    async def set_target_nm(self, target: float) -> float:
+        """Set target thickness (nm)."""
+        return await self.set_target_thickness(target * 10)
+
+    async def get_target_um(self) -> float:
+        """Get target thickness (nm)."""
+        return await self.get_target_thickness() / 10_000
+
+    async def set_target_um(self, target: float) -> float:
+        """Set target thickness (um)."""
+        return await self.set_target_thickness(target * 10_000)
+
+    @abstractmethod
+    async def reset_thickness(self) -> None:
+        """Reset measured thickness."""
+
+    # CTRL OUT parameters
+
+    @abstractmethod
+    async def get_ctrl_out_mode(self) -> OutCTRLMode:
+        """Get the mode of the control output."""
+
+    @abstractmethod
+    async def set_ctrl_out_mode(self, mode: OutCTRLMode) -> OutCTRLMode:
+        """Set the mode of the control output."""
+
+    @abstractmethod
+    async def get_ctrl_out_value(self) -> bool:
+        """Get control output value."""
+
+    @abstractmethod
+    async def set_ctrl_out_value(self, value: bool) -> bool:
+        """Set control output value."""
+
+    @abstractmethod
+    async def get_ctrl_pwm_mode(self) -> PwmCTRLMode:
+        """Get the mode of the PWM output."""
+
+    @abstractmethod
+    async def set_ctrl_pwm_mode(self, mode: PwmCTRLMode) -> PwmCTRLMode:
+        """Set the mode of the PWM output."""
+
+    @abstractmethod
+    async def get_ctrl_pwm_value(self) -> float:
+        """Get PWM output value."""
+
+    @abstractmethod
+    async def set_ctrl_pwm_value(self, value: float) -> float:
+        """Set PWM output value."""
+
+    @abstractmethod
+    async def get_ctrl_pwm_scale(self) -> int:
+        """Get PWM output scale."""
+
+    @abstractmethod
+    async def set_ctrl_pwm_scale(self, scale: int) -> int:
+        """Set PWM output scale."""
+
+    # MEASUREMENT START/STOP
+
+    @abstractmethod
+    async def get_running_state(self) -> bool:
+        """Get running state."""
+
+    @abstractmethod
+    async def set_running_state(self, running: bool) -> bool:
+        """Set running state."""
+
+    async def start_measurement(self, reset: bool = True) -> bool:
+        """Start measurement"""
+        if reset:
+            await self.reset_thickness()
+        return await self.set_running_state(True)
+
+    async def stop_measurement(self) -> bool:
+        """Stop measurement."""
+        return await self.set_running_state(False)
+
+    # Read FTM parameters in single call
+
+    @abstractmethod
+    async def read_parameters(self) -> FTMParameters:
+        """Read FTM Parameters"""

scietex_hal_qcm-1.0.0/src/scietex/hal/qcm/base/rs485/__init__.py

@@ -0,0 +1,3 @@
+"""RS485 devices."""
+
+from .gated_ftm import RS485GatedFTM