opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__py3-none-any.whl

opentrons/hardware_control/ot3api.py

@@ -52,6 +52,7 @@ from opentrons_shared_data.errors.exceptions import (
     InvalidActuator,
     FirmwareUpdateFailedError,
     PipetteLiquidNotFoundError,
+    PipetteOverpressureError,
 )
 
 from .util import use_or_initialize_loop, check_motion_bounds
@@ -74,6 +75,8 @@ from .types import (
     DoorStateNotification,
     ErrorMessageNotification,
     HardwareEvent,
+    AsynchronousModuleErrorNotification,
+    ModuleDisconnectedNotification,
     HardwareEventHandler,
     HardwareAction,
     HepaFanState,
@@ -367,6 +370,24 @@ class OT3API(
 
         return futures
 
+    def _send_module_notification(self, event: HardwareEvent) -> None:
+        if not isinstance(
+            event,
+            (
+                AsynchronousModuleErrorNotification,
+                ModuleDisconnectedNotification,
+            ),
+        ):
+            return
+        mod_log.info(
+            f"Forwarding module event {event.event} for {event.module_model} {event.module_serial} at {event.port}"
+        )
+        for cb in self._callbacks:
+            try:
+                cb(event)
+            except Exception:
+                mod_log.exception("Errored during module asynchronous callback")
+
     def _reset_last_mount(self) -> None:
         self._last_moved_mount = None
 
@@ -422,7 +443,9 @@ class OT3API(
 
         await api_instance.set_status_bar_enabled(status_bar_enabled)
         module_controls = await AttachedModulesControl.build(
-            api_instance, board_revision=backend.board_revision
+            api_instance,
+            board_revision=backend.board_revision,
+            event_callback=api_instance._send_module_notification,
         )
         backend.module_controls = module_controls
         await backend.build_estop_detector()
@@ -484,7 +507,9 @@ class OT3API(
         )
         await api_instance.cache_instruments()
         module_controls = await AttachedModulesControl.build(
-            api_instance, board_revision=backend.board_revision
+            api_instance,
+            board_revision=backend.board_revision,
+            event_callback=api_instance._send_module_notification,
         )
         backend.module_controls = module_controls
         await backend.watch(api_instance.loop)
@@ -627,9 +652,10 @@ class OT3API(
             self.is_simulator
         ), "Cannot build simulating module from non-simulating hardware control API"
 
-        return await self._backend.module_controls.build_module(
-            port="",
-            usb_port=USBPort(name="", port_number=1, port_group=PortGroup.LEFT),
+        return await self._backend.module_controls.register_simulated_module(
+            simulated_usb_port=USBPort(
+                name="", port_number=1, port_group=PortGroup.LEFT
+            ),
             type=modules.ModuleType.from_model(model),
             sim_model=model.value,
         )
@@ -1499,6 +1525,7 @@ class OT3API(
         acquire_lock: bool = True,
         check_bounds: MotionChecks = MotionChecks.NONE,
         expect_stalls: bool = False,
+        delay: Optional[Tuple[List[Axis], float]] = None,
     ) -> None:
         """Worker function to apply robot motion."""
         machine_pos = machine_from_deck(
@@ -1532,6 +1559,7 @@ class OT3API(
                     machine_pos,
                     speed or 400.0,
                     HWStopCondition.stall if expect_stalls else HWStopCondition.none,
+                    delay=delay,
                 )
             except Exception:
                 self._log.exception("Move failed")
@@ -3057,9 +3085,11 @@ class OT3API(
     async def aspirate_while_tracking(
         self,
         mount: Union[top_types.Mount, OT3Mount],
-        z_distance: float,
+        end_point: top_types.Point,
         volume: float,
-        flow_rate: float = 1.0,
+        rate: float = 1.0,
+        movement_delay: Optional[float] = None,
+        end_critical_point: Optional[CriticalPoint] = None,
     ) -> None:
         """
         Aspirate a volume of liquid (in microliters/uL) while moving the z axis synchronously.
@@ -3067,19 +3097,35 @@ class OT3API(
         :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.
+        :param rate: The rate multiplier to aspirate with.
+        :param movement_delay: Time to wait after the pipette starts aspirating before x/y/z movement.
         """
         realmount = OT3Mount.from_mount(mount)
         aspirate_spec = self._pipette_handler.plan_check_aspirate(
-            realmount, volume, flow_rate
+            realmount, volume, rate
         )
         if not aspirate_spec:
             return
+        end_position = target_position_from_absolute(
+            realmount,
+            end_point,
+            partial(self.critical_point_for, cp_override=end_critical_point),
+            top_types.Point(*self._config.left_mount_offset),
+            top_types.Point(*self._config.right_mount_offset),
+            top_types.Point(*self._config.gripper_mount_offset),
+        )
+
         target_pos = target_positions_from_plunger_tracking(
             realmount,
             aspirate_spec.plunger_distance,
-            z_distance,
-            self._current_position,
+            end_position,
+        )
+
+        delay: Optional[Tuple[List[Axis], float]] = None
+        if movement_delay is not None:
+            delay = ([Axis.X, Axis.Y, Axis.Z_L, Axis.Z_R], movement_delay)
+        self._log.info(
+            f"aspirate_while_tracking: end at {end_point} {end_critical_point}, machine pos {end_position}, with plunger {target_pos}, delay {delay}"
         )
         try:
             await self._backend.set_active_current(
@@ -3093,7 +3139,13 @@ class OT3API(
                     target_pos,
                     speed=aspirate_spec.speed,
                     home_flagged_axes=False,
+                    delay=delay,
                 )
+        except PipetteOverpressureError:
+            self._log.exception("Aspirate failed with overpressure")
+            # refresh positions during an over pressure here so we know where the gantry stopped.
+            await self.refresh_positions()
+            raise
         except Exception:
             self._log.exception("Aspirate failed")
             aspirate_spec.instr.set_current_volume(0)
@@ -3104,11 +3156,13 @@ class OT3API(
     async def dispense_while_tracking(
         self,
         mount: Union[top_types.Mount, OT3Mount],
-        z_distance: float,
+        end_point: top_types.Point,
         volume: float,
         push_out: Optional[float],
-        flow_rate: float = 1.0,
+        rate: float = 1.0,
         is_full_dispense: bool = False,
+        movement_delay: Optional[float] = None,
+        end_critical_point: Optional[CriticalPoint] = None,
     ) -> None:
         """
         Dispense a volume of liquid (in microliters/uL) while moving the z axis synchronously.
@@ -3116,21 +3170,36 @@ class OT3API(
         :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.
+        :param rate: The rate multiplier to dispense with.
+        :param movement_delay: Time to wait after the pipette starts dispensing before x/y/z movement.
         """
         realmount = OT3Mount.from_mount(mount)
         dispense_spec = self._pipette_handler.plan_check_dispense(
-            realmount, volume, flow_rate, push_out, is_full_dispense
+            realmount, volume, rate, push_out, is_full_dispense
         )
         if not dispense_spec:
             return
+        end_position = target_position_from_absolute(
+            realmount,
+            end_point,
+            partial(self.critical_point_for, cp_override=end_critical_point),
+            top_types.Point(*self._config.left_mount_offset),
+            top_types.Point(*self._config.right_mount_offset),
+            top_types.Point(*self._config.gripper_mount_offset),
+        )
+
         target_pos = target_positions_from_plunger_tracking(
             realmount,
             dispense_spec.plunger_distance,
-            z_distance,
-            self._current_position,
+            end_position,
         )
 
+        delay: Optional[Tuple[List[Axis], float]] = None
+        if movement_delay is not None:
+            delay = ([Axis.X, Axis.Y, Axis.Z_L, Axis.Z_R], movement_delay)
+        self._log.info(
+            f"dispense_while_tracking: end at {end_point} {end_critical_point}, machine pos {end_position}, with plunger {target_pos}, delay {delay}"
+        )
         try:
             await self._backend.set_active_current(
                 {dispense_spec.axis: dispense_spec.current}
@@ -3143,7 +3212,13 @@ class OT3API(
                     target_pos,
                     speed=dispense_spec.speed,
                     home_flagged_axes=False,
+                    delay=delay,
                 )
+        except PipetteOverpressureError:
+            self._log.exception("Aspirate failed with overpressure")
+            # refresh positions during an over pressure here so we know where the gantry stopped.
+            await self.refresh_positions()
+            raise
         except Exception:
             self._log.exception("dispense failed")
             dispense_spec.instr.set_current_volume(0)

opentrons/hardware_control/poller.py

@@ -5,6 +5,7 @@ from abc import ABC, abstractmethod
 from typing import AsyncGenerator, List, Optional
 from opentrons.hardware_control.modules.errors import AbsorbanceReaderDisconnectedError
 from opentrons_shared_data.errors.exceptions import ModuleCommunicationError
+from opentrons.drivers.asyncio.communication.errors import SerialException
 
 
 log = logging.getLogger(__name__)
@@ -88,6 +89,18 @@ class Poller:
         except asyncio.InvalidStateError:
             log.warning("Poller waiter was already cancelled")
 
+    def _error_callback(self, exc: Exception) -> None:
+        try:
+            self._reader.on_error(exc)
+        except Exception:
+            log.exception("Exception in reader callback")
+
+    def _complete_all(
+        self, exc: Exception | None, previous: List["asyncio.Future[None]"]
+    ) -> None:
+        for waiter in previous:
+            Poller._set_waiter_complete(waiter, exc)
+
     async def _poll_once(self) -> None:
         """Trigger a single read, notifying listeners of success or error."""
         previous_waiters = self._poll_waiters
@@ -99,14 +112,15 @@ class Poller:
         except asyncio.CancelledError:
             raise
         except AbsorbanceReaderDisconnectedError as e:
-            for waiter in previous_waiters:
-                Poller._set_waiter_complete(waiter, None)
-            self._reader.on_error(e)
+            self._error_callback(e)
+            self._complete_all(e, previous_waiters)
+        except SerialException as se:
+            log.error(f"Polling gcode error: {se}")
+            self._error_callback(se)
+            self._complete_all(se, previous_waiters)
         except Exception as e:
             log.exception("Polling exception")
-            self._reader.on_error(e)
-            for waiter in previous_waiters:
-                Poller._set_waiter_complete(waiter, e)
+            self._error_callback(e)
+            self._complete_all(e, previous_waiters)
         else:
-            for waiter in previous_waiters:
-                Poller._set_waiter_complete(waiter)
+            self._complete_all(None, previous_waiters)

opentrons/hardware_control/protocols/liquid_handler.py

@@ -125,17 +125,21 @@ class LiquidHandler(
     async def aspirate_while_tracking(
         self,
         mount: MountArgType,
-        z_distance: float,
+        end_point: Point,
         volume: float,
         flow_rate: float = 1.0,
+        movement_delay: Optional[float] = None,
+        end_critical_point: Optional[CriticalPoint] = None,
     ) -> 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 end_point: The deck coordinate point to move the tip to during the aspirate.
         :param volume: The volume of liquid to be aspirated.
         :param flow_rate: The flow rate to aspirate with.
+        :param movement_delay: Time to wait after the pipette starts aspirating before x/y/z movement.
+        :param end_critical_point: The critical point for the end_point position.
         """
         ...
 
@@ -164,19 +168,23 @@ class LiquidHandler(
     async def dispense_while_tracking(
         self,
         mount: MountArgType,
-        z_distance: float,
+        end_point: Point,
         volume: float,
         push_out: Optional[float],
         flow_rate: float = 1.0,
         is_full_dispense: bool = False,
+        movement_delay: Optional[float] = None,
+        end_critical_point: Optional[CriticalPoint] = None,
     ) -> 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 end_point: The deck coordinate point to move the tip to during the dispense.
         :param volume: The volume of liquid to be dispensed.
         :param flow_rate: The flow rate to dispense with.
+        :param movement_delay: Time to wait after the pipette starts dispensing before x/y/z movement.
+        :param end_critical_point: The critical point for the end_point position.
         """
         ...
 

opentrons/hardware_control/scripts/update_module_fw.py

@@ -1,4 +1,5 @@
 """Module Firmware update script."""
+
 import argparse
 import asyncio
 from glob import glob
@@ -14,6 +15,7 @@ from opentrons.hardware_control import modules
 from opentrons.hardware_control.modules.mod_abc import AbstractModule
 from opentrons.hardware_control.modules.update import update_firmware
 from opentrons.hardware_control.types import BoardRevision
+from opentrons.hardware_control.execution_manager import ExecutionManager
 
 
 # Constants for checking if module is back online
@@ -84,6 +86,9 @@ async def build_module(
             port=port,
             usb_port=mod.usb_port,
             type=modules.MODULE_TYPE_BY_NAME[mod.name],
+            execution_manager=ExecutionManager(),
+            disconnected_callback=lambda *args: None,
+            error_callback=lambda *args: None,
             simulating=False,
             hw_control_loop=loop,
         )

opentrons/hardware_control/types.py

@@ -2,12 +2,26 @@ from asyncio import Queue
 import enum
 import logging
 from dataclasses import dataclass
-from typing import cast, Tuple, Union, List, Callable, Dict, TypeVar, Type
+from typing import (
+    cast,
+    Tuple,
+    Union,
+    List,
+    Callable,
+    Dict,
+    TypeVar,
+    Type,
+    TYPE_CHECKING,
+)
 from typing_extensions import Literal
 from opentrons import types as top_types
 from opentrons_shared_data.pipette.types import PipetteChannelType
+from opentrons_shared_data.errors.exceptions import EnumeratedError
 from opentrons.config import feature_flags
 
+if TYPE_CHECKING:
+    from .modules.types import ModuleModel
+
 MODULE_LOG = logging.getLogger(__name__)
 
 
@@ -384,6 +398,8 @@ class HardwareEventType(enum.Enum):
     DOOR_SWITCH_CHANGE = enum.auto()
     ERROR_MESSAGE = enum.auto()
     ESTOP_CHANGE = enum.auto()
+    ASYNCHRONOUS_MODULE_ERROR = enum.auto()
+    MODULE_DISCONNECTED = enum.auto()
 
 
 @dataclass
@@ -428,10 +444,35 @@ class ErrorMessageNotification:
     event: Literal[HardwareEventType.ERROR_MESSAGE] = HardwareEventType.ERROR_MESSAGE
 
 
+@dataclass(frozen=True)
+class AsynchronousModuleErrorNotification:
+    exception: EnumeratedError
+    module_serial: str | None
+    module_model: "ModuleModel"
+    port: str
+    event: Literal[
+        HardwareEventType.ASYNCHRONOUS_MODULE_ERROR
+    ] = HardwareEventType.ASYNCHRONOUS_MODULE_ERROR
+
+
+@dataclass(frozen=True)
+class ModuleDisconnectedNotification:
+    module_serial: str | None
+    module_model: "ModuleModel"
+    port: str
+    event: Literal[
+        HardwareEventType.MODULE_DISCONNECTED
+    ] = HardwareEventType.MODULE_DISCONNECTED
+
+
 # new event types get new dataclasses
 # when we add more event types we add them here
 HardwareEvent = Union[
-    DoorStateNotification, ErrorMessageNotification, EstopStateNotification
+    DoorStateNotification,
+    ErrorMessageNotification,
+    EstopStateNotification,
+    AsynchronousModuleErrorNotification,
+    ModuleDisconnectedNotification,
 ]
 
 HardwareEventHandler = Callable[[HardwareEvent], None]

opentrons/legacy_commands/commands.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, List, Sequence, Union, overload
+from typing import TYPE_CHECKING, List, Sequence, Union, overload, Optional
 
 
 from .helpers import (
@@ -31,10 +31,21 @@ def aspirate(
     location: Location,
     flow_rate: float,
     rate: float,
+    end_location: Optional[Location],
 ) -> command_types.AspirateCommand:
     location_text = stringify_location(location)
-    template = "Aspirating {volume} uL from {location} at {flow} uL/sec"
-    text = template.format(volume=float(volume), location=location_text, flow=flow_rate)
+    end_location_text = (
+        f" while moving to {stringify_location(end_location)}"
+        if end_location is not None
+        else ""
+    )
+    template = "Aspirating {volume} uL from {location} at {flow} uL/sec{end}"
+    text = template.format(
+        volume=float(volume),
+        location=location_text,
+        flow=flow_rate,
+        end=end_location_text,
+    )
 
     return {
         "name": command_types.ASPIRATE,
@@ -44,6 +55,7 @@ def aspirate(
             "location": location,
             "rate": rate,
             "text": text,
+            "end_location": end_location,
         },
     }
 
@@ -54,10 +66,21 @@ def dispense(
     location: Location,
     flow_rate: float,
     rate: float,
+    end_location: Optional[Location],
 ) -> command_types.DispenseCommand:
     location_text = stringify_location(location)
-    template = "Dispensing {volume} uL into {location} at {flow} uL/sec"
-    text = template.format(volume=float(volume), location=location_text, flow=flow_rate)
+    end_location_text = (
+        f" while moving to {stringify_location(end_location)}"
+        if end_location is not None
+        else ""
+    )
+    template = "Dispensing {volume} uL into {location} at {flow} uL/sec{end}"
+    text = template.format(
+        volume=float(volume),
+        location=location_text,
+        flow=flow_rate,
+        end=end_location_text,
+    )
 
     return {
         "name": command_types.DISPENSE,
@@ -67,6 +90,7 @@ def dispense(
             "location": location,
             "rate": rate,
             "text": text,
+            "end_location": end_location,
         },
     }
 
@@ -208,6 +232,35 @@ def mix(
     }
 
 
+def dynamic_mix(
+    instrument: InstrumentContext,
+    repetitions: int,
+    volume: float,
+    aspirate_start_location: Location,
+    aspirate_end_location: Union[Location, None],
+    dispense_start_location: Location,
+    dispense_end_location: Union[Location, None],
+    movement_delay: float,
+) -> command_types.DynamicMixCommand:
+    text = "Dynamically mixing {repetitions} times with a volume of {volume} ul".format(
+        repetitions=repetitions, volume=float(volume)
+    )
+    return {
+        "name": command_types.MIX,
+        "payload": {
+            "instrument": instrument,
+            "aspirate_start_location": aspirate_start_location,
+            "aspirate_end_location": aspirate_end_location,
+            "dispense_start_location": dispense_start_location,
+            "dispense_end_location": dispense_end_location,
+            "volume": volume,
+            "repetitions": repetitions,
+            "text": text,
+            "movement_delay": movement_delay,
+        },
+    }
+
+
 def blow_out(
     instrument: InstrumentContext, location: Location
 ) -> command_types.BlowOutCommand:

opentrons/legacy_commands/module_commands.py

@@ -89,6 +89,24 @@ def thermocycler_set_block_temp(
     }
 
 
+def thermocycler_start_set_block_temp(
+    temperature: float,
+) -> command_types.ThermocyclerStartSetBlockTempCommand:
+    temp = round(float(temperature), utils.TC_GCODE_ROUNDING_PRECISION)
+    text = f"Starting to set Thermocycler well block temperature to {temp} °C"
+    # TODO: BC 2019-09-05 this time resolving logic is partially duplicated
+    # in the thermocycler api class definition, with this command logger
+    # implementation, there isn't a great way to avoid this, but it should
+    # be consolidated as soon as an alternative to the publisher is settled on.
+    return {
+        "name": command_types.THERMOCYCLER_START_SET_BLOCK_TEMP,
+        "payload": {
+            "temperature": temperature,
+            "text": text,
+        },
+    }
+
+
 def thermocycler_execute_profile(
     steps: List[ThermocyclerStep], repetitions: int
 ) -> command_types.ThermocyclerExecuteProfileCommand:
@@ -102,6 +120,19 @@ def thermocycler_execute_profile(
     }
 
 
+def thermocycler_start_execute_profile(
+    steps: List[ThermocyclerStep], repetitions: int
+) -> command_types.ThermocyclerStartExecuteProfileCommand:
+    text = (
+        f"In the background, thermocycler starting to run {repetitions} repetitions "
+        f" of cycle composed of the following steps: {steps}"
+    )
+    return {
+        "name": command_types.THERMOCYCLER_START_EXECUTE_PROFILE,
+        "payload": {"text": text, "steps": steps},
+    }
+
+
 def thermocycler_wait_for_hold() -> command_types.ThermocyclerWaitForHoldCommand:
     text = "Waiting for hold time duration"
     return {"name": command_types.THERMOCYCLER_WAIT_FOR_HOLD, "payload": {"text": text}}
@@ -120,6 +151,17 @@ def thermocycler_set_lid_temperature(
     return {"name": command_types.THERMOCYCLER_SET_LID_TEMP, "payload": {"text": text}}
 
 
+def thermocycler_start_set_lid_temperature(
+    temperature: float,
+) -> command_types.ThermocyclerStartSetLidTempCommand:
+    temp = round(float(temperature), utils.TC_GCODE_ROUNDING_PRECISION)
+    text = f"Starting to set Thermocycler lid temperature to {temp} °C"
+    return {
+        "name": command_types.THERMOCYCLER_START_SET_LID_TEMP,
+        "payload": {"text": text},
+    }
+
+
 def thermocycler_deactivate_lid() -> command_types.ThermocyclerDeactivateLidCommand:
     text = "Deactivating Thermocycler lid heating"
     return {
@@ -183,6 +225,16 @@ def heater_shaker_set_and_wait_for_shake_speed(
     }
 
 
+def heater_shaker_set_shake_speed(
+    rpm: int,
+) -> command_types.HeaterShakerSetShakeSpeedCommand:
+    text = f"Setting Heater-Shaker to Shake at {rpm} RPM"
+    return {
+        "name": command_types.HEATER_SHAKER_SET_SHAKE_SPEED,
+        "payload": {"text": text},
+    }
+
+
 def heater_shaker_open_labware_latch() -> command_types.HeaterShakerOpenLabwareLatchCommand:
     text = "Unlatching labware on Heater-Shaker"
     return {

opentrons/legacy_commands/protocol_commands.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
-from typing import Optional
+from typing import Optional, Tuple
 from . import types as command_types
+from opentrons.protocol_api.tasks import Task
 
 
 def comment(msg: str) -> command_types.CommentCommand:
@@ -52,3 +53,54 @@ def move_labware(text: str) -> command_types.MoveLabwareCommand:
         "name": command_types.MOVE_LABWARE,
         "payload": {"text": text},
     }
+
+
+def capture_image(
+    resolution: Optional[Tuple[int, int]],
+    zoom: Optional[float],
+    contrast: Optional[float],
+    brightness: Optional[float],
+    saturation: Optional[float],
+) -> command_types.CaptureImageCommand:
+    text = "Capturing an image"
+    if resolution:
+        text += f" with resolution {resolution[0]}x{resolution[1]}"
+    if zoom:
+        text += f" zoom of {zoom}X"
+    if contrast:
+        text += f" contrast of {contrast}%"
+    if brightness:
+        text += f" brightness of {brightness}%"
+    if saturation:
+        text += f" saturation of {saturation}%"
+    text += "."
+    return {
+        "name": command_types.CAPTURE_IMAGE,
+        "payload": {
+            "text": text,
+            "resolution": resolution,
+            "zoom": zoom,
+            "contrast": contrast,
+            "brightness": brightness,
+            "saturation": saturation,
+        },
+    }
+
+
+def wait_for_tasks(tasks: list[Task]) -> command_types.WaitForTasksCommand:
+    task_ids = [task.created_at.strftime("%Y-%m-%d %H:%M:%S") for task in tasks]
+    msg = f"Waiting for tasks that started at: {task_ids}."
+    return {
+        "name": command_types.WAIT_FOR_TASKS,
+        "payload": {"text": msg},
+    }
+
+
+def create_timer(seconds: float) -> command_types.CreateTimerCommand:
+    return {
+        "name": command_types.CREATE_TIMER,
+        "payload": {
+            "text": f"Creating background timer for {seconds} seconds.",
+            "time": seconds,
+        },
+    }