fix(api): update flex stacker motion params for DVT (#17697)

Author: ahiuchingau

api/src/opentrons/drivers/flex_stacker/driver.py

@@ -20,6 +20,7 @@
     StackerInfo,
     HardwareRevision,
     MoveParams,
+    AxisParams,
     LimitSwitchStatus,
     LEDColor,
     StallGuardParams,
@@ -57,56 +58,67 @@
 STALLGUARD_CONFIG = {
     StackerAxis.X: StallGuardParams(StackerAxis.X, True, 2),
     StackerAxis.Z: StallGuardParams(StackerAxis.Z, True, 2),
-    StackerAxis.L: StallGuardParams(StackerAxis.L, True, 2),
 }
 
 STACKER_MOTION_CONFIG = {
     StackerAxis.X: {
-        "home": MoveParams(
-            StackerAxis.X,
-            max_speed=10.0,  # mm/s
-            acceleration=100.0,  # mm/s^2
-            max_speed_discont=40,  # mm/s
-            current=1.5,  # mAmps
+        "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": MoveParams(
-            StackerAxis.X,
-            max_speed=200.0,
-            acceleration=1500.0,
-            max_speed_discont=40,
-            current=1.0,
+        "move": AxisParams(
+            run_current=1.0,
+            hold_current=0.75,
+            move_params=MoveParams(
+                max_speed=200.0,
+                acceleration=1500.0,
+                max_speed_discont=40.0,
+            ),
         ),
     },
     StackerAxis.Z: {
-        "home": MoveParams(
-            StackerAxis.Z,
-            max_speed=10.0,
-            acceleration=100.0,
-            max_speed_discont=40,
-            current=1.5,
+        "home": AxisParams(
+            run_current=1.5,
+            hold_current=1.8,
+            move_params=MoveParams(
+                max_speed=10.0,
+                acceleration=100.0,
+                max_speed_discont=25.0,
+            ),
         ),
-        "move": MoveParams(
-            StackerAxis.Z,
-            max_speed=200.0,
-            acceleration=500.0,
-            max_speed_discont=40,
-            current=1.5,
+        "move": AxisParams(
+            run_current=1.5,
+            hold_current=0.5,
+            move_params=MoveParams(
+                max_speed=150.0,
+                acceleration=500.0,
+                max_speed_discont=25.0,
+            ),
         ),
     },
     StackerAxis.L: {
-        "home": MoveParams(
-            StackerAxis.L,
-            max_speed=100.0,
-            acceleration=800.0,
-            max_speed_discont=40,
-            current=0.8,
+        "home": AxisParams(
+            run_current=0.8,
+            hold_current=0.15,
+            move_params=MoveParams(
+                max_speed=100.0,
+                acceleration=800.0,
+                max_speed_discont=40.0,
+            ),
         ),
-        "move": MoveParams(
-            StackerAxis.L,
-            max_speed=100.0,
-            acceleration=800.0,
-            max_speed_discont=40,
-            current=0.6,
+        "move": AxisParams(
+            run_current=0.6,
+            hold_current=0.15,
+            move_params=MoveParams(
+                max_speed=100.0,
+                acceleration=800.0,
+                max_speed_discont=40.0,
+            ),
         ),
     },
 }
@@ -183,18 +195,12 @@ def parse_installation_detected(cls, response: str) -> bool:
     def parse_move_params(cls, response: str) -> MoveParams:
         """Parse move params."""
         field_names = MoveParams.get_fields()
-        pattern = r"\s".join(
-            [
-                rf"{f}:(?P<{f}>(\d*\.)?\d+)" if f != "M" else rf"{f}:(?P<{f}>[XZL])"
-                for f in field_names
-            ]
-        )
-        _RE = re.compile(f"^{GCODE.GET_MOVE_PARAMS} {pattern}$")
+        pattern = r"\s".join(rf"{f}:(?P<{f}>(\d*\.)?\d+)" for f in field_names)
+        _RE = re.compile(rf"^{GCODE.GET_MOVE_PARAMS} M:([XZL]) {pattern}$")
         m = _RE.match(response)
         if not m:
             raise ValueError(f"Incorrect Response for move params: {response}")
         return MoveParams(
-            axis=StackerAxis(m.group("M")),
             max_speed=float(m.group("V")),
             acceleration=float(m.group("A")),
             max_speed_discont=float(m.group("D")),
@@ -294,14 +300,9 @@ def append_move_params(
     ) -> CommandBuilder:
         """Append move params."""
         if params is not None:
-            if params.max_speed is not None:
-                command.add_float("V", params.max_speed, GCODE_ROUNDING_PRECISION)
-            if params.acceleration is not None:
-                command.add_float("A", params.acceleration, GCODE_ROUNDING_PRECISION)
-            if params.max_speed_discont is not None:
-                command.add_float(
-                    "D", params.max_speed_discont, GCODE_ROUNDING_PRECISION
-                )
+            command.add_float("V", params.max_speed, GCODE_ROUNDING_PRECISION)
+            command.add_float("A", params.acceleration, GCODE_ROUNDING_PRECISION)
+            command.add_float("D", params.max_speed_discont, GCODE_ROUNDING_PRECISION)
         return command
 
     @classmethod
@@ -410,6 +411,7 @@ async def set_stallguard_threshold(
         self, axis: StackerAxis, enable: bool, threshold: int
     ) -> bool:
         """Enables and sets the stallguard threshold for the given axis motor."""
+        assert axis != StackerAxis.L, "Stallguard not supported for L axis"
         if not -64 < threshold < 63:
             raise ValueError(
                 f"Threshold value ({threshold}) should be between -64 and 63."

api/src/opentrons/drivers/flex_stacker/errors.py

@@ -7,6 +7,13 @@
 )
 
 
+class EStopTriggered(ErrorResponse):
+    """Raised when the estop is triggered during a move."""
+
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
 class MotorStallDetected(ErrorResponse):
     """Raised when a motor stall is detected."""
 
@@ -47,6 +54,7 @@ class StackerErrorCodes(BaseErrorCode):
     """Stacker-specific error codes."""
 
     UNHANDLED_GCODE = ("ERR003", UnhandledGcode)
+    ESTOP_TRIGGERED = ("ERR006", EStopTriggered)
     MOTOR_STALL_DETECTED = ("ERR403", MotorStallDetected)
     MOTOR_QUEUE_FULL = ("ERR404", MotorQueueFull)
     UNEXPECTED_LIMIT_SWITCH = ("ERR405", UnexpectedLimitSwitch)

api/src/opentrons/drivers/flex_stacker/simulator.py

@@ -184,7 +184,7 @@ async def get_tof_sensor_status(self, sensor: TOFSensor) -> TOFSensorStatus:
     @ensure_yield
     async def get_motion_params(self, axis: StackerAxis) -> MoveParams:
         """Get the motion parameters used by the given axis motor."""
-        return MoveParams(axis, 1, 1, 1)
+        return MoveParams(1, 1, 1)
 
     @ensure_yield
     async def get_stallguard_threshold(self, axis: StackerAxis) -> StallGuardParams:

api/src/opentrons/drivers/flex_stacker/types.py

@@ -207,16 +207,40 @@ class TOFSensorStatus:
 class MoveParams:
     """Move Parameters."""
 
-    axis: Optional[StackerAxis] = None
-    max_speed: Optional[float] = None
-    acceleration: Optional[float] = None
-    max_speed_discont: Optional[float] = None
-    current: Optional[float] = 0
+    max_speed: float
+    acceleration: float
+    max_speed_discont: float
 
     @classmethod
     def get_fields(cls) -> List[str]:
         """Get parsing fields."""
-        return ["M", "V", "A", "D"]
+        return ["V", "A", "D"]
+
+    def update(
+        self,
+        max_speed: Optional[float] = None,
+        acceleration: Optional[float] = None,
+        max_speed_discont: Optional[float] = None,
+    ) -> "MoveParams":
+        """Update the move parameters and return a new object."""
+        return MoveParams(
+            max_speed=max_speed if max_speed is not None else self.max_speed,
+            acceleration=acceleration
+            if acceleration is not None
+            else self.acceleration,
+            max_speed_discont=max_speed_discont
+            if max_speed_discont is not None
+            else self.max_speed_discont,
+        )
+
+
+@dataclass
+class AxisParams:
+    """Axis Parameters."""
+
+    run_current: float
+    hold_current: float
+    move_params: MoveParams
 
 
 @dataclass

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

@@ -47,9 +47,9 @@
 
 # Maximum distance in mm the axis can travel.
 MAX_TRAVEL = {
-    StackerAxis.X: 192.5,
-    StackerAxis.Z: 136.0,
-    StackerAxis.L: 23.0,
+    StackerAxis.X: 194.0,
+    StackerAxis.Z: 139.5,
+    StackerAxis.L: 22.0,
 }
 
 # The offset in mm to subtract from MAX_TRAVEL when moving an axis before we home.
@@ -122,8 +122,7 @@ async def build(
         )
 
         # Enable stallguard
-        for axis in StackerAxis:
-            config = STALLGUARD_CONFIG[axis]
+        for axis, config in STALLGUARD_CONFIG.items():
             await driver.set_stallguard_threshold(
                 axis, config.enabled, config.threshold
             )
@@ -272,13 +271,14 @@ async def move_axis(
     ) -> bool:
         """Move the axis in a direction by the given distance in mm."""
         await self.reset_stall_detected()
-        motion_params = STACKER_MOTION_CONFIG[axis]["move"]
-        await self._driver.set_run_current(axis, current or motion_params.current or 0)
-        if any([speed, acceleration, current]):
-            motion_params = self._reader.motion_params[axis]
-            motion_params.current = current or motion_params.current
-            motion_params.max_speed = speed or motion_params.max_speed
-            motion_params.acceleration = acceleration or motion_params.acceleration
+        default = STACKER_MOTION_CONFIG[axis]["move"]
+        await self._driver.set_run_current(
+            axis, current if current is not None else default.run_current
+        )
+        await self._driver.set_ihold_current(axis, default.hold_current)
+        motion_params = default.move_params.update(
+            max_speed=speed, acceleration=acceleration
+        )
         distance = direction.distance(distance)
         res = await self._driver.move_in_mm(axis, distance, params=motion_params)
         if res == MoveResult.STALL_ERROR:
@@ -295,14 +295,14 @@ async def home_axis(
         current: Optional[float] = None,
     ) -> bool:
         await self.reset_stall_detected()
-        motion_params = STACKER_MOTION_CONFIG[axis]["home"]
-        await self._driver.set_run_current(axis, current or motion_params.current or 0)
-        # Set the max hold current for the Z axis
-        if axis == StackerAxis.Z:
-            await self._driver.set_ihold_current(axis, 1.8)
-        if any([speed, acceleration]):
-            motion_params.max_speed = speed or motion_params.max_speed
-            motion_params.acceleration = acceleration or motion_params.acceleration
+        default = STACKER_MOTION_CONFIG[axis]["home"]
+        await self._driver.set_run_current(
+            axis, current if current is not None else default.run_current
+        )
+        await self._driver.set_ihold_current(axis, default.hold_current)
+        motion_params = default.move_params.update(
+            max_speed=speed, acceleration=acceleration
+        )
         success = await self._driver.move_to_limit_switch(
             axis=axis, direction=direction, params=motion_params
         )
@@ -320,14 +320,11 @@ async def close_latch(
         # Dont move the latch if its already closed.
         if self.limit_switch_status[StackerAxis.L] == StackerAxisState.EXTENDED:
             return True
-        motion_params = STACKER_MOTION_CONFIG[StackerAxis.L]["move"]
-        speed = velocity or motion_params.max_speed
-        accel = acceleration or motion_params.acceleration
         success = await self.home_axis(
             StackerAxis.L,
             Direction.RETRACT,
-            speed=speed,
-            acceleration=accel,
+            speed=velocity,
+            acceleration=acceleration,
         )
         # Check that the latch is closed.
         await self._reader.get_limit_switch_status()
@@ -345,18 +342,14 @@ async def open_latch(
         # Dont move the latch if its already opened.
         if self.limit_switch_status[StackerAxis.L] == StackerAxisState.RETRACTED:
             return True
-        motion_params = STACKER_MOTION_CONFIG[StackerAxis.L]["move"]
-        speed = velocity or motion_params.max_speed
-        accel = acceleration or motion_params.acceleration
-        distance = MAX_TRAVEL[StackerAxis.L]
         # The latch only has one limit switch, so we have to travel a fixed distance
         # to open the latch.
         success = await self.move_axis(
             StackerAxis.L,
             Direction.EXTEND,
-            distance=distance,
-            speed=speed,
-            acceleration=accel,
+            distance=MAX_TRAVEL[StackerAxis.L],
+            speed=velocity,
+            acceleration=acceleration,
         )
         # Check that the latch is opened.
         await self._reader.get_limit_switch_status()
@@ -394,7 +387,9 @@ async def store_labware(self, labware_height: float) -> bool:
 
         # Transfer
         await self.open_latch()
-        z_speed = (STACKER_MOTION_CONFIG[StackerAxis.Z]["move"].max_speed or 0) / 2
+        z_speed = (
+            STACKER_MOTION_CONFIG[StackerAxis.Z]["move"].move_params.max_speed or 0
+        ) / 2
         await self.move_axis(
             StackerAxis.Z, Direction.EXTEND, (labware_height / 2), z_speed
         )
@@ -433,7 +428,9 @@ def __init__(self, driver: AbstractFlexStackerDriver) -> None:
         }
         self.platform_state = PlatformState.UNKNOWN
         self.hopper_door_closed = False
-        self.motion_params = {axis: MoveParams(axis=axis) for axis in StackerAxis}
+        self.motion_params: Dict[StackerAxis, Optional[MoveParams]] = {
+            axis: None for axis in StackerAxis
+        }
         self.get_config = True
 
     async def read(self) -> None:

api/tests/opentrons/drivers/flex_stacker/test_driver.py

@@ -89,7 +89,6 @@ async def test_get_motion_params(
     connection.send_command.return_value = "M120 M:X V:200.000 A:1500.000 D:5.000"
     response = await subject.get_motion_params(types.StackerAxis.X)
     assert response == types.MoveParams(
-        axis=types.StackerAxis.X,
         acceleration=1500.0,
         max_speed=200.0,
         max_speed_discont=5.0,