dls-dodal 1.55.1__py3-none-any.whl → 1.57.0__py3-none-any.whl

dodal/devices/i24/pmac.py

@@ -17,8 +17,9 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.motors import XYZStage
 
-HOME_STR = r"\#1hmz\#2hmz\#3hmz"  # Command to home the PMAC motors
+HOME_STR = r"\#5hmz\#6hmz\#7hmz"  # Command to home the PMAC motors
 ZERO_STR = "!x0y0z0"  # Command to blend any ongoing move into new position
+CS_STR = "&2"
 
 
 class ScanState(IntEnum):
@@ -196,12 +197,12 @@ class PMAC(XYZStage):
     """Device to control the chip stage on I24."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.pmac_string = epics_signal_rw(str, prefix + "PMAC_STRING")
+        self.pmac_string = epics_signal_rw(str, f"{prefix}-MO-IOC-13:PMAC:console")
         self.home = PMACStringMove(
             self.pmac_string,
-            HOME_STR,
+            f"{CS_STR}{HOME_STR}",
         )
-        self.to_xyz_zero = PMACStringMove(self.pmac_string, ZERO_STR)
+        self.to_xyz_zero = PMACStringMove(self.pmac_string, f"{CS_STR}{ZERO_STR}")
 
         self.laser = PMACStringLaser(self.pmac_string)
 
@@ -211,8 +212,8 @@ class PMAC(XYZStage):
 
         # These next signals are readback values on PVARS which are set by the motion
         # program.
-        self.scanstatus = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2401")
-        self.counter = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2402")
+        self.scanstatus = epics_signal_r(float, f"{prefix}-MO-STEP-13:pmac:read:P2401")
+        self.counter = epics_signal_r(float, f"{prefix}-MO-STEP-13:pmac:read:P2402")
 
         # A couple of soft signals for running a collection: program number to send to
         # the PMAC_STRING and expected collection time.
@@ -228,4 +229,4 @@ class PMAC(XYZStage):
         )
         self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 
-        super().__init__(prefix, name)
+        super().__init__(f"{prefix}-MO-CHIP-01:", name)

dodal/devices/mx_phase1/beamstop.py

@@ -18,9 +18,6 @@ class BeamstopPositions(StrictEnum):
     robot load however all 3 resolution positions are the same. We also
     do not use the robot load position in Hyperion.
 
-    Until we support moving the beamstop it is only necessary to check whether the
-    beamstop is in beam or not.
-
     See Also:
         https://github.com/DiamondLightSource/mx-bluesky/issues/484
 
@@ -86,11 +83,13 @@ class Beamstop(StandardReadable):
             return BeamstopPositions.UNKNOWN
 
     async def _set_selected_position(self, position: BeamstopPositions) -> None:
-        if position == BeamstopPositions.DATA_COLLECTION:
-            await asyncio.gather(
-                self.x_mm.set(self._in_beam_xyz_mm[0]),
-                self.y_mm.set(self._in_beam_xyz_mm[1]),
-                self.z_mm.set(self._in_beam_xyz_mm[2]),
-            )
-        elif position == BeamstopPositions.UNKNOWN:
-            raise ValueError(f"Cannot set beamstop to position {position}")
+        match position:
+            case BeamstopPositions.DATA_COLLECTION:
+                # Move z first as it could be under the table
+                await self.z_mm.set(self._in_beam_xyz_mm[2])
+                await asyncio.gather(
+                    self.x_mm.set(self._in_beam_xyz_mm[0]),
+                    self.y_mm.set(self._in_beam_xyz_mm[1]),
+                )
+            case _:
+                raise ValueError(f"Cannot set beamstop to position {position}")

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -48,9 +48,6 @@ class PinTipDetection(StandardReadable):
     INVALID_POSITION = np.array([np.iinfo(np.int32).min, np.iinfo(np.int32).min])
 
     def __init__(self, prefix: str, name: str = ""):
-        self._prefix: str = prefix
-        self._name = name
-
         self.triggered_tip, self._tip_setter = soft_signal_r_and_setter(
             Tip, name="triggered_tip"
         )

dodal/devices/p60/enums.py

@@ -16,11 +16,11 @@ class PsuMode(StrictEnum):
 
 
 class PassEnergy(StrictEnum):
-    E1 = 1
-    E2 = 2
-    E5 = 5
-    E10 = 10
-    E20 = 20
-    E50 = 50
-    E100 = 100
-    E200 = 200
+    E1 = "1"
+    E2 = "2"
+    E5 = "5"
+    E10 = "10"
+    E20 = "20"
+    E50 = "50"
+    E100 = "100"
+    E200 = "200"

dodal/devices/p60/lab_xray_source.py

@@ -1,11 +1,12 @@
+from enum import Enum
+
 from ophyd_async.core import (
     StandardReadable,
-    StrictEnum,
     soft_signal_r_and_setter,
 )
 
 
-class LabXraySource(StrictEnum):
+class LabXraySource(float, Enum):
     AL_KALPHA = 1486.6
     MG_KALPHA = 1253.6
 

dodal/devices/pressure_jump_cell.py

@@ -1,7 +1,8 @@
 import asyncio
-from dataclasses import dataclass
+from enum import IntEnum
+from typing import Generic, TypeVar
 
-from bluesky.protocols import HasName, Movable
+from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     DeviceVector,
@@ -26,23 +27,23 @@ class StopState(StrictEnum):
     STOP = "STOP"
 
 
-class FastValveControlRequest(StrictEnum):
+class ValveControlRequest(StrictEnum):
     OPEN = "Open"
     CLOSE = "Close"
     RESET = "Reset"
-    ARM = "Arm"
-    DISARM = "Disarm"
 
 
-class ValveControlRequest(StrictEnum):
-    OPEN = "Open"
-    CLOSE = "Close"
-    RESET = "Reset"
+class FastValveControlRequest(StrictEnum):
+    OPEN = ValveControlRequest.OPEN.value
+    CLOSE = ValveControlRequest.CLOSE.value
+    RESET = ValveControlRequest.RESET.value
+    ARM = "Arm"
+    DISARM = "Disarm"
 
 
-class ValveOpenSeqRequest(StrictEnum):
-    INACTIVE = "0"
-    OPEN_SEQ = "1"
+class ValveOpenSeqRequest(IntEnum):
+    INACTIVE = 0
+    OPEN_SEQ = 1
 
 
 class PumpMotorDirectionState(StrictEnum):
@@ -60,138 +61,89 @@ class ValveState(StrictEnum):
 
 
 class FastValveState(StrictEnum):
-    FAULT = "Fault"
-    OPEN = "Open"
+    FAULT = ValveState.FAULT.value
+    OPEN = ValveState.OPEN.value
     OPEN_ARMED = "Open Armed"
-    CLOSED = "Closed"
+    CLOSED = ValveState.CLOSED.value
     CLOSED_ARMED = "Closed Armed"
     NONE = "Unused"
 
 
-@dataclass
-class AllValvesControlState:
-    valve_1: ValveControlRequest | None = None
-    valve_3: ValveControlRequest | None = None
-    valve_5: FastValveControlRequest | None = None
-    valve_6: FastValveControlRequest | None = None
+TValveControlRequest = TypeVar(
+    "TValveControlRequest", bound=ValveControlRequest | FastValveControlRequest
+)
+
+
+class ValveControl(
+    StandardReadable, Movable[TValveControlRequest], Generic[TValveControlRequest]
+):
+    def __init__(
+        self,
+        prefix: str,
+        valve_control_type: type[TValveControlRequest],
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.control = epics_signal_rw(valve_control_type, prefix + ":CON")
+            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: TValveControlRequest):
+        if value.value == "Open":
+            await self.open.set(ValveOpenSeqRequest.OPEN_SEQ)
+            await asyncio.sleep(OPENSEQ_PULSE_LENGTH)
+            await self.open.set(ValveOpenSeqRequest.INACTIVE)
+        else:
+            await self.control.set(value)
 
 
-class AllValvesControl(StandardReadable, Movable[AllValvesControlState]):
+class AllValvesControl(StandardReadable):
     """
-    valves 2, 4, 7, 8 are not controlled by the IOC,
-    as they are under manual control.
-    fast_valves: tuple[int, ...] = (5, 6)
-    slow_valves: tuple[int, ...] = (1, 3)
+    The default IOC for this device only controls
+    specific valves. Other valves are under manual
+    control.
     """
 
     def __init__(
         self,
         prefix: str,
         name: str = "",
-        fast_valves: tuple[int, ...] = (5, 6),
-        slow_valves: tuple[int, ...] = (1, 3),
+        fast_valves_numbers: tuple[int, ...] = (5, 6),
+        slow_valves_numbers: tuple[int, ...] = (1, 3),
     ) -> None:
-        self.fast_valves = fast_valves
-        self.slow_valves = slow_valves
         with self.add_children_as_readables():
             self.valve_states: DeviceVector[SignalR[ValveState]] = DeviceVector(
                 {
                     i: epics_signal_r(ValveState, f"{prefix}V{i}:STA")
-                    for i in self.slow_valves
+                    for i in slow_valves_numbers
                 }
             )
             self.fast_valve_states: DeviceVector[SignalR[FastValveState]] = (
                 DeviceVector(
                     {
                         i: epics_signal_r(FastValveState, f"{prefix}V{i}:STA")
-                        for i in self.fast_valves
+                        for i in fast_valves_numbers
                     }
                 )
             )
 
-        self.fast_valve_control: DeviceVector[FastValveControl] = DeviceVector(
-            {i: FastValveControl(f"{prefix}V{i}") for i in self.fast_valves}
-        )
-
-        self.valve_control: DeviceVector[ValveControl] = DeviceVector(
-            {i: ValveControl(f"{prefix}V{i}") for i in self.slow_valves}
-        )
-
-        super().__init__(name)
-
-    async def set_valve(
-        self,
-        valve: int,
-        value: ValveControlRequest | FastValveControlRequest,
-    ):
-        if valve in self.slow_valves and (isinstance(value, ValveControlRequest)):
-            if value == ValveControlRequest.OPEN:
-                await self.valve_control[valve].set(ValveOpenSeqRequest.OPEN_SEQ)
-                await asyncio.sleep(OPENSEQ_PULSE_LENGTH)
-                await self.valve_control[valve].set(ValveOpenSeqRequest.INACTIVE)
-            else:
-                await self.valve_control[valve].set(value)
-
-        elif valve in self.fast_valves and (isinstance(value, FastValveControlRequest)):
-            if value == FastValveControlRequest.OPEN:
-                await self.fast_valve_control[valve].set(ValveOpenSeqRequest.OPEN_SEQ)
-                await asyncio.sleep(OPENSEQ_PULSE_LENGTH)
-                await self.fast_valve_control[valve].set(ValveOpenSeqRequest.INACTIVE)
-            else:
-                await self.fast_valve_control[valve].set(value)
-
-    @AsyncStatus.wrap
-    async def set(self, value: AllValvesControlState):
-        await asyncio.gather(
-            *(
-                self.set_valve(int(i[-1]), value)
-                for i, value in value.__dict__.items()
-                if value is not None
-            )
-        )
-
-
-class ValveControl(
-    StandardReadable, Movable[ValveControlRequest | ValveOpenSeqRequest]
-):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            self.close = epics_signal_rw(ValveControlRequest, prefix + ":CON")
-            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
-
-        super().__init__(name)
-
-    def set(self, value: ValveControlRequest | ValveOpenSeqRequest) -> AsyncStatus:
-        set_status = None
-
-        if isinstance(value, ValveControlRequest):
-            set_status = self.close.set(value)
-        elif isinstance(value, ValveOpenSeqRequest):
-            set_status = self.open.set(value.value)
+        self.fast_valve_control = {
+            i: ValveControl(f"{prefix}V{i}", FastValveControlRequest)
+            for i in fast_valves_numbers
+        }
 
-        return set_status
+        self.slow_valve_control = {
+            i: ValveControl(f"{prefix}V{i}", ValveControlRequest)
+            for i in slow_valves_numbers
+        }
 
+        all_valves = self.fast_valve_control | self.slow_valve_control
 
-class FastValveControl(
-    StandardReadable, Movable[FastValveControlRequest | ValveOpenSeqRequest]
-):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            self.close = epics_signal_rw(FastValveControlRequest, prefix + ":CON")
-            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
+        self.valve_control: DeviceVector[ValveControl] = DeviceVector(all_valves)
 
         super().__init__(name)
 
-    def set(self, value: FastValveControlRequest | ValveOpenSeqRequest) -> AsyncStatus:
-        set_status = None
-
-        if isinstance(value, FastValveControlRequest):
-            set_status = self.close.set(value)
-        elif isinstance(value, ValveOpenSeqRequest):
-            set_status = self.open.set(value.value)
-
-        return set_status
-
 
 class Pump(StandardReadable):
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -249,25 +201,27 @@ class PressureTransducer(StandardReadable):
         super().__init__(name)
 
 
-class PressureJumpCellController(HasName):
+class PressureJumpCellController(StandardReadable):
+    """
+    Top-level control for a fixed pressure or pressure jumps.
+    """
+
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.stop = epics_signal_rw(StopState, f"{prefix}STOP")
+        with self.add_children_as_readables():
+            self.stop = epics_signal_rw(StopState, f"{prefix}STOP")
 
-        self.target_pressure = epics_signal_rw(float, f"{prefix}TARGET")
-        self.timeout = epics_signal_rw(float, f"{prefix}TIMER.HIGH")
-        self.go = epics_signal_rw(bool, f"{prefix}GO")
+            self.target_pressure = epics_signal_rw(float, f"{prefix}TARGET")
+            self.timeout = epics_signal_rw(float, f"{prefix}TIMER.HIGH")
+            self.go = epics_signal_rw(bool, f"{prefix}GO")
 
-        ## Jump logic ##
-        self.start_pressure = epics_signal_rw(float, f"{prefix}JUMPF")
-        self.target_pressure = epics_signal_rw(float, f"{prefix}JUMPT")
-        self.jump_ready = epics_signal_rw(bool, f"{prefix}SETJUMP")
+            self.from_pressure = epics_signal_rw(float, f"{prefix}JUMPF")
+            self.to_pressure = epics_signal_rw(float, f"{prefix}JUMPT")
+            self.jump_ready = epics_signal_rw(bool, f"{prefix}SETJUMP")
 
-        self._name = name
-        super().__init__()
+            self.result = epics_signal_r(str, f"{prefix}RESULT")
 
-    @property
-    def name(self):
-        return self._name
+            self._name = name
+        super().__init__(name)
 
 
 class PressureJumpCell(StandardReadable):

dodal/devices/scintillator.py

@@ -1,10 +1,82 @@
-from ophyd_async.core import StandardReadable
+from math import isclose
+
+from ophyd_async.core import Reference, StandardReadable, StrictEnum, derived_signal_rw
 from ophyd_async.epics.motor import Motor
 
+from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
+from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
+
+
+class InOut(StrictEnum):
+    """Currently Hyperion only needs to move the scintillator out for data collection."""
+
+    OUT = "Out"
+    UNKNOWN = "Unknown"
+
 
 class Scintillator(StandardReadable):
-    def __init__(self, prefix: str, name: str = ""):
+    """Moves a scintillator into and out of the beam.
+
+    The scintillator will light up when hit with xrays, this allows scientists to use it
+    in conjunction with the optical OAV camera to commission the beamline.
+
+    When moved out of the beam it is parked under the table. This parking has a potential
+    to collide with the aperture/scatterguard if that is not correctly parked already.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        aperture_scatterguard: Reference[ApertureScatterguard],
+        beamline_parameters: GDABeamlineParameters,
+        name: str = "",
+    ):
         with self.add_children_as_readables():
-            self.y = Motor(prefix + "-MO-SCIN-01:Y")
-            self.z = Motor(prefix + "-MO-SCIN-01:Z")
+            self.y_mm = Motor(f"{prefix}Y")
+            self.z_mm = Motor(f"{prefix}Z")
+            self.selected_pos = derived_signal_rw(
+                self._get_selected_position,
+                self._set_selected_position,
+                y=self.y_mm,
+                z=self.z_mm,
+            )
+
+        self._aperture_scatterguard = aperture_scatterguard
+        self._scintillator_out_yz_mm = [
+            float(beamline_parameters[f"scin_{axis}_SCIN_OUT"]) for axis in ("y", "z")
+        ]
+        self._yz_tolerance_mm = [
+            float(beamline_parameters[f"scin_{axis}_tolerance"]) for axis in ("y", "z")
+        ]
+
         super().__init__(name)
+
+    def _get_selected_position(self, y: float, z: float) -> InOut:
+        current_pos = [y, z]
+        if all(
+            isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
+            for axis_pos, axis_in_beam, axis_tolerance in zip(
+                current_pos,
+                self._scintillator_out_yz_mm,
+                self._yz_tolerance_mm,
+                strict=False,
+            )
+        ):
+            return InOut.OUT
+        else:
+            return InOut.UNKNOWN
+
+    async def _set_selected_position(self, position: InOut) -> None:
+        match position:
+            case InOut.OUT:
+                if (
+                    self._aperture_scatterguard().selected_aperture.get_value()
+                    != ApertureValue.PARKED
+                ):
+                    raise ValueError(
+                        "Cannot move scintillator out if aperture/scatterguard is not parked"
+                    )
+                await self.y_mm.set(self._scintillator_out_yz_mm[0])
+                await self.z_mm.set(self._scintillator_out_yz_mm[1])
+            case _:
+                raise ValueError(f"Cannot set scintillator to position {position}")

dodal/devices/smargon.py

@@ -3,7 +3,7 @@ from collections.abc import Collection, Generator
 from dataclasses import dataclass
 from enum import Enum
 from math import isclose
-from typing import NotRequired, TypedDict, cast
+from typing import TypedDict, cast
 
 from bluesky import plan_stubs as bps
 from bluesky.protocols import Movable
@@ -12,6 +12,7 @@ from ophyd_async.core import (
     AsyncStatus,
     Device,
     StrictEnum,
+    set_and_wait_for_value,
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
@@ -42,7 +43,7 @@ class StubOffsets(Device):
     set them so that the current position is zero or to pre-defined positions.
     """
 
-    def __init__(self, name: str = "", prefix: str = ""):
+    def __init__(self, prefix: str, name: str = ""):
         self.center_at_current_position = SetWhenEnabled(prefix=prefix + "CENTER_CS")
         self.to_robot_load = SetWhenEnabled(prefix=prefix + "SET_STUBS_TO_RL")
         super().__init__(name)
@@ -104,15 +105,15 @@ class DeferMoves(StrictEnum):
     OFF = "Defer Off"
 
 
-class CombinedMove(TypedDict):
+class CombinedMove(TypedDict, total=False):
     """A move on multiple axes at once using a deferred move"""
 
-    x: NotRequired[float | None]
-    y: NotRequired[float | None]
-    z: NotRequired[float | None]
-    omega: NotRequired[float | None]
-    phi: NotRequired[float | None]
-    chi: NotRequired[float | None]
+    x: float | None
+    y: float | None
+    z: float | None
+    omega: float | None
+    phi: float | None
+    chi: float | None
 
 
 class Smargon(XYZStage, Movable):
@@ -123,7 +124,9 @@ class Smargon(XYZStage, Movable):
     Robot loading can nudge these and lead to errors.
     """
 
-    def __init__(self, prefix: str = "", name: str = ""):
+    DEFERRED_MOVE_SET_TIMEOUT = 5
+
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.chi = Motor(prefix + "CHI")
             self.phi = Motor(prefix + "PHI")
@@ -161,15 +164,29 @@ class Smargon(XYZStage, Movable):
 
     @AsyncStatus.wrap
     async def set(self, value: CombinedMove):
+        """This will move all motion together in a deferred move.
+
+        Once defer_move is on, sets to any axis do not immediately move the axis. Instead
+        the setpoint will go to that value. Then, when defer_move is switched off all
+        axes will move at the same time. The put callbacks on the axes themselves will
+        only come back after the motion on that axis finished.
+        """
         await self.defer_move.set(DeferMoves.ON)
         try:
-            tasks = []
-            for k, v in value.items():
-                if v is not None:
-                    tasks.append(getattr(self, k).set(v))
+            finished_moving = []
+            for motor_name, new_setpoint in value.items():
+                if new_setpoint is not None and isinstance(new_setpoint, int | float):
+                    axis: Motor = getattr(self, motor_name)
+                    await axis.check_motor_limit(
+                        await axis.user_setpoint.get_value(), new_setpoint
+                    )
+                    put_completion = await set_and_wait_for_value(
+                        axis.user_setpoint,
+                        new_setpoint,
+                        timeout=self.DEFERRED_MOVE_SET_TIMEOUT,
+                        wait_for_set_completion=False,
+                    )
+                    finished_moving.append(put_completion)
         finally:
             await self.defer_move.set(DeferMoves.OFF)
-        # The set() coroutines will not complete until after defer moves has been
-        # switched back off so we cannot wait for them until this point.
-        # see https://github.com/DiamondLightSource/dodal/issues/1315
-        await asyncio.gather(*tasks)
+        await asyncio.gather(*finished_moving)

dodal/devices/synchrotron.py

@@ -38,8 +38,7 @@ class SynchrotronMode(StrictEnum):
 class Synchrotron(StandardReadable):
     def __init__(
         self,
-        prefix: str = "",
-        name: str = "synchrotron",
+        name: str = "",
         *,
         signal_prefix=Prefix.SIGNAL,
         status_prefix=Prefix.STATUS,

dodal/devices/thawer.py

@@ -1,56 +1,63 @@
-from asyncio import Task, create_task, sleep
+from asyncio import CancelledError, Task, create_task, sleep
 
 from bluesky.protocols import Movable, Stoppable
 from ophyd_async.core import (
     AsyncStatus,
     Device,
+    OnOff,
     Reference,
     SignalRW,
     StandardReadable,
-    StrictEnum,
 )
 from ophyd_async.epics.core import epics_signal_rw
 
+from dodal.log import LOGGER
+
 
 class ThawingException(Exception):
     pass
 
 
-class ThawerStates(StrictEnum):
-    OFF = "Off"
-    ON = "On"
-
-
 class ThawingTimer(Device, Stoppable, Movable[float]):
-    def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
+    def __init__(self, control_signal: SignalRW[OnOff]) -> None:
         self._control_signal_ref = Reference(control_signal)
         self._thawing_task: Task | None = None
         super().__init__("thaw_for_time_s")
 
     @AsyncStatus.wrap
     async def set(self, value: float):
-        await self._control_signal_ref().set(ThawerStates.ON)
-        if self._thawing_task and not self._thawing_task.done():
-            raise ThawingException("Thawing task already in progress")
+        if self._thawing_task:
+            LOGGER.info("Thawing task already in progress, resetting timer")
+            self._thawing_task.cancel()
+        else:
+            LOGGER.info("Thawing started")
+            await self._control_signal_ref().set(OnOff.ON)
         self._thawing_task = create_task(sleep(value))
         try:
             await self._thawing_task
-        finally:
-            await self._control_signal_ref().set(ThawerStates.OFF)
+        except CancelledError:
+            LOGGER.info("Timer task cancelled.")
+            raise
+        else:
+            LOGGER.info("Thawing completed")
+            await self._control_signal_ref().set(OnOff.OFF)
 
     @AsyncStatus.wrap
     async def stop(self, *args, **kwargs):
         if self._thawing_task:
             self._thawing_task.cancel()
+            self._thawing_task = None
+        LOGGER.info("Thawer stopped.")
+        await self._control_signal_ref().set(OnOff.OFF)
 
 
 class Thawer(StandardReadable, Stoppable):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.control = epics_signal_rw(ThawerStates, prefix + ":CTRL")
+        self.control = epics_signal_rw(OnOff, prefix + ":CTRL")
         self.thaw_for_time_s = ThawingTimer(self.control)
         super().__init__(name)
 
     @AsyncStatus.wrap
     async def stop(self, *args, **kwargs):
         await self.thaw_for_time_s.stop()
-        await self.control.set(ThawerStates.OFF)
+        await self.control.set(OnOff.OFF)