Merge branch 'edge' into testing-1000ul-height-estimation

Author: andySigler

api-client/src/maintenance_runs/types.ts

@@ -7,6 +7,7 @@ import type {
 import type {
   RunCommandSummary,
   LegacyLabwareOffsetCreateData,
+  LabwareOffsetCreateData,
   RunStatus,
   RunAction,
 } from '../runs'
@@ -42,7 +43,7 @@ export interface MaintenanceRunError {
 }
 
 export interface CreateMaintenanceRunData {
-  labwareOffsets?: LegacyLabwareOffsetCreateData[]
+  labwareOffsets?: LegacyLabwareOffsetCreateData[] | LabwareOffsetCreateData[]
 }
 
 export interface LabwareDefinitionSummary {

api-client/src/runs/types.ts

@@ -172,6 +172,12 @@ export interface LegacyLabwareOffsetCreateData {
   vector: VectorOffset
 }
 
+export interface LabwareOffsetCreateData {
+  definitionUri: string
+  locationSequence: LabwareOffsetLocationSequence
+  vector: VectorOffset
+}
+
 type RunTimeParameterValuesType = string | number | boolean | { id: string }
 export type RunTimeParameterValuesCreateData = Record<
   string,

api-client/src/types.ts

@@ -1,6 +1,6 @@
 import type { AxiosRequestConfig } from 'axios'
 import type { ResponsePromise } from './request'
-import type { ModuleModel } from '@opentrons/shared-data'
+import type { AddressableAreaName, ModuleModel } from '@opentrons/shared-data'
 
 export interface HostConfig {
   hostname: string
@@ -60,7 +60,7 @@ export interface OnModuleOffsetLocationSequenceComponent
 export interface OnAddressableAreaOffsetLocationSequenceComponent
   extends BaseOffsetLocationSequenceComponent {
   kind: 'onAddressableArea'
-  addressableAreaName: string
+  addressableAreaName: AddressableAreaName
 }
 
 export type LabwareOffsetLocationSequenceComponent =

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

@@ -45,6 +45,10 @@ def __init__(self, serial_number: Optional[str] = None) -> None:
         self._tof_registers: Dict[TOFSensor, Dict[int, int]] = {
             a: {} for a in TOFSensor
         }
+        self._tof_sensor_status: Dict[TOFSensor, TOFSensorStatus] = {
+            s: TOFSensorStatus(s, TOFSensorState.IDLE, TOFSensorMode.MEASURE, True)
+            for s in TOFSensor
+        }
 
     def set_limit_switch(self, status: LimitSwitchStatus) -> bool:
         self._limit_switch_status = status
@@ -116,6 +120,9 @@ async def set_stallguard_threshold(
     @ensure_yield
     async def enable_tof_sensor(self, sensor: TOFSensor, enable: bool) -> bool:
         """Enable or disable the TOF sensor."""
+        state = TOFSensorState.IDLE if enable else TOFSensorState.DISABLED
+        self._tof_sensor_status[sensor].state = state
+        self._tof_sensor_status[sensor].ok = enable
         return True
 
     @ensure_yield
@@ -174,17 +181,12 @@ async def get_tof_driver_register(self, sensor: TOFSensor, reg: int) -> int:
     @ensure_yield
     async def get_tof_sensor_status(self, sensor: TOFSensor) -> TOFSensorStatus:
         """Get the status of the tof sensor."""
-        return TOFSensorStatus(
-            sensor=sensor,
-            mode=TOFSensorMode.MEASURE,
-            state=TOFSensorState.IDLE,
-            ok=True,
-        )
+        return self._tof_sensor_status[sensor]
 
     @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/drivers/flex_stacker/utils.py

@@ -1,3 +1,7 @@
+NUMBER_OF_ZONES = 10
+NUMBER_OF_BINS = 128
+
+
 def validate_histogram_frame(data: bytes, next_frame_id: int) -> bool:
     """Validate Histogram frame, Raise error if invalid."""
     start_delimn = data[0]