fix(api): Use correct PLATFORM_OFFSET and add LATCH_CLEARANCE for store/dispense_labware functions of the FlexStacker. (#18907)

Author: vegano1

api/src/opentrons/hardware_control/modules/flex_stacker.py

@@ -78,7 +78,113 @@
 
 # The labware platform will contact the labware this mm before the platform
 # touches the +Z endstop.
-PLATFORM_OFFSET = 4
+PLATFORM_OFFSET = 2.25
+
+# Should put the bottom of the plate above this mm above the latch when dispensing.
+# Should put the bottom of the plate this mm below the latch when storing.
+LATCH_CLEARANCE = 2.5
+
+# Configs
+TOF_DETECTION_CONFIG = {
+    TOFSensor.X: {
+        Direction.EXTEND: TOFDetection(
+            TOFSensor.X,
+            zones=[5, 6, 7],
+            bins=list(range(30, 40)),
+            threshold=1000,
+        ),
+        Direction.RETRACT: TOFDetection(
+            TOFSensor.X,
+            zones=[5, 6, 7],
+            bins=list(range(17, 30)),
+            threshold=1000,
+        ),
+    },
+    TOFSensor.Z: {
+        Direction.EXTEND: TOFDetection(
+            TOFSensor.Z,
+            zones=[1, 2, 3],
+            bins=list(range(15, 63)),
+            threshold=1000,
+        ),
+        Direction.RETRACT: TOFDetection(
+            TOFSensor.Z,
+            zones=[1, 2, 3],
+            bins=list(range(15, 63)),
+            threshold=1000,
+        ),
+    },
+}
+
+
+# Stallguard defaults
+STALLGUARD_CONFIG = {
+    StackerAxis.X: StallGuardParams(StackerAxis.X, True, 0),
+    StackerAxis.Z: StallGuardParams(StackerAxis.Z, True, 0),
+}
+
+STACKER_MOTION_CONFIG = {
+    StackerAxis.X: {
+        "home": AxisParams(
+            run_current=1.5,  # mAmps
+            hold_current=0.75,
+            move_params=MoveParams(
+                max_speed=10.0,  # mm/s
+                acceleration=100.0,  # mm/s^2
+                max_speed_discont=40.0,  # mm/s
+            ),
+        ),
+        "move": AxisParams(
+            run_current=1.2,
+            hold_current=0.75,
+            move_params=MoveParams(
+                max_speed=200.0,
+                acceleration=1500.0,
+                max_speed_discont=40.0,
+            ),
+        ),
+    },
+    StackerAxis.Z: {
+        "home": AxisParams(
+            run_current=1.5,
+            hold_current=1.5,
+            move_params=MoveParams(
+                max_speed=10.0,
+                acceleration=100.0,
+                max_speed_discont=25.0,
+            ),
+        ),
+        "move": AxisParams(
+            run_current=1.5,
+            hold_current=1.5,
+            move_params=MoveParams(
+                max_speed=150.0,
+                acceleration=500.0,
+                max_speed_discont=25.0,
+            ),
+        ),
+    },
+    StackerAxis.L: {
+        "home": AxisParams(
+            run_current=1.2,
+            hold_current=0.5,
+            move_params=MoveParams(
+                max_speed=100.0,
+                acceleration=800.0,
+                max_speed_discont=40.0,
+            ),
+        ),
+        "move": AxisParams(
+            run_current=1.2,
+            hold_current=0.5,
+            move_params=MoveParams(
+                max_speed=100.0,
+                acceleration=800.0,
+                max_speed_discont=40.0,
+            ),
+        ),
+    },
+}
 
 # Configs
 TOF_DETECTION_CONFIG = {
@@ -521,16 +627,12 @@ async def dispense_labware(
 
         # Transfer
         await self.open_latch()
-        # NOTE: When moving from the +Z limit switch down, the PLATFORM_OFFSET makes
-        # sure the bottom of the next labware is sitting N mm above the latch.
-        # So when moving the labware_height we dont need to add an additional
-        # offset to make sure we arent cutting it too close since the labware
-        # will always be above the latch.
-        await self.move_axis(StackerAxis.Z, Direction.RETRACT, labware_height)
+        latch_clear_distance = labware_height + PLATFORM_OFFSET - LATCH_CLEARANCE
+        await self.move_axis(StackerAxis.Z, Direction.RETRACT, latch_clear_distance)
         await self.close_latch()
 
         # Move Z down the rest of the way
-        z_distance = MAX_TRAVEL[StackerAxis.Z] - labware_height - HOME_OFFSET_SM
+        z_distance = MAX_TRAVEL[StackerAxis.Z] - latch_clear_distance - HOME_OFFSET_SM
         await self.move_axis(StackerAxis.Z, Direction.RETRACT, z_distance)
         await self.home_axis(StackerAxis.Z, Direction.RETRACT)
 
@@ -553,12 +655,13 @@ async def store_labware(
             await self.verify_shuttle_labware_presence(Direction.RETRACT, True)
 
         # Move the Z so the labware sits right under any labware already stored
-        distance = MAX_TRAVEL[StackerAxis.Z] - labware_height - PLATFORM_OFFSET
+        latch_clear_distance = labware_height + PLATFORM_OFFSET + LATCH_CLEARANCE
+        distance = MAX_TRAVEL[StackerAxis.Z] - latch_clear_distance
         await self.move_axis(StackerAxis.Z, Direction.EXTEND, distance)
 
         await self.open_latch()
         # Move the labware the rest of the way at half move speed to increase torque.
-        remaining_z = labware_height + PLATFORM_OFFSET - HOME_OFFSET_SM
+        remaining_z = latch_clear_distance - HOME_OFFSET_SM
         speed_z = STACKER_MOTION_CONFIG[StackerAxis.Z]["move"].move_params.max_speed / 2
         await self.move_axis(StackerAxis.Z, Direction.EXTEND, remaining_z, speed_z)
         await self.home_axis(StackerAxis.Z, Direction.EXTEND, speed_z)

api/tests/opentrons/hardware_control/modules/test_hc_flexstacker.py

@@ -14,6 +14,7 @@
 from opentrons.hardware_control import modules, ExecutionManager
 from opentrons.drivers.rpi_drivers.types import USBPort
 from opentrons.hardware_control.modules.flex_stacker import (
+    LATCH_CLEARANCE,
     MAX_TRAVEL,
     HOME_OFFSET_MD,
     HOME_OFFSET_SM,
@@ -357,12 +358,13 @@ async def test_store_labware_motion_sequence(
         verify_shuttle_labware_presence.assert_any_call(Direction.RETRACT, True)
 
         # Assertions for offset calculation and move_axis
-        distance = MAX_TRAVEL[StackerAxis.Z] - labware_height - PLATFORM_OFFSET
+        latch_clear_distance = labware_height + PLATFORM_OFFSET + LATCH_CLEARANCE
+        distance = MAX_TRAVEL[StackerAxis.Z] - latch_clear_distance
         move_axis.assert_any_call(StackerAxis.Z, Direction.EXTEND, distance)
 
         # Verify labware transfer
         open_latch.assert_called_once()
-        z_distance = MAX_TRAVEL[StackerAxis.Z] - distance - HOME_OFFSET_SM
+        z_distance = latch_clear_distance - HOME_OFFSET_SM
         z_speed = STACKER_MOTION_CONFIG[StackerAxis.Z]["move"].move_params.max_speed / 2
         move_axis.assert_any_call(StackerAxis.Z, Direction.EXTEND, z_distance, z_speed)
         home_axis.assert_any_call(StackerAxis.Z, Direction.EXTEND, z_speed)
@@ -426,11 +428,14 @@ async def test_dispense_labware_motion_sequence(
 
         # Verify labware transfer
         open_latch.assert_called_once()
-        move_axis.assert_any_call(StackerAxis.Z, Direction.RETRACT, labware_height)
+        latch_clear_distance = labware_height + PLATFORM_OFFSET - LATCH_CLEARANCE
+        move_axis.assert_any_call(
+            StackerAxis.Z, Direction.RETRACT, latch_clear_distance
+        )
         close_latch.assert_called_once()
 
         # Assertions for offset calculation and move_axis/home_axis
-        z_distance = MAX_TRAVEL[StackerAxis.Z] - labware_height - HOME_OFFSET_SM
+        z_distance = MAX_TRAVEL[StackerAxis.Z] - latch_clear_distance - HOME_OFFSET_SM
         move_axis.assert_any_call(StackerAxis.Z, Direction.RETRACT, z_distance)
         home_axis.assert_any_call(StackerAxis.Z, Direction.RETRACT)