feat(app, api, shared-data, robot-server): Add module fixtures to deck configuration

api/src/opentrons/calibration_storage/deck_configuration.py

@@ -10,6 +10,7 @@
 class _CutoutFixturePlacementModel(pydantic.BaseModel):
     cutoutId: str
     cutoutFixtureId: str
+    opentronsModuleSerialNumber: Optional[str]
 
 
 class _DeckConfigurationModel(pydantic.BaseModel):
@@ -26,7 +27,9 @@ def serialize_deck_configuration(
     data = _DeckConfigurationModel.construct(
         cutoutFixtures=[
             _CutoutFixturePlacementModel.construct(
-                cutoutId=e.cutout_id, cutoutFixtureId=e.cutout_fixture_id
+                cutoutId=e.cutout_id,
+                cutoutFixtureId=e.cutout_fixture_id,
+                opentronsModuleSerialNumber=e.opentrons_modules_serial_number,
             )
             for e in cutout_fixture_placements
         ],
@@ -50,7 +53,9 @@ def deserialize_deck_configuration(
     else:
         cutout_fixture_placements = [
             CutoutFixturePlacement(
-                cutout_id=e.cutoutId, cutout_fixture_id=e.cutoutFixtureId
+                cutout_id=e.cutoutId,
+                cutout_fixture_id=e.cutoutFixtureId,
+                opentrons_modules_serial_number=e.opentronsModuleSerialNumber,
             )
             for e in parsed.cutoutFixtures
         ]

api/src/opentrons/calibration_storage/types.py

@@ -42,3 +42,4 @@ class UriDetails:
 class CutoutFixturePlacement:
     cutout_fixture_id: str
     cutout_id: str
+    opentrons_modules_serial_number: typing.Optional[str]

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

@@ -9,6 +9,7 @@
     Tuple,
     Awaitable,
     Union,
+    Set,
     cast,
     TYPE_CHECKING,
 )
@@ -64,6 +65,22 @@ def from_model(cls, model: ModuleModel) -> ModuleType:
         if isinstance(model, MagneticBlockModel):
             return cls.MAGNETIC_BLOCK
 
+    @classmethod
+    def to_module_fixture_id(cls, module_type: ModuleType) -> str:
+        if module_type == ModuleType.THERMOCYCLER:
+            # Thermocyclers are "loaded" in B1 only
+            return "thermocyclerModuleFront"
+        if module_type == ModuleType.TEMPERATURE:
+            return "temperatureModule"
+        if module_type == ModuleType.HEATER_SHAKER:
+            return "heaterShakerModule"
+        if module_type == ModuleType.MAGNETIC_BLOCK:
+            return "magneticBlockModule"
+        else:
+            raise ValueError(
+                f"Module Type {module_type} does not have a related fixture ID."
+            )
+
 
 class MagneticModuleModel(str, Enum):
     MAGNETIC_V1: str = "magneticModuleV1"

api/src/opentrons/protocol_api/core/engine/protocol.py

@@ -3,7 +3,8 @@
 from typing import Dict, Optional, Type, Union, List, Tuple, TYPE_CHECKING
 
 from opentrons.protocol_engine.commands import LoadModuleResult
-from opentrons_shared_data.deck.dev_types import DeckDefinitionV4, SlotDefV3
+from opentrons_shared_data.deck.dev_types import DeckDefinitionV5, SlotDefV3
+from opentrons.protocol_engine.resources import deck_configuration_provider
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from opentrons_shared_data.labware.dev_types import LabwareDefinition as LabwareDefDict
 from opentrons_shared_data.pipette.dev_types import PipetteNameType
@@ -393,6 +394,7 @@ def load_module(
         model: ModuleModel,
         deck_slot: Optional[DeckSlotName],
         configuration: Optional[str],
+        addressable_area: Optional[str],
     ) -> Union[ModuleCore, NonConnectedModuleCore]:
         """Load a module into the protocol."""
         assert configuration is None, "Module `configuration` is deprecated"
@@ -411,10 +413,16 @@ def load_module(
         normalized_deck_slot = deck_slot.to_equivalent_for_robot_type(robot_type)
         self._ensure_module_location(normalized_deck_slot, module_type)
 
-        result = self._engine_client.load_module(
-            model=EngineModuleModel(model),
-            location=DeckSlotLocation(slotName=normalized_deck_slot),
-        )
+        if robot_type == "OT-3 Standard" and isinstance(addressable_area, str):
+            result = self._engine_client.load_module(
+                model=EngineModuleModel(model),
+                location=AddressableAreaLocation(addressableAreaName=addressable_area),
+            )
+        else:
+            result = self._engine_client.load_module(
+                model=EngineModuleModel(model),
+                location=DeckSlotLocation(slotName=normalized_deck_slot),
+            )
 
         module_core = self._get_module_core(load_module_result=result, model=model)
 
@@ -602,7 +610,7 @@ def set_last_location(
         self._last_location = location
         self._last_mount = mount
 
-    def get_deck_definition(self) -> DeckDefinitionV4:
+    def get_deck_definition(self) -> DeckDefinitionV5:
         """Get the geometry definition of the robot's deck."""
         return self._engine_client.state.labware.get_deck_definition()
 
@@ -625,10 +633,26 @@ def get_staging_slot_definitions(self) -> Dict[str, SlotDefV3]:
     def _ensure_module_location(
         self, slot: DeckSlotName, module_type: ModuleType
     ) -> None:
-        slot_def = self.get_slot_definition(slot)
-        compatible_modules = slot_def["compatibleModuleTypes"]
-        if module_type.value not in compatible_modules:
-            raise ValueError(f"A {module_type.value} cannot be loaded into slot {slot}")
+        if self._engine_client.state.config.robot_type == "OT-2 Standard":
+            slot_def = self.get_slot_definition(slot)
+            compatible_modules = slot_def["compatibleModuleTypes"]
+            if module_type.value not in compatible_modules:
+                raise ValueError(
+                    f"A {module_type.value} cannot be loaded into slot {slot}"
+                )
+        else:
+            cutout_fixture_id = ModuleType.to_module_fixture_id(module_type)
+            module_fixture = deck_configuration_provider.get_cutout_fixture(
+                cutout_fixture_id,
+                self._engine_client.state.addressable_areas.state.deck_definition,
+            )
+            cutout_id = self._engine_client.state.addressable_areas.get_cutout_id_by_deck_slot_name(
+                slot
+            )
+            if cutout_id not in module_fixture["mayMountTo"]:
+                raise ValueError(
+                    f"A {module_type.value} cannot be loaded into slot {slot}"
+                )
 
     def get_slot_item(
         self, slot_name: Union[DeckSlotName, StagingSlotName]

api/src/opentrons/protocol_api/core/legacy/deck.py

@@ -278,8 +278,11 @@ def resolve_module_location(
         if isinstance(location, str) or isinstance(location, int):
             slot_def = self.get_slot_definition(str(location))
             compatible_modules = slot_def["compatibleModuleTypes"]
+            cutout_fixture_id = ModuleType.to_module_fixture_id(module_type)
             if module_type.value in compatible_modules:
                 return location
+            elif cutout_fixture_id == slot_def["id"]:
+                return location
             else:
                 raise ValueError(
                     f"A {dn_from_type[module_type]} cannot be loaded"

api/src/opentrons/protocol_api/core/legacy/legacy_protocol_core.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Dict, List, Optional, Set, Union, cast, Tuple
 
-from opentrons_shared_data.deck.dev_types import DeckDefinitionV4, SlotDefV3
+from opentrons_shared_data.deck.dev_types import DeckDefinitionV5, SlotDefV3
 from opentrons_shared_data.labware.dev_types import LabwareDefinition
 from opentrons_shared_data.pipette.dev_types import PipetteNameType
 from opentrons_shared_data.robot.dev_types import RobotType
@@ -288,6 +288,7 @@ def load_module(
         model: ModuleModel,
         deck_slot: Optional[DeckSlotName],
         configuration: Optional[str],
+        addressable_area: Optional[str],
     ) -> legacy_module_core.LegacyModuleCore:
         """Load a module."""
         resolved_type = ModuleType.from_model(model)
@@ -491,7 +492,7 @@ def get_labware_on_labware(
     ) -> Optional[LegacyLabwareCore]:
         assert False, "get_labware_on_labware only supported on engine core"
 
-    def get_deck_definition(self) -> DeckDefinitionV4:
+    def get_deck_definition(self) -> DeckDefinitionV5:
         """Get the geometry definition of the robot's deck."""
         assert False, "get_deck_definition only supported on engine core"
 

api/src/opentrons/protocol_api/core/protocol.py

@@ -5,7 +5,7 @@
 from abc import abstractmethod, ABC
 from typing import Generic, List, Optional, Union, Tuple, Dict, TYPE_CHECKING
 
-from opentrons_shared_data.deck.dev_types import DeckDefinitionV4, SlotDefV3
+from opentrons_shared_data.deck.dev_types import DeckDefinitionV5, SlotDefV3
 from opentrons_shared_data.pipette.dev_types import PipetteNameType
 from opentrons_shared_data.labware.dev_types import LabwareDefinition
 from opentrons_shared_data.robot.dev_types import RobotType
@@ -119,6 +119,7 @@ def load_module(
         model: ModuleModel,
         deck_slot: Optional[DeckSlotName],
         configuration: Optional[str],
+        addressable_area: Optional[str],
     ) -> ModuleCoreType:
         ...
 
@@ -188,7 +189,7 @@ def set_last_location(
         ...
 
     @abstractmethod
-    def get_deck_definition(self) -> DeckDefinitionV4:
+    def get_deck_definition(self) -> DeckDefinitionV5:
         """Get the geometry definition of the robot's deck."""
 
     @abstractmethod

api/src/opentrons/protocol_api/protocol_context.py

@@ -800,10 +800,15 @@ def load_module(
         if isinstance(deck_slot, StagingSlotName):
             raise ValueError("Cannot load a module onto a staging slot.")
 
+        addressable_area = validation.ensure_and_convert_module_fixture_location(
+            location, self._api_version, self._core.robot_type, requested_model
+        )
+
         module_core = self._core.load_module(
             model=requested_model,
             deck_slot=deck_slot,
             configuration=configuration,
+            addressable_area=addressable_area,
         )
 
         module_context = _create_module_context(

api/src/opentrons/protocol_api/validation.py

@@ -87,6 +87,10 @@ class InvalidTrashBinLocationError(ValueError):
     """An error raised when attempting to load trash bins in invalid slots."""
 
 
+class InvalidFixtureLocationError(ValueError):
+    """An error raised when attempting to load a fixture in an invalid cutout."""
+
+
 def ensure_mount_for_pipette(
     mount: Union[str, Mount, None], pipette: PipetteNameType
 ) -> Mount:
@@ -332,6 +336,109 @@ def ensure_and_convert_trash_bin_location(
     return map_trash_bin_addressable_area[slot_name_ot3]
 
 
+def ensure_and_convert_module_fixture_location(
+    deck_slot: Optional[Union[int, str]],
+    api_version: APIVersion,
+    robot_type: RobotType,
+    model: ModuleModel,
+) -> Optional[str]:
+    """Ensure module fixture load location is valid.
+
+    Also, convert the deck slot to a valid module fixture addressable area.
+    """
+
+    if robot_type == "OT-2 Standard":
+        # OT-2 Utilizes the existing compatibleModulelTypes list of traditional addressable areas
+        return None
+
+    if isinstance(model, MagneticBlockModel):
+        valid_slots = [
+            DeckSlotName(slot)
+            for slot in [
+                "A1",
+                "B1",
+                "C1",
+                "D1",
+                "A2",
+                "B2",
+                "C2",
+                "D2",
+                "A3",
+                "B3",
+                "C3",
+                "D3",
+            ]
+        ]
+        addressable_areas = [
+            "magneticBlockV1A1",
+            "magneticBlockV1B1",
+            "magneticBlockV1C1",
+            "magneticBlockV1D1",
+            "magneticBlockV1A2",
+            "magneticBlockV1B2",
+            "magneticBlockV1C2",
+            "magneticBlockV1D2",
+            "magneticBlockV1A3",
+            "magneticBlockV1B3",
+            "magneticBlockV1C3",
+            "magneticBlockV1D3",
+        ]
+
+    elif isinstance(model, HeaterShakerModuleModel):
+        valid_slots = [
+            DeckSlotName(slot)
+            for slot in ["A1", "B1", "C1", "D1", "A3", "B3", "C3", "D3"]
+        ]
+        addressable_areas = [
+            "heaterShakerV1A1",
+            "heaterShakerV1B1",
+            "heaterShakerV1C1",
+            "heaterShakerV1D1",
+            "heaterShakerV1A3",
+            "heaterShakerV1B3",
+            "heaterShakerV1C3",
+            "heaterShakerV1D3",
+        ]
+    elif isinstance(model, TemperatureModuleModel):
+        valid_slots = [
+            DeckSlotName(slot)
+            for slot in ["A1", "B1", "C1", "D1", "A3", "B3", "C3", "D3"]
+        ]
+        addressable_areas = [
+            "temperatureModuleV2A1",
+            "temperatureModuleV2B1",
+            "temperatureModuleV2C1",
+            "temperatureModuleV2D1",
+            "temperatureModuleV2A3",
+            "temperatureModuleV2B3",
+            "temperatureModuleV2C3",
+            "temperatureModuleV2D3",
+        ]
+    elif isinstance(model, ThermocyclerModuleModel):
+        return "thermocyclerModuleV2"
+    else:
+        return None
+
+    map_addressable_area = {
+        slot: addressable_area
+        for slot, addressable_area in zip(valid_slots, addressable_areas)
+    }
+    if isinstance(deck_slot, int) or isinstance(deck_slot, str):
+        slot_name_ot3 = ensure_and_convert_deck_slot(deck_slot, api_version, robot_type)
+        if not isinstance(slot_name_ot3, DeckSlotName):
+            raise ValueError("Staging areas not permitted for module fixtures.")
+        if slot_name_ot3 not in valid_slots:
+            raise InvalidFixtureLocationError(
+                f"Invalid location: {slot_name_ot3} for fixture: {model.name}."
+            )
+
+        return map_addressable_area[slot_name_ot3]
+    else:
+        raise ValueError(
+            "Location must be provided when loading modules except for the Thermocycler."
+        )
+
+
 def ensure_hold_time_seconds(
     seconds: Optional[float], minutes: Optional[float]
 ) -> float:

api/src/opentrons/protocol_engine/clients/sync_client.py

@@ -1,6 +1,6 @@
 """Control a `ProtocolEngine` without async/await."""
 
-from typing import cast, List, Optional, Dict
+from typing import cast, List, Optional, Dict, Union
 
 from opentrons_shared_data.pipette.dev_types import PipetteNameType
 from opentrons_shared_data.labware.dev_types import LabwareUri
@@ -25,6 +25,7 @@
     Liquid,
     NozzleLayoutConfigurationType,
     AddressableOffsetVector,
+    AddressableAreaLocation,
 )
 from .transports import ChildThreadTransport
 
@@ -264,7 +265,7 @@ def move_to_coordinates(
     def load_module(
         self,
         model: ModuleModel,
-        location: DeckSlotLocation,
+        location: Union[DeckSlotLocation, AddressableAreaLocation],
     ) -> commands.LoadModuleResult:
         """Execute a LoadModule command and return the result."""
         request = commands.LoadModuleCreate(