opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__py3-none-any.whl

opentrons/protocol_engine/commands/move_labware.py

@@ -38,6 +38,7 @@ from ..types import (
     LabwareLocationSequence,
     NotOnDeckLocationSequenceComponent,
     OFF_DECK_LOCATION,
+    WASTE_CHUTE_LOCATION,
 )
 from ..errors import (
     LabwareMovementNotAllowedError,
@@ -228,9 +229,10 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                 )
                 eventual_destination_location_sequence = [
                     NotOnDeckLocationSequenceComponent(
-                        logicalLocationName=OFF_DECK_LOCATION
+                        logicalLocationName=WASTE_CHUTE_LOCATION
                     )
                 ]
+
             elif fixture_validation.is_trash(area_name):
                 # When dropping labware in the trash bins we want to ensure they are lids
                 # and enforce a y-axis drop offset to ensure they fall within the trash bin
@@ -351,7 +353,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
             validated_new_loc = self._state_view.geometry.ensure_valid_gripper_location(
                 available_new_location,
             )
-
             user_pick_up_offset = (
                 Point.from_xyz_attrs(params.pickUpOffset)
                 if params.pickUpOffset is not None
@@ -464,7 +465,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
             new_location=available_new_location,
             new_offset_id=new_offset_id,
         )
-
         if labware_validation.validate_definition_is_lid(
             definition=self._state_view.labware.get_definition(params.labwareId)
         ):
@@ -498,7 +498,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                     parent_labware_ids=parent_updates,
                     lid_ids=lid_updates,
                 )
-
         return SuccessData(
             public=MoveLabwareResult(
                 offsetId=new_offset_id,

opentrons/protocol_engine/commands/move_to_addressable_area_for_drop_tip.py

@@ -85,7 +85,7 @@ class MoveToAddressableAreaForDropTipParams(PipetteIdMixin, MovementMixin):
     ignoreTipConfiguration: bool | SkipJsonSchema[None] = Field(
         True,
         description=(
-            "Whether to utilize the critical point of the tip configuraiton when moving to an addressable area."
+            "Whether to utilize the critical point of the tip configuration when moving to an addressable area."
             " If True, this command will ignore the tip configuration and use the center of the entire instrument"
             " as the critical point for movement."
             " If False, this command will use the critical point provided by the current tip configuration."

opentrons/protocol_engine/commands/movement_common.py

@@ -48,8 +48,8 @@ class WellLocationMixin(BaseModel):
     )
 
 
-class LiquidHandlingWellLocationMixin(BaseModel):
-    """Mixin for command requests that take a location that's somewhere in a well."""
+class LiquidHandlingWellMixin(BaseModel):
+    """Base Mixin for command requests that take a well."""
 
     labwareId: str = Field(
         ...,
@@ -59,12 +59,39 @@ class LiquidHandlingWellLocationMixin(BaseModel):
         ...,
         description="Name of well to use in labware.",
     )
+
+
+class LiquidHandlingWellLocationMixin(LiquidHandlingWellMixin):
+    """Mixin for command requests that take a location that's somewhere in a well."""
+
     wellLocation: LiquidHandlingWellLocation = Field(
         default_factory=LiquidHandlingWellLocation,
         description="Relative well location at which to perform the operation",
     )
 
 
+class DynamicLiquidHandlingWellLocationMixin(LiquidHandlingWellMixin):
+    """Mixin for command requests that move between two locations in a well."""
+
+    trackFromLocation: LiquidHandlingWellLocation = Field(
+        default_factory=LiquidHandlingWellLocation,
+        description="Relative well location at which to start the operation",
+    )
+    trackToLocation: LiquidHandlingWellLocation = Field(
+        default_factory=LiquidHandlingWellLocation,
+        description="Relative well location at which to end the operation",
+    )
+    movement_delay: float | SkipJsonSchema[None] = Field(
+        None,
+        description=(
+            "Optional movement delay in seconds."
+            " When this argument is used, the x/y/z movement will wait movement_delay seconds"
+            " after the pipetting action starts before beginning the x/y/z move."
+        ),
+        json_schema_extra=_remove_default,
+    )
+
+
 class MovementMixin(BaseModel):
     """Mixin for command requests that move a pipette."""
 
@@ -152,6 +179,7 @@ async def move_to_well(
     minimum_z_height: Optional[float] = None,
     speed: Optional[float] = None,
     operation_volume: Optional[float] = None,
+    offset_pipette_for_reservoir_subwells: bool = False,
 ) -> MoveToWellOperationReturn:
     """Execute a move to well microoperation."""
     try:
@@ -165,6 +193,7 @@ async def move_to_well(
             minimum_z_height=minimum_z_height,
             speed=speed,
             operation_volume=operation_volume,
+            offset_pipette_for_reservoir_subwells=offset_pipette_for_reservoir_subwells,
         )
     except StallOrCollisionDetectedError as e:
         return DefinedErrorData(

opentrons/protocol_engine/commands/pick_up_tip.py

@@ -10,7 +10,7 @@ from typing_extensions import Literal
 from ..errors import ErrorOccurrence, PickUpTipTipNotAttachedError
 from ..resources import ModelUtils
 from ..state import update_types
-from ..types import PickUpTipWellLocation, LabwareWellId
+from ..types import PickUpTipWellLocation, LabwareWellId, TipRackWellState
 from .pipetting_common import (
     PipetteIdMixin,
 )
@@ -121,10 +121,14 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
         labware_id = params.labwareId
         well_name = params.wellName
 
-        tips_to_mark_as_used = self._state_view.tips.compute_tips_to_mark_as_used(
-            labware_id=labware_id,
-            well_name=well_name,
-            nozzle_map=self._state_view.pipettes.get_nozzle_configuration(pipette_id),
+        tips_to_mark_as_empty = (
+            self._state_view.tips.compute_tips_to_mark_as_used_or_empty(
+                labware_id=labware_id,
+                well_name=well_name,
+                nozzle_map=self._state_view.pipettes.get_nozzle_configuration(
+                    pipette_id
+                ),
+            )
         )
 
         well_location = self._state_view.geometry.convert_pick_up_tip_well_location(
@@ -160,16 +164,20 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
                     ),
                 )
                 .set_fluid_empty(pipette_id=pipette_id, clean_tip=True)
-                .mark_tips_as_used(
-                    labware_id=labware_id, well_names=tips_to_mark_as_used
+                .update_tip_rack_well_state(
+                    tip_state=TipRackWellState.EMPTY,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_empty,
                 )
             )
             state_update = (
                 update_types.StateUpdate.reduce(
                     update_types.StateUpdate(), move_result.state_update
                 )
-                .mark_tips_as_used(
-                    labware_id=labware_id, well_names=tips_to_mark_as_used
+                .update_tip_rack_well_state(
+                    tip_state=TipRackWellState.EMPTY,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_empty,
                 )
                 .set_fluid_unknown(pipette_id=pipette_id)
             )
@@ -197,8 +205,10 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
                         labware_id=labware_id, well_name=well_name
                     ),
                 )
-                .mark_tips_as_used(
-                    labware_id=labware_id, well_names=tips_to_mark_as_used
+                .update_tip_rack_well_state(
+                    tip_state=TipRackWellState.EMPTY,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_empty,
                 )
                 .set_fluid_empty(pipette_id=pipette_id, clean_tip=True)
                 .set_pipette_ready_to_aspirate(

opentrons/protocol_engine/commands/pipetting_common.py

@@ -9,10 +9,15 @@ from pydantic import BaseModel, Field
 from opentrons_shared_data.errors import ErrorCodes
 from opentrons.protocol_engine.errors.error_occurrence import ErrorOccurrence
 from opentrons.protocol_engine.types import AspiratedFluid, FluidKind
-from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
+from opentrons_shared_data.errors.exceptions import (
+    PipetteOverpressureError,
+    StallOrCollisionDetectedError,
+)
 from .command import DefinedErrorData, SuccessData
 from opentrons.protocol_engine.state.update_types import StateUpdate
+from opentrons.types import Point
 
+from .movement_common import StallOrCollisionError
 
 if TYPE_CHECKING:
     from ..execution.pipetting import PipettingHandler
@@ -241,11 +246,15 @@ async def aspirate_while_tracking(
     well_name: str,
     volume: float,
     flow_rate: float,
+    end_point: Point,
     location_if_error: ErrorLocationInfo,
     command_note_adder: CommandNoteAdder,
     pipetting: PipettingHandler,
     model_utils: ModelUtils,
-) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[OverpressureError]:
+    movement_delay: Optional[float] = None,
+) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[
+    OverpressureError
+] | DefinedErrorData[StallOrCollisionError]:
     """Execute an aspirate while tracking microoperation."""
     try:
         volume_aspirated = await pipetting.aspirate_while_tracking(
@@ -254,6 +263,7 @@ async def aspirate_while_tracking(
             well_name=well_name,
             volume=volume,
             flow_rate=flow_rate,
+            end_point=end_point,
             command_note_adder=command_note_adder,
         )
     except PipetteOverpressureError as e:
@@ -272,6 +282,21 @@ async def aspirate_while_tracking(
             ),
             state_update=StateUpdate().set_fluid_unknown(pipette_id=pipette_id),
         )
+    except StallOrCollisionDetectedError as e:
+        return DefinedErrorData(
+            public=StallOrCollisionError(
+                id=model_utils.generate_id(),
+                createdAt=model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=model_utils.generate_id(),
+                        createdAt=model_utils.get_timestamp(),
+                        error=e,
+                    )
+                ],
+            ),
+            state_update=StateUpdate().clear_all_pipette_locations(),
+        )
     else:
         return SuccessData(
             public=BaseLiquidHandlingResult(
@@ -290,11 +315,15 @@ async def dispense_while_tracking(
     well_name: str,
     volume: float,
     flow_rate: float,
+    end_point: Point,
     push_out: float | None,
     location_if_error: ErrorLocationInfo,
     pipetting: PipettingHandler,
     model_utils: ModelUtils,
-) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[OverpressureError]:
+    movement_delay: Optional[float] = None,
+) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[
+    OverpressureError
+] | DefinedErrorData[StallOrCollisionError]:
     """Execute an dispense while tracking microoperation."""
     # The current volume won't be none since it passed validation
     current_volume = (
@@ -309,6 +338,7 @@ async def dispense_while_tracking(
             well_name=well_name,
             volume=volume,
             flow_rate=flow_rate,
+            end_point=end_point,
             push_out=push_out,
             is_full_dispense=is_full_dispense,
         )
@@ -332,6 +362,21 @@ async def dispense_while_tracking(
                 pipette_id=pipette_id, ready_to_aspirate=False
             ),
         )
+    except StallOrCollisionDetectedError as e:
+        return DefinedErrorData(
+            public=StallOrCollisionError(
+                id=model_utils.generate_id(),
+                createdAt=model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=model_utils.generate_id(),
+                        createdAt=model_utils.get_timestamp(),
+                        error=e,
+                    )
+                ],
+            ),
+            state_update=StateUpdate().clear_all_pipette_locations(),
+        )
     else:
         return SuccessData(
             public=BaseLiquidHandlingResult(

opentrons/protocol_engine/commands/set_tip_state.py

@@ -0,0 +1,97 @@
+"""Set tip state command request, result, and implementation models."""
+
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Optional, Type, List
+from typing_extensions import Literal
+
+from ..errors.error_occurrence import ErrorOccurrence
+from ..state.update_types import StateUpdate
+from ..types import TipRackWellState
+
+
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+
+
+SetTipStateCommandType = Literal["setTipState"]
+
+
+class SetTipStateParams(BaseModel):
+    """Payload needed to set tip wells of a tip rack to the requested state."""
+
+    labwareId: str = Field(
+        ..., description="Identifier of tip rack labware to set tip wells in."
+    )
+    wellNames: List[str] = Field(
+        ..., description="Names of the well to set tip well state for."
+    )
+    tipWellState: TipRackWellState = Field(
+        ..., description="State to set tip wells to."
+    )
+
+
+class SetTipStateResult(BaseModel):
+    """Result data from the execution of a setTipState command."""
+
+    pass
+
+
+class SetTipStateImplementation(
+    AbstractCommandImpl[SetTipStateParams, SuccessData[SetTipStateResult]]
+):
+    """Set tip state command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+
+    async def execute(
+        self, params: SetTipStateParams
+    ) -> SuccessData[SetTipStateResult]:
+        """Set the tip rack wells to the requested state."""
+        labware_id = params.labwareId
+        well_names = params.wellNames
+
+        self._state_view.labware.raise_if_not_tip_rack(labware_id=labware_id)
+        self._state_view.labware.raise_if_wells_are_invalid(
+            labware_id=labware_id, well_names=well_names
+        )
+
+        return SuccessData(
+            public=SetTipStateResult(),
+            state_update=StateUpdate().update_tip_rack_well_state(
+                tip_state=params.tipWellState,
+                labware_id=labware_id,
+                well_names=well_names,
+            ),
+        )
+
+
+class SetTipState(BaseCommand[SetTipStateParams, SetTipStateResult, ErrorOccurrence]):
+    """Set tip state command model."""
+
+    commandType: SetTipStateCommandType = "setTipState"
+    params: SetTipStateParams
+    result: Optional[SetTipStateResult] = None
+
+    _ImplementationCls: Type[SetTipStateImplementation] = SetTipStateImplementation
+
+
+class SetTipStateCreate(BaseCommandCreate[SetTipStateParams]):
+    """Set tip state command creation request model."""
+
+    commandType: SetTipStateCommandType = "setTipState"
+    params: SetTipStateParams
+
+    _CommandCls: Type[SetTipState] = SetTipState

opentrons/protocol_engine/commands/temperature_module/set_target_temperature.py

@@ -1,25 +1,35 @@
 """Command models to start heating a Temperature Module."""
 from __future__ import annotations
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Any
 from typing_extensions import Literal, Type
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
-    from opentrons.protocol_engine.execution import EquipmentHandler
+    from opentrons.protocol_engine.execution import EquipmentHandler, TaskHandler
 
 SetTargetTemperatureCommandType = Literal["temperatureModule/setTargetTemperature"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class SetTargetTemperatureParams(BaseModel):
     """Input parameters to set a Temperature Module's target temperature."""
 
     moduleId: str = Field(..., description="Unique ID of the Temperature Module.")
     celsius: float = Field(..., description="Target temperature in °C.")
+    taskId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Id for the background task that manages the temperature",
+        json_schema_extra=_remove_default,
+    )
 
 
 class SetTargetTemperatureResult(BaseModel):
@@ -30,6 +40,11 @@ class SetTargetTemperatureResult(BaseModel):
         description="The target temperature that was set after validation "
         "and type conversion (if any).",
     )
+    taskId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="The task id for the setTargetTemperature task",
+        json_schema_extra=_remove_default,
+    )
 
 
 class SetTargetTemperatureImpl(
@@ -43,10 +58,12 @@ class SetTargetTemperatureImpl(
         self,
         state_view: StateView,
         equipment: EquipmentHandler,
+        task_handler: TaskHandler,
         **unused_dependencies: object,
     ) -> None:
         self._state_view = state_view
         self._equipment = equipment
+        self._task_handler = task_handler
 
     async def execute(
         self, params: SetTargetTemperatureParams
@@ -56,19 +73,33 @@ class SetTargetTemperatureImpl(
         module_substate = self._state_view.modules.get_temperature_module_substate(
             module_id=params.moduleId
         )
-
         # Verify temperature from temperature module view
         validated_temp = module_substate.validate_target_temperature(params.celsius)
-
         # Allow propagation of ModuleNotAttachedError.
         temp_hardware_module = self._equipment.get_module_hardware_api(
             module_substate.module_id
         )
 
-        if temp_hardware_module is not None:
-            await temp_hardware_module.start_set_temperature(celsius=validated_temp)
+        async def start_set_temperature(task_handler: TaskHandler) -> None:
+            if temp_hardware_module is not None:
+                async with task_handler.synchronize_cancel_previous(
+                    module_substate.module_id
+                ):
+                    await temp_hardware_module.start_set_temperature(
+                        celsius=validated_temp
+                    )
+                    await temp_hardware_module.await_temperature(
+                        awaiting_temperature=validated_temp
+                    )
+
+        task = await self._task_handler.create_task(
+            task_function=start_set_temperature, id=params.taskId
+        )
+
         return SuccessData(
-            public=SetTargetTemperatureResult(targetTemperature=validated_temp),
+            public=SetTargetTemperatureResult(
+                targetTemperature=validated_temp, taskId=task.id
+            ),
         )
 
 

opentrons/protocol_engine/commands/thermocycler/__init__.py

@@ -73,6 +73,15 @@ from .run_profile import (
     RunProfileCreate,
 )
 
+from .start_run_extended_profile import (
+    StartRunExtendedProfileCommandType,
+    StartRunExtendedProfileParams,
+    StartRunExtendedProfileStepParams,
+    StartRunExtendedProfileResult,
+    StartRunExtendedProfile,
+    StartRunExtendedProfileCreate,
+)
+
 from .run_extended_profile import (
     RunExtendedProfileCommandType,
     RunExtendedProfileParams,
@@ -140,6 +149,13 @@ __all__ = [
     "RunProfileResult",
     "RunProfile",
     "RunProfileCreate",
+    # Start run profile command models,
+    "StartRunExtendedProfileCommandType",
+    "StartRunExtendedProfileParams",
+    "StartRunExtendedProfileStepParams",
+    "StartRunExtendedProfileResult",
+    "StartRunExtendedProfile",
+    "StartRunExtendedProfileCreate",
     # Run extended profile command models.
     "RunExtendedProfileCommandType",
     "RunExtendedProfileParams",

opentrons/protocol_engine/commands/thermocycler/run_extended_profile.py

@@ -33,6 +33,11 @@ class ProfileStep(BaseModel):
     holdSeconds: float = Field(
         ..., description="Time to hold target temperature in seconds."
     )
+    rampRate: float | SkipJsonSchema[None] = Field(
+        None,
+        description="How quickly to change temperature in °C/second.",
+        json_schema_extra=_remove_default,
+    )
 
 
 class ProfileCycle(BaseModel):
@@ -68,6 +73,7 @@ def _transform_profile_step(
     return ThermocyclerStep(
         temperature=thermocycler_state.validate_target_block_temperature(step.celsius),
         hold_time_seconds=step.holdSeconds,
+        ramp_rate=thermocycler_state.validate_ramp_rate(step.rampRate, step.celsius),
     )
 
 

opentrons/protocol_engine/commands/thermocycler/run_profile.py

@@ -30,6 +30,11 @@ class RunProfileStepParams(BaseModel):
     holdSeconds: float = Field(
         ..., description="Time to hold target temperature at in seconds."
     )
+    rampRate: float | SkipJsonSchema[None] = Field(
+        None,
+        description="How quickly to change temperature in °C/second.",
+        json_schema_extra=_remove_default,
+    )
 
 
 class RunProfileParams(BaseModel):
@@ -81,6 +86,9 @@ class RunProfileImpl(
                     profile_step.celsius
                 ),
                 hold_time_seconds=profile_step.holdSeconds,
+                ramp_rate=thermocycler_state.validate_ramp_rate(
+                    profile_step.rampRate, profile_step.celsius
+                ),
             )
             for profile_step in params.profile
         ]

opentrons/protocol_engine/commands/thermocycler/set_target_block_temperature.py

@@ -1,4 +1,4 @@
-"""Command models to start heating a Thermocycler's block."""
+"""Command models for heating a Thermocycler's block."""
 from __future__ import annotations
 from typing import Optional, TYPE_CHECKING, Any
 from typing_extensions import Literal, Type
@@ -11,7 +11,7 @@ from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
-    from opentrons.protocol_engine.execution import EquipmentHandler
+    from opentrons.protocol_engine.execution import EquipmentHandler, TaskHandler
 
 
 SetTargetBlockTemperatureCommandType = Literal["thermocycler/setTargetBlockTemperature"]
@@ -39,6 +39,17 @@ class SetTargetBlockTemperatureParams(BaseModel):
         " the given hold time has elapsed.",
         json_schema_extra=_remove_default,
     )
+    ramp_rate: float | SkipJsonSchema[None] = Field(
+        None,
+        description="The rate in C°/second to change temperature from the current target."
+        " If unspecified, the Thermocycler will change temperature at the fastest possible rate.",
+        json_schema_extra=_remove_default,
+    )
+    taskId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Id for the background task that manages the temperature.",
+        json_schema_extra=_remove_default,
+    )
 
 
 class SetTargetBlockTemperatureResult(BaseModel):
@@ -48,6 +59,11 @@ class SetTargetBlockTemperatureResult(BaseModel):
         ...,
         description="The target block temperature that was set after validation.",
     )
+    taskId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Id for the background task that manages the temperature.",
+        json_schema_extra=_remove_default,
+    )
 
 
 class SetTargetBlockTemperatureImpl(
@@ -62,10 +78,12 @@ class SetTargetBlockTemperatureImpl(
         self,
         state_view: StateView,
         equipment: EquipmentHandler,
+        task_handler: TaskHandler,
         **unused_dependencies: object,
     ) -> None:
         self._state_view = state_view
         self._equipment = equipment
+        self._task_handler = task_handler
 
     async def execute(
         self,
@@ -90,19 +108,38 @@ class SetTargetBlockTemperatureImpl(
             hold_time = thermocycler_state.validate_hold_time(params.holdTimeSeconds)
         else:
             hold_time = None
+        target_ramp_rate: Optional[float]
+        if params.ramp_rate is not None:
+            target_ramp_rate = thermocycler_state.validate_ramp_rate(
+                params.ramp_rate, target_temperature
+            )
+        else:
+            target_ramp_rate = None
 
         thermocycler_hardware = self._equipment.get_module_hardware_api(
             thermocycler_state.module_id
         )
 
-        if thermocycler_hardware is not None:
-            await thermocycler_hardware.set_target_block_temperature(
-                target_temperature, volume=target_volume, hold_time_seconds=hold_time
-            )
+        async def set_target_block_temperature(task_handler: TaskHandler) -> None:
+            if thermocycler_hardware is not None:
+                async with task_handler.synchronize_cancel_latest(
+                    thermocycler_state.module_id + "-block"
+                ):
+                    await thermocycler_hardware.set_target_block_temperature(
+                        celsius=target_temperature,
+                        volume=target_volume,
+                        ramp_rate=target_ramp_rate,
+                        hold_time_seconds=hold_time,
+                    )
+                    await thermocycler_hardware.wait_for_block_target()
+
+        task = await self._task_handler.create_task(
+            task_function=set_target_block_temperature, id=params.taskId
+        )
 
         return SuccessData(
             public=SetTargetBlockTemperatureResult(
-                targetBlockTemperature=target_temperature
+                targetBlockTemperature=target_temperature, taskId=task.id
             ),
         )