opentrons 8.7.0a7__py3-none-any.whl → 8.8.0a7__py3-none-any.whl

opentrons/hardware_control/backends/ot3controller.py

@@ -49,6 +49,7 @@ from .ot3utils import (
     gripper_jaw_state_from_fw,
     get_system_constraints,
     get_system_constraints_for_plunger_acceleration,
+    add_delay_to_move_group,
 )
 from .tip_presence_manager import TipPresenceManager
 
@@ -657,11 +658,17 @@ class OT3Controller(FlexBackend):
         speed: float,
         stop_condition: HWStopCondition,
         nodes_in_moves_only: bool,
+        delay: Optional[Tuple[List[Axis], float]] = None,
     ) -> Tuple[Optional[MoveGroupRunner], bool]:
         if not target:
             return None, False
-        move_target = MoveTarget.build(position=target, max_speed=speed)
+        # Create a target that doesn't incorporate the plunger into a joint axis with the gantry
+        plunger_axes = [Axis.P_L, Axis.P_R]
+
         try:
+            move_target = self._move_manager.devectorize_axes(
+                origin, target, speed, plunger_axes
+            )
             _, movelist = self._move_manager.plan_motion(
                 origin=origin, target_list=[move_target]
             )
@@ -683,6 +690,28 @@ class OT3Controller(FlexBackend):
         move_group, _ = create_move_group(
             origin, moves, ordered_nodes, MoveStopCondition[stop_condition.name]
         )
+
+        if delay is not None:
+            delay_axes, delay_time = delay
+            delay_nodes = [axis_to_node(ax) for ax in delay_axes]
+            move_group = add_delay_to_move_group(
+                move_group, ordered_nodes, (delay_nodes, delay_time)
+            )
+
+        (
+            plunger_slowed,
+            error_str,
+        ) = self._move_manager.ensure_pipette_flow_rate_unchanged(
+            [node_to_axis(node) for node in ordered_nodes],
+            origin,
+            target,
+            speed,
+            move_group,
+            [(ax, axis_to_node(ax)) for ax in plunger_axes],
+        )
+        if plunger_slowed:
+            log.error(error_str)
+
         return (
             MoveGroupRunner(
                 move_groups=[move_group],
@@ -728,6 +757,7 @@ class OT3Controller(FlexBackend):
         speed: float,
         stop_condition: HWStopCondition = HWStopCondition.none,
         nodes_in_moves_only: bool = True,
+        delay: Optional[Tuple[List[Axis], float]] = None,
     ) -> None:
         """Move to a position.
 
@@ -750,7 +780,7 @@ class OT3Controller(FlexBackend):
 
         maybe_runners = (
             self._build_move_node_axis_runner(
-                origin, target, speed, stop_condition, nodes_in_moves_only
+                origin, target, speed, stop_condition, nodes_in_moves_only, delay
             ),
             self._build_move_gear_axis_runner(
                 possible_q_axis_origin,
@@ -1766,6 +1796,7 @@ class OT3Controller(FlexBackend):
         max_allowed_grip_error: float,
         hard_limit_lower: float,
         hard_limit_upper: float,
+        disable_geometry_grip_check: bool = False,
     ) -> None:
         """
         Check if the gripper is at the expected location.
@@ -1808,6 +1839,7 @@ class OT3Controller(FlexBackend):
         if (
             current_gripper_position - expected_gripper_position_min
             < -max_allowed_grip_error
+            and not disable_geometry_grip_check
         ):
             raise FailedGripperPickupError(
                 message="Failed to grip: jaws closed too far",
@@ -1821,6 +1853,7 @@ class OT3Controller(FlexBackend):
         if (
             current_gripper_position - expected_gripper_position_max
             > max_allowed_grip_error
+            and not disable_geometry_grip_check
         ):
             raise FailedGripperPickupError(
                 message="Failed to grip: jaws could not close far enough",

opentrons/hardware_control/backends/ot3simulator.py

@@ -367,6 +367,7 @@ class OT3Simulator(FlexBackend):
         speed: Optional[float] = None,
         stop_condition: HWStopCondition = HWStopCondition.none,
         nodes_in_moves_only: bool = True,
+        delay: Optional[Tuple[List[Axis], float]] = None,
     ) -> None:
         """Move to a position.
 
@@ -849,6 +850,7 @@ class OT3Simulator(FlexBackend):
         max_allowed_grip_error: float,
         hard_limit_lower: float,
         hard_limit_upper: float,
+        disable_geometry_grip_check: bool = False,
     ) -> None:
         # This is a (pretty bad) simulation of the gripper actually gripping something,
         # but it should work.

opentrons/hardware_control/backends/ot3utils.py

@@ -1,4 +1,5 @@
 """Shared utilities for ot3 hardware control."""
+import copy
 from typing import Dict, Iterable, List, Set, Tuple, TypeVar, cast, Sequence, Optional
 from typing_extensions import Literal
 from logging import getLogger
@@ -57,6 +58,8 @@ from opentrons_hardware.hardware_control.motion import (
     MoveStopCondition,
     create_gripper_jaw_step,
     create_tip_action_step,
+    SingleMoveStep,
+    MoveGroupSingleAxisStep,
 )
 from opentrons_hardware.hardware_control.constants import interrupts_per_sec
 
@@ -376,6 +379,40 @@ def motor_nodes(devices: Set[FirmwareTarget]) -> Set[NodeId]:
     return {NodeId(target) for target in motor_nodes if target in NodeId}
 
 
+def add_delay_to_move_group(
+    group: MoveGroup,
+    present_nodes: Iterable[NodeId],
+    delay: Tuple[List[NodeId], float],
+) -> MoveGroup:
+    delay_nodes, delay_time = delay
+    if delay_time == 0.0:
+        return group
+
+    as_single_moves: Dict[NodeId, List[SingleMoveStep]] = {}
+    for node in present_nodes:
+        as_single_moves[node] = [step[node] for step in group]
+
+    delay_step = MoveGroupSingleAxisStep(
+        distance_mm=np.float64(0),
+        velocity_mm_sec=np.float64(0),
+        duration_sec=np.float64(delay_time),
+    )
+    for node in present_nodes:
+        if node in delay_nodes:
+            # Add the delay at the beginning
+            as_single_moves[node] = [copy.deepcopy(delay_step)] + as_single_moves[node]
+        else:
+            # Add the delay at the end.
+            as_single_moves[node] = as_single_moves[node] + [copy.deepcopy(delay_step)]
+
+    new_move_group: MoveGroup = []
+    for i in range(len(group) + 1):
+        new_move_group.append(
+            {node: as_single_moves[node][i] for node in present_nodes}
+        )
+    return new_move_group
+
+
 def create_move_group(
     origin: Coordinates[Axis, CoordinateValue],
     moves: List[Move[Axis]],

opentrons/hardware_control/module_control.py

@@ -30,6 +30,7 @@ from .types import (
     StatusBarUpdateEvent,
     HardwareEvent,
     AsynchronousModuleErrorNotification,
+    ModuleDisconnectedNotification,
 )
 from . import modules
 
@@ -164,13 +165,28 @@ class AttachedModulesControl:
         self.subscribe_to_api_event(mod)
         return mod
 
-    def _disconnected_callback(self, port: str, serial: Optional[str]) -> None:
+    def _disconnected_callback(
+        self, model: str, port: str, serial: Optional[str]
+    ) -> None:
         """Used by the module to indicate that it was disconnected and should be deleted."""
         mod = ModuleAtPort(port=port, serial=serial, name="")
         asyncio.run_coroutine_threadsafe(
             self.unregister_modules([mod]),
             self._api.loop,
         )
+        try:
+            self._api.loop.call_soon(
+                self._event_callback,
+                ModuleDisconnectedNotification(
+                    module_serial=serial,
+                    module_model=modules.module_model_from_string(model),
+                    port=port,
+                ),
+            )
+        except Exception:
+            log.exception(
+                f"Module disconnect callback for module {model} {serial} at {port} failed"
+            )
 
     def _async_error_callback(
         self,
@@ -218,10 +234,15 @@ class AttachedModulesControl:
         for removed_mod in removed_modules:
             try:
                 self._available_modules.remove(removed_mod)
+                # Important: this wants to be after the remove because this may trigger
+                # recursion back to here; we therefore want the module to already be
+                # removed so that the recursion terminates next loop
+                removed_mod.disconnected_callback()
             except ValueError:
-                log.exception(
+                log.warning(
                     f"Removed Module {removed_mod} not found in attached modules"
                 )
+
         for removed_mod in removed_modules:
             log.info(
                 f"Module {removed_mod.name()} detached from port {removed_mod.port}"

opentrons/hardware_control/modules/mod_abc.py

@@ -105,7 +105,7 @@ class AbstractModule(abc.ABC):
     def disconnected_callback(self) -> None:
         """Called from within the module object to signify the object is no longer connected"""
         if self._disconnected_callback is not None:
-            self._disconnected_callback(self.port, self.serial_number)
+            self._disconnected_callback(self.model(), self.port, self.serial_number)
 
     def error_callback(self, exc: Exception) -> None:
         """Called from within the module object when an asynchronous hardware error occurrs."""

opentrons/hardware_control/modules/types.py

@@ -59,7 +59,7 @@ UploadFunction = Callable[[str, str, Dict[str, Any]], Awaitable[Tuple[bool, str]
 class ModuleDisconnectedCallback(Protocol):
     """Protocol for the callback when the module should be disconnected."""
 
-    def __call__(self, port: str, serial: str | None) -> None:
+    def __call__(self, model: str, port: str, serial: str | None) -> None:
         ...
 
 

opentrons/hardware_control/motion_utilities.py

@@ -195,8 +195,7 @@ def target_position_from_plunger(
 def target_positions_from_plunger_tracking(
     mount: Union[Mount, OT3Mount],
     plunger_delta: float,
-    z_delta: float,
-    current_position: Dict[Axis, float],
+    end_position: OrderedDict[Axis, float],
 ) -> "OrderedDict[Axis, float]":
     """Create a target position for machine axes including plungers for dynamic liquid tracking.
 
@@ -206,10 +205,11 @@ def target_positions_from_plunger_tracking(
     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
+    plunger_pos = OrderedDict()
+    plunger = Axis.of_main_tool_actuator(mount)
+    plunger_pos[plunger] = plunger_delta
+    end_position.update(plunger_pos)
+    return end_position
 
 
 def deck_point_from_machine_point(

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
@@ -75,6 +76,7 @@ from .types import (
     ErrorMessageNotification,
     HardwareEvent,
     AsynchronousModuleErrorNotification,
+    ModuleDisconnectedNotification,
     HardwareEventHandler,
     HardwareAction,
     HepaFanState,
@@ -371,7 +373,10 @@ class OT3API(
     def _send_module_notification(self, event: HardwareEvent) -> None:
         if not isinstance(
             event,
-            AsynchronousModuleErrorNotification,
+            (
+                AsynchronousModuleErrorNotification,
+                ModuleDisconnectedNotification,
+            ),
         ):
             return
         mod_log.info(
@@ -1483,6 +1488,7 @@ class OT3API(
         expected_grip_width: float,
         grip_width_uncertainty_wider: float,
         grip_width_uncertainty_narrower: float,
+        disable_geometry_grip_check: bool = False,
     ) -> None:
         """Ensure that a gripper pickup succeeded.
 
@@ -1503,6 +1509,7 @@ class OT3API(
             gripper.max_allowed_grip_error,
             gripper.min_jaw_width,
             gripper.max_jaw_width,
+            disable_geometry_grip_check,
         )
 
     def gripper_jaw_can_home(self) -> bool:
@@ -1518,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(
@@ -1551,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")
@@ -3076,9 +3085,10 @@ 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,
     ) -> None:
         """
         Aspirate a volume of liquid (in microliters/uL) while moving the z axis synchronously.
@@ -3086,20 +3096,33 @@ 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,
+            self.critical_point_for,
+            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)
         try:
             await self._backend.set_active_current(
                 {aspirate_spec.axis: aspirate_spec.current}
@@ -3112,7 +3135,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)
@@ -3123,11 +3152,12 @@ 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,
     ) -> None:
         """
         Dispense a volume of liquid (in microliters/uL) while moving the z axis synchronously.
@@ -3135,21 +3165,34 @@ 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,
+            self.critical_point_for,
+            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)
+
         try:
             await self._backend.set_active_current(
                 {dispense_spec.axis: dispense_spec.current}
@@ -3162,7 +3205,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/protocols/gripper_controller.py

@@ -41,6 +41,7 @@ class GripperController(Protocol):
         expected_grip_width: float,
         grip_width_uncertainty_wider: float,
         grip_width_uncertainty_narrower: float,
+        disable_geometry_grip_check: bool = False,
     ) -> None:
         """Ensure that a gripper pickup succeeded."""
 

opentrons/hardware_control/protocols/liquid_handler.py

@@ -125,9 +125,10 @@ 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,
     ) -> None:
         """
         Aspirate a volume of liquid (in microliters/uL) while moving the z axis synchronously.
@@ -136,6 +137,7 @@ class LiquidHandler(
         :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 movement_delay: Time to wait after the pipette starts aspirating before x/y/z movement.
         """
         ...
 
@@ -164,11 +166,12 @@ 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,
     ) -> None:
         """
         Dispense a volume of liquid (in microliters/uL) while moving the z axis synchronously.
@@ -177,6 +180,7 @@ class LiquidHandler(
         :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 movement_delay: Time to wait after the pipette starts dispensing before x/y/z movement.
         """
         ...
 

opentrons/hardware_control/types.py

@@ -399,6 +399,7 @@ class HardwareEventType(enum.Enum):
     ERROR_MESSAGE = enum.auto()
     ESTOP_CHANGE = enum.auto()
     ASYNCHRONOUS_MODULE_ERROR = enum.auto()
+    MODULE_DISCONNECTED = enum.auto()
 
 
 @dataclass
@@ -454,6 +455,16 @@ class AsynchronousModuleErrorNotification:
     ] = 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[
@@ -461,6 +472,7 @@ HardwareEvent = Union[
     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: