feat(api): Speed up instrument calibration (#18469)

<!--
Thanks for taking the time to open a Pull Request (PR)! Please make sure
you've read the "Opening Pull Requests" section of our Contributing
Guide:


https://github.com/Opentrons/opentrons/blob/edge/CONTRIBUTING.md#opening-pull-requests

GitHub provides robust markdown to format your PR. Links, diagrams,
pictures, and videos along with text formatting make it possible to
create a rich and informative PR. For more information on GitHub
markdown, see:


https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax

To ensure your code is reviewed quickly and thoroughly, please fill out
the sections below to the best of your ability!
-->

# Overview

So previously we were limiting the gantry speed for the calibration
process. This was a remnant of when we were considering doing a x/y
capacitive sweep instead of a z probe. This however does not give us
anything and just slows down the process.

Additionally we probe all 4 edges to account for any error, however we
also probe quite a large bounds on each edge. To preserve the ability to
overcome the same level of positional error I made it so that the first
x and the first y edges still use the older, larger sweeping region with
the same number of strides, however once we have a good idea of where
the first ones are we don't have to sweep such a large area for the
second two, so I reduced the starting stride distance and the number of
probes required for this.

All of this together the time to calibrate the pipette changed from
~2:10 from hitting go until the time it tells you to take off the probe
to 1:45.

The gripper also has benefits going from about ~4:10  to ~3:25
<!--
Describe your PR at a high level. State acceptance criteria and how this
PR fits into other work. Link issues, PRs, and other relevant resources.
-->

## Test Plan and Hands on Testing

<!--
Describe your testing of the PR. Emphasize testing not reflected in the
code. Attach protocols, logs, screenshots and any other assets that
support your testing.
-->

## Changelog

<!--
List changes introduced by this PR considering future developers and the
end user. Give careful thought and clear documentation to breaking
changes.
-->

## Review requests

<!--
- What do you need from reviewers to feel confident this PR is ready to
merge?
- Ask questions.
-->

## Risk assessment

<!--
- Indicate the level of attention this PR needs.
- Provide context to guide reviewers.
- Discuss trade-offs, coupling, and side effects.
- Look for the possibility, even if you think it's small, that your
change may affect some other part of the system.
- For instance, changing return tip behavior may also change the
behavior of labware calibration.
- How do your unit tests and on hands on testing mitigate this PR's
risks and the risk of future regressions?
- Especially in high risk PRs, explain how you know your testing is
enough.
-->

Author: ryanthecoder

api/src/opentrons/config/defaults_ot3.py

@@ -74,7 +74,6 @@
 DEFAULT_RIGHT_MOUNT_OFFSET: Final[Offset] = (40.5, -60.5, 255.675)
 DEFAULT_GRIPPER_MOUNT_OFFSET: Final[Offset] = (84.55, -12.75, 93.85)
 DEFAULT_SAFE_HOME_DISTANCE: Final = 5
-DEFAULT_CALIBRATION_AXIS_MAX_SPEED: Final = 30
 DEFAULT_EMULSIFYING_PIPETTE_AXIS_MAX_SPEED: Final = 90
 
 DEFAULT_MAX_SPEEDS: Final[ByGantryLoad[Dict[OT3AxisKind, float]]] = ByGantryLoad(

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

@@ -73,12 +73,6 @@ def get_pressure_sensor_available(self, pipette_axis: Axis) -> bool:
     def update_constraints_for_gantry_load(self, gantry_load: GantryLoad) -> None:
         ...
 
-    def update_constraints_for_calibration_with_gantry_load(
-        self,
-        gantry_load: GantryLoad,
-    ) -> None:
-        ...
-
     def update_constraints_for_plunger_acceleration(
         self,
         mount: OT3Mount,

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

@@ -48,7 +48,6 @@
     moving_pipettes_in_move_group,
     gripper_jaw_state_from_fw,
     get_system_constraints,
-    get_system_constraints_for_calibration,
     get_system_constraints_for_plunger_acceleration,
 )
 from .tip_presence_manager import TipPresenceManager
@@ -409,19 +408,6 @@ def get_pressure_sensor_available(self, pipette_axis: Axis) -> bool:
         pip_node = axis_to_node(pipette_axis)
         return self._pressure_sensor_available[pip_node]
 
-    def update_constraints_for_calibration_with_gantry_load(
-        self,
-        gantry_load: GantryLoad,
-    ) -> None:
-        self._move_manager.update_constraints(
-            get_system_constraints_for_calibration(
-                self._configuration.motion_settings, gantry_load
-            )
-        )
-        log.debug(
-            f"Set system constraints for calibration: {self._move_manager.get_constraints()}"
-        )
-
     def update_constraints_for_gantry_load(self, gantry_load: GantryLoad) -> None:
         self._move_manager.update_constraints(
             get_system_constraints(self._configuration.motion_settings, gantry_load)

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

@@ -230,12 +230,6 @@ async def restore_system_constraints(self) -> AsyncIterator[None]:
     def update_constraints_for_gantry_load(self, gantry_load: GantryLoad) -> None:
         self._sim_gantry_load = gantry_load
 
-    def update_constraints_for_calibration_with_gantry_load(
-        self,
-        gantry_load: GantryLoad,
-    ) -> None:
-        self._sim_gantry_load = gantry_load
-
     def update_constraints_for_plunger_acceleration(
         self,
         mount: OT3Mount,

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

@@ -3,7 +3,6 @@
 from typing_extensions import Literal
 from logging import getLogger
 from opentrons.config.defaults_ot3 import (
-    DEFAULT_CALIBRATION_AXIS_MAX_SPEED,
     DEFAULT_EMULSIFYING_PIPETTE_AXIS_MAX_SPEED,
 )
 from opentrons.config.types import OT3MotionSettings, OT3CurrentSettings, GantryLoad
@@ -256,29 +255,6 @@ def get_system_constraints(
     return constraints
 
 
-def get_system_constraints_for_calibration(
-    config: OT3MotionSettings,
-    gantry_load: GantryLoad,
-) -> "SystemConstraints[Axis]":
-    conf_by_pip = config.by_gantry_load(gantry_load)
-    constraints = {}
-    for axis_kind in [
-        OT3AxisKind.P,
-        OT3AxisKind.X,
-        OT3AxisKind.Y,
-        OT3AxisKind.Z,
-        OT3AxisKind.Z_G,
-    ]:
-        for axis in Axis.of_kind(axis_kind):
-            constraints[axis] = AxisConstraints.build(
-                conf_by_pip["acceleration"][axis_kind],
-                conf_by_pip["max_speed_discontinuity"][axis_kind],
-                conf_by_pip["direction_change_speed_discontinuity"][axis_kind],
-                DEFAULT_CALIBRATION_AXIS_MAX_SPEED,
-            )
-    return constraints
-
-
 def get_system_constraints_for_plunger_acceleration(
     config: OT3MotionSettings,
     gantry_load: GantryLoad,

api/src/opentrons/hardware_control/ot3_calibration.py

@@ -1,7 +1,7 @@
 """Functions and utilites for OT3 calibration."""
 from __future__ import annotations
 from functools import lru_cache
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing_extensions import Final, Literal, TYPE_CHECKING
 from typing import Tuple, List, Dict, Any, Optional, Union
 import datetime
@@ -181,6 +181,7 @@ async def find_edge_binary(
     mount: OT3Mount,
     slot_edge_nominal: Point,
     search_axis: Union[Literal[Axis.X, Axis.Y]],
+    edge_settings: EdgeSenseSettings,
     direction_if_hit: Literal[1, -1],
     raise_verify_error: bool = True,
     probe: InstrumentProbeType = InstrumentProbeType.PRIMARY,
@@ -209,7 +210,6 @@ async def find_edge_binary(
     The absolute position at which the center of the effector is inside the slot
     and its edge is aligned with the calibration slot edge.
     """
-    edge_settings = hcapi.config.calibration.edge_sense
     # Our first search position is at the slot edge nominal at the probe's edge
     checking_pos = slot_edge_nominal + critical_edge_offset(
         search_axis, direction_if_hit
@@ -281,12 +281,14 @@ async def find_slot_center_binary(
     """Find the center of the calibration slot by binary-searching its edges.
     Returns the XY-center of the slot.
     """
+    edge_settings = hcapi.config.calibration.edge_sense
     # Find all four edges of the calibration slot
     plus_x_edge = await find_edge_binary(
         hcapi,
         mount,
         estimated_center + EDGES["right"],
         Axis.X,
+        edge_settings,
         -1,
         raise_verify_error,
         probe=probe,
@@ -299,18 +301,26 @@ async def find_slot_center_binary(
         mount,
         estimated_center + EDGES["top"],
         Axis.Y,
+        edge_settings,
         -1,
         raise_verify_error,
         probe=probe,
     )
     LOG.info(f"Found +y edge at {plus_y_edge.y}mm")
     estimated_center = estimated_center._replace(y=plus_y_edge.y - EDGES["top"].y)
 
+    # since we have a good idea where the edges are now we can reduce the second set of sweeps
+    fast_edge_settings = replace(
+        edge_settings,
+        search_initial_tolerance_mm=edge_settings.search_initial_tolerance_mm / 4,
+        search_iteration_limit=edge_settings.search_iteration_limit - 2,
+    )
     minus_x_edge = await find_edge_binary(
         hcapi,
         mount,
         estimated_center + EDGES["left"],
         Axis.X,
+        fast_edge_settings,
         1,
         raise_verify_error,
         probe=probe,
@@ -323,6 +333,7 @@ async def find_slot_center_binary(
         mount,
         estimated_center + EDGES["bottom"],
         Axis.Y,
+        fast_edge_settings,
         1,
         raise_verify_error,
         probe=probe,
@@ -369,7 +380,6 @@ async def _probe_deck_at(
     mount: OT3Mount,
     target: Point,
     settings: CapacitivePassSettings,
-    speed: float = 50,
     probe: InstrumentProbeType = InstrumentProbeType.PRIMARY,
 ) -> Tuple[float, bool]:
     here = await api.gantry_position(mount)
@@ -378,7 +388,7 @@ async def _probe_deck_at(
     )
     safe_height = max(here.z, target.z, abs_transit_height)
     await api.move_to(mount, here._replace(z=safe_height))
-    await api.move_to(mount, target._replace(z=safe_height), speed=speed)
+    await api.move_to(mount, target._replace(z=safe_height))
     await api.move_to(mount, target._replace(z=abs_transit_height))
     _found_pos, contact = await api.capacitive_probe(
         mount, Axis.by_mount(mount), target.z, settings, probe=probe
@@ -610,34 +620,32 @@ async def _calibrate_mount(
         pip = hcapi.hardware_instruments[mount.to_mount()]
         num_channels = int(pip.channels)  # type: ignore[union-attr]
         nominal_center += OFFSET_SECONDARY_PROBE.get(num_channels, Point())
-    async with hcapi.restore_system_constrants():
-        await hcapi.set_system_constraints_for_calibration()
-        try:
-            # find the center of the calibration sqaure
-            offset = await find_calibration_structure_position(
-                hcapi,
-                mount,
-                nominal_center,
-                method=method,
-                raise_verify_error=raise_verify_error,
-                probe=probe,
-            )
-            # update center with values obtained during calibration
-            LOG.info(f"Found calibration value {offset} for mount {mount.name}")
-            return offset
-
-        except (
-            InaccurateNonContactSweepError,
-            EarlyCapacitiveSenseTrigger,
-            CalibrationStructureNotFoundError,
-            EdgeNotFoundError,
-        ):
-            LOG.info(
-                "Error occurred during calibration. Resetting to current saved calibration value."
-            )
-            await hcapi.reset_instrument_offset(mount, to_default=False)
-            # re-raise exception after resetting instrument offset
-            raise
+    try:
+        # find the center of the calibration sqaure
+        offset = await find_calibration_structure_position(
+            hcapi,
+            mount,
+            nominal_center,
+            method=method,
+            raise_verify_error=raise_verify_error,
+            probe=probe,
+        )
+        # update center with values obtained during calibration
+        LOG.info(f"Found calibration value {offset} for mount {mount.name}")
+        return offset
+
+    except (
+        InaccurateNonContactSweepError,
+        EarlyCapacitiveSenseTrigger,
+        CalibrationStructureNotFoundError,
+        EdgeNotFoundError,
+    ):
+        LOG.info(
+            "Error occurred during calibration. Resetting to current saved calibration value."
+        )
+        await hcapi.reset_instrument_offset(mount, to_default=False)
+        # re-raise exception after resetting instrument offset
+        raise
 
 
 async def find_calibration_structure_position(

api/src/opentrons/hardware_control/ot3api.py

@@ -303,11 +303,6 @@ async def set_gantry_load(self, gantry_load: GantryLoad) -> None:
     async def get_serial_number(self) -> Optional[str]:
         return await self._backend.get_serial_number()
 
-    async def set_system_constraints_for_calibration(self) -> None:
-        self._backend.update_constraints_for_calibration_with_gantry_load(
-            self._gantry_load
-        )
-
     async def set_system_constraints_for_plunger_acceleration(
         self, mount: OT3Mount, acceleration: float
     ) -> None:

api/src/opentrons/hardware_control/protocols/flex_calibratable.py

@@ -74,9 +74,6 @@ async def capacitive_sweep(
     async def restore_system_constrants(self) -> AsyncIterator[None]:
         yield
 
-    async def set_system_constraints_for_calibration(self) -> None:
-        ...
-
     async def reset_instrument_offset(
         self, mount: Union[top_types.Mount, OT3Mount], to_default: bool = True
     ) -> None:

api/tests/opentrons/hardware_control/test_ot3_calibration.py

@@ -55,6 +55,17 @@ def mock_move_to(ot3_hardware: ThreadManager[OT3API]) -> Iterator[AsyncMock]:
         yield mock_move
 
 
+@pytest.fixture
+def mock_find_edge_binary() -> Iterator[AsyncMock]:
+    with patch(
+        "opentrons.hardware_control.ot3_calibration.find_edge_binary",
+        AsyncMock(
+            spec=find_edge_binary,
+        ),
+    ) as mock_find_edge_binary:
+        yield mock_find_edge_binary
+
+
 @pytest.fixture
 def mock_capacitive_probe(ot3_hardware: ThreadManager[OT3API]) -> Iterator[AsyncMock]:
     managed = ot3_hardware.managed_obj
@@ -183,11 +194,13 @@ async def test_find_edge(
 ) -> None:
     await ot3_hardware.home()
     mock_capacitive_probe.side_effect = probe_results
+    edge_settings = ot3_hardware.config.calibration.edge_sense
     result = await find_edge_binary(
         ot3_hardware,
         OT3Mount.RIGHT,
         Point(0, 0, 0),
         Axis.X,
+        edge_settings,
         direction_if_hit,
         False,
     )
@@ -202,6 +215,27 @@ async def test_find_edge(
         )
 
 
+async def test_find_slot_center(
+    ot3_hardware: ThreadManager[OT3API], mock_find_edge_binary: AsyncMock
+) -> None:
+    await ot3_hardware.home()
+    mock_find_edge_binary.return_value = Point(0, 0, 0)
+    await find_slot_center_binary(
+        ot3_hardware,
+        OT3Mount.RIGHT,
+        Point(0, 0, 0),
+        False,
+    )
+    # we want to make sure that the final edge probe is at the same distance as the settings change
+    final_pass_distance = 0.046875
+    for call in mock_find_edge_binary.mock_calls:
+        # call[1] is positional args and [4] is the EdgeSenseSettings arg
+        settings = call[1][4]
+        start_tolerance = settings.search_initial_tolerance_mm
+        search_limit = settings.search_iteration_limit
+        assert start_tolerance / (2**search_limit) == final_pass_distance
+
+
 @pytest.mark.parametrize(
     "search_axis,direction_if_hit,probe_results",
     [
@@ -238,12 +272,14 @@ async def test_find_edge_early_trigger(
 ) -> None:
     await ot3_hardware.home()
     mock_capacitive_probe.side_effect = ((3, True), ())
+    edge_settings = ot3_hardware.config.calibration.edge_sense
     with pytest.raises(EarlyCapacitiveSenseTrigger):
         await find_edge_binary(
             ot3_hardware,
             OT3Mount.RIGHT,
             Point(0.0, 0.0, 0.0),
             Axis.Y,
+            edge_settings,
             -1,
         )