matterlab-mfcs 0.1.0__py3-none-any.whl

matterlab_mfcs/__init__.py

@@ -0,0 +1,25 @@
+from matterlab_mfcs.enums import (
+    GasNumber,
+    PressureUnit,
+    StandardFlowUnit,
+    TemperatureUnit,
+    TotalStandardVolumeUnit,
+    TotalVolumeUnit,
+    TrueMassFlowUnit,
+    VolumetricFlowUnit,
+)
+from matterlab_mfcs.alicat_mfc import AlicatMFC
+from matterlab_mfcs.base_mfc import MassFlowController
+
+__all__ = [
+    "AlicatMFC",
+    "GasNumber",
+    "MassFlowController",
+    "PressureUnit",
+    "StandardFlowUnit",
+    "TemperatureUnit",
+    "TotalStandardVolumeUnit",
+    "TotalVolumeUnit",
+    "TrueMassFlowUnit",
+    "VolumetricFlowUnit",
+]

matterlab_mfcs/alicat_mfc.py

@@ -0,0 +1,619 @@
+from __future__ import annotations
+
+import struct
+from datetime import date
+from enum import IntEnum
+from logging import Logger
+from typing import Optional, Union
+
+from matterlab_serial_device import SerialDevice, open_close
+
+from matterlab_mfcs.base_mfc import MassFlowController
+from matterlab_mfcs.enums import GasNumber, PressureUnit, StandardFlowUnit, TemperatureUnit, VolumetricFlowUnit
+
+
+MODBUS_EXCEPTION_CODES = {
+    0x01: "illegal function",
+    0x02: "illegal data address",
+    0x03: "illegal data value",
+    0x04: "slave device failure",
+    0x05: "acknowledge",
+    0x06: "slave device busy",
+    0x08: "memory parity error",
+    0x0A: "gateway path unavailable",
+    0x0B: "gateway target failed to respond",
+}
+
+
+class AlicatMFC(MassFlowController, SerialDevice):
+    """Alicat Modbus RTU driver built on matterlab_serial_device."""
+
+    ui_fields = ("com_port", "address")
+
+    @staticmethod
+    def _int_arg(value: Union[int, IntEnum]) -> int:
+        return int(value)
+
+    def __init__(
+        self,
+        com_port: str,
+        address: int = 1,
+        baudrate: int = 19200,
+        bytesize: int = 8,
+        parity: str = "none",
+        stopbits: int = 1,
+        timeout: float = 0.4,
+        connect_hardware: bool = True,
+        share_port: bool = False,
+        logger: Optional[Logger] = None,
+        **kwargs,
+    ) -> None:
+        MassFlowController.__init__(self, logger=logger)
+        SerialDevice.__init__(
+            self,
+            com_port=com_port,
+            baudrate=baudrate,
+            bytesize=bytesize,
+            parity=parity,
+            stopbits=stopbits,
+            timeout=timeout,
+            connect_hardware=connect_hardware,
+            share_port=share_port,
+            logger=self.logger,
+            **kwargs,
+        )
+        if address < 1 or address > 247:
+            raise ValueError("Modbus slave address must be between 1 and 247.")
+        self.address = address
+
+    @staticmethod
+    def crc16_modbus(data: bytes) -> int:
+        """Compute the Modbus RTU CRC16 used by Alicat devices."""
+        crc = 0xFFFF
+        for byte in data:
+            crc ^= byte
+            for _ in range(8):
+                if crc & 1:
+                    crc = (crc >> 1) ^ 0xA001
+                else:
+                    crc >>= 1
+        return crc & 0xFFFF
+
+    @classmethod
+    def _append_crc(cls, payload: bytes) -> bytes:
+        return payload + struct.pack("<H", cls.crc16_modbus(payload))
+
+    def _query_frame_open(self, request: bytes, response_len: int) -> bytes:
+        response = self.query(request, read_delay=0, return_bytes=True, num_bytes=response_len)
+        self._validate_response(response)
+        return response
+
+    def _build_request(self, function_code: int, payload: bytes) -> bytes:
+        return self._append_crc(bytes([self.address, function_code]) + payload)
+
+    @classmethod
+    def _validate_response(cls, response: bytes) -> None:
+        if len(response) < 5:
+            raise RuntimeError(f"incomplete Modbus RTU response: {response.hex(' ')}")
+
+        body, crc_bytes = response[:-2], response[-2:]
+        got_crc = struct.unpack("<H", crc_bytes)[0]
+        want_crc = cls.crc16_modbus(body)
+        if got_crc != want_crc:
+            raise RuntimeError(f"CRC mismatch: got 0x{got_crc:04X}, expected 0x{want_crc:04X}")
+
+        function = body[1]
+        if function & 0x80:
+            code = body[2]
+            raise RuntimeError(
+                f"Modbus exception 0x{code:02X}: {MODBUS_EXCEPTION_CODES.get(code, 'unknown error')}"
+            )
+
+    def _read_register_payload_open(self, function_code: int, register_address: int, register_count: int) -> bytes:
+        request = self._build_request(function_code, struct.pack(">HH", register_address, register_count))
+        response = self._query_frame_open(request, 5 + register_count * 2)
+        return response[3:-2]
+
+    def _read_registers_open(self, function_code: int, register_address: int, register_count: int) -> tuple[int, ...]:
+        payload = self._read_register_payload_open(function_code, register_address, register_count)
+        return struct.unpack(f">{register_count}H", payload)
+
+    def _read_holding_value_open(self, register_address: int, format_code: str):
+        payload = self._read_register_payload_open(0x03, register_address, struct.calcsize(">" + format_code) // 2)
+        return struct.unpack(">" + format_code, payload)[0]
+
+    def _write_registers_open(self, register_address: int, values: tuple[int, ...]) -> tuple[int, int]:
+        payload = struct.pack(">HHB", register_address, len(values), len(values) * 2) + struct.pack(f">{len(values)}H", *values)
+        response = self._query_frame_open(self._build_request(0x10, payload), 8)
+        return struct.unpack(">HH", response[2:6])
+
+    def _read_scaled_integer_open(self, value_register_address: int, decimals_register_address: int) -> float:
+        raw = self._read_holding_value_open(value_register_address, "i")
+        decimals = self._read_holding_value_open(decimals_register_address, "H")
+        return raw / (10 ** decimals)
+
+    @open_close
+    def _read_registers(self, function_code: int, register_address: int, register_count: int) -> tuple[int, ...]:
+        return self._read_registers_open(function_code, register_address, register_count)
+
+    @open_close
+    def _read_holding_value(self, register_address: int, format_code: str):
+        return self._read_holding_value_open(register_address, format_code)
+
+    @open_close
+    def _read_scaled_integer(self, value_register_address: int, decimals_register_address: int) -> float:
+        return self._read_scaled_integer_open(value_register_address, decimals_register_address)
+
+    @open_close
+    def _write_value(self, register_address: int, format_code: str, value):
+        values = struct.unpack(">HH", struct.pack(">" + format_code, value))
+        self._write_registers_open(register_address, values)
+        return value
+
+    def _execute_command_integer_open(self, command_id: int, argument: int) -> int:
+        command_registers = struct.unpack(">HH", struct.pack(">I", command_id))
+        argument_registers = struct.unpack(">HH", struct.pack(">i", argument))
+        self._write_registers_open(1001, command_registers + argument_registers)
+        while True:
+            current_id, current_argument, status, result = struct.unpack(">IiIi", self._read_register_payload_open(0x04, 1001, 8))
+            if current_id != command_id or current_argument != argument or status == 1:
+                continue
+            if status != 0:
+                raise RuntimeError(f"Alicat command {command_id} failed with status {status}")
+            return result
+
+    def _execute_command_float_open(self, command_id: int, argument: float) -> float:
+        command_registers = struct.unpack(">HH", struct.pack(">I", command_id))
+        argument_registers = struct.unpack(">HH", struct.pack(">f", argument))
+        self._write_registers_open(1001, command_registers + argument_registers)
+        while True:
+            current_id, current_argument, status, result = struct.unpack(">IfIf", self._read_register_payload_open(0x04, 1001, 8))
+            if current_id != command_id or current_argument != argument or status == 1:
+                continue
+            if status != 0:
+                raise RuntimeError(f"Alicat command {command_id} failed with status {status}")
+            return result
+
+    @open_close
+    def _command_integer(self, command_id: int, argument: int) -> int:
+        return self._execute_command_integer_open(command_id, argument)
+
+    @open_close
+    def _command_float(self, command_id: int, argument: float) -> float:
+        return self._execute_command_float_open(command_id, argument)
+
+    @property
+    def byte_order_test(self) -> float:
+        return self._read_holding_value(1087, "f")
+
+    @property
+    def firmware_version(self) -> tuple[int, int]:
+        major, minor = self._read_registers(0x03, 1089, 2)
+        return major, minor
+
+    @property
+    def serial_number(self) -> int:
+        return self._read_holding_value(1093, "I")
+
+    @property
+    def manufacture_date(self) -> date:
+        month_day, year = self._read_registers(0x03, 1095, 2)
+        return date(year, month_day >> 8, month_day & 0xFF)
+
+    @property
+    def calibration_date(self) -> date:
+        month_day, year = self._read_registers(0x03, 1097, 2)
+        return date(year, month_day >> 8, month_day & 0xFF)
+
+    @property
+    def gas_number(self) -> GasNumber:
+        return GasNumber(self._read_holding_value(1346, "H"))
+
+    @property
+    def device_status(self) -> int:
+        return self._read_holding_value(1347, "I")
+
+    @property
+    def setpoint(self) -> float:
+        return self._read_holding_value(1349, "f")
+
+    @setpoint.setter
+    def setpoint(self, setpoint: float) -> None:        
+        self._write_value(1349, "f", setpoint)
+
+    def write_setpoint_integer(self, setpoint: int) -> int:
+        return self._write_value(1299, "i", setpoint)
+
+    @property
+    def valve_drive(self) -> float:
+        return self._read_holding_value(1351, "f")
+
+    @property
+    def pressure(self) -> float:
+        return self._read_holding_value(1353, "f")
+
+    @property
+    def secondary_pressure(self) -> float:
+        return self._read_holding_value(1355, "f")
+
+    @property
+    def barometric_pressure(self) -> float:
+        return self._read_holding_value(1357, "f")
+
+    @property
+    def temperature(self) -> float:
+        return self._read_holding_value(1359, "f")
+
+    @property
+    def volumetric_flow(self) -> float:
+        return self._read_holding_value(1361, "f")
+
+    @property
+    def mass_flow(self) -> float:
+        return self._read_holding_value(1363, "f")
+
+    @property
+    def totalizer_1(self) -> float:
+        return self._read_holding_value(1365, "f")
+
+    @property
+    def totalizer_2(self) -> float:
+        return self._read_holding_value(1367, "f")
+
+    @property
+    def humidity(self) -> float:
+        return self._read_holding_value(1369, "f")
+
+    def setpoint_from_integer(self) -> float:
+        return self._read_scaled_integer(1299, 1650)
+
+    def valve_drive_from_integer(self) -> float:
+        return self._read_scaled_integer(1301, 1662)
+
+    def pressure_from_integer(self) -> float:
+        return self._read_scaled_integer(1303, 1674)
+
+    def secondary_pressure_from_integer(self) -> float:
+        return self._read_scaled_integer(1305, 1686)
+
+    def barometric_pressure_from_integer(self) -> float:
+        return self._read_scaled_integer(1307, 1698)
+
+    def temperature_from_integer(self) -> float:
+        return self._read_scaled_integer(1309, 1710)
+
+    def volumetric_flow_from_integer(self) -> float:
+        return self._read_scaled_integer(1311, 1722)
+
+    def mass_flow_from_integer(self) -> float:
+        return self._read_scaled_integer(1313, 1734)
+
+    def totalizer_1_from_integer(self) -> float:
+        return self._read_scaled_integer(1315, 1746)
+
+    def totalizer_2_from_integer(self) -> float:
+        return self._read_scaled_integer(1317, 1758)
+
+    def humidity_from_integer(self) -> float:
+        return self._read_scaled_integer(1319, 1770)
+
+    @property
+    def setpoint_minimum(self) -> float:
+        return self._read_holding_value(1645, "f")
+
+    @property
+    def setpoint_maximum(self) -> float:
+        return self._read_holding_value(1647, "f")
+
+    @property
+    def setpoint_units(self) -> int:
+        return StandardFlowUnit(self._read_holding_value(1649, "H"))
+
+    @property
+    def setpoint_decimal_places(self) -> int:
+        return self._read_holding_value(1650, "H")
+
+    @property
+    def pressure_minimum(self) -> float:
+        return self._read_holding_value(1669, "f")
+
+    @property
+    def pressure_maximum(self) -> float:
+        return self._read_holding_value(1671, "f")
+
+    @property
+    def pressure_units(self) -> PressureUnit:
+        return PressureUnit(self._read_holding_value(1673, "H"))
+
+    @property
+    def pressure_decimal_places(self) -> int:
+        return self._read_holding_value(1674, "H")
+
+    @property
+    def barometric_pressure_minimum(self) -> float:
+        return self._read_holding_value(1693, "f")
+
+    @property
+    def barometric_pressure_maximum(self) -> float:
+        return self._read_holding_value(1695, "f")
+
+    @property
+    def barometric_pressure_units(self) -> int:
+        return self._read_holding_value(1697, "H")
+
+    @property
+    def barometric_pressure_decimal_places(self) -> int:
+        return self._read_holding_value(1698, "H")
+
+    @property
+    def temperature_minimum(self) -> float:
+        return self._read_holding_value(1705, "f")
+
+    @property
+    def temperature_maximum(self) -> float:
+        return self._read_holding_value(1707, "f")
+
+    @property
+    def temperature_units(self) -> TemperatureUnit:
+        return TemperatureUnit(self._read_holding_value(1709, "H"))
+
+    @property
+    def temperature_decimal_places(self) -> int:
+        return self._read_holding_value(1710, "H")
+
+    @property
+    def volumetric_flow_minimum(self) -> float:
+        return self._read_holding_value(1717, "f")
+
+    @property
+    def volumetric_flow_maximum(self) -> float:
+        return self._read_holding_value(1719, "f")
+
+    @property
+    def volumetric_flow_units(self) -> VolumetricFlowUnit:
+        return VolumetricFlowUnit(self._read_holding_value(1721, "H"))
+
+    @property
+    def volumetric_flow_decimal_places(self) -> int:
+        return self._read_holding_value(1722, "H")
+
+    @property
+    def mass_flow_minimum(self) -> float:
+        return self._read_holding_value(1729, "f")
+
+    @property
+    def mass_flow_maximum(self) -> float:
+        return self._read_holding_value(1731, "f")
+
+    @property
+    def mass_flow_units(self) -> int:
+        return self._read_holding_value(1733, "H")
+
+    @property
+    def mass_flow_decimal_places(self) -> int:
+        return self._read_holding_value(1734, "H")
+
+    @property
+    def totalizer_1_minimum(self) -> float:
+        return self._read_holding_value(1741, "f")
+
+    @property
+    def totalizer_1_maximum(self) -> float:
+        return self._read_holding_value(1743, "f")
+
+    @property
+    def totalizer_1_units(self) -> int:
+        return self._read_holding_value(1745, "H")
+
+    @property
+    def totalizer_1_decimal_places(self) -> int:
+        return self._read_holding_value(1746, "H")
+
+    @property
+    def totalizer_2_minimum(self) -> float:
+        return self._read_holding_value(1753, "f")
+
+    @property
+    def totalizer_2_maximum(self) -> float:
+        return self._read_holding_value(1755, "f")
+
+    @property
+    def totalizer_2_units(self) -> int:
+        return self._read_holding_value(1757, "H")
+
+    @property
+    def totalizer_2_decimal_places(self) -> int:
+        return self._read_holding_value(1758, "H")
+
+    @property
+    def humidity_minimum(self) -> float:
+        return self._read_holding_value(1765, "f")
+
+    @property
+    def humidity_maximum(self) -> float:
+        return self._read_holding_value(1767, "f")
+
+    @property
+    def humidity_units(self) -> int:
+        return self._read_holding_value(1769, "H")
+
+    @property
+    def humidity_decimal_places(self) -> int:
+        return self._read_holding_value(1770, "H")
+
+    def no_operation(self) -> int:
+        return self._command_integer(0, 0)
+
+    def read_serial_number_command(self) -> int:
+        return self._command_integer(65570, 0)
+
+    def read_partial_serial_number(self, which: int) -> int:
+        return self._command_integer(81, which)
+
+    def read_manufacture_date_part(self, which: int) -> int:
+        return self._command_integer(82, which)
+
+    def read_calibration_date_part(self, which: int) -> int:
+        return self._command_integer(83, which)
+
+    def read_firmware_version_part(self, which: int) -> int:
+        return self._command_integer(84, which)
+
+    def query_reading_type(self, which: int) -> int:
+        return self._command_integer(28, which)
+
+    def query_reading_source(self, which: int) -> int:
+        return self._command_integer(27, which)
+
+    def query_reading_minimum_integer(self, which: int) -> int:
+        return self._command_integer(65538, which)
+
+    def query_reading_minimum_float(self, which: int) -> float:
+        return self._command_float(65536, float(which))
+
+    def query_reading_maximum_integer(self, which: int) -> int:
+        return self._command_integer(65539, which)
+
+    def query_reading_maximum_float(self, which: int) -> float:
+        return self._command_float(65537, float(which))
+
+    def query_reading_units(self, which: int) -> int:
+        return self._command_integer(29, which)
+
+    def set_reading_engineering_units(self, which: int, units: Union[int, IntEnum]) -> int:
+        return self._command_integer(65300 + which, self._int_arg(units))
+
+    def query_reading_decimal_places(self, which: int) -> int:
+        return self._command_integer(30, which)
+
+    def flow_averaging_time_constant(self, value: int = 65535) -> int:
+        return self._command_integer(50, value)
+
+    def pressure_averaging_time_constant(self, value: int = 65535) -> int:
+        return self._command_integer(47, value)
+
+    def primary_pressure_averaging_time_constant(self, value: int = 65535) -> int:
+        return self._command_integer(48, value)
+
+    def secondary_pressure_averaging_time_constant(self, value: int = 65535) -> int:
+        return self._command_integer(49, value)
+
+    def closed_loop_active_on_zero_pressure_setpoint(self, mode: int = 65535) -> int:
+        return self._command_integer(51, mode)
+
+    def reading_zero_band(self, value: int = 65535) -> int:
+        return self._command_integer(44, value)
+
+    def autotare_enabled(self, mode: int = 0) -> int:
+        return self._command_integer(40, mode)
+
+    def autotare_delay(self, value: int = 0) -> int:
+        return self._command_integer(45, value)
+
+    def hold_valves(self, mode: int) -> int:
+        return self._command_integer(6, mode)
+
+    def process_variable(self, value: int = 65535) -> int:
+        return self._command_integer(43, value)
+
+    def closed_loop_deadband_integer(self, value: int = -1) -> int:
+        return self._command_integer(65554, value)
+
+    def closed_loop_deadband_float(self, value: float = -1.0) -> float:
+        return self._command_float(65555, value)
+
+    def closed_loop_deadband_mode(self, mode: int = 0) -> int:
+        return self._command_integer(41, mode)
+
+    def query_totalizer_batch_integer(self, which: int) -> int:
+        return self._command_integer(65543, which)
+
+    def query_totalizer_batch_float(self, which: int) -> float:
+        return self._command_float(65540, float(which))
+
+    def set_totalizer_batch_1_integer(self, value: int) -> int:
+        return self._command_integer(65544, value)
+
+    def set_totalizer_batch_1_float(self, value: float) -> float:
+        return self._command_float(65541, value)
+
+    def set_totalizer_batch_2_integer(self, value: int) -> int:
+        return self._command_integer(65545, value)
+
+    def set_totalizer_batch_2_float(self, value: float) -> float:
+        return self._command_float(65542, value)
+
+    def query_setpoint_limit_integer(self, which: int) -> int:
+        return self._command_integer(65548, which)
+
+    def set_minimum_setpoint_limit_integer(self, value: int) -> int:
+        return self._command_integer(65550, value)
+
+    def set_maximum_setpoint_limit_integer(self, value: int) -> int:
+        return self._command_integer(65552, value)
+
+    def query_setpoint_limit_float(self, which: int) -> float:
+        return self._command_float(65549, float(which))
+
+    def set_minimum_setpoint_limit_float(self, value: float) -> float:
+        return self._command_float(65551, value)
+
+    def set_maximum_setpoint_limit_float(self, value: float) -> float:
+        return self._command_float(65553, value)
+
+    def set_power_up_setpoint(self) -> int:
+        return self._command_integer(12, 0)
+
+    def setpoint_maximum_ramp_saved(self, value: int = -1) -> int:
+        return self._command_integer(65546, value)
+
+    def setpoint_maximum_ramp_temporary(self, value: int = -1) -> int:
+        return self._command_integer(65547, value)
+
+    def setpoint_ramp_enabled(self, value: int = 0) -> int:
+        return self._command_integer(42, value)
+
+    def set_active_valve(self, value: int = 65535) -> int:
+        return self._command_integer(15, value)
+
+    def set_loop_control_variable(self, value: int) -> int:
+        return self._command_integer(11, value)
+
+    def set_loop_control_algorithm(self, value: int) -> int:
+        return self._command_integer(13, value)
+
+    def read_closed_loop_control_gain(self, which: int) -> int:
+        return self._command_integer(14, which)
+
+    def set_proportional_closed_loop_control_gain(self, value: int) -> int:
+        return self._command_integer(8, value)
+
+    def set_integral_closed_loop_control_gain(self, value: int) -> int:
+        return self._command_integer(10, value)
+
+    def set_derivative_closed_loop_control_gain(self, value: int) -> int:
+        return self._command_integer(9, value)
+
+    def control_gain_gas_compensation(self, mode: int = 0) -> int:
+        return self._command_integer(62, mode)
+
+    def perform_tare(self, which: int) -> int:
+        return self._command_integer(4, which)
+
+    def perform_pressure_sensor_tare(self, milliseconds: int = 0) -> int:
+        return self._command_integer(31, milliseconds)
+
+    def perform_secondary_pressure_sensor_tare(self, milliseconds: int = 0) -> int:
+        return self._command_integer(32, milliseconds)
+
+    def perform_flow_tare(self, milliseconds: int = 0) -> int:
+        return self._command_integer(33, milliseconds)
+
+    def reset_totalizer(self, which: int) -> int:
+        return self._command_integer(80, which)
+
+    def reset_totalizer_1(self) -> int:
+        return self._command_integer(5, 0)
+
+    def set_selected_gas(self, gas_number: Union[int, IntEnum]) -> GasNumber:
+        return GasNumber(self._command_integer(1, self._int_arg(gas_number)))

matterlab_mfcs/base_mfc.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from enum import IntEnum
+from logging import Logger, getLogger
+from typing import Optional, Union
+
+from matterlab_mfcs.enums import GasNumber
+
+
+class MassFlowController(ABC):
+    """Abstract base class for Matter Lab mass flow controllers."""
+
+    category = "MassFlowController"
+    ui_fields = ("com_port", "address")
+
+    def __init__(self, logger: Optional[Logger] = None) -> None:
+        self.logger = logger if logger is not None else getLogger(
+            f"{self.__class__.__module__}.{self.__class__.__name__}"
+        )
+
+    @property
+    @abstractmethod
+    def serial_number(self) -> int:
+        """Return the device serial number."""
+
+    @property
+    @abstractmethod
+    def device_status(self) -> int:
+        """Return the device status bitfield or device-defined status code."""
+
+    @property
+    @abstractmethod
+    def gas_number(self) -> GasNumber:
+        """Return the currently selected gas number."""
+
+    @property
+    @abstractmethod
+    def setpoint(self) -> float:
+        """Return the current setpoint in engineering units."""
+
+    @setpoint.setter
+    @abstractmethod
+    def setpoint(self, value: float) -> None:
+        """Set the current setpoint in engineering units."""
+
+    @property
+    @abstractmethod
+    def volumetric_flow(self) -> float:
+        """Return the current volumetric flow reading in engineering units."""
+
+    @property
+    @abstractmethod
+    def mass_flow(self) -> float:
+        """Return the current mass flow reading in engineering units."""
+
+    @property
+    @abstractmethod
+    def pressure(self) -> float:
+        """Return the current pressure reading in engineering units."""
+
+    @property
+    @abstractmethod
+    def temperature(self) -> float:
+        """Return the current temperature reading in engineering units."""
+
+    @abstractmethod
+    def set_selected_gas(self, gas_number: Union[int, IntEnum]) -> GasNumber:
+        """Select the active gas number and return the device response."""
+
+    def stop(self) -> None:
+        """Convenience helper for setting the setpoint to zero."""
+        self.setpoint = 0.0

matterlab_mfcs/enums.py

@@ -0,0 +1,595 @@
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class DisplayIntEnum(IntEnum):
+    __labels__: dict[int, str] = {}
+
+    def __str__(self) -> str:
+        return self.__labels__.get(int(self), self.name)
+
+
+class StandardFlowUnit(DisplayIntEnum):
+    UNSPECIFIED = 0
+    UNKNOWN = 1
+    STANDARD_MICROLITER_PER_MINUTE = 2
+    STANDARD_MILLILITER_PER_SECOND = 3
+    STANDARD_MILLILITER_PER_MINUTE = 4
+    STANDARD_MILLILITER_PER_HOUR = 5
+    STANDARD_LITER_PER_SECOND = 6
+    STANDARD_LITER_PER_MINUTE = 7
+    STANDARD_LITER_PER_HOUR = 8
+    STANDARD_CUBIC_CENTIMETER_PER_SECOND = 11
+    STANDARD_CUBIC_CENTIMETER_PER_MINUTE = 12
+    STANDARD_CUBIC_CENTIMETER_PER_HOUR = 13
+    STANDARD_CUBIC_METER_PER_MINUTE = 14
+    STANDARD_CUBIC_METER_PER_HOUR = 15
+    STANDARD_CUBIC_METER_PER_DAY = 16
+    STANDARD_CUBIC_INCH_PER_MINUTE = 17
+    STANDARD_CUBIC_FOOT_PER_MINUTE = 18
+    STANDARD_CUBIC_FOOT_PER_HOUR = 19
+    THOUSAND_STANDARD_CUBIC_FEET_PER_MINUTE = 20
+    STANDARD_CUBIC_FOOT_PER_DAY = 21
+    NORMAL_MICROLITER_PER_MINUTE = 32
+    NORMAL_MILLILITER_PER_SECOND = 33
+    NORMAL_MILLILITER_PER_MINUTE = 34
+    NORMAL_MILLILITER_PER_HOUR = 35
+    NORMAL_LITER_PER_SECOND = 36
+    NORMAL_LITER_PER_MINUTE = 37
+    NORMAL_LITER_PER_HOUR = 38
+    NORMAL_CUBIC_CENTIMETER_PER_SECOND = 41
+    NORMAL_CUBIC_CENTIMETER_PER_MINUTE = 42
+    NORMAL_CUBIC_CENTIMETER_PER_HOUR = 43
+    NORMAL_CUBIC_METER_PER_MINUTE = 44
+    NORMAL_CUBIC_METER_PER_HOUR = 45
+    NORMAL_CUBIC_METER_PER_DAY = 46
+    COUNT = 62
+    PERCENT_FULL_SCALE = 63
+    SLPM = 7
+    SCCM = 12
+    NLPM = 37
+    NCCM = 42
+
+
+class TrueMassFlowUnit(DisplayIntEnum):
+    MILLIGRAM_PER_SECOND = 64
+    MILLIGRAM_PER_MINUTE = 65
+    GRAM_PER_SECOND = 66
+    GRAM_PER_MINUTE = 67
+    GRAM_PER_HOUR = 68
+    KILOGRAM_PER_MINUTE = 69
+    KILOGRAM_PER_HOUR = 70
+    OUNCE_PER_SECOND = 71
+    OUNCE_PER_MINUTE = 72
+    POUND_PER_MINUTE = 73
+    POUND_PER_HOUR = 74
+
+
+class TotalStandardVolumeUnit(DisplayIntEnum):
+    UNSPECIFIED = 0
+    UNKNOWN = 1
+    STANDARD_MICROLITER = 2
+    STANDARD_MILLILITER = 3
+    STANDARD_LITER = 4
+    STANDARD_CUBIC_CENTIMETER = 6
+    STANDARD_CUBIC_METER = 7
+    STANDARD_CUBIC_INCH = 8
+    STANDARD_CUBIC_FOOT = 9
+    THOUSAND_STANDARD_CUBIC_FEET = 10
+    NORMAL_MICROLITER = 32
+    NORMAL_MILLILITER = 33
+    NORMAL_LITER = 34
+    NORMAL_CUBIC_CENTIMETER = 36
+    NORMAL_CUBIC_METER = 37
+
+
+class VolumetricFlowUnit(DisplayIntEnum):
+    UNSPECIFIED = 0
+    UNKNOWN = 1
+    MICROLITER_PER_MINUTE = 2
+    MILLILITER_PER_SECOND = 3
+    MILLILITER_PER_MINUTE = 4
+    MILLILITER_PER_HOUR = 5
+    LITER_PER_SECOND = 6
+    LITER_PER_MINUTE = 7
+    LITER_PER_HOUR = 8
+    US_GALLON_PER_MINUTE = 9
+    US_GALLON_PER_HOUR = 10
+    CUBIC_CENTIMETER_PER_SECOND = 11
+    CUBIC_CENTIMETER_PER_MINUTE = 12
+    CUBIC_CENTIMETER_PER_HOUR = 13
+    CUBIC_METER_PER_MINUTE = 14
+    CUBIC_METER_PER_HOUR = 15
+    CUBIC_METER_PER_DAY = 16
+    CUBIC_INCH_PER_MINUTE = 17
+    CUBIC_FOOT_PER_MINUTE = 18
+    CUBIC_FOOT_PER_HOUR = 19
+    CUBIC_FOOT_PER_DAY = 21
+    COUNT = 62
+    PERCENT_FULL_SCALE = 63
+    LPM = 7
+    SCCM = 12
+    CFM = 18
+
+
+class TotalVolumeUnit(DisplayIntEnum):
+    UNSPECIFIED = 0
+    UNKNOWN = 1
+    MICROLITER = 2
+    MILLILITER = 3
+    LITER = 4
+    US_GALLON = 5
+    CUBIC_CENTIMETER = 6
+    CUBIC_METER = 7
+    CUBIC_INCH = 8
+    CUBIC_FOOT = 9
+    MICROPOISE = 61
+
+
+class PressureUnit(DisplayIntEnum):
+    UNSPECIFIED = 0
+    UNKNOWN = 1
+    PASCAL = 2
+    HECTOPASCAL = 3
+    KILOPASCAL = 4
+    MEGAPASCAL = 5
+    MILLIBAR = 6
+    BAR = 7
+    GRAM_FORCE_PER_SQUARE_CENTIMETER = 8
+    KILOGRAM_FORCE_PER_SQUARE_CENTIMETER = 9
+    PSI = 10
+    PSF = 11
+    MILLITORR = 12
+    TORR = 13
+    MILLIMETER_MERCURY_0C = 14
+    INCHES_MERCURY_0C = 15
+    MILLIMETER_WATER_4C = 16
+    MILLIMETER_WATER_60F = 17
+    CENTIMETER_WATER_4C = 18
+    CENTIMETER_WATER_60F = 19
+    INCH_WATER_4C = 20
+    INCH_WATER_60F = 21
+    ATMOSPHERE = 22
+    VOLT = 61
+    COUNT = 62
+    PERCENT_FULL_SCALE = 63
+
+
+class TemperatureUnit(DisplayIntEnum):
+    UNSPECIFIED = 0
+    UNKNOWN = 1
+    CELSIUS = 2
+    FAHRENHEIT = 3
+    KELVIN = 4
+    RANKINE = 5
+
+
+class GasNumber(DisplayIntEnum):
+    AIR = 0
+    ARGON = 1
+    METHANE = 2
+    CARBON_MONOXIDE = 3
+    CARBON_DIOXIDE = 4
+    ETHANE = 5
+    HYDROGEN = 6
+    HELIUM = 7
+    NITROGEN = 8
+    NITROUS_OXIDE = 9
+    NEON = 10
+    OXYGEN = 11
+    PROPANE = 12
+    NORMAL_BUTANE = 13
+    ACETYLENE = 14
+    ETHYLENE = 15
+    ISOBUTANE = 16
+    KRYPTON = 17
+    XENON = 18
+    SULFUR_HEXAFLUORIDE = 19
+    C_25 = 20
+    C_10 = 21
+    C_8 = 22
+    C_2 = 23
+    C_75 = 24
+    HE_25 = 25
+    HE_75 = 26
+    A1025 = 27
+    STAR29 = 28
+    P_5 = 29
+    NITRIC_OXIDE = 30
+    NITROGEN_TRIFLUORIDE = 31
+    AMMONIA = 32
+    CHLORINE = 33
+    HYDROGEN_SULFIDE = 34
+    SULFUR_DIOXIDE = 35
+    PROPYLENE = 36
+    ONE_BUTENE = 80
+    CIS_BUTENE = 81
+    ISOBUTENE = 82
+    TRANS_2_BUTENE = 83
+    CARBONYL_SULFIDE = 84
+    DIMETHYL_ETHER = 85
+    SILANE = 86
+    R_11 = 100
+    R_115 = 101
+    R_116 = 102
+    R_124 = 103
+    R_125 = 104
+    R_134A = 105
+    R_14 = 106
+    R_142B = 107
+    R_143A = 108
+    R_152A = 109
+    R_22 = 110
+    R_23 = 111
+    R_32 = 112
+    R_318 = 113
+    R_404A = 114
+    R_407C = 115
+    R_410A = 116
+    R_507A = 117
+    C_15 = 140
+    C_20 = 141
+    C_50 = 142
+    HE_50 = 143
+    HE_90 = 144
+    BIO5M = 145
+    BIO10M = 146
+    BIO15M = 147
+    BIO20M = 148
+    BIO25M = 149
+    BIO30M = 150
+    BIO35M = 151
+    BIO40M = 152
+    BIO45M = 153
+    BIO50M = 154
+    BIO55M = 155
+    BIO60M = 156
+    BIO65M = 157
+    BIO70M = 158
+    BIO75M = 159
+    BIO80M = 160
+    BIO85M = 161
+    BIO90M = 162
+    BIO95M = 163
+    EAN_32 = 164
+    EAN_36 = 165
+    EAN_40 = 166
+    HEOX20 = 167
+    HEOX21 = 168
+    HEOX30 = 169
+    HEOX40 = 170
+    HEOX50 = 171
+    HEOX60 = 172
+    HEOX80 = 173
+    HEOX99 = 174
+    EA_40 = 175
+    EA_60 = 176
+    EA_80 = 177
+    METABOLIC_EXHALANT = 178
+    LG_4_5 = 179
+    LG_6 = 180
+    LG_7 = 181
+    LG_9 = 182
+    HENE_9 = 183
+    LG_9_4 = 184
+    SYNG_1 = 185
+    SYNG_2 = 186
+    SYNG_3 = 187
+    SYNG_4 = 188
+    NATG_1 = 189
+    NATG_2 = 190
+    NATG_3 = 191
+    COAL_GAS = 192
+    ENDO = 193
+    HHO = 194
+    HD_5 = 195
+    HD_10 = 196
+    OCG_89 = 197
+    OCG_93 = 198
+    OCG_95 = 199
+    FG_1 = 200
+    FG_2 = 201
+    FG_3 = 202
+    FG_4 = 203
+    FG_5 = 204
+    FG_6 = 205
+    P_10 = 206
+    DEUTERIUM = 210
+    AR = 1
+    CH4 = 2
+    CO = 3
+    CO2 = 4
+    H2 = 6
+    HE = 7
+    N2 = 8
+    N2O = 9
+    O2 = 11
+    C3H8 = 12
+    SF6 = 19
+    NH3 = 32
+    CL2 = 33
+    H2S = 34
+    SO2 = 35
+
+
+StandardFlowUnit.__labels__ = {
+    0: "default",
+    1: "---",
+    2: "SuL/m",
+    3: "SmL/s",
+    4: "SmL/m",
+    5: "SmL/h",
+    6: "SL/s",
+    7: "SLPM",
+    8: "SL/h",
+    11: "SCCS",
+    12: "SCCM",
+    13: "Scm^3/h",
+    14: "Sm^3/m",
+    15: "Sm^3/h",
+    16: "Sm^3/d",
+    17: "Sin^3/m",
+    18: "SCFM",
+    19: "SCFH",
+    20: "kSCFM",
+    21: "SCFD",
+    32: "NuL/m",
+    33: "NmL/s",
+    34: "NmL/m",
+    35: "NmL/h",
+    36: "NL/s",
+    37: "NLPM",
+    38: "NL/h",
+    41: "NCCS",
+    42: "NCCM",
+    43: "Ncm^3/h",
+    44: "Nm^3/m",
+    45: "Nm^3/h",
+    46: "Nm^3/d",
+    62: "count",
+    63: "%",
+}
+
+TrueMassFlowUnit.__labels__ = {
+    64: "mg/s",
+    65: "mg/m",
+    66: "g/s",
+    67: "g/m",
+    68: "g/h",
+    69: "kg/m",
+    70: "kg/h",
+    71: "oz/s",
+    72: "oz/m",
+    73: "lb/m",
+    74: "lb/h",
+}
+
+TotalStandardVolumeUnit.__labels__ = {
+    0: "default",
+    1: "---",
+    2: "SuL",
+    3: "SmL",
+    4: "SL",
+    6: "Scm^3",
+    7: "Sm^3",
+    8: "Sin^3",
+    9: "Sft^3",
+    10: "kSft^3",
+    32: "NuL",
+    33: "NmL",
+    34: "NL",
+    36: "Ncm^3",
+    37: "Nm^3",
+}
+
+VolumetricFlowUnit.__labels__ = {
+    0: "default",
+    1: "---",
+    2: "uL/m",
+    3: "mL/s",
+    4: "mL/m",
+    5: "mL/h",
+    6: "L/s",
+    7: "LPM",
+    8: "L/h",
+    9: "US GPM",
+    10: "US GPH",
+    11: "CCS",
+    12: "CCM",
+    13: "cm^3/h",
+    14: "m^3/m",
+    15: "m^3/h",
+    16: "m^3/d",
+    17: "in^3/m",
+    18: "CFM",
+    19: "CFH",
+    21: "CFD",
+    62: "count",
+    63: "%",
+}
+
+TotalVolumeUnit.__labels__ = {
+    0: "default",
+    1: "---",
+    2: "uL",
+    3: "mL",
+    4: "L",
+    5: "US GAL",
+    6: "cm^3",
+    7: "m^3",
+    8: "in^3",
+    9: "ft^3",
+    61: "uP",
+}
+
+PressureUnit.__labels__ = {
+    0: "default",
+    1: "---",
+    2: "Pa",
+    3: "hPa",
+    4: "kPa",
+    5: "MPa",
+    6: "mbar",
+    7: "bar",
+    8: "g/cm^2",
+    9: "kg/cm^2",
+    10: "PSI",
+    11: "PSF",
+    12: "mTorr",
+    13: "torr",
+    14: "mmHg",
+    15: "inHg",
+    16: "mmH2O",
+    17: "mmH2O(60F)",
+    18: "cmH2O",
+    19: "cmH2O(60F)",
+    20: "inH2O",
+    21: "inH2O(60F)",
+    22: "atm",
+    61: "V",
+    62: "count",
+    63: "%",
+}
+
+TemperatureUnit.__labels__ = {
+    0: "default",
+    1: "---",
+    2: "C",
+    3: "F",
+    4: "K",
+    5: "Ra",
+}
+
+GasNumber.__labels__ = {
+    0: "Air",
+    1: "Ar",
+    2: "CH4",
+    3: "CO",
+    4: "CO2",
+    5: "C2H6",
+    6: "H2",
+    7: "He",
+    8: "N2",
+    9: "N2O",
+    10: "Ne",
+    11: "O2",
+    12: "C3H8",
+    13: "nC4H10",
+    14: "C2H2",
+    15: "C2H4",
+    16: "iC4H10",
+    17: "Kr",
+    18: "Xe",
+    19: "SF6",
+    20: "C-25",
+    21: "C-10",
+    22: "C-8",
+    23: "C-2",
+    24: "C-75",
+    25: "He-25",
+    26: "He-75",
+    27: "A1025",
+    28: "Star29",
+    29: "P-5",
+    30: "NO",
+    31: "NF3",
+    32: "NH3",
+    33: "Cl2",
+    34: "H2S",
+    35: "SO2",
+    36: "C3H6",
+    80: "1Buten",
+    81: "cButen",
+    82: "iButen",
+    83: "tButen",
+    84: "COS",
+    85: "DME",
+    86: "SiH4",
+    100: "R-11",
+    101: "R-115",
+    102: "R-116",
+    103: "R-124",
+    104: "R-125",
+    105: "R-134A",
+    106: "R-14",
+    107: "R-142b",
+    108: "R-143a",
+    109: "R-152a",
+    110: "R-22",
+    111: "R-23",
+    112: "R-32",
+    113: "R-318",
+    114: "R-404A",
+    115: "R-407C",
+    116: "R-410A",
+    117: "R-507A",
+    140: "C-15",
+    141: "C-20",
+    142: "C-50",
+    143: "He-50",
+    144: "He-90",
+    145: "Bio5M",
+    146: "Bio10M",
+    147: "Bio15M",
+    148: "Bio20M",
+    149: "Bio25M",
+    150: "Bio30M",
+    151: "Bio35M",
+    152: "Bio40M",
+    153: "Bio45M",
+    154: "Bio50M",
+    155: "Bio55M",
+    156: "Bio60M",
+    157: "Bio65M",
+    158: "Bio70M",
+    159: "Bio75M",
+    160: "Bio80M",
+    161: "Bio85M",
+    162: "Bio90M",
+    163: "Bio95M",
+    164: "EAN-32",
+    165: "EAN-36",
+    166: "EAN-40",
+    167: "HeOx20",
+    168: "HeOx21",
+    169: "HeOx30",
+    170: "HeOx40",
+    171: "HeOx50",
+    172: "HeOx60",
+    173: "HeOx80",
+    174: "HeOx99",
+    175: "EA-40",
+    176: "EA-60",
+    177: "EA-80",
+    178: "Metab",
+    179: "LG-4.5",
+    180: "LG-6",
+    181: "LG-7",
+    182: "LG-9",
+    183: "HeNe-9",
+    184: "LG-9.4",
+    185: "SynG-1",
+    186: "SynG-2",
+    187: "SynG-3",
+    188: "SynG-4",
+    189: "NatG-1",
+    190: "NatG-2",
+    191: "NatG-3",
+    192: "CoalG",
+    193: "Endo",
+    194: "HHO",
+    195: "HD-5",
+    196: "HD-10",
+    197: "OCG-89",
+    198: "OCG-93",
+    199: "OCG-95",
+    200: "FG-1",
+    201: "FG-2",
+    202: "FG-3",
+    203: "FG-4",
+    204: "FG-5",
+    205: "FG-6",
+    206: "P-10",
+    210: "D2",
+}

matterlab_mfcs-0.1.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: matterlab_mfcs
+Version: 0.1.0
+Summary: Python APIs for mass flow controllers used in the Matter Lab.
+Author: Han Hao
+License-Expression: MIT
+Keywords: alicat,massflowcontroller,automation,matterlab
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: matterlab_serial_device
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# Matter Lab Mass Flow Controllers
+
+`matterlab_mfcs` provides Python drivers for mass flow controllers used in Matter Lab automation workflows.
+
+The first supported device family is Alicat instruments using the Modbus RTU manual bundled with this workspace.
+
+## Installation
+
+Use the `matterlab` conda environment and install the package in editable mode during development:
+
+```bash
+pip install -e .[dev]
+```
+
+The package depends on `matterlab_serial_device` for serial communication.
+
+## Quick Start
+
+```python
+from matterlab_mfcs import AlicatMFC
+
+mfc = AlicatMFC(com_port="COM5", address=1)
+print(mfc.firmware_version)
+print(mfc.serial_number)
+print(mfc.pressure)
+print(mfc.temperature)
+```
+
+## Testing
+
+Unit tests are the default:
+
+```bash
+pytest
+```
+
+Real hardware validation is opt-in:
+
+```bash
+pytest tests/test_alicat_mfc_real.py --run-real --com-port COM5 --address 1
+```
+
+## Notes
+
+- Source code lives under `src/`
+- Pytest uses `src` as the import root
+- Real hardware tests are skipped unless explicitly enabled
+- The Alicat Modbus CRC implementation matches the Modbus RTU framing validated against the local device on `COM5`
+- Multi-read snapshots should live in scripts or tests, not inside the driver

matterlab_mfcs-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+matterlab_mfcs/__init__.py,sha256=pF-PvCvSwF1CQuAuEU4szrcawfFDi1xP_xbGAKdgP3s,558
+matterlab_mfcs/alicat_mfc.py,sha256=goEDoC9E44oGVM1aHF7e9nR9BJUkzm9khBJQc2gJJl8,22701
+matterlab_mfcs/base_mfc.py,sha256=W2hu4-KckdzCBbE4QaPZJqITFbaCTanal0S7N_LUApI,2163
+matterlab_mfcs/enums.py,sha256=WblSL0uy3Q2Um69hvCWGtzXz7Wl_208YHGsuk-2bttg,11113
+matterlab_mfcs-0.1.0.dist-info/METADATA,sha256=ye_yNbQMjMblY96DdEv8txpdwwnmLNoRHrNqSx2JNyA,2116
+matterlab_mfcs-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+matterlab_mfcs-0.1.0.dist-info/top_level.txt,sha256=OEZVQlwF9jRrMVkVQOsT4mADB7R00Ke4O_JurcBUpyo,15
+matterlab_mfcs-0.1.0.dist-info/RECORD,,

matterlab_mfcs-0.1.0.dist-info/WHEEL

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

matterlab_mfcs-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+matterlab_mfcs