opentrons 8.6.0a1__py3-none-any.whl

opentrons/config/types.py

@@ -0,0 +1,183 @@
+from enum import Enum
+from dataclasses import dataclass, asdict, fields
+from typing import Dict, Tuple, TypeVar, Generic, List, cast
+from typing_extensions import TypedDict, Literal
+from opentrons.hardware_control.types import OT3AxisKind
+
+
+class AxisDict(TypedDict):
+    X: float
+    Y: float
+    Z: float
+    A: float
+    B: float
+    C: float
+
+
+Vt = TypeVar("Vt")
+
+
+class GantryLoad(Enum):
+    HIGH_THROUGHPUT_1000 = "high_throughput_1000"
+    HIGH_THROUGHPUT_200 = "high_throughput_200"
+    LOW_THROUGHPUT = "low_throughput"
+
+
+@dataclass
+class ByGantryLoad(Generic[Vt]):
+    high_throughput_1000: Vt
+    high_throughput_200: Vt
+    low_throughput: Vt
+
+    def __getitem__(self, key: GantryLoad) -> Vt:
+        return cast(Vt, asdict(self)[key.value])
+
+
+PerPipetteAxisSettings = ByGantryLoad[Dict[OT3AxisKind, float]]
+
+
+class CurrentDictDefault(TypedDict):
+    default: AxisDict
+
+
+CurrentDictModelEntries = TypedDict(
+    "CurrentDictModelEntries",
+    {"2.1": AxisDict, "A": AxisDict, "B": AxisDict, "C": AxisDict},
+    total=False,
+)
+
+
+class CurrentDict(CurrentDictDefault, CurrentDictModelEntries):
+    pass
+
+
+Offset = Tuple[float, float, float]
+
+
+@dataclass
+class RobotConfig:
+    model: Literal["OT-2 Standard"]
+    name: str
+    version: int
+    gantry_steps_per_mm: Dict[str, float]
+    acceleration: Dict[str, float]
+    serial_speed: int
+    default_pipette_configs: Dict[str, float]
+    default_current: CurrentDict
+    low_current: CurrentDict
+    high_current: CurrentDict
+    default_max_speed: AxisDict
+    log_level: str
+    z_retract_distance: float
+    left_mount_offset: Offset
+
+
+OT3Transform = List[List[float]]
+
+
+@dataclass(frozen=True)
+class OT3MotionSettings:
+    default_max_speed: PerPipetteAxisSettings
+    acceleration: PerPipetteAxisSettings
+    max_speed_discontinuity: PerPipetteAxisSettings
+    direction_change_speed_discontinuity: PerPipetteAxisSettings
+
+    def by_gantry_load(
+        self, gantry_load: GantryLoad
+    ) -> Dict[str, Dict[OT3AxisKind, float]]:
+        return dict(
+            (field.name, getattr(self, field.name)[gantry_load])
+            for field in fields(self)
+        )
+
+
+@dataclass(frozen=True)
+class OT3CurrentSettings:
+    hold_current: PerPipetteAxisSettings
+    run_current: PerPipetteAxisSettings
+
+    def by_gantry_load(
+        self, gantry_load: GantryLoad
+    ) -> Dict[str, Dict[OT3AxisKind, float]]:
+        return dict(
+            (field.name, getattr(self, field.name)[gantry_load])
+            for field in fields(self)
+        )
+
+
+@dataclass(frozen=True)
+class CapacitivePassSettings:
+    prep_distance_mm: float
+    max_overrun_distance_mm: float
+    speed_mm_per_s: float
+    sensor_threshold_pf: float
+
+
+@dataclass(frozen=True)
+class ZSenseSettings:
+    pass_settings: CapacitivePassSettings
+
+
+@dataclass
+class LiquidProbeSettings:
+    mount_speed: float
+    plunger_speed: float
+    plunger_impulse_time: float
+    sensor_threshold_pascals: float
+    aspirate_while_sensing: bool
+    z_overlap_between_passes_mm: float
+    plunger_reset_offset: float
+    samples_for_baselining: int
+    sample_time_sec: float
+
+
+@dataclass(frozen=True)
+class EdgeSenseSettings:
+    overrun_tolerance_mm: float
+    early_sense_tolerance_mm: float
+    pass_settings: CapacitivePassSettings
+    search_initial_tolerance_mm: float
+    search_iteration_limit: int
+
+    def __init__(
+        self,
+        overrun_tolerance_mm: float,
+        early_sense_tolerance_mm: float,
+        pass_settings: CapacitivePassSettings,
+        search_initial_tolerance_mm: float,
+        search_iteration_limit: int,
+    ) -> None:
+        if overrun_tolerance_mm > pass_settings.max_overrun_distance_mm:
+            raise ValueError("Overrun tolerance and pass setting distance do not match")
+        object.__setattr__(self, "overrun_tolerance_mm", overrun_tolerance_mm)
+        object.__setattr__(self, "early_sense_tolerance_mm", early_sense_tolerance_mm)
+        object.__setattr__(self, "pass_settings", pass_settings)
+        object.__setattr__(
+            self, "search_initial_tolerance_mm", search_initial_tolerance_mm
+        )
+        object.__setattr__(self, "search_iteration_limit", search_iteration_limit)
+
+
+@dataclass(frozen=True)
+class OT3CalibrationSettings:
+    z_offset: ZSenseSettings
+    edge_sense: EdgeSenseSettings
+    probe_length: float
+
+
+@dataclass
+class OT3Config:
+    model: Literal["OT-3 Standard"]
+    name: str
+    version: int
+    log_level: str
+    motion_settings: OT3MotionSettings
+    current_settings: OT3CurrentSettings
+    safe_home_distance: float
+    deck_transform: OT3Transform
+    carriage_offset: Offset
+    left_mount_offset: Offset
+    right_mount_offset: Offset
+    gripper_mount_offset: Offset
+    calibration: OT3CalibrationSettings
+    liquid_sense: LiquidProbeSettings

opentrons/drivers/absorbance_reader/__init__.py

@@ -0,0 +1,11 @@
+from .abstract import AbstractAbsorbanceReaderDriver
+from .driver import AbsorbanceReaderDriver
+from .simulator import SimulatingDriver
+from .hid_protocol import AbsorbanceHidInterface
+
+__all__ = [
+    "AbstractAbsorbanceReaderDriver",
+    "AbsorbanceReaderDriver",
+    "SimulatingDriver",
+    "AbsorbanceHidInterface",
+]

opentrons/drivers/absorbance_reader/abstract.py

@@ -0,0 +1,72 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Tuple
+from opentrons.drivers.types import (
+    ABSMeasurementMode,
+    AbsorbanceReaderLidStatus,
+    AbsorbanceReaderDeviceState,
+    AbsorbanceReaderPlatePresence,
+)
+
+
+class AbstractAbsorbanceReaderDriver(ABC):
+    @abstractmethod
+    async def connect(self) -> None:
+        """Connect to absorbance reader"""
+        ...
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        """Disconnect from absorbance reader"""
+        ...
+
+    @abstractmethod
+    async def is_connected(self) -> bool:
+        """Check connection to absorbance reader"""
+        ...
+
+    @abstractmethod
+    async def get_lid_status(self) -> AbsorbanceReaderLidStatus:
+        ...
+
+    @abstractmethod
+    async def get_available_wavelengths(self) -> List[int]:
+        ...
+
+    @abstractmethod
+    async def initialize_measurement(
+        self,
+        wavelengths: List[int],
+        mode: ABSMeasurementMode = ABSMeasurementMode.SINGLE,
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
+        """Initialize measurement for the device in single or multi mode for the given wavelengths"""
+        ...
+
+    @abstractmethod
+    async def get_measurement(self) -> List[List[float]]:
+        """Gets one or more measurements based on the current configuration."""
+        ...
+
+    @abstractmethod
+    async def get_status(self) -> AbsorbanceReaderDeviceState:
+        ...
+
+    @abstractmethod
+    async def get_device_info(self) -> Dict[str, str]:
+        """Get device info"""
+        ...
+
+    @abstractmethod
+    async def get_uptime(self) -> int:
+        """Get device uptime"""
+        ...
+
+    @abstractmethod
+    async def get_plate_presence(self) -> AbsorbanceReaderPlatePresence:
+        """Check if there is a plate in the reader."""
+        ...
+
+    @abstractmethod
+    async def update_firmware(self, firmware_file_path: str) -> Tuple[bool, str]:
+        """Updates the firmware on the device."""
+        ...

opentrons/drivers/absorbance_reader/async_byonoy.py

@@ -0,0 +1,352 @@
+import asyncio
+import os
+import re
+from concurrent.futures.thread import ThreadPoolExecutor
+from functools import partial
+from typing import Any, Optional, List, Dict, Tuple
+
+from .hid_protocol import (
+    AbsorbanceHidInterface as AbsProtocol,
+    ErrorCodeNames,
+    DeviceStateNames,
+    SlotStateNames,
+    MeasurementConfig,
+)
+from opentrons.drivers.types import (
+    AbsorbanceReaderLidStatus,
+    AbsorbanceReaderPlatePresence,
+    AbsorbanceReaderDeviceState,
+    ABSMeasurementMode,
+)
+from opentrons.drivers.rpi_drivers.types import USBPort
+from opentrons.hardware_control.modules.errors import AbsorbanceReaderDisconnectedError
+
+
+SN_PARSER = re.compile(r'ATTRS{serial}=="(?P<serial>.+?)"')
+# match semver V0.0.0 (old format) or one integer (latest format)
+VERSION_PARSER = re.compile(r"(?P<version>(V\d+\.\d+\.\d+|^\d+$))")
+SERIAL_PARSER = re.compile(r"(?P<serial>(OPT|BYO)[A-Z]{3}[0-9]+)")
+
+
+class AsyncByonoy:
+    """Async wrapper around Byonoy Device Library."""
+
+    @staticmethod
+    def match_device_with_sn(
+        sn: str, devices: List[AbsProtocol.Device]
+    ) -> AbsProtocol.Device:
+        for device in devices:
+            if device.sn == sn:
+                return device
+        raise RuntimeError(f"Unavailble module with serial number: {sn}")
+
+    @staticmethod
+    def serial_number_from_port(name: str) -> str:
+        """
+        Get the serial number from a port using pyusb.
+        """
+        import usb.core as usb_core  # type: ignore[import-untyped]
+
+        port_numbers = tuple(int(s) for s in name.split("-")[1].split("."))
+        device = usb_core.find(port_numbers=port_numbers)
+        if device:
+            return str(device.serial_number)
+        raise RuntimeError(f"Could not find serial number for port: {name}")
+
+    @classmethod
+    async def create(
+        cls,
+        port: str,
+        usb_port: USBPort,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> "AsyncByonoy":
+        """
+        Create an AsyncByonoy instance.
+
+        Args:
+            port: url or port name
+            baud_rate: the baud rate
+            timeout: optional timeout in seconds
+            write_timeout: optional write timeout in seconds
+            loop: optional event loop. if None get_running_loop will be used
+            reset_buffer_before_write: reset the serial input buffer before
+             writing to it
+        """
+        loop = loop or asyncio.get_running_loop()
+        executor = ThreadPoolExecutor(max_workers=1)
+
+        import byonoy_devices as byonoy  # type: ignore[import-not-found]
+
+        interface: AbsProtocol = byonoy
+
+        device_sn = cls.serial_number_from_port(usb_port.name)
+        found: List[AbsProtocol.Device] = await loop.run_in_executor(
+            executor=executor, func=byonoy.available_devices
+        )
+        device = cls.match_device_with_sn(device_sn, found)
+
+        return cls(
+            interface=interface,
+            device=device,
+            executor=executor,
+            loop=loop,
+        )
+
+    def __init__(
+        self,
+        interface: AbsProtocol,
+        device: AbsProtocol.Device,
+        executor: ThreadPoolExecutor,
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        """
+        Constructor
+
+        Args:
+            serial: connected Serial object
+            executor: a thread pool executor
+            loop: event loop
+        """
+        self._interface = interface
+        self._device = device
+        self._executor = executor
+        self._loop = loop
+        self._supported_wavelengths: Optional[list[int]] = None
+        self._device_handle: Optional[int] = None
+        self._current_config: Optional[MeasurementConfig] = None
+
+    async def open(self) -> bool:
+        """
+        Open the connection.
+
+        Returns: boolean denoting connection success.
+        """
+
+        err, device_handle = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.open_device, self._device),
+        )
+        self._raise_if_error(err.name, f"Error opening device: {err}")
+        self._device_handle = device_handle
+        return bool(device_handle)
+
+    async def close(self) -> None:
+        """Close the connection."""
+        handle = self._verify_device_handle()
+        await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.free_device, handle),
+        )
+        self._device_handle = None
+
+    async def is_open(self) -> bool:
+        """True if connection is open."""
+        if self._device_handle is None:
+            return False
+        handle = self._verify_device_handle()
+        return await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.device_open, handle),
+        )
+
+    async def get_device_information(self) -> Dict[str, str]:
+        """Get serial number and version info."""
+        handle = self._verify_device_handle()
+        err, device_info = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.get_device_information, handle),
+        )
+        self._raise_if_error(err.name, f"Error getting device information: {err}")
+        serial_match = SERIAL_PARSER.match(device_info.sn)
+        version_match = VERSION_PARSER.search(device_info.version)
+        serial = serial_match["serial"].strip() if serial_match else "OPTMAA00000"
+        version = version_match["version"].lower() if version_match else "v0"
+        info = {
+            "serial": serial,
+            "version": version,
+            "model": "ABS96",
+        }
+        return info
+
+    async def get_device_status(self) -> AbsorbanceReaderDeviceState:
+        """Get state information of the device."""
+        handle = self._verify_device_handle()
+        err, status = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.get_device_status, handle),
+        )
+        self._raise_if_error(err.name, f"Error getting device status: {err}")
+        return self.convert_device_state(status.name)
+
+    async def update_firmware(self, firmware_file_path: str) -> Tuple[bool, str]:
+        """Updates the firmware of the device."""
+        handle = self._verify_device_handle()
+        if not os.path.exists(firmware_file_path):
+            return False, f"Firmware file not found: {firmware_file_path}"
+        err = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.update_device, handle, firmware_file_path),
+        )
+        if err.name != "NO_ERROR":
+            return False, f"Byonoy update failed with error: {err}"
+        return True, ""
+
+    async def get_device_uptime(self) -> int:
+        """Get how long in seconds the device has been running for."""
+        handle = self._verify_device_handle()
+        err, uptime = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.get_device_uptime, handle),
+        )
+        self._raise_if_error(err.name, "Error getting device uptime: ")
+        return uptime
+
+    async def get_lid_status(self) -> AbsorbanceReaderLidStatus:
+        """Get the state of the absorbance lid."""
+        handle = self._verify_device_handle()
+        err, lid_info = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.get_device_parts_aligned, handle),
+        )
+        self._raise_if_error(err.name, f"Error getting lid status: {err}")
+        return (
+            AbsorbanceReaderLidStatus.ON if lid_info else AbsorbanceReaderLidStatus.OFF
+        )
+
+    async def get_supported_wavelengths(self) -> list[int]:
+        """Get a list of the wavelength readings this device supports."""
+        handle = self._verify_device_handle()
+        err, wavelengths = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.abs96_get_available_wavelengths, handle),
+        )
+        self._raise_if_error(err.name, "Error getting available wavelengths: ")
+        self._supported_wavelengths = wavelengths
+        return wavelengths
+
+    async def get_measurement(self) -> List[List[float]]:
+        """Gets one or more measurements based on the current configuration."""
+        handle = self._verify_device_handle()
+        assert (
+            self._current_config is not None
+        ), "Cannot get measurement without initializing."
+        measure_func: Any = self._interface.abs96_single_measure
+        if isinstance(self._current_config, AbsProtocol.MultiMeasurementConfig):
+            measure_func = self._interface.abs96_multiple_measure
+        err, measurements = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(
+                measure_func,
+                handle,
+                self._current_config,
+            ),
+        )
+        self._raise_if_error(err.name, f"Error getting measurement: {err}")
+        return measurements if isinstance(measurements[0], List) else [measurements]  # type: ignore
+
+    async def get_plate_presence(self) -> AbsorbanceReaderPlatePresence:
+        """Get the state of the plate for the reader."""
+        handle = self._verify_device_handle()
+        err, presence = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.get_device_slot_status, handle),
+        )
+        self._raise_if_error(err.name, f"Error getting slot status: {err}")
+        return self.convert_plate_presence(presence.name)
+
+    def _get_supported_wavelengths(self) -> List[int]:
+        handle = self._verify_device_handle()
+        wavelengths: List[int]
+        err, wavelengths = self._interface.abs96_get_available_wavelengths(handle)
+        self._raise_if_error(err.name, f"Error getting available wavelengths: {err}")
+        self._supported_wavelengths = wavelengths
+        return wavelengths
+
+    def _initialize_measurement(self, conf: MeasurementConfig) -> None:
+        handle = self._verify_device_handle()
+        if isinstance(conf, AbsProtocol.SingleMeasurementConfig):
+            err = self._interface.abs96_initialize_single_measurement(handle, conf)
+        else:
+            err = self._interface.abs96_initialize_multiple_measurement(handle, conf)
+        self._raise_if_error(err.name, f"Error initializing measurement: {err}")
+        self._current_config = conf
+
+    def _initialize(
+        self,
+        mode: ABSMeasurementMode,
+        wavelengths: List[int],
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
+        if not self._supported_wavelengths:
+            self._get_supported_wavelengths()
+        assert self._supported_wavelengths
+        conf: MeasurementConfig
+        if set(wavelengths).issubset(self._supported_wavelengths):
+            if mode == ABSMeasurementMode.SINGLE:
+                conf = self._interface.Abs96SingleMeasurementConfig()
+                conf.sample_wavelength = wavelengths[0] or 0
+                conf.reference_wavelength = reference_wavelength or 0
+            else:
+                conf = self._interface.Abs96MultipleMeasurementConfig()
+                conf.sample_wavelengths = wavelengths
+        else:
+            raise ValueError(
+                f"Unsupported wavelength: {wavelengths}, expected: {self._supported_wavelengths}"
+            )
+        self._initialize_measurement(conf)
+
+    async def initialize(
+        self,
+        mode: ABSMeasurementMode,
+        wavelengths: List[int],
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
+        """initialize the device so we can start reading samples from it."""
+        await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._initialize, mode, wavelengths, reference_wavelength),
+        )
+
+    def _verify_device_handle(self) -> int:
+        assert self._device_handle is not None, RuntimeError(
+            "Device handle not set up."
+        )
+        return self._device_handle
+
+    def _raise_if_error(
+        self,
+        err_name: ErrorCodeNames,
+        msg: str = "Error occurred: ",
+    ) -> None:
+        if err_name in [
+            "DEVICE_CLOSED",
+            "DEVICE_COMMUNICATION_FAILURE",
+            "UNSUPPORTED_OPERATION",
+        ]:
+            raise AbsorbanceReaderDisconnectedError(self._device.sn)
+        if err_name != "NO_ERROR":
+            raise RuntimeError(msg, err_name)
+
+    @staticmethod
+    def convert_device_state(
+        device_state: DeviceStateNames,
+    ) -> AbsorbanceReaderDeviceState:
+        state_map: Dict[DeviceStateNames, AbsorbanceReaderDeviceState] = {
+            "UNKNOWN": AbsorbanceReaderDeviceState.UNKNOWN,
+            "OK": AbsorbanceReaderDeviceState.OK,
+            "BROKEN_FW": AbsorbanceReaderDeviceState.BROKEN_FW,
+            "ERROR": AbsorbanceReaderDeviceState.ERROR,
+        }
+        return state_map[device_state]
+
+    @staticmethod
+    def convert_plate_presence(
+        slot_state: SlotStateNames,
+    ) -> AbsorbanceReaderPlatePresence:
+        state_map: Dict[SlotStateNames, AbsorbanceReaderPlatePresence] = {
+            "UNKNOWN": AbsorbanceReaderPlatePresence.UNKNOWN,
+            "EMPTY": AbsorbanceReaderPlatePresence.ABSENT,
+            "OCCUPIED": AbsorbanceReaderPlatePresence.PRESENT,
+            "UNDETERMINED": AbsorbanceReaderPlatePresence.UNKNOWN,
+        }
+        return state_map[slot_state]

opentrons/drivers/absorbance_reader/driver.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Dict, Optional, List, Tuple, TYPE_CHECKING
+
+from opentrons.drivers.types import (
+    ABSMeasurementMode,
+    AbsorbanceReaderLidStatus,
+    AbsorbanceReaderDeviceState,
+    AbsorbanceReaderPlatePresence,
+)
+from opentrons.drivers.absorbance_reader.abstract import (
+    AbstractAbsorbanceReaderDriver,
+)
+from opentrons.drivers.rpi_drivers.types import USBPort
+
+if TYPE_CHECKING:
+    from .async_byonoy import AsyncByonoy as AsyncByonoyType
+
+
+class AbsorbanceReaderDriver(AbstractAbsorbanceReaderDriver):
+    @classmethod
+    async def create(
+        cls,
+        port: str,
+        usb_port: USBPort,
+        loop: Optional[asyncio.AbstractEventLoop],
+    ) -> AbsorbanceReaderDriver:
+        """Create an absorbance reader driver."""
+        from .async_byonoy import AsyncByonoy
+
+        connection = await AsyncByonoy.create(port=port, usb_port=usb_port, loop=loop)
+        return cls(connection=connection)
+
+    def __init__(self, connection: AsyncByonoyType) -> None:
+        self._connection = connection
+
+    async def connect(self) -> None:
+        """Connect to absorbance reader"""
+        await self._connection.open()
+
+    async def disconnect(self) -> None:
+        """Disconnect from absorbance reader"""
+        await self._connection.close()
+
+    async def is_connected(self) -> bool:
+        """Check connection to absorbance reader"""
+        return await self._connection.is_open()
+
+    async def get_device_info(self) -> Dict[str, str]:
+        """Get device info"""
+        return await self._connection.get_device_information()
+
+    async def update_firmware(self, firmware_file_path: str) -> Tuple[bool, str]:
+        return await self._connection.update_firmware(firmware_file_path)
+
+    async def get_uptime(self) -> int:
+        return await self._connection.get_device_uptime()
+
+    async def get_lid_status(self) -> AbsorbanceReaderLidStatus:
+        return await self._connection.get_lid_status()
+
+    async def get_available_wavelengths(self) -> List[int]:
+        return await self._connection.get_supported_wavelengths()
+
+    async def initialize_measurement(
+        self,
+        wavelengths: List[int],
+        mode: ABSMeasurementMode = ABSMeasurementMode.SINGLE,
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
+        await self._connection.initialize(mode, wavelengths, reference_wavelength)
+
+    async def get_measurement(self) -> List[List[float]]:
+        return await self._connection.get_measurement()
+
+    async def get_status(self) -> AbsorbanceReaderDeviceState:
+        return await self._connection.get_device_status()
+
+    async def get_plate_presence(self) -> AbsorbanceReaderPlatePresence:
+        return await self._connection.get_plate_presence()