opentrons 8.3.2a0__py2.py3-none-any.whl → 8.4.0__py2.py3-none-any.whl

opentrons/hardware_control/modules/types.py

@@ -13,10 +13,16 @@ from typing import (
     Optional,
     cast,
     TYPE_CHECKING,
+    TypeGuard,
 )
 from typing_extensions import TypedDict
 from pathlib import Path
 
+from opentrons.drivers.flex_stacker.types import (
+    LimitSwitchStatus,
+    PlatformStatus,
+    StackerAxis,
+)
 from opentrons.drivers.rpi_drivers.types import USBPort
 
 if TYPE_CHECKING:
@@ -27,6 +33,7 @@ if TYPE_CHECKING:
         HeaterShakerModuleType,
         MagneticBlockType,
         AbsorbanceReaderType,
+        FlexStackerModuleType,
     )
 
 
@@ -50,9 +57,113 @@ UploadFunction = Callable[[str, str, Dict[str, Any]], Awaitable[Tuple[bool, str]
 ModuleDisconnectedCallback = Optional[Callable[[str, str | None], None]]
 
 
+class MagneticModuleData(TypedDict):
+    engaged: bool
+    height: float
+
+
+class TemperatureModuleData(TypedDict):
+    currentTemp: float
+    targetTemp: float | None
+
+
+class HeaterShakerData(TypedDict):
+    temperatureStatus: str
+    speedStatus: str
+    labwareLatchStatus: str
+    currentTemp: float
+    targetTemp: float | None
+    currentSpeed: int
+    targetSpeed: int | None
+    errorDetails: str | None
+
+
+class ThermocyclerData(TypedDict):
+    lid: str
+    lidTarget: float | None
+    lidTemp: float
+    lidTempStatus: str
+    currentTemp: float | None
+    targetTemp: float | None
+    holdTime: float | None
+    rampRate: float | None
+    currentCycleIndex: int | None
+    totalCycleCount: int | None
+    currentStepIndex: int | None
+    totalStepCount: int | None
+
+
+class AbsorbanceReaderData(TypedDict):
+    uptime: int
+    deviceStatus: str
+    lidStatus: str
+    platePresence: str
+    measureMode: str
+    sampleWavelengths: List[int]
+    referenceWavelength: int
+
+
+class FlexStackerData(TypedDict):
+    latchState: str
+    platformState: str
+    hopperDoorState: str
+    axisStateX: str
+    axisStateZ: str
+    errorDetails: str | None
+
+
+ModuleData = Union[
+    Dict[Any, Any],  # This allows an empty dict as module data
+    MagneticModuleData,
+    TemperatureModuleData,
+    HeaterShakerData,
+    ThermocyclerData,
+    AbsorbanceReaderData,
+    FlexStackerData,
+]
+
+
+class ModuleDataValidator:
+    @classmethod
+    def is_magnetic_module_data(
+        cls, data: ModuleData | None
+    ) -> TypeGuard[MagneticModuleData]:
+        return data is not None and "engaged" in data.keys()
+
+    @classmethod
+    def is_temperature_module_data(
+        cls, data: ModuleData | None
+    ) -> TypeGuard[TemperatureModuleData]:
+        return data is not None and "targetTemp" in data.keys()
+
+    @classmethod
+    def is_heater_shaker_data(
+        cls, data: ModuleData | None
+    ) -> TypeGuard[HeaterShakerData]:
+        return data is not None and "labwareLatchStatus" in data.keys()
+
+    @classmethod
+    def is_thermocycler_data(
+        cls, data: ModuleData | None
+    ) -> TypeGuard[ThermocyclerData]:
+        return data is not None and "lid" in data.keys()
+
+    @classmethod
+    def is_absorbance_reader_data(
+        cls, data: ModuleData | None
+    ) -> TypeGuard[AbsorbanceReaderData]:
+        return data is not None and "uptime" in data.keys()
+
+    @classmethod
+    def is_flex_stacker_data(
+        cls, data: ModuleData | None
+    ) -> TypeGuard[FlexStackerData]:
+        return data is not None and "platformState" in data.keys()
+
+
 class LiveData(TypedDict):
     status: str
-    data: Dict[str, Union[float, str, bool, List[int], None]]
+    data: ModuleData | None
 
 
 class ModuleType(str, Enum):
@@ -62,6 +173,7 @@ class ModuleType(str, Enum):
     HEATER_SHAKER: HeaterShakerModuleType = "heaterShakerModuleType"
     MAGNETIC_BLOCK: MagneticBlockType = "magneticBlockType"
     ABSORBANCE_READER: AbsorbanceReaderType = "absorbanceReaderType"
+    FLEX_STACKER: FlexStackerModuleType = "flexStackerModuleType"
 
     @classmethod
     def from_model(cls, model: ModuleModel) -> ModuleType:
@@ -77,6 +189,8 @@ class ModuleType(str, Enum):
             return cls.MAGNETIC_BLOCK
         if isinstance(model, AbsorbanceReaderModel):
             return cls.ABSORBANCE_READER
+        if isinstance(model, FlexStackerModuleModel):
+            return cls.FLEX_STACKER
 
     @classmethod
     def to_module_fixture_id(cls, module_type: ModuleType) -> str:
@@ -91,6 +205,8 @@ class ModuleType(str, Enum):
             return "magneticBlockV1"
         if module_type == ModuleType.ABSORBANCE_READER:
             return "absorbanceReaderV1"
+        if module_type == ModuleType.FLEX_STACKER:
+            return "flexStackerModuleV1"
         else:
             raise ValueError(
                 f"Module Type {module_type} does not have a related fixture ID."
@@ -124,6 +240,10 @@ class AbsorbanceReaderModel(str, Enum):
     ABSORBANCE_READER_V1: str = "absorbanceReaderV1"
 
 
+class FlexStackerModuleModel(str, Enum):
+    FLEX_STACKER_V1: str = "flexStackerModuleV1"
+
+
 def module_model_from_string(model_string: str) -> ModuleModel:
     for model_enum in {
         MagneticModuleModel,
@@ -132,6 +252,7 @@ def module_model_from_string(model_string: str) -> ModuleModel:
         HeaterShakerModuleModel,
         MagneticBlockModel,
         AbsorbanceReaderModel,
+        FlexStackerModuleModel,
     }:
         try:
             return cast(ModuleModel, model_enum(model_string))
@@ -184,6 +305,7 @@ ModuleModel = Union[
     HeaterShakerModuleModel,
     MagneticBlockModel,
     AbsorbanceReaderModel,
+    FlexStackerModuleModel,
 ]
 
 
@@ -225,3 +347,71 @@ class LidStatus(str, Enum):
     OFF = "off"
     UNKNOWN = "unknown"
     ERROR = "error"
+
+
+class FlexStackerStatus(str, Enum):
+    IDLE = "idle"
+    DISPENSING = "dispensing"
+    STORING = "storing"
+    ERROR = "error"
+
+
+class PlatformState(str, Enum):
+    UNKNOWN = "unknown"
+    EXTENDED = "extended"
+    RETRACTED = "retracted"
+
+    @classmethod
+    def from_status(cls, status: PlatformStatus) -> "PlatformState":
+        """Get the state from the platform status."""
+        if status.E and not status.R:
+            return cls.EXTENDED
+        if status.R and not status.E:
+            return cls.RETRACTED
+        return cls.UNKNOWN
+
+
+class StackerAxisState(str, Enum):
+    UNKNOWN = "unknown"
+    EXTENDED = "extended"
+    RETRACTED = "retracted"
+
+    @classmethod
+    def from_status(
+        cls, status: LimitSwitchStatus, axis: StackerAxis
+    ) -> "StackerAxisState":
+        """Get the axis state from the limit switch status."""
+        match axis:
+            case StackerAxis.X:
+                if status.XE and not status.XR:
+                    return cls.EXTENDED
+                if status.XR and not status.XE:
+                    return cls.RETRACTED
+            case StackerAxis.Z:
+                if status.ZE and not status.ZR:
+                    return cls.EXTENDED
+                if status.ZR and not status.ZE:
+                    return cls.RETRACTED
+            case StackerAxis.L:
+                return cls.EXTENDED if status.LR else cls.RETRACTED
+        return cls.UNKNOWN
+
+
+class LatchState(str, Enum):
+    CLOSED = "closed"
+    OPENED = "opened"
+
+    @classmethod
+    def from_state(cls, state: StackerAxisState) -> "LatchState":
+        """Get the latch state from the axis state."""
+        return cls.CLOSED if state == StackerAxisState.EXTENDED else cls.OPENED
+
+
+class HopperDoorState(str, Enum):
+    CLOSED = "closed"
+    OPENED = "opened"
+
+    @classmethod
+    def from_state(cls, state: bool) -> "HopperDoorState":
+        """Get the hopper door state from the door state boolean."""
+        return cls.CLOSED if state else cls.OPENED

opentrons/hardware_control/modules/utils.py

@@ -13,6 +13,7 @@ from .magdeck import MagDeck
 from .thermocycler import Thermocycler
 from .heater_shaker import HeaterShaker
 from .absorbance_reader import AbsorbanceReader
+from .flex_stacker import FlexStacker
 
 
 log = logging.getLogger(__name__)
@@ -26,6 +27,7 @@ MODULE_TYPE_BY_NAME = {
     Thermocycler.name(): Thermocycler.MODULE_TYPE,
     HeaterShaker.name(): HeaterShaker.MODULE_TYPE,
     AbsorbanceReader.name(): AbsorbanceReader.MODULE_TYPE,
+    FlexStacker.name(): FlexStacker.MODULE_TYPE,
 }
 
 _MODULE_CLS_BY_TYPE: Dict[ModuleType, Type[AbstractModule]] = {
@@ -34,6 +36,7 @@ _MODULE_CLS_BY_TYPE: Dict[ModuleType, Type[AbstractModule]] = {
     Thermocycler.MODULE_TYPE: Thermocycler,
     HeaterShaker.MODULE_TYPE: HeaterShaker,
     AbsorbanceReader.MODULE_TYPE: AbsorbanceReader,
+    FlexStacker.MODULE_TYPE: FlexStacker,
 }
 
 

opentrons/hardware_control/motion_utilities.py

@@ -192,6 +192,26 @@ def target_position_from_plunger(
     return all_axes_pos
 
 
+def target_positions_from_plunger_tracking(
+    mount: Union[Mount, OT3Mount],
+    plunger_delta: float,
+    z_delta: float,
+    current_position: Dict[Axis, float],
+) -> "OrderedDict[Axis, float]":
+    """Create a target position for machine axes including plungers for dynamic liquid tracking.
+
+    The x/y axes remain constant but the plunger and Z move to create a tracking action.
+
+    plunger_delta: the distance the plunger should move- should be determined based on desired
+    volume to aspirate/dispense.
+    z_delta: the distance to move the z axis- should be determined based on volume and well geometry.
+    """
+    all_axes_pos = target_position_from_plunger(mount, plunger_delta, current_position)
+    z_ax = Axis.by_mount(mount)
+    all_axes_pos[z_ax] = current_position[z_ax] + z_delta
+    return all_axes_pos
+
+
 def deck_point_from_machine_point(
     machine_point: Point, attitude: AttitudeMatrix, offset: Point
 ) -> Point:

opentrons/hardware_control/ot3api.py

@@ -99,6 +99,7 @@ from .types import (
     HardwareFeatureFlags,
     FailedTipStateCheck,
     PipetteSensorResponseQueue,
+    TipScrapeType,
 )
 from .errors import (
     UpdateOngoingError,
@@ -126,6 +127,7 @@ from .motion_utilities import (
     target_position_from_absolute,
     target_position_from_relative,
     target_position_from_plunger,
+    target_positions_from_plunger_tracking,
     offset_for_mount,
     deck_from_machine,
     machine_from_deck,
@@ -450,9 +452,11 @@ class OT3API(
             checked_config = config
 
         backend = await OT3Simulator.build(
-            {OT3Mount.from_mount(k): v for k, v in attached_instruments.items()}
-            if attached_instruments
-            else {},
+            (
+                {OT3Mount.from_mount(k): v for k, v in attached_instruments.items()}
+                if attached_instruments
+                else {}
+            ),
             checked_modules,
             checked_config,
             checked_loop,
@@ -2051,12 +2055,16 @@ class OT3API(
         mount: Union[top_types.Mount, OT3Mount],
         volume: Optional[float] = None,
         rate: float = 1.0,
+        correction_volume: float = 0.0,
     ) -> None:
         """
         Aspirate a volume of liquid (in microliters/uL) using this pipette."""
         realmount = OT3Mount.from_mount(mount)
         aspirate_spec = self._pipette_handler.plan_check_aspirate(
-            realmount, volume, rate
+            mount=realmount,
+            volume=volume,
+            rate=rate,
+            correction_volume=correction_volume,
         )
         if not aspirate_spec:
             return
@@ -2093,12 +2101,19 @@ class OT3API(
         volume: Optional[float] = None,
         rate: float = 1.0,
         push_out: Optional[float] = None,
+        correction_volume: float = 0.0,
+        is_full_dispense: bool = False,
     ) -> None:
         """
         Dispense a volume of liquid in microliters(uL) using this pipette."""
         realmount = OT3Mount.from_mount(mount)
         dispense_spec = self._pipette_handler.plan_check_dispense(
-            realmount, volume, rate, push_out
+            mount=realmount,
+            volume=volume,
+            rate=rate,
+            push_out=push_out,
+            is_full_dispense=is_full_dispense,
+            correction_volume=correction_volume,
         )
         if not dispense_spec:
             return
@@ -2329,6 +2344,7 @@ class OT3API(
         mount: Union[top_types.Mount, OT3Mount],
         home_after: bool = False,
         ignore_plunger: bool = False,
+        scrape_type: TipScrapeType = TipScrapeType.NONE,
     ) -> None:
         realmount = OT3Mount.from_mount(mount)
         if ignore_plunger is False:
@@ -2340,18 +2356,27 @@ class OT3API(
             spec = self._pipette_handler.plan_ht_drop_tip()
             await self._tip_motor_action(realmount, spec.tip_action_moves)
         else:
-            spec = self._pipette_handler.plan_lt_drop_tip(realmount)
+            spec = self._pipette_handler.plan_lt_drop_tip(realmount, scrape_type)
             for move in spec.tip_action_moves:
                 async with self._backend.motor_current(move.currents):
-                    target_pos = target_position_from_plunger(
-                        realmount, move.distance, self._current_position
-                    )
-                    await self._move(
-                        target_pos,
-                        speed=move.speed,
-                        home_flagged_axes=False,
-                    )
-
+                    if not move.scrape_axis:
+                        target_pos = target_position_from_plunger(
+                            realmount, move.distance, self._current_position
+                        )
+                        await self._move(
+                            target_pos,
+                            speed=move.speed,
+                            home_flagged_axes=False,
+                        )
+                    else:
+                        target_pos = OrderedDict(self._current_position)
+                        target_pos[move.scrape_axis] += move.distance
+                        self._log.info(f"Moving to target Pos: {target_pos}")
+                        await self._move(
+                            target_pos,
+                            speed=move.speed,
+                            home_flagged_axes=False,
+                        )
         for shake in spec.shake_off_moves:
             await self.move_rel(mount, shake[0], speed=shake[1])
 
@@ -2974,6 +2999,103 @@ class OT3API(
 
     AMKey = TypeVar("AMKey")
 
+    async def aspirate_while_tracking(
+        self,
+        mount: Union[top_types.Mount, OT3Mount],
+        z_distance: float,
+        volume: float,
+        flow_rate: float = 1.0,
+    ) -> None:
+        """
+        Aspirate a volume of liquid (in microliters/uL) while moving the z axis synchronously.
+
+        :param mount: A robot mount that the instrument is on.
+        :param z_distance: The distance the z axis will move during apsiration.
+        :param volume: The volume of liquid to be aspirated.
+        :param flow_rate: The flow rate to aspirate with.
+        """
+        realmount = OT3Mount.from_mount(mount)
+        aspirate_spec = self._pipette_handler.plan_check_aspirate(
+            realmount, volume, flow_rate
+        )
+        if not aspirate_spec:
+            return
+        target_pos = target_positions_from_plunger_tracking(
+            realmount,
+            aspirate_spec.plunger_distance,
+            z_distance,
+            self._current_position,
+        )
+        try:
+            await self._backend.set_active_current(
+                {aspirate_spec.axis: aspirate_spec.current}
+            )
+            async with self.restore_system_constrants():
+                await self.set_system_constraints_for_plunger_acceleration(
+                    realmount, aspirate_spec.acceleration
+                )
+                await self._move(
+                    target_pos,
+                    speed=aspirate_spec.speed,
+                    home_flagged_axes=False,
+                )
+        except Exception:
+            self._log.exception("Aspirate failed")
+            aspirate_spec.instr.set_current_volume(0)
+            raise
+        else:
+            aspirate_spec.instr.add_current_volume(aspirate_spec.volume)
+
+    async def dispense_while_tracking(
+        self,
+        mount: Union[top_types.Mount, OT3Mount],
+        z_distance: float,
+        volume: float,
+        push_out: Optional[float],
+        flow_rate: float = 1.0,
+        is_full_dispense: bool = False,
+    ) -> None:
+        """
+        Dispense a volume of liquid (in microliters/uL) while moving the z axis synchronously.
+
+        :param mount: A robot mount that the instrument is on.
+        :param z_distance: The distance the z axis will move during dispensing.
+        :param volume: The volume of liquid to be dispensed.
+        :param flow_rate: The flow rate to dispense with.
+        """
+        realmount = OT3Mount.from_mount(mount)
+        dispense_spec = self._pipette_handler.plan_check_dispense(
+            realmount, volume, flow_rate, push_out, is_full_dispense
+        )
+        if not dispense_spec:
+            return
+        target_pos = target_positions_from_plunger_tracking(
+            realmount,
+            dispense_spec.plunger_distance,
+            z_distance,
+            self._current_position,
+        )
+
+        try:
+            await self._backend.set_active_current(
+                {dispense_spec.axis: dispense_spec.current}
+            )
+            async with self.restore_system_constrants():
+                await self.set_system_constraints_for_plunger_acceleration(
+                    realmount, dispense_spec.acceleration
+                )
+                await self._move(
+                    target_pos,
+                    speed=dispense_spec.speed,
+                    home_flagged_axes=False,
+                )
+        except Exception:
+            self._log.exception("dispense failed")
+            dispense_spec.instr.set_current_volume(0)
+            raise
+        else:
+            dispense_spec.instr.remove_current_volume(dispense_spec.volume)
+
     @property
     def attached_subsystems(self) -> Dict[SubSystem, SubSystemState]:
         """Get a view of the state of the currently-attached subsystems."""
@@ -3010,3 +3132,11 @@ class OT3API(
 
     async def get_hepa_uv_state(self) -> Optional[HepaUVState]:
         return await self._backend.get_hepa_uv_state()
+
+    async def increase_evo_disp_count(
+        self,
+        mount: Union[top_types.Mount, OT3Mount],
+    ) -> None:
+        """Tell a pipette to increase its evo-tip-dispense-count in eeprom."""
+        realmount = OT3Mount.from_mount(mount)
+        await self._backend.increase_evo_disp_count(realmount)

opentrons/hardware_control/protocols/liquid_handler.py

@@ -2,7 +2,7 @@ from typing import Optional
 from typing_extensions import Protocol
 
 from opentrons.types import Point
-from opentrons.hardware_control.types import CriticalPoint
+from opentrons.hardware_control.types import CriticalPoint, TipScrapeType
 from .types import MountArgType, CalibrationType, ConfigType
 
 from .instrument_configurer import InstrumentConfigurer
@@ -98,6 +98,7 @@ class LiquidHandler(
         mount: MountArgType,
         volume: Optional[float] = None,
         rate: float = 1.0,
+        correction_volume: float = 0.0,
     ) -> None:
         """
         Aspirate a volume of liquid (in microliters/uL) using this pipette
@@ -117,6 +118,24 @@ class LiquidHandler(
         volume : [float] The number of microliters to aspirate
         rate : [float] Set plunger speed for this aspirate, where
             speed = rate * aspirate_speed
+        correction_volume : Correction volume in uL for the specified aspirate volume
+        """
+        ...
+
+    async def aspirate_while_tracking(
+        self,
+        mount: MountArgType,
+        z_distance: float,
+        volume: float,
+        flow_rate: float = 1.0,
+    ) -> None:
+        """
+        Aspirate a volume of liquid (in microliters/uL) while moving the z axis synchronously.
+
+        :param mount: A robot mount that the instrument is on.
+        :param z_distance: The distance the z axis will move during apsiration.
+        :param volume: The volume of liquid to be aspirated.
+        :param flow_rate: The flow rate to aspirate with.
         """
         ...
 
@@ -126,6 +145,8 @@ class LiquidHandler(
         volume: Optional[float] = None,
         rate: float = 1.0,
         push_out: Optional[float] = None,
+        correction_volume: float = 0.0,
+        is_full_dispense: bool = False,
     ) -> None:
         """
         Dispense a volume of liquid in microliters(uL) using this pipette
@@ -136,6 +157,26 @@ class LiquidHandler(
         volume : [float] The number of microliters to dispense
         rate : [float] Set plunger speed for this dispense, where
             speed = rate * dispense_speed
+        correction_volume : Correction volume in uL for the specified dispense volume
+        """
+        ...
+
+    async def dispense_while_tracking(
+        self,
+        mount: MountArgType,
+        z_distance: float,
+        volume: float,
+        push_out: Optional[float],
+        flow_rate: float = 1.0,
+        is_full_dispense: bool = False,
+    ) -> None:
+        """
+        Dispense a volume of liquid (in microliters/uL) while moving the z axis synchronously.
+
+        :param mount: A robot mount that the instrument is on.
+        :param z_distance: The distance the z axis will move during dispensing.
+        :param volume: The volume of liquid to be dispensed.
+        :param flow_rate: The flow rate to dispense with.
         """
         ...
 
@@ -187,6 +228,7 @@ class LiquidHandler(
         mount: MountArgType,
         home_after: bool = True,
         ignore_plunger: bool = False,
+        scrape_type: TipScrapeType = TipScrapeType.NONE,
     ) -> None:
         ...
 
@@ -218,3 +260,7 @@ class LiquidHandler(
         max_z_dist : maximum depth to probe for liquid
         """
         ...
+
+    async def increase_evo_disp_count(self, mount: MountArgType) -> None:
+        """Tell a pipette to increase it's evo-tip-dispense-count in eeprom."""
+        ...

opentrons/hardware_control/types.py

@@ -636,6 +636,12 @@ class InstrumentProbeType(enum.Enum):
     BOTH = enum.auto()
 
 
+class TipScrapeType(enum.Enum):
+    NONE = enum.auto()
+    RIGHT_ONE_COL = enum.auto()
+    LEFT_ONE_COL = enum.auto()
+
+
 class GripperProbe(enum.Enum):
     FRONT = enum.auto()
     REAR = enum.auto()