ophyd-async 0.9.0a2__py3-none-any.whl → 0.10.0a2__py3-none-any.whl

ophyd_async/epics/core/_aioca.py

@@ -1,6 +1,8 @@
 import logging
 import sys
+import typing
 from collections.abc import Sequence
+from functools import cache
 from math import isnan, nan
 from typing import Any, Generic, cast
 
@@ -47,6 +49,7 @@ def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
             )
+        return None
 
     limits = Limits()
     if limits_range := get_limits("alarm"):
@@ -181,6 +184,9 @@ def make_converter(
         Dbr, get_unique({k: v.datatype for k, v in values.items()}, "datatypes")
     )
     is_array = bool([v for v in values.values() if v.element_count > 1])
+    # Make the datatype canonical for the inference below
+    if datatype == typing.Sequence[str]:
+        datatype = Sequence[str]
     # Infer a datatype and converter from the dbr
     inferred_datatype, converter_cls = _datatype_converter_from_dbr[(pv_dbr, is_array)]
     # Some override cases
@@ -227,19 +233,18 @@ def make_converter(
     )
 
 
-_tried_pyepics = False
-
-
+# Cached call to avoid repeated initialization attempts
+@cache
 def _use_pyepics_context_if_imported():
-    global _tried_pyepics
-    if not _tried_pyepics:
-        ca = sys.modules.get("epics.ca", None)
-        if ca:
-            ca.use_initial_context()
-        _tried_pyepics = True
+    """Sets up the pyepics context if the module is imported."""
+    ca = sys.modules.get("epics.ca", None)
+    if ca:
+        ca.use_initial_context()
 
 
 class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
+    """Backend for a signal to interact with PVs over channel access."""
+
     def __init__(
         self,
         datatype: type[SignalDatatypeT] | None,
@@ -293,13 +298,27 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
             write_value = self.initial_values[self.write_pv]
         else:
             write_value = self.converter.write_value(value)
-        await caput(
-            self.write_pv,
-            write_value,
-            datatype=self.converter.write_dbr,
-            wait=wait,
-            timeout=None,
-        )
+        try:
+            await caput(
+                self.write_pv,
+                write_value,
+                datatype=self.converter.write_dbr,
+                wait=wait,
+                timeout=None,
+            )
+        except CANothing as exc:
+            # If we ran into a write error, check to see if there is a list
+            # of valid choices, and if the value we tried to write is in that list.
+            valid_choices = self.converter.metadata.get("choices")
+            if valid_choices:
+                if value not in valid_choices:
+                    msg = (
+                        f"{value} is not a valid choice for {self.write_pv}, "
+                        f"valid choices: {self.converter.metadata.get('choices')}"
+                    )
+                    raise ValueError(msg) from exc
+                raise
+            raise
 
     async def get_datakey(self, source: str) -> DataKey:
         value = await self._caget(self.read_pv, FORMAT_CTRL)

ophyd_async/epics/core/_epics_connector.py

@@ -10,6 +10,8 @@ from ._signal import EpicsSignalBackend, get_signal_backend_type, split_protocol
 
 @dataclass
 class PvSuffix:
+    """Define the PV suffix to be appended to the device prefix."""
+
     read_suffix: str
     write_suffix: str | None = None
 
@@ -36,6 +38,8 @@ def fill_backend_with_prefix(
 
 
 class EpicsDeviceConnector(DeviceConnector):
+    """Used for connecting signals to static EPICS pvs."""
+
     def __init__(self, prefix: str) -> None:
         self.prefix = prefix
 

ophyd_async/epics/core/_epics_device.py

@@ -5,6 +5,8 @@ from ._pvi_connector import PviDeviceConnector
 
 
 class EpicsDevice(Device):
+    """Baseclass to allow child signals to be created declaratively."""
+
     def __init__(self, prefix: str, with_pvi: bool = False, name: str = ""):
         if with_pvi:
             connector = PviDeviceConnector(prefix)

ophyd_async/epics/core/_p4p.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import atexit
 import logging
+import typing
 from collections.abc import Mapping, Sequence
 from math import isnan, nan
 from typing import Any, Generic
@@ -46,6 +47,7 @@ def _limits_from_value(value: Any) -> Limits:
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
             )
+        return None
 
     limits = Limits()
     if limits_range := get_limits("valueAlarm", "lowAlarmLimit", "highAlarmLimit"):
@@ -245,6 +247,9 @@ def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverte
         {k: _get_specifier(v) for k, v in values.items()},
         "value type specifiers",
     )
+    # Make the datatype canonical for the inference below
+    if datatype == typing.Sequence[str]:
+        datatype = Sequence[str]
     # Infer a datatype and converter from the typeid and specifier
     inferred_datatype, converter_cls = _datatype_converter_from_typeid[
         (typeid, specifier)
@@ -328,13 +333,16 @@ async def pvget_with_timeout(pv: str, timeout: float) -> Any:
 
 
 def _pva_request_string(fields: Sequence[str]) -> str:
-    """Converts a list of requested fields into a PVA request string which can be
-    passed to p4p.
+    """Convert a list of requested fields into a PVA request string.
+
+    This can be passed to p4p.
     """
     return f"field({','.join(fields)})"
 
 
 class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
+    """Backend for a signal to interact with PVs over pva."""
+
     def __init__(
         self,
         datatype: type[SignalDatatypeT] | None,

ophyd_async/epics/core/_pvi_connector.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Literal, cast
+
 from ophyd_async.core import (
     Device,
     DeviceConnector,
@@ -7,6 +9,7 @@ from ophyd_async.core import (
     Signal,
     SignalR,
     SignalRW,
+    SignalW,
     SignalX,
 )
 from ophyd_async.core._utils import LazyMock
@@ -16,6 +19,27 @@ from ._signal import PvaSignalBackend, pvget_with_timeout
 
 Entry = dict[str, str]
 
+OldPVIVector = list[Entry | None]
+# The older PVI structure has vectors of the form
+# structure[] ttlout
+#     (none)
+#     structure
+#         string d PANDABLOCKS_IOC:TTLOUT1:PVI
+#     structure
+#         string d PANDABLOCKS_IOC:TTLOUT2:PVI
+#     structure
+#         string d PANDABLOCKS_IOC:TTLOUT3:PVI
+
+
+FastCSPVIVector = dict[Literal["d"], Entry]
+# The newer pva FastCS PVI structure has vectors of the form
+# structure ttlout
+#     structure d
+#         string v1 FASTCS_PANDA:Ttlout1:PVI
+#         string v2 FASTCS_PANDA:Ttlout2:PVI
+#         string v3 FASTCS_PANDA:Ttlout3:PVI
+#         string v4 FASTCS_PANDA:Ttlout4:PVI
+
 
 def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
     match entry:
@@ -23,6 +47,8 @@ def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
             return SignalR, read_pv, read_pv
         case {"r": read_pv, "w": write_pv}:
             return SignalRW, read_pv, write_pv
+        case {"w": write_pv}:
+            return SignalW, write_pv, write_pv
         case {"rw": read_write_pv}:
             return SignalRW, read_write_pv, read_write_pv
         case {"x": execute_pv}:
@@ -31,7 +57,26 @@ def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
             raise TypeError(f"Can't process entry {entry}")
 
 
+def _is_device_vector_entry(entry: Entry | OldPVIVector | FastCSPVIVector) -> bool:
+    return isinstance(entry, list) or (
+        entry.keys() == {"d"} and isinstance(entry["d"], dict)
+    )
+
+
 class PviDeviceConnector(DeviceConnector):
+    """Connect to PVI structure served over PVA.
+
+    At init, fill in all the type hinted signals. At connection check their
+    types and fill in any extra signals.
+
+    :param prefix:
+        The PV prefix of the device, "PVI" will be appended to it to get the PVI
+        PV.
+    :param error_hint:
+        If given, this will be appended to the error message if any of they type
+        hinted Signals are not present.
+    """
+
     def __init__(self, prefix: str = "", error_hint: str = "") -> None:
         # TODO: what happens if we get a leading "pva://" here?
         self.prefix = prefix
@@ -70,21 +115,33 @@ class PviDeviceConnector(DeviceConnector):
         device.set_name(device.name)
         return await super().connect_mock(device, mock)
 
+    def _fill_vector_child(self, name: str, entry: OldPVIVector | FastCSPVIVector):
+        if isinstance(entry, list):
+            for i, e in enumerate(entry):
+                if e:
+                    self._fill_child(name, e, i)
+        else:
+            for i_string, e in entry["d"].items():
+                self._fill_child(name, {"d": e}, int(i_string.lstrip("v")))
+
     async def connect_real(
         self, device: Device, timeout: float, force_reconnect: bool
     ) -> None:
         pvi_structure = await pvget_with_timeout(self.pvi_pv, timeout)
-        entries: dict[str, Entry | list[Entry | None]] = pvi_structure["value"].todict()
+
+        entries: dict[str, Entry | OldPVIVector | FastCSPVIVector] = pvi_structure[
+            "value"
+        ].todict()
         # Fill based on what PVI gives us
         for name, entry in entries.items():
-            if isinstance(entry, dict):
-                # This is a child
-                self._fill_child(name, entry)
+            if _is_device_vector_entry(entry):
+                self._fill_vector_child(
+                    name, cast(OldPVIVector | FastCSPVIVector, entry)
+                )
             else:
-                # This is a DeviceVector of children
-                for i, e in enumerate(entry):
-                    if e:
-                        self._fill_child(name, e, i)
+                # This is a child
+                self._fill_child(name, cast(Entry, entry))
+
         # Check that all the requested children have been filled
         suffix = f"\n{self.error_hint}" if self.error_hint else ""
         self.filler.check_filled(f"{self.pvi_pv}: {entries}{suffix}")

ophyd_async/epics/core/_signal.py

@@ -1,10 +1,11 @@
-"""EPICS Signals over CA or PVA"""
+"""EPICS Signals over CA or PVA."""
 
 from __future__ import annotations
 
 from enum import Enum
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
     SignalBackend,
     SignalDatatypeT,
     SignalR,
@@ -73,6 +74,7 @@ def get_signal_backend_type(protocol: EpicsProtocol) -> type[EpicsSignalBackend]
             return CaSignalBackend
         case EpicsProtocol.PVA:
             return PvaSignalBackend
+    raise TypeError(f"Unsupported protocol: {protocol}")
 
 
 def _epics_signal_backend(
@@ -91,20 +93,18 @@ def epics_signal_rw(
     read_pv: str,
     write_pv: str | None = None,
     name: str = "",
+    timeout: float = DEFAULT_TIMEOUT,
 ) -> SignalRW[SignalDatatypeT]:
-    """Create a `SignalRW` backed by 1 or 2 EPICS PVs
-
-    Parameters
-    ----------
-    datatype:
-        Check that the PV is of this type
-    read_pv:
-        The PV to read and monitor
-    write_pv:
-        If given, use this PV to write to, otherwise use read_pv
+    """Create a `SignalRW` backed by 1 or 2 EPICS PVs.
+
+    :param datatype: Check that the PV is of this type
+    :param read_pv: The PV to read and monitor
+    :param write_pv: If given, use this PV to write to, otherwise use read_pv
+    :param name: The name of the signal (defaults to empty string)
+    :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, read_pv, write_pv or read_pv)
-    return SignalRW(backend, name=name)
+    return SignalRW(backend, name=name, timeout=timeout)
 
 
 def epics_signal_rw_rbv(
@@ -112,67 +112,67 @@ def epics_signal_rw_rbv(
     write_pv: str,
     read_suffix: str = "_RBV",
     name: str = "",
+    timeout: float = DEFAULT_TIMEOUT,
 ) -> SignalRW[SignalDatatypeT]:
-    """Create a `SignalRW` backed by 1 or 2 EPICS PVs, with a suffix on the readback pv
-
-    Parameters
-    ----------
-    datatype:
-        Check that the PV is of this type
-    write_pv:
-        The PV to write to
-    read_suffix:
-        Append this suffix to the write pv to create the readback pv
-    """
+    """Create a `SignalRW` backed by 1 or 2 EPICS PVs, with a suffix on the readback pv.
 
+    :param datatype: Check that the PV is of this type
+    :param write_pv: The PV to write to
+    :param read_suffix: Append this suffix to the write pv to create the readback pv
+    :param name: The name of the signal (defaults to empty string)
+    :param timeout: A timeout to be used when reading (not connecting) this signal
+    """
     base_pv, field = get_pv_basename_and_field(write_pv)
     if field is not None:
         read_pv = f"{base_pv}{read_suffix}.{field}"
     else:
         read_pv = f"{write_pv}{read_suffix}"
 
-    return epics_signal_rw(datatype, read_pv, write_pv, name)
+    return epics_signal_rw(datatype, read_pv, write_pv, name, timeout=timeout)
 
 
 def epics_signal_r(
-    datatype: type[SignalDatatypeT], read_pv: str, name: str = ""
+    datatype: type[SignalDatatypeT],
+    read_pv: str,
+    name: str = "",
+    timeout: float = DEFAULT_TIMEOUT,
 ) -> SignalR[SignalDatatypeT]:
-    """Create a `SignalR` backed by 1 EPICS PV
-
-    Parameters
-    ----------
-    datatype
-        Check that the PV is of this type
-    read_pv:
-        The PV to read and monitor
+    """Create a `SignalR` backed by 1 EPICS PV.
+
+    :param datatype: Check that the PV is of this type
+    :param read_pv: The PV to read from
+    :param name: The name of the signal (defaults to empty string)
+    :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, read_pv, read_pv)
-    return SignalR(backend, name=name)
+    return SignalR(backend, name=name, timeout=timeout)
 
 
 def epics_signal_w(
-    datatype: type[SignalDatatypeT], write_pv: str, name: str = ""
+    datatype: type[SignalDatatypeT],
+    write_pv: str,
+    name: str = "",
+    timeout: float = DEFAULT_TIMEOUT,
 ) -> SignalW[SignalDatatypeT]:
-    """Create a `SignalW` backed by 1 EPICS PVs
-
-    Parameters
-    ----------
-    datatype:
-        Check that the PV is of this type
-    write_pv:
-        The PV to write to
+    """Create a `SignalW` backed by 1 EPICS PVs.
+
+    :param datatype: Check that the PV is of this type
+    :param write_pv: The PV to write to
+    :param name: The name of the signal (defaults to empty string)
+    :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, write_pv, write_pv)
-    return SignalW(backend, name=name)
+    return SignalW(backend, name=name, timeout=timeout)
 
 
-def epics_signal_x(write_pv: str, name: str = "") -> SignalX:
-    """Create a `SignalX` backed by 1 EPICS PVs
+def epics_signal_x(
+    write_pv: str, name: str = "", timeout: float = DEFAULT_TIMEOUT
+) -> SignalX:
+    """Create a `SignalX` backed by 1 EPICS PVs.
 
-    Parameters
-    ----------
-    write_pv:
-        The PV to write its initial value to on trigger
+    :param write_pv: The PV to write its initial value to on trigger
+    :param name: The name of the signal
+    :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(None, write_pv, write_pv)
-    return SignalX(backend, name=name)
+    return SignalX(backend, name=name, timeout=timeout)

ophyd_async/epics/core/_util.py

@@ -13,12 +13,12 @@ from ophyd_async.core import (
 
 
 def get_pv_basename_and_field(pv: str) -> tuple[str, str | None]:
-    """Simple utility function for extracting base pv name without field"""
-
+    """Split PV into record name and field."""
     if "." in pv:
-        return (pv.split(".", -1)[0], pv.split(".", -1)[1])
+        record, field = pv.split(".", maxsplit=1)
     else:
-        return (pv, None)
+        record, field = pv, None
+    return (record, field)
 
 
 def get_supported_values(

ophyd_async/epics/demo/__init__.py

@@ -0,0 +1,16 @@
+"""Demo EPICS Devices for the tutorial."""
+
+from ._ioc import start_ioc_subprocess
+from ._motor import DemoMotor
+from ._point_detector import DemoPointDetector
+from ._point_detector_channel import DemoPointDetectorChannel, EnergyMode
+from ._stage import DemoStage
+
+__all__ = [
+    "DemoMotor",
+    "DemoStage",
+    "EnergyMode",
+    "DemoPointDetectorChannel",
+    "DemoPointDetector",
+    "start_ioc_subprocess",
+]

ophyd_async/epics/demo/__main__.py

@@ -0,0 +1,31 @@
+"""Used for tutorial `Implementing Devices`."""
+
+# Import bluesky and ophyd
+import bluesky.plan_stubs as bps  # noqa: F401
+import bluesky.plans as bp  # noqa: F401
+from bluesky.callbacks.best_effort import BestEffortCallback
+from bluesky.run_engine import RunEngine, autoawait_in_bluesky_event_loop
+
+from ophyd_async.core import init_devices
+from ophyd_async.epics import demo, testing
+
+# Create a run engine and make ipython use it for `await` commands
+RE = RunEngine(call_returns_result=True)
+autoawait_in_bluesky_event_loop()
+
+# Add a callback for plotting
+bec = BestEffortCallback()
+RE.subscribe(bec)
+
+# Start IOC with demo pvs in subprocess
+prefix = testing.generate_random_pv_prefix()
+ioc = demo.start_ioc_subprocess(prefix, num_channels=3)
+
+# All Devices created within this block will be
+# connected and named at the end of the with block
+with init_devices():
+    # Create a sample stage with X and Y motors
+    stage = demo.DemoStage(f"{prefix}STAGE:")
+    # Create a multi channel counter with the same number
+    # of counters as the IOC
+    pdet = demo.DemoPointDetector(f"{prefix}DET:", num_channels=3)

ophyd_async/epics/demo/_ioc.py

@@ -0,0 +1,32 @@
+import atexit
+from pathlib import Path
+
+from ophyd_async.epics.testing import TestingIOC
+
+HERE = Path(__file__).absolute().parent
+
+
+def start_ioc_subprocess(prefix: str, num_channels: int) -> TestingIOC:
+    """Start an IOC subprocess for sample stage and sensor.
+
+    :param prefix: The prefix for the IOC PVs.
+    :param num_channels: The number of point detector channels to create.
+    """
+    ioc = TestingIOC()
+    # Create X and Y motors
+    for suffix in ["X", "Y"]:
+        ioc.add_database(HERE / "motor.db", P=f"{prefix}STAGE:{suffix}:")
+    # Create a multichannel counter with num_counters
+    ioc.add_database(HERE / "point_detector.db", P=f"{prefix}DET:")
+    for i in range(1, num_channels + 1):
+        ioc.add_database(
+            HERE / "point_detector_channel.db",
+            P=f"{prefix}DET:",
+            CHANNEL=str(i),
+            X=f"{prefix}STAGE:X:",
+            Y=f"{prefix}STAGE:Y:",
+        )
+    # Start IOC and register it to be stopped at exit
+    ioc.start()
+    atexit.register(ioc.stop)
+    return ioc

ophyd_async/epics/demo/_motor.py

@@ -0,0 +1,82 @@
+import asyncio
+from typing import Annotated as A
+
+import numpy as np
+from bluesky.protocols import Movable, Stoppable
+
+from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
+    DEFAULT_TIMEOUT,
+    CalculatableTimeout,
+    SignalR,
+    SignalRW,
+    SignalX,
+    StandardReadable,
+    WatchableAsyncStatus,
+    WatcherUpdate,
+    observe_value,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
+
+
+class DemoMotor(EpicsDevice, StandardReadable, Movable, Stoppable):
+    """A demo movable that moves based on velocity."""
+
+    # Whether set() should complete successfully or not
+    _set_success = True
+    # Define some signals
+    readback: A[SignalR[float], PvSuffix("Readback"), Format.HINTED_SIGNAL]
+    velocity: A[SignalRW[float], PvSuffix("Velocity"), Format.CONFIG_SIGNAL]
+    units: A[SignalR[str], PvSuffix("Readback.EGU"), Format.CONFIG_SIGNAL]
+    setpoint: A[SignalRW[float], PvSuffix("Setpoint")]
+    precision: A[SignalR[int], PvSuffix("Readback.PREC")]
+    # If a signal name clashes with a bluesky verb add _ to the attribute name
+    stop_: A[SignalX, PvSuffix("Stop.PROC")]
+
+    def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
+        super().set_name(name, child_name_separator=child_name_separator)
+        # Readback should be named the same as its parent in read()
+        self.readback.set_name(name)
+
+    @WatchableAsyncStatus.wrap
+    async def set(  # type: ignore
+        self, new_position: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT
+    ):
+        # The move should complete successfully unless stop(success=False) is called
+        self._set_success = True
+        # Get some variables for the progress bar reporting
+        old_position, units, precision, velocity = await asyncio.gather(
+            self.setpoint.get_value(),
+            self.units.get_value(),
+            self.precision.get_value(),
+            self.velocity.get_value(),
+        )
+        # If not supplied, calculate a suitable timeout for the move
+        if timeout == CALCULATE_TIMEOUT:
+            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
+        # Wait for the value to set, but don't wait for put completion callback
+        await self.setpoint.set(new_position, wait=False)
+        # Observe the readback Signal, and on each new position...
+        async for current_position in observe_value(
+            self.readback, done_timeout=timeout
+        ):
+            # Emit a progress bar update
+            yield WatcherUpdate(
+                current=current_position,
+                initial=old_position,
+                target=new_position,
+                name=self.name,
+                unit=units,
+                precision=precision,
+            )
+            # If we are at the desired position the break
+            if np.isclose(current_position, new_position):
+                break
+        # If we were told to stop and report an error then do so
+        if not self._set_success:
+            raise RuntimeError("Motor was stopped")
+
+    async def stop(self, success=True):
+        self._set_success = success
+        await self.stop_.trigger()

ophyd_async/epics/demo/_point_detector.py

@@ -0,0 +1,42 @@
+from typing import Annotated as A
+
+from bluesky.protocols import Triggerable
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DeviceVector,
+    SignalR,
+    SignalRW,
+    SignalX,
+    StandardReadable,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
+
+from ._point_detector_channel import DemoPointDetectorChannel
+
+
+class DemoPointDetector(StandardReadable, EpicsDevice, Triggerable):
+    """A demo detector that produces a point values based on X and Y motors."""
+
+    acquire_time: A[SignalRW[float], PvSuffix("AcquireTime"), Format.CONFIG_SIGNAL]
+    start: A[SignalX, PvSuffix("Start.PROC")]
+    acquiring: A[SignalR[bool], PvSuffix("Acquiring")]
+    reset: A[SignalX, PvSuffix("Reset.PROC")]
+
+    def __init__(self, prefix: str, num_channels: int = 3, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.channel = DeviceVector(
+                {
+                    i: DemoPointDetectorChannel(f"{prefix}{i}:")
+                    for i in range(1, num_channels + 1)
+                }
+            )
+        super().__init__(prefix=prefix, name=name)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        await self.reset.trigger()
+        timeout = await self.acquire_time.get_value() + DEFAULT_TIMEOUT
+        await self.start.trigger(timeout=timeout)