scietex.hal.qcm 1.0.0__py3-none-any.whl

scietex/hal/qcm/__init__.py

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

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

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