opentrons 8.7.0a7__py3-none-any.whl → 8.8.0a7__py3-none-any.whl

opentrons/protocol_engine/commands/aspirate_while_tracking.py

@@ -13,7 +13,7 @@ from .pipetting_common import (
     aspirate_while_tracking,
 )
 from .movement_common import (
-    LiquidHandlingWellLocationMixin,
+    DynamicLiquidHandlingWellLocationMixin,
     DestinationPositionResult,
     StallOrCollisionError,
     move_to_well,
@@ -45,7 +45,7 @@ class AspirateWhileTrackingParams(
     PipetteIdMixin,
     AspirateVolumeMixin,
     FlowRateMixin,
-    LiquidHandlingWellLocationMixin,
+    DynamicLiquidHandlingWellLocationMixin,
 ):
     """Parameters required to aspirate from a specific well."""
 
@@ -107,14 +107,20 @@ class AspirateWhileTrackingImplementation(
             )
         state_update = StateUpdate()
 
+        end_point = self._state_view.geometry.get_well_position(
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+            well_location=params.trackToLocation,
+            operation_volume=-params.volume,
+            pipette_id=params.pipetteId,
+        )
         move_result = await move_to_well(
             movement=self._movement,
             model_utils=self._model_utils,
             pipette_id=params.pipetteId,
             labware_id=params.labwareId,
             well_name=params.wellName,
-            well_location=params.wellLocation,
-            operation_volume=-params.volume,
+            well_location=params.trackFromLocation,
         )
         state_update.append(move_result.state_update)
         if isinstance(move_result, DefinedErrorData):
@@ -128,6 +134,7 @@ class AspirateWhileTrackingImplementation(
             well_name=params.wellName,
             volume=params.volume,
             flow_rate=params.flowRate,
+            end_point=end_point,
             location_if_error={
                 "retryLocation": (
                     move_result.public.position.x,
@@ -138,7 +145,48 @@ class AspirateWhileTrackingImplementation(
             command_note_adder=self._command_note_adder,
             pipetting=self._pipetting,
             model_utils=self._model_utils,
+            movement_delay=params.movement_delay,
         )
+        if isinstance(aspirate_result, DefinedErrorData):
+            if isinstance(aspirate_result.public, OverpressureError):
+                return DefinedErrorData(
+                    public=OverpressureError(
+                        id=aspirate_result.public.id,
+                        createdAt=aspirate_result.public.createdAt,
+                        wrappedErrors=aspirate_result.public.wrappedErrors,
+                        errorInfo=aspirate_result.public.errorInfo,
+                    ),
+                    state_update=aspirate_result.state_update.set_liquid_operated(
+                        labware_id=params.labwareId,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            params.labwareId,
+                            params.wellName,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
+                    ),
+                    state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
+                )
+            elif isinstance(aspirate_result.public, StallOrCollisionError):
+                return DefinedErrorData(
+                    public=StallOrCollisionError(
+                        id=aspirate_result.public.id,
+                        createdAt=aspirate_result.public.createdAt,
+                        wrappedErrors=aspirate_result.public.wrappedErrors,
+                        errorInfo=aspirate_result.public.errorInfo,
+                    ),
+                    state_update=aspirate_result.state_update.set_liquid_operated(
+                        labware_id=params.labwareId,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            params.labwareId,
+                            params.wellName,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
+                    ),
+                    state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
+                )
+
         position_after_aspirate = await self._gantry_mover.get_position(
             params.pipetteId
         )
@@ -147,21 +195,6 @@ class AspirateWhileTrackingImplementation(
             y=position_after_aspirate.y,
             z=position_after_aspirate.z,
         )
-        if isinstance(aspirate_result, DefinedErrorData):
-            return DefinedErrorData(
-                public=aspirate_result.public,
-                state_update=aspirate_result.state_update.set_liquid_operated(
-                    labware_id=params.labwareId,
-                    well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                        params.labwareId,
-                        params.wellName,
-                        params.pipetteId,
-                    ),
-                    volume_added=CLEAR,
-                ),
-                state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
-            )
-
         return SuccessData(
             public=AspirateWhileTrackingResult(
                 volume=aspirate_result.public.volume,

opentrons/protocol_engine/commands/capture_image.py

@@ -0,0 +1,302 @@
+"""Command models to capture an image with a camera."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING, Tuple, Any
+from datetime import datetime
+
+from typing_extensions import Literal, Type
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons_shared_data.data_files import MimeType
+from opentrons.system.camera import (
+    CONTRAST_DEFAULT,
+    BRIGHTNESS_DEFAULT,
+    SATURATION_DEFAULT,
+    ZOOM_MIN,
+    ZOOM_MAX,
+    ZOOM_DEFAULT,
+    RESOLUTION_MIN,
+    RESOLUTION_MAX,
+    RESOLUTION_DEFAULT,
+)
+from ..types import PreconditionTypes
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors import (
+    CameraDisabledError,
+    CameraSettingsInvalidError,
+    FileNameInvalidError,
+)
+from ..errors.error_occurrence import ErrorOccurrence
+
+from ..resources.file_provider import (
+    ImageCaptureCmdFileNameMetadata,
+)
+from ..resources import FileProvider
+from ..resources.file_provider import SPECIAL_CHARACTERS
+from ..resources import CameraProvider
+from ..resources.camera_provider import ImageParameters
+from ..state import update_types
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+CaptureImageCommandType = Literal["captureImage"]
+
+
+class CaptureImageParams(BaseModel):
+    """Input parameters for an image capture."""
+
+    fileName: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Optional file name to use when storing the results of an Image Capture.",
+        json_schema_extra=_remove_default,
+    )
+    resolution: Optional[Tuple[int, int]] = Field(
+        None,
+        description="Width by height resolution in pixels for the image to be captured with.",
+    )
+    zoom: Optional[float] = Field(
+        None,
+        description="Multiplier to use when cropping and scaling a captured image. Scale is 1.0 to 2.0.",
+    )
+    pan: Optional[Tuple[int, int]] = Field(
+        None,
+        description="X/Y (pixels) position to pan to for a given zoom. Default is the center of the image.",
+    )
+    contrast: Optional[float] = Field(
+        None,
+        description="The contrast to use when processing an image. Scale is 0% to 100%.",
+    )
+    brightness: Optional[float] = Field(
+        None,
+        description="The brightness to use when processing an image. Scale is 0% to 100%.",
+    )
+    saturation: Optional[float] = Field(
+        None,
+        description="The saturation to use when processing an image. Scale is 0% to 100%.",
+    )
+
+
+class CaptureImageResult(BaseModel):
+    """Result data from running an image capture."""
+
+    fileId: Optional[str] = Field(
+        None,
+        description="File ID for image files output as a result of an image capture action.",
+    )
+    resolution: Tuple[int, int] = Field(
+        ...,
+        description="Width by height resolution in pixels the image was captured with.",
+    )
+    zoom: float = Field(
+        ...,
+        description="Multiplier used when cropping and scaling the captured image. Scale is 1.0 to 2.0.",
+    )
+    pan: Optional[Tuple[int, int]] = Field(
+        None,
+        description="X/Y (pixels) position panned to.",
+    )
+    contrast: float = Field(
+        ...,
+        description="The contrast used when processing the image. Scale is 0% to 100%.",
+    )
+    brightness: float = Field(
+        ...,
+        description="The brightness used when processing the image. Scale is 0% to 100%.",
+    )
+    saturation: float = Field(
+        ...,
+        description="The saturation used when processing the image. Scale is 0% to 100%.",
+    )
+
+
+def _converted_image_params(params: CaptureImageParams) -> ImageParameters:
+    return ImageParameters(
+        resolution=params.resolution,
+        zoom=params.zoom,
+        pan=params.pan,
+        contrast=(
+            (params.contrast / 100) * 2.0 if params.contrast is not None else None
+        ),
+        brightness=(
+            int(((params.brightness * 256) // 100) - 128) * -1
+            if params.brightness is not None
+            else None
+        ),
+        saturation=(
+            (params.saturation / 100) * 2.0 if params.saturation is not None else None
+        ),
+    )
+
+
+def _revert_image_parameters(
+    file_id: Optional[str], image_params: ImageParameters
+) -> CaptureImageResult:
+    contrast = (
+        image_params.contrast if image_params.contrast is not None else CONTRAST_DEFAULT
+    )
+    brightness = (
+        image_params.brightness
+        if image_params.brightness is not None
+        else BRIGHTNESS_DEFAULT
+    )
+    saturation = (
+        image_params.saturation
+        if image_params.saturation is not None
+        else SATURATION_DEFAULT
+    )
+    # todo (chb, 2025-10-29): Eventually we will have override defaults that can be passed into the Camera state, load those if they exist
+
+    return CaptureImageResult(
+        fileId=file_id,
+        resolution=image_params.resolution
+        if image_params.resolution is not None
+        else RESOLUTION_DEFAULT,
+        zoom=image_params.zoom if image_params.zoom is not None else ZOOM_DEFAULT,
+        pan=image_params.pan,
+        contrast=(contrast / 2) * 100.0,
+        brightness=round((((brightness * -1) + 128) * 100) / 256),
+        saturation=(saturation / 2) * 100.0,
+    )
+
+
+def _validate_image_params(params: CaptureImageParams) -> None:
+    # Validate the filename param provided to fail analysis
+    if params.fileName is not None and set(SPECIAL_CHARACTERS).intersection(
+        set(params.fileName)
+    ):
+        raise FileNameInvalidError(
+            message=f"Capture image filename cannot contain character(s): {SPECIAL_CHARACTERS.intersection(set(params.fileName))}"
+        )
+
+    # Validate the image filter parameters
+    if params.zoom is not None and (params.zoom < ZOOM_MIN or params.zoom > ZOOM_MAX):
+        raise CameraSettingsInvalidError(
+            message="Capture image zoom must be a valid value from 1.0X to 2.0X zoom."
+        )
+    if params.resolution is not None and (
+        params.resolution[0] < RESOLUTION_MIN[0]
+        or params.resolution[1] < RESOLUTION_MIN[1]
+        or params.resolution[0] > RESOLUTION_MAX[0]
+        or params.resolution[1] > RESOLUTION_MAX[1]
+    ):
+        raise CameraSettingsInvalidError(
+            message="Capture image resolution must be a valid resolution from 240p through 8K resolutuon."
+        )
+    if params.brightness is not None and (
+        params.brightness < 0 or params.brightness > 100
+    ):
+        raise CameraSettingsInvalidError(
+            message="Capture image brightness must be a percentage from 0% to 100%."
+        )
+    if params.contrast is not None and (params.contrast < 0 or params.contrast > 100):
+        raise CameraSettingsInvalidError(
+            message="Capture image contrast must be a percentage from 0% to 100%."
+        )
+    if params.saturation is not None and (
+        params.saturation < 0 or params.saturation > 100
+    ):
+        raise CameraSettingsInvalidError(
+            message="Capture image saturation must be a percentage from 0% to 100%."
+        )
+
+
+class CaptureImageImpl(
+    AbstractCommandImpl[CaptureImageParams, SuccessData[CaptureImageResult]]
+):
+    """Execution implementation of an image capture."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        file_provider: FileProvider,
+        camera_provider: CameraProvider,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._file_provider = file_provider
+        self._camera_provider = camera_provider
+
+    async def execute(
+        self, params: CaptureImageParams
+    ) -> SuccessData[CaptureImageResult]:
+        """Initiate an image capture with a camera."""
+        state_update = update_types.StateUpdate()
+        state_update.precondition_update = update_types.PreconditionUpdate(
+            {PreconditionTypes.IS_CAMERA_USED: True}
+        )
+
+        # Validate that the provided parameters are all acceptable. We do this here and in system/camera.py to ensure analysis fails properly.
+        _validate_image_params(params)
+
+        # Handle capturing an image with the CameraProvider - Engine camera settings take priority
+        camera_settings = await self._camera_provider.get_camera_settings()
+        engine_camera_settings = self._state_view.camera.get_enablement_settings()
+        if (
+            engine_camera_settings is None and camera_settings.cameraEnabled is False
+        ) or (
+            engine_camera_settings is not None
+            and engine_camera_settings.cameraEnabled is False
+        ):
+            raise CameraDisabledError(
+                "Cannot capture image because Camera is disabled."
+            )
+
+        parameters = _converted_image_params(params=params)
+        camera_data = await self._camera_provider.capture_image(
+            self._state_view.config.robot_type, parameters
+        )
+
+        # Conditionally save file if camera data was returned - in simulation we don't return anything.
+        file_id: str | None = None
+        if camera_data:
+            this_cmd_id = self._state_view.commands.get_running_command_id()
+            prev_cmd = self._state_view.commands.get_most_recently_finalized_command()
+            prev_cmd_id = prev_cmd.command.id if prev_cmd is not None else None
+
+            file_info = await self._file_provider.write_file(
+                data=camera_data,
+                mime_type=MimeType.IMAGE_JPEG,
+                command_metadata=ImageCaptureCmdFileNameMetadata(
+                    step_number=len(self._state_view.commands.get_all()),
+                    command_timestamp=datetime.now(),
+                    base_filename=params.fileName,
+                    command_id=this_cmd_id or "",
+                    prev_command_id=prev_cmd_id or "",
+                ),
+            )
+            file_id = file_info.id
+            state_update.files_added = update_types.FilesAddedUpdate(file_ids=[file_id])
+
+        result = _revert_image_parameters(file_id=file_id, image_params=parameters)
+
+        return SuccessData(
+            public=result,
+            state_update=state_update,
+        )
+
+
+class CaptureImage(
+    BaseCommand[CaptureImageParams, CaptureImageResult, ErrorOccurrence]
+):
+    """A command to execute an Absorbance Reader measurement."""
+
+    commandType: CaptureImageCommandType = "captureImage"
+    params: CaptureImageParams
+    result: Optional[CaptureImageResult] = None
+
+    _ImplementationCls: Type[CaptureImageImpl] = CaptureImageImpl
+
+
+class CaptureImageCreate(BaseCommandCreate[CaptureImageParams]):
+    """A request to execute an Absorbance Reader measurement."""
+
+    commandType: CaptureImageCommandType = "captureImage"
+    params: CaptureImageParams
+
+    _CommandCls: Type[CaptureImage] = CaptureImage

opentrons/protocol_engine/commands/command.py

@@ -178,6 +178,7 @@ class AbstractCommandImpl(
         hardware_api: HardwareControlAPI,
         equipment: execution.EquipmentHandler,
         file_provider: execution.FileProvider,
+        camera_provider: execution.CameraProvider,
         movement: execution.MovementHandler,
         gantry_mover: execution.GantryMover,
         labware_movement: execution.LabwareMovementHandler,

opentrons/protocol_engine/commands/command_unions.py

@@ -441,6 +441,14 @@ from .identify_module import (
     IdentifyModuleCommandType,
 )
 
+from .capture_image import (
+    CaptureImage,
+    CaptureImageParams,
+    CaptureImageCreate,
+    CaptureImageResult,
+    CaptureImageCommandType,
+)
+
 Command = Annotated[
     Union[
         AirGapInPlace,
@@ -494,6 +502,7 @@ Command = Annotated[
         SealPipetteToTip,
         PressureDispense,
         UnsealPipetteFromTip,
+        CaptureImage,
         heater_shaker.WaitForTemperature,
         heater_shaker.SetTargetTemperature,
         heater_shaker.DeactivateHeater,
@@ -602,6 +611,7 @@ CommandParams = Union[
     SealPipetteToTipParams,
     PressureDispenseParams,
     UnsealPipetteFromTipParams,
+    CaptureImageParams,
     heater_shaker.WaitForTemperatureParams,
     heater_shaker.SetTargetTemperatureParams,
     heater_shaker.DeactivateHeaterParams,
@@ -708,6 +718,7 @@ CommandType = Union[
     SealPipetteToTipCommandType,
     PressureDispenseCommandType,
     UnsealPipetteFromTipCommandType,
+    CaptureImageCommandType,
     heater_shaker.WaitForTemperatureCommandType,
     heater_shaker.SetTargetTemperatureCommandType,
     heater_shaker.DeactivateHeaterCommandType,
@@ -815,6 +826,7 @@ CommandCreate = Annotated[
         SealPipetteToTipCreate,
         PressureDispenseCreate,
         UnsealPipetteFromTipCreate,
+        CaptureImageCreate,
         heater_shaker.WaitForTemperatureCreate,
         heater_shaker.SetTargetTemperatureCreate,
         heater_shaker.DeactivateHeaterCreate,
@@ -930,6 +942,7 @@ CommandResult = Union[
     SealPipetteToTipResult,
     PressureDispenseResult,
     UnsealPipetteFromTipResult,
+    CaptureImageResult,
     heater_shaker.WaitForTemperatureResult,
     heater_shaker.SetTargetTemperatureResult,
     heater_shaker.DeactivateHeaterResult,

opentrons/protocol_engine/commands/dispense_while_tracking.py

@@ -19,7 +19,7 @@ from .pipetting_common import (
     dispense_while_tracking,
 )
 from .movement_common import (
-    LiquidHandlingWellLocationMixin,
+    DynamicLiquidHandlingWellLocationMixin,
     DestinationPositionResult,
     StallOrCollisionError,
     move_to_well,
@@ -49,7 +49,7 @@ class DispenseWhileTrackingParams(
     PipetteIdMixin,
     DispenseVolumeMixin,
     FlowRateMixin,
-    LiquidHandlingWellLocationMixin,
+    DynamicLiquidHandlingWellLocationMixin,
 ):
     """Payload required to dispense to a specific well."""
 
@@ -100,14 +100,24 @@ class DispenseWhileTrackingImplementation(
         # TODO(pbm, 10-15-24): call self._state_view.geometry.validate_dispense_volume_into_well()
 
         state_update = StateUpdate()
+
+        end_point = self._state_view.geometry.get_well_position(
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+            well_location=params.trackToLocation,
+            operation_volume=params.volume,
+            pipette_id=params.pipetteId,
+        )
+
         move_result = await move_to_well(
             movement=self._movement,
             model_utils=self._model_utils,
             pipette_id=params.pipetteId,
             labware_id=params.labwareId,
             well_name=params.wellName,
-            well_location=params.wellLocation,
+            well_location=params.trackFromLocation,
         )
+
         state_update.append(move_result.state_update)
         if isinstance(move_result, DefinedErrorData):
             return DefinedErrorData(
@@ -120,6 +130,7 @@ class DispenseWhileTrackingImplementation(
             well_name=well_name,
             volume=params.volume,
             flow_rate=params.flowRate,
+            end_point=end_point,
             push_out=params.pushOut,
             location_if_error={
                 "retryLocation": (
@@ -130,7 +141,49 @@ class DispenseWhileTrackingImplementation(
             },
             pipetting=self._pipetting,
             model_utils=self._model_utils,
+            movement_delay=params.movement_delay,
         )
+
+        if isinstance(dispense_result, DefinedErrorData):
+            if isinstance(dispense_result.public, OverpressureError):
+                return DefinedErrorData(
+                    public=OverpressureError(
+                        id=dispense_result.public.id,
+                        createdAt=dispense_result.public.createdAt,
+                        wrappedErrors=dispense_result.public.wrappedErrors,
+                        errorInfo=dispense_result.public.errorInfo,
+                    ),
+                    state_update=dispense_result.state_update.set_liquid_operated(
+                        labware_id=params.labwareId,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            params.labwareId,
+                            params.wellName,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
+                    ),
+                    state_update_if_false_positive=dispense_result.state_update_if_false_positive,
+                )
+            elif isinstance(dispense_result.public, StallOrCollisionError):
+                return DefinedErrorData(
+                    public=StallOrCollisionError(
+                        id=dispense_result.public.id,
+                        createdAt=dispense_result.public.createdAt,
+                        wrappedErrors=dispense_result.public.wrappedErrors,
+                        errorInfo=dispense_result.public.errorInfo,
+                    ),
+                    state_update=dispense_result.state_update.set_liquid_operated(
+                        labware_id=params.labwareId,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            params.labwareId,
+                            params.wellName,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
+                    ),
+                    state_update_if_false_positive=dispense_result.state_update_if_false_positive,
+                )
+
         position_after_dispense = await self._gantry_mover.get_position(
             params.pipetteId
         )
@@ -139,22 +192,6 @@ class DispenseWhileTrackingImplementation(
             y=position_after_dispense.y,
             z=position_after_dispense.z,
         )
-
-        if isinstance(dispense_result, DefinedErrorData):
-            return DefinedErrorData(
-                public=dispense_result.public,
-                state_update=dispense_result.state_update.set_liquid_operated(
-                    labware_id=params.labwareId,
-                    well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                        params.labwareId,
-                        params.wellName,
-                        params.pipetteId,
-                    ),
-                    volume_added=CLEAR,
-                ),
-                state_update_if_false_positive=dispense_result.state_update_if_false_positive,
-            )
-
         return SuccessData(
             public=DispenseWhileTrackingResult(
                 volume=dispense_result.public.volume,

opentrons/protocol_engine/commands/flex_stacker/common.py

@@ -10,6 +10,10 @@ from opentrons_shared_data.errors import ErrorCodes
 from opentrons_shared_data.errors.exceptions import CommandPreconditionViolated
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 
+from opentrons.protocol_engine.errors.exceptions import (
+    LabwarePoolNotCompatibleWithModuleError,
+)
+
 
 from ...errors import ErrorOccurrence
 from ...types import (
@@ -35,6 +39,15 @@ if TYPE_CHECKING:
     from opentrons.protocol_engine.execution.equipment import LoadedLabwarePoolData
     from opentrons.protocol_engine.state.module_substates import FlexStackerSubState
 
+
+# The stacker cannot dispense labware where there is no gap between the top surface
+# of the bottom labware being dispensed, and bottom surface of the top labware.
+# This is because the stacker latch, which holds the labware stack, needs enough
+# empty space to free the bottom labware, but still hold the top labware once it
+# closes.
+STACKER_INCOMPATIBLE_LABWARE = set(["opentrons_tough_universal_lid"])
+
+
 INITIAL_COUNT_DESCRIPTION = dedent(
     """\
         The number of labware that should be initially stored in the stacker. This number will be silently clamped to
@@ -911,3 +924,25 @@ def build_retrieve_labware_move_updates(
             lid_offset_location,
         )
     return locations_for_ids, offset_ids_by_id
+
+
+def validate_labware_pool_compatible_with_stacker(
+    pool_primary_definition: LabwareDefinition,
+    pool_adapter_definition: LabwareDefinition | None,
+    pool_lid_definition: LabwareDefinition | None,
+) -> None:
+    """Verifies that the given labware pool is compatible with the stacker."""
+    labware_pool = set(
+        lw.parameters.loadName
+        for lw in [
+            pool_primary_definition,
+            pool_adapter_definition,
+            pool_lid_definition,
+        ]
+        if lw is not None
+    )
+    incompatible_labware = list(labware_pool & STACKER_INCOMPATIBLE_LABWARE)
+    if incompatible_labware:
+        raise LabwarePoolNotCompatibleWithModuleError(
+            f"The stacker cannot store {incompatible_labware}"
+        )

opentrons/protocol_engine/commands/flex_stacker/set_stored_labware.py

@@ -31,6 +31,7 @@ from .common import (
     primary_location_sequences,
     adapter_location_sequences_with_default,
     lid_location_sequences_with_default,
+    validate_labware_pool_compatible_with_stacker,
 )
 
 if TYPE_CHECKING:
@@ -210,6 +211,12 @@ class SetStoredLabwareImpl(
             )
         )
 
+        validate_labware_pool_compatible_with_stacker(
+            pool_primary_definition=labware_def,
+            pool_adapter_definition=adapter_def,
+            pool_lid_definition=lid_def,
+        )
+
         pool_height = self._state_view.geometry.get_height_of_labware_stack(
             pool_definitions
         )

opentrons/protocol_engine/commands/heater_shaker/set_shake_speed.py

@@ -100,7 +100,7 @@ class SetShakeSpeedImpl(
         async def start_shake(task_handler: TaskHandler) -> None:
             if hs_hardware_module is not None:
                 async with task_handler.synchronize_cancel_previous(
-                    hs_module_substate.module_id
+                    hs_module_substate.module_id + "-shake"
                 ):
                     await hs_hardware_module.set_speed(rpm=validated_speed)