chore: internal-release->edge for 0.13.0

Author: sfoster1

api/release-notes-internal.md

@@ -20,11 +20,13 @@ For more details about this release, please see the full [technical change log][
 - The ODD should prompt you to update your pipettes when you attach one that needs it (!)
 - The 96 shouldn't fall down when you attach it now (!)
 - More little stall detection fixes
+- The ODD will now display a spinner until the robot server has started
+- Homing now goes to the limit switch then backs off until the limit switch is released
+- Support for PVT (v3.5) pipettes
 
 ## Big Things That Don't Work Yet So Don't Report Bugs About Them
 
 ### ODD
-- The ODD doesn't really tell you if the robot server hasn't started yet; if a robot looks on but has the name "opentrons", or says it's not network-connected when you know it is, probably the server isn't up yet, give it another little bit
 - It can take a while for the robot to start after installing an update (it's the firmware updates happening on boot). Allow 10 minutes after an update that has a firmware change.
 
 ### Robot Control
@@ -33,14 +35,15 @@ For more details about this release, please see the full [technical change log][
 
 ## Big Things That Do Work Please Do Report Bugs About Them
 ### Robot Control
-- Liquid handling protocols with 1 and 8 channel pipettes
+- Protocol behavior
 - Labware movement between slots/modules, both manual and with gripper, from python protocols
 - Labware drop/gripper crash errors, but they're very insensitive
 - Pipette and gripper automated offset calibration
 - Network connectivity and discoverability
 - Firmware update for all devices 
 - Cancelling a protocol run. We're even more sure we fixed this so definitely tell us if it's not.
 - USB connectivity
+- Stall detection firing basically ever unless you clearly ran into something
 
 ### ODD
 - Protocol execution including end-of-protocol screen

api/src/opentrons/hardware_control/backends/ot3controller.py

@@ -31,7 +31,7 @@
     create_move_group,
     axis_to_node,
     get_current_settings,
-    create_home_group,
+    create_home_groups,
     node_to_axis,
     sensor_node_for_mount,
     sensor_node_for_pipette,
@@ -40,6 +40,7 @@
     create_gripper_jaw_home_group,
     create_gripper_jaw_hold_group,
     create_tip_action_group,
+    create_tip_action_home_group,
     PipetteAction,
     motor_nodes,
     LIMIT_SWITCH_OVERTRAVEL_DISTANCE,
@@ -115,6 +116,7 @@
     AionotifyEvent,
     OT3Mount,
     OT3AxisMap,
+    OT3AxisKind,
     CurrentConfig,
     MotorStatus,
     InstrumentProbeType,
@@ -495,85 +497,69 @@ def _get_axis_home_distance(self, axis: Axis) -> float:
         else:
             return -1 * self.axis_bounds[axis][1] - self.axis_bounds[axis][0]
 
+    def _build_axes_home_groups(
+        self, axes: Sequence[Axis], speed_settings: Dict[OT3AxisKind, float]
+    ) -> List[MoveGroup]:
+        present_axes = [ax for ax in axes if self.axis_is_present(ax)]
+        if not present_axes:
+            return []
+        else:
+            distances = {ax: self._get_axis_home_distance(ax) for ax in present_axes}
+            velocities = {
+                ax: -1 * speed_settings[Axis.to_kind(ax)] for ax in present_axes
+            }
+            return create_home_groups(distances, velocities)
+
     def _build_home_pipettes_runner(
         self,
         axes: Sequence[Axis],
         gantry_load: GantryLoad,
     ) -> Optional[MoveGroupRunner]:
+        pipette_axes = [ax for ax in axes if ax in Axis.pipette_axes()]
+        if not pipette_axes:
+            return None
+
         speed_settings = self._configuration.motion_settings.max_speed_discontinuity[
             gantry_load
         ]
-
-        distances_pipette = {
-            ax: self._get_axis_home_distance(ax)
-            for ax in axes
-            if ax in Axis.pipette_axes()
-        }
-        velocities_pipette = {
-            ax: -1 * speed_settings[Axis.to_kind(ax)]
-            for ax in axes
-            if ax in Axis.pipette_axes()
-        }
-
-        move_group_pipette = []
-        if distances_pipette and velocities_pipette:
-            pipette_move = self._filter_move_group(
-                create_home_group(distances_pipette, velocities_pipette)
-            )
-            move_group_pipette.append(pipette_move)
-
-        if move_group_pipette:
-            return MoveGroupRunner(move_groups=move_group_pipette, start_at_index=2)
-        return None
+        move_groups: List[MoveGroup] = self._build_axes_home_groups(
+            pipette_axes, speed_settings
+        )
+        return MoveGroupRunner(move_groups=move_groups)
 
     def _build_home_gantry_z_runner(
         self,
         axes: Sequence[Axis],
         gantry_load: GantryLoad,
     ) -> Optional[MoveGroupRunner]:
+        gantry_axes = [ax for ax in axes if ax in Axis.gantry_axes()]
+        if not gantry_axes:
+            return None
+
         speed_settings = self._configuration.motion_settings.max_speed_discontinuity[
             gantry_load
         ]
 
-        distances_gantry = {
-            ax: self._get_axis_home_distance(ax)
-            for ax in axes
-            if ax in Axis.gantry_axes() and ax not in Axis.ot3_mount_axes()
-        }
-        velocities_gantry = {
-            ax: -1 * speed_settings[Axis.to_kind(ax)]
-            for ax in axes
-            if ax in Axis.gantry_axes() and ax not in Axis.ot3_mount_axes()
-        }
-        distances_z = {
-            ax: self._get_axis_home_distance(ax)
-            for ax in axes
-            if ax in Axis.ot3_mount_axes()
-        }
-        velocities_z = {
-            ax: -1 * speed_settings[Axis.to_kind(ax)]
-            for ax in axes
-            if ax in Axis.ot3_mount_axes()
-        }
-        move_group_gantry_z = []
-        if distances_z and velocities_z:
-            z_move = self._filter_move_group(
-                create_home_group(distances_z, velocities_z)
-            )
-            move_group_gantry_z.append(z_move)
-        if distances_gantry and velocities_gantry:
-            # home X axis before Y axis, to avoid collision with thermo-cycler lid
-            # that could be in the back-left corner
-            for ax in [Axis.X, Axis.Y]:
-                if ax in axes:
-                    gantry_move = self._filter_move_group(
-                        create_home_group(
-                            {ax: distances_gantry[ax]}, {ax: velocities_gantry[ax]}
-                        )
-                    )
-                    move_group_gantry_z.append(gantry_move)
-        if move_group_gantry_z:
-            return MoveGroupRunner(move_groups=move_group_gantry_z)
+        # first home all the present mount axes
+        z_axes = list(filter(lambda ax: ax in Axis.ot3_mount_axes(), gantry_axes))
+        z_groups = self._build_axes_home_groups(z_axes, speed_settings)
+
+        # home X axis before Y axis, to avoid collision with thermo-cycler lid
+        # that could be in the back-left corner
+        x_groups = (
+            self._build_axes_home_groups([Axis.X], speed_settings)
+            if Axis.X in gantry_axes
+            else []
+        )
+        y_groups = (
+            self._build_axes_home_groups([Axis.Y], speed_settings)
+            if Axis.Y in gantry_axes
+            else []
+        )
+
+        move_groups = [*z_groups, *x_groups, *y_groups]
+        if move_groups:
+            return MoveGroupRunner(move_groups=move_groups)
         return None
 
     @requires_update
@@ -619,18 +605,6 @@ async def home(
             self._handle_motor_status_response(position)
         return axis_convert(self._position, 0.0)
 
-    def _filter_move_group(self, move_group: MoveGroup) -> MoveGroup:
-        new_group: MoveGroup = []
-        for step in move_group:
-            new_group.append(
-                {
-                    node: axis_step
-                    for node, axis_step in step.items()
-                    if node in self._motor_nodes()
-                }
-            )
-        return new_group
-
     async def tip_action(
         self,
         axes: Sequence[Axis],
@@ -640,10 +614,17 @@ async def tip_action(
     ) -> None:
         if tip_action == "home":
             speed = speed * -1
-        move_group = create_tip_action_group(
-            axes, distance, speed, cast(PipetteAction, tip_action)
-        )
-        runner = MoveGroupRunner(move_groups=[move_group])
+            runner = MoveGroupRunner(
+                move_groups=create_tip_action_home_group(axes, distance, speed)
+            )
+        else:
+            runner = MoveGroupRunner(
+                move_groups=[
+                    create_tip_action_group(
+                        axes, distance, speed, cast(PipetteAction, tip_action)
+                    )
+                ]
+            )
         positions = await runner.run(can_messenger=self._messenger)
         for axis, point in positions.items():
             self._position.update({axis: point[0]})

api/src/opentrons/hardware_control/backends/ot3utils.py

@@ -1,6 +1,7 @@
 """Shared utilities for ot3 hardware control."""
 from typing import Dict, Iterable, List, Set, Tuple, TypeVar, Sequence, cast
 from typing_extensions import Literal
+from logging import getLogger
 from opentrons.config.defaults_ot3 import DEFAULT_CALIBRATION_AXIS_MAX_SPEED
 from opentrons.config.types import OT3MotionSettings, OT3CurrentSettings, GantryLoad
 from opentrons.hardware_control.types import (
@@ -46,12 +47,14 @@
     NodeIdMotionValues,
     create_home_step,
     create_backoff_step,
+    create_tip_action_backoff_step,
     MoveGroup,
     MoveType,
     MoveStopCondition,
     create_gripper_jaw_step,
     create_tip_action_step,
 )
+from opentrons_hardware.hardware_control.constants import interrupts_per_sec
 
 GRIPPER_JAW_HOME_TIME: float = 10
 GRIPPER_JAW_GRIP_TIME: float = 10
@@ -83,6 +86,8 @@
 
 USB_SUBSYSTEM = {target: subsystem for subsystem, target in SUBSYSTEM_USB.items()}
 
+LOG = getLogger(__name__)
+
 
 def axis_nodes() -> List["NodeId"]:
     return [
@@ -331,6 +336,11 @@ def create_move_group(
     for move in moves:
         unit_vector = move.unit_vector
         for block in move.blocks:
+            if block.time < (3.0 / interrupts_per_sec):
+                LOG.info(
+                    f"Skipping move block with time {block.time} (<{3.0/interrupts_per_sec})"
+                )
+                continue
             distances = unit_vector_multiplication(unit_vector, block.distance)
             node_id_distances = _convert_to_node_id_dict(distances)
             velocities = unit_vector_multiplication(unit_vector, block.initial_speed)
@@ -349,21 +359,39 @@ def create_move_group(
     return move_group, {k: float(v) for k, v in pos.items()}
 
 
-def create_home_group(
+def create_home_groups(
     distance: Dict[Axis, float], velocity: Dict[Axis, float]
-) -> MoveGroup:
+) -> List[MoveGroup]:
     node_id_distances = _convert_to_node_id_dict(distance)
     node_id_velocities = _convert_to_node_id_dict(velocity)
-    home = create_home_step(
-        distance=node_id_distances,
-        velocity=node_id_velocities,
-    )
+    home_group = [
+        create_home_step(distance=node_id_distances, velocity=node_id_velocities)
+    ]
     # halve the homing speed for backoff
     backoff_velocities = {k: v / 2 for k, v in node_id_velocities.items()}
-    backoff = create_backoff_step(backoff_velocities)
+    backoff_group = [create_backoff_step(backoff_velocities)]
+    return [home_group, backoff_group]
 
-    move_group: MoveGroup = [home, backoff]
-    return move_group
+
+def create_tip_action_home_group(
+    axes: Sequence[Axis], distance: float, velocity: float
+) -> List[MoveGroup]:
+    current_nodes = [axis_to_node(ax) for ax in axes]
+    home_group = [
+        create_tip_action_step(
+            velocity={node_id: np.float64(velocity) for node_id in current_nodes},
+            distance={node_id: np.float64(distance) for node_id in current_nodes},
+            present_nodes=current_nodes,
+            action=PipetteTipActionType.home,
+        )
+    ]
+
+    backoff_group = [
+        create_tip_action_backoff_step(
+            velocity={node_id: np.float64(velocity / 2) for node_id in current_nodes}
+        )
+    ]
+    return [home_group, backoff_group]
 
 
 def create_tip_action_group(

api/src/opentrons/hardware_control/instruments/ot3/gripper.py

@@ -3,7 +3,7 @@
 """ Classes and functions for gripper state tracking
 """
 import logging
-from typing import Any, Optional, Set, Dict
+from typing import Any, Optional, Set, Dict, Tuple
 
 from opentrons.types import Point
 from opentrons.config import gripper_config
@@ -237,7 +237,7 @@ def _reload_gripper(
     new_config: GripperDefinition,
     attached_instr: Gripper,
     cal_offset: GripperCalibrationOffset,
-) -> Gripper:
+) -> Tuple[Gripper, bool]:
     # Once we have determined that the new and attached grippers
     # are similar enough that we might skip, see if the configs
     # match closely enough.
@@ -247,7 +247,7 @@ def _reload_gripper(
         and cal_offset == attached_instr._calibration_offset
     ):
         # Same config, good enough
-        return attached_instr
+        return attached_instr, True
     else:
         newdict = new_config.dict()
         olddict = attached_instr.config.dict()
@@ -257,22 +257,25 @@ def _reload_gripper(
                 changed.add(k)
         if changed.intersection(RECONFIG_KEYS):
             # Something has changed that requires reconfig
-            return Gripper(
-                new_config,
-                cal_offset,
-                attached_instr._gripper_id,
+            return (
+                Gripper(
+                    new_config,
+                    cal_offset,
+                    attached_instr._gripper_id,
+                ),
+                False,
             )
         else:
             # update just the cal offset and update info
             attached_instr._calibration_offset = cal_offset
-            return attached_instr
+            return attached_instr, True
 
 
 def compare_gripper_config_and_check_skip(
     freshly_detected: AttachedGripper,
     attached: Optional[Gripper],
     cal_offset: GripperCalibrationOffset,
-) -> Optional[Gripper]:
+) -> Tuple[Optional[Gripper], bool]:
     """
     Given the gripper config for an attached gripper (if any) freshly read
     from disk, and any attached instruments,
@@ -288,7 +291,7 @@ def compare_gripper_config_and_check_skip(
     if not config and not attached:
         # nothing attached now, nothing used to be attached, nothing
         # to reconfigure
-        return attached
+        return attached, True
 
     if config and attached:
         # something was attached and something is attached. are they
@@ -298,6 +301,6 @@ def compare_gripper_config_and_check_skip(
             return _reload_gripper(config, attached, cal_offset)
 
     if config:
-        return Gripper(config, cal_offset, serial)
+        return Gripper(config, cal_offset, serial), False
     else:
-        return None
+        return None, False