ophyd-async 0.12.2__tar.gz → 0.13.0__tar.gz

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.12.2
+Version: 0.13.0
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -49,10 +49,11 @@ Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Requires-Dist: stamina>=23.1.0
+Requires-Dist: scanspec>=1.0a1
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca
-Requires-Dist: aioca>=1.6; extra == "ca"
+Requires-Dist: aioca>=2.0a4; extra == "ca"
 Provides-Extra: pva
 Requires-Dist: p4p>=4.2.0; extra == "pva"
 Provides-Extra: tango

ophyd_async-0.13.0/docs/explanations/decisions/0011-buffer-updates-camonitor.md

@@ -0,0 +1,33 @@
+# 11. Buffer updates when using `camonitor`
+
+Date: 2025-07-30
+
+## Status
+
+Accepted
+
+## Context
+
+The ChannelAccess signal backend uses aioca.camonitor to subscribe to changes in PV values. By default it deals with backpressure by dropping excessive updates that it is too slow to handle. It also has a mode whereby it will buffer the updates, lagging behind if there are too many.
+
+```python
+# The following will buffer every update to the PV
+aioca.camonitor(my_pv, all_updates=True)
+```
+
+## Decision
+
+Default `all_updates` to `True` in the ChannelAccess backend, but provide a feature flag via an environment variable so it can be reverted at runtime if necessary.
+
+```bash
+# The following should restore the old behavior 
+export OPHYD_ASYNC_EPICS_CA_KEEP_ALL_UPDATES=False
+```
+
+## Consequences
+
+If backpressure is causing a problem, ophyd-async will slow down and lag behind. This is deemed to be an easier problem to spot and debug than updates being silently dropped. 
+
+It is the responsibility of IOCs to not push updates too quickly (<=10Hz) rather than the responsibility of ophyd-async to handle them. If an IOC is pushing updates too quickly, it should be fixed.
+
+There may be unknown bugs and race conditions exposed by this change, they can be temporarily remedied by disabling the feature (see above).

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/pyproject.toml

@@ -20,7 +20,8 @@ dependencies = [
     "colorlog",
     "pydantic>=2.0",
     "pydantic-numpy",
-    "stamina>=23.1.0"
+    "stamina>=23.1.0",
+    "scanspec>=1.0a1",
 ]
 dynamic = ["version"]
 license.file = "LICENSE"
@@ -29,7 +30,7 @@ requires-python = ">=3.10"
 
 [project.optional-dependencies]
 sim = ["h5py"]
-ca = ["aioca>=1.6"]
+ca = ["aioca>=2.0a4"]
 pva = ["p4p>=4.2.0"]
 tango = ["pytango==10.0.0"]
 demo = ["ipython", "matplotlib", "pyqt6"]

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.12.2'
-__version_tuple__ = version_tuple = (0, 12, 2)
+__version__ = version = '0.13.0'
+__version_tuple__ = version_tuple = (0, 13, 0)

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/core/__init__.py

@@ -16,6 +16,12 @@ from ._detector import (
 )
 from ._device import Device, DeviceConnector, DeviceVector, init_devices
 from ._device_filler import DeviceFiller
+from ._enums import (
+    EnabledDisabled,
+    EnableDisable,
+    InOut,
+    OnOff,
+)
 from ._flyer import FlyerController, FlyMotorInfo, StandardFlyer
 from ._hdf_dataset import HDFDatasetDescription, HDFDocumentComposer
 from ._log import config_ophyd_async_logging
@@ -209,4 +215,9 @@ __all__ = [
     # Back compat - delete before 1.0
     "ConfigSignal",
     "HintedSignal",
+    # Standard enums
+    "EnabledDisabled",
+    "EnableDisable",
+    "InOut",
+    "OnOff",
 ]

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/core/_detector.py

@@ -104,7 +104,11 @@ class DetectorController(ABC):
 
     @abstractmethod
     def get_deadtime(self, exposure: float | None) -> float:
-        """For a given exposure, how long should the time between exposures be."""
+        """Get state-independent deadtime.
+
+        For a given exposure, what is the safest minimum time between exposures that
+        can be determined without reading signals.
+        """
 
     @abstractmethod
     async def prepare(self, trigger_info: TriggerInfo) -> None:
@@ -313,14 +317,7 @@ class StandardDetector(
         if value.trigger != DetectorTrigger.INTERNAL and not value.deadtime:
             msg = "Deadtime must be supplied when in externally triggered mode"
             raise ValueError(msg)
-        required_deadtime = self._controller.get_deadtime(value.livetime)
-        if value.deadtime and required_deadtime > value.deadtime:
-            msg = (
-                f"Detector {self._controller} needs at least {required_deadtime}s "
-                f"deadtime, but trigger logic provides only {value.deadtime}s"
-            )
-            raise ValueError(msg)
-        elif not value.deadtime:
+        if not value.deadtime:
             value.deadtime = self._controller.get_deadtime(value.livetime)
         self._trigger_info = value
         self._number_of_events_iter = iter(

ophyd_async-0.13.0/src/ophyd_async/core/_enums.py

@@ -0,0 +1,21 @@
+from ._utils import StrictEnum
+
+
+class OnOff(StrictEnum):
+    ON = "On"
+    OFF = "Off"
+
+
+class EnableDisable(StrictEnum):
+    ENABLE = "Enable"
+    DISABLE = "Disable"
+
+
+class EnabledDisabled(StrictEnum):
+    ENABLED = "Enabled"
+    DISABLED = "Disabled"
+
+
+class InOut(StrictEnum):
+    IN = "In"
+    OUT = "Out"

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/adaravis/__init__.py

@@ -5,12 +5,11 @@ https://github.com/areaDetector/ADAravis
 
 from ._aravis import AravisDetector
 from ._aravis_controller import AravisController
-from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
+from ._aravis_io import AravisDriverIO, AravisTriggerSource
 
 __all__ = [
     "AravisDetector",
     "AravisController",
     "AravisDriverIO",
-    "AravisTriggerMode",
     "AravisTriggerSource",
 ]

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/adaravis/_aravis_controller.py

@@ -1,9 +1,9 @@
 import asyncio
 
-from ophyd_async.core import DetectorTrigger, TriggerInfo
+from ophyd_async.core import DetectorTrigger, OnOff, TriggerInfo
 from ophyd_async.epics import adcore
 
-from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
+from ._aravis_io import AravisDriverIO, AravisTriggerSource
 
 # The deadtime of an ADaravis controller varies depending on the exact model of camera.
 # Ideally we would maximize performance by dynamically retrieving the deadtime at
@@ -23,14 +23,14 @@ class AravisController(adcore.ADBaseController[AravisDriverIO]):
 
         if trigger_info.trigger is DetectorTrigger.INTERNAL:
             # Set trigger mode off to ignore the trigger source
-            await self.driver.trigger_mode.set(AravisTriggerMode.OFF)
+            await self.driver.trigger_mode.set(OnOff.OFF)
         elif trigger_info.trigger in {
             DetectorTrigger.CONSTANT_GATE,
             DetectorTrigger.EDGE_TRIGGER,
         }:
             # Trigger on the rising edge of Line1
             # trigger mode must be set first and on it's own!
-            await self.driver.trigger_mode.set(AravisTriggerMode.ON)
+            await self.driver.trigger_mode.set(OnOff.ON)
             await self.driver.trigger_source.set(AravisTriggerSource.LINE1)
         else:
             raise ValueError(f"ADAravis does not support {trigger_info.trigger}")

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/adaravis/_aravis_io.py

@@ -1,20 +1,10 @@
 from typing import Annotated as A
 
-from ophyd_async.core import SignalRW, StrictEnum, SubsetEnum
+from ophyd_async.core import OnOff, SignalRW, SubsetEnum
 from ophyd_async.epics import adcore
 from ophyd_async.epics.core import PvSuffix
 
 
-class AravisTriggerMode(StrictEnum):
-    """GigEVision GenICAM standard TriggerMode."""
-
-    ON = "On"
-    """Use TriggerSource to trigger each frame"""
-
-    OFF = "Off"
-    """Just trigger as fast as you can"""
-
-
 class AravisTriggerSource(SubsetEnum):
     """Which trigger source to use when TriggerMode=On."""
 
@@ -27,5 +17,5 @@ class AravisDriverIO(adcore.ADBaseIO):
     This mirrors the interface provided by ADAravis/db/aravisCamera.template.
     """
 
-    trigger_mode: A[SignalRW[AravisTriggerMode], PvSuffix.rbv("TriggerMode")]
+    trigger_mode: A[SignalRW[OnOff], PvSuffix.rbv("TriggerMode")]
     trigger_source: A[SignalRW[AravisTriggerSource], PvSuffix.rbv("TriggerSource")]

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/adcore/__init__.py

@@ -7,7 +7,6 @@ from ._core_detector import AreaDetector, ContAcqAreaDetector
 from ._core_io import (
     ADBaseDatasetDescriber,
     ADBaseIO,
-    ADCallbacks,
     ADCompression,
     ADState,
     NDArrayBaseIO,
@@ -18,6 +17,7 @@ from ._core_io import (
     NDPluginBaseIO,
     NDPluginCBIO,
     NDPluginStatsIO,
+    NDROIStatIO,
 )
 from ._core_logic import DEFAULT_GOOD_STATES, ADBaseContAcqController, ADBaseController
 from ._core_writer import ADWriter
@@ -33,12 +33,11 @@ from ._utils import (
     NDAttributeParam,
     NDAttributePv,
     NDAttributePvDbrType,
-    stop_busy_record,
+    ndattributes_to_xml,
 )
 
 __all__ = [
     "ADBaseIO",
-    "ADCallbacks",
     "ADCompression",
     "ADBaseContAcqController",
     "AreaDetector",
@@ -50,6 +49,7 @@ __all__ = [
     "NDFileHDFIO",
     "NDPluginBaseIO",
     "NDPluginStatsIO",
+    "NDROIStatIO",
     "DEFAULT_GOOD_STATES",
     "ADBaseDatasetDescriber",
     "ADBaseController",
@@ -64,8 +64,8 @@ __all__ = [
     "NDAttributePv",
     "NDAttributeParam",
     "NDAttributeDataType",
-    "stop_busy_record",
     "NDAttributePvDbrType",
     "NDCBFlushOnSoftTrgMode",
     "NDPluginCBIO",
+    "ndattributes_to_xml",
 ]

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/adcore/_core_io.py

@@ -1,17 +1,19 @@
 import asyncio
 from typing import Annotated as A
 
-from ophyd_async.core import DatasetDescriber, SignalR, SignalRW, StrictEnum
+from ophyd_async.core import (
+    DatasetDescriber,
+    DeviceVector,
+    EnableDisable,
+    SignalR,
+    SignalRW,
+    StrictEnum,
+)
 from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
 from ._utils import ADBaseDataType, ADFileWriteMode, ADImageMode, convert_ad_dtype_to_np
 
 
-class ADCallbacks(StrictEnum):
-    ENABLE = "Enable"
-    DISABLE = "Disable"
-
-
 class NDArrayBaseIO(EpicsDevice):
     """Class responsible for passing detector data from drivers to pluglins.
 
@@ -53,7 +55,7 @@ class NDPluginBaseIO(NDArrayBaseIO):
     """
 
     nd_array_port: A[SignalRW[str], PvSuffix.rbv("NDArrayPort")]
-    enable_callbacks: A[SignalRW[ADCallbacks], PvSuffix.rbv("EnableCallbacks")]
+    enable_callbacks: A[SignalRW[EnableDisable], PvSuffix.rbv("EnableCallbacks")]
     nd_array_address: A[SignalRW[int], PvSuffix.rbv("NDArrayAddress")]
     array_size0: A[SignalR[int], PvSuffix("ArraySize0_RBV")]
     array_size1: A[SignalR[int], PvSuffix("ArraySize1_RBV")]
@@ -87,6 +89,56 @@ class NDPluginStatsIO(NDPluginBaseIO):
     hist_max: A[SignalRW[float], PvSuffix.rbv("HistMax")]
 
 
+class NDROIStatIO(NDPluginBaseIO):
+    """Plugin for calculating basic statistics for multiple ROIs.
+
+    Each ROI is implemented as an instance of NDROIStatNIO,
+    and the collection of ROIs is held as a DeviceVector.
+
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginROIStat.html
+    """
+
+    def __init__(self, prefix, num_channels=8, with_pvi=False, name=""):
+        self.channels = DeviceVector(
+            {i: NDROIStatNIO(f"{prefix}{i}:") for i in range(1, num_channels + 1)}
+        )
+        super().__init__(prefix, with_pvi, name)
+
+
+class NDROIStatNIO(EpicsDevice):
+    """Defines the parameters for a single ROI used for statistics calculation.
+
+    Each instance represents a single ROI, with attributes for its position
+    (min_x, min_y) and size (size_x, size_y), as well as a name and use status.
+
+    See definition in ADApp/pluginSrc/NDPluginROIStat.h in https://github.com/areaDetector/ADCore.
+
+    Attributes:
+        name: The name of the ROI.
+        use: Flag indicating whether the ROI is used.
+        min_x: The start X-coordinate of the ROI.
+        min_y: The start Y-coordinate of the ROI.
+        size_x: The width of the ROI.
+        size_y: The height of the ROI.
+        min_value: Minimum count value in the ROI.
+        max_value: Maximum count value in the ROI.
+        mean_value: Mean counts value in the ROI.
+        total: Total counts in the ROI.
+    """
+
+    name_: A[SignalRW[str], PvSuffix("Name")]
+    use: A[SignalRW[bool], PvSuffix.rbv("Use")]
+    min_x: A[SignalRW[int], PvSuffix.rbv("MinX")]
+    min_y: A[SignalRW[int], PvSuffix.rbv("MinY")]
+    size_x: A[SignalRW[int], PvSuffix.rbv("SizeX")]
+    size_y: A[SignalRW[int], PvSuffix.rbv("SizeY")]
+    # stats
+    min_value: A[SignalR[float], PvSuffix("MinValue_RBV")]
+    max_value: A[SignalR[float], PvSuffix("MaxValue_RBV")]
+    mean_value: A[SignalR[float], PvSuffix("MeanValue_RBV")]
+    total: A[SignalR[float], PvSuffix("Total_RBV")]
+
+
 class ADState(StrictEnum):
     """Default set of states of an AreaDetector driver.
 

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/adcore/_core_logic.py

@@ -6,19 +6,20 @@ from ophyd_async.core import (
     AsyncStatus,
     DetectorController,
     DetectorTrigger,
+    EnableDisable,
     TriggerInfo,
     observe_value,
     set_and_wait_for_value,
 )
+from ophyd_async.epics.core import stop_busy_record
 
 from ._core_io import (
     ADBaseIO,
-    ADCallbacks,
     ADState,
     NDCBFlushOnSoftTrgMode,
     NDPluginCBIO,
 )
-from ._utils import ADImageMode, stop_busy_record
+from ._utils import ADImageMode
 
 # Default set of states that we should consider "good" i.e. the acquisition
 #  is complete and went well
@@ -198,7 +199,7 @@ class ADBaseContAcqController(ADBaseController[ADBaseIO]):
 
         # Configure the CB plugin to collect the correct number of triggers
         await asyncio.gather(
-            self.cb_plugin.enable_callbacks.set(ADCallbacks.ENABLE),
+            self.cb_plugin.enable_callbacks.set(EnableDisable.ENABLE),
             self.cb_plugin.pre_count.set(0),
             self.cb_plugin.post_count.set(trigger_info.total_number_of_exposures),
             self.cb_plugin.preset_trigger_count.set(1),

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/adcore/_core_writer.py

@@ -12,19 +12,19 @@ from event_model import (  # type: ignore
 from pydantic import PositiveInt
 
 from ophyd_async.core._detector import DetectorWriter
+from ophyd_async.core._enums import EnableDisable
 from ophyd_async.core._providers import DatasetDescriber, PathInfo, PathProvider
 from ophyd_async.core._signal import (
     observe_value,
     set_and_wait_for_value,
-    wait_for_value,
 )
 from ophyd_async.core._status import AsyncStatus
 from ophyd_async.core._utils import DEFAULT_TIMEOUT, error_if_none
+from ophyd_async.epics.core import stop_busy_record
 
 # from ophyd_async.epics.adcore._core_logic import ADBaseDatasetDescriber
 from ._core_io import (
     ADBaseDatasetDescriber,
-    ADCallbacks,
     NDArrayBaseIO,
     NDFileIO,
     NDFilePluginIO,
@@ -89,7 +89,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         )
 
         if isinstance(self.fileio, NDFilePluginIO):
-            await self.fileio.enable_callbacks.set(ADCallbacks.ENABLE)
+            await self.fileio.enable_callbacks.set(EnableDisable.ENABLE)
 
         # Set the directory creation depth first, since dir creation callback happens
         # when directory path PV is processed.
@@ -213,8 +213,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
 
     async def close(self):
         # Already done a caput callback in _capture_status, so can't do one here
-        await self.fileio.capture.set(False, wait=False)
-        await wait_for_value(self.fileio.capture, False, DEFAULT_TIMEOUT)
+        await stop_busy_record(self.fileio.capture, False, timeout=DEFAULT_TIMEOUT)
         if self._capture_status and not self._capture_status.done:
             # We kicked off an open, so wait for it to return
             await self._capture_status

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/adcore/_utils.py

@@ -1,14 +1,12 @@
+from collections.abc import Sequence
 from dataclasses import dataclass
+from xml.etree import ElementTree as ET
 
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    SignalDatatypeT,
     SignalR,
-    SignalRW,
     StrictEnum,
     SubsetEnum,
     SupersetEnum,
-    wait_for_value,
 )
 
 
@@ -136,10 +134,37 @@ class NDAttributeParam:
     description: str = ""  # A description that appears in the HDF file as an attribute
 
 
-async def stop_busy_record(
-    signal: SignalRW[SignalDatatypeT],
-    value: SignalDatatypeT,
-    timeout: float = DEFAULT_TIMEOUT,
-) -> None:
-    await signal.set(value, wait=False)
-    await wait_for_value(signal, value, timeout=timeout)
+def ndattributes_to_xml(
+    ndattributes: Sequence[NDAttributeParam | NDAttributePv],
+) -> str:
+    """Convert a set of NDAttribute params to XML."""
+    root = ET.Element("Attributes")
+    for ndattribute in ndattributes:
+        if isinstance(ndattribute, NDAttributeParam):
+            ET.SubElement(
+                root,
+                "Attribute",
+                name=ndattribute.name,
+                type="PARAM",
+                source=ndattribute.param,
+                addr=str(ndattribute.addr),
+                datatype=ndattribute.datatype.value,
+                description=ndattribute.description,
+            )
+        elif isinstance(ndattribute, NDAttributePv):
+            ET.SubElement(
+                root,
+                "Attribute",
+                name=ndattribute.name,
+                type="EPICS_PV",
+                source=ndattribute.signal.source.split("ca://")[-1],
+                dbrtype=ndattribute.dbrtype.value,
+                description=ndattribute.description,
+            )
+        else:
+            raise ValueError(
+                f"Invalid type for ndattributes: {type(ndattribute)}. "
+                "Expected NDAttributePv or NDAttributeParam."
+            )
+    xml_text = ET.tostring(root, encoding="unicode")
+    return xml_text

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/advimba/__init__.py

@@ -4,7 +4,6 @@ from ._vimba_io import (
     VimbaConvertFormat,
     VimbaDriverIO,
     VimbaExposeOutMode,
-    VimbaOnOff,
     VimbaOverlap,
     VimbaTriggerSource,
 )
@@ -14,7 +13,6 @@ __all__ = [
     "VimbaController",
     "VimbaDriverIO",
     "VimbaExposeOutMode",
-    "VimbaOnOff",
     "VimbaTriggerSource",
     "VimbaOverlap",
     "VimbaConvertFormat",

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,18 +1,15 @@
 import asyncio
 
-from ophyd_async.core import (
-    DetectorTrigger,
-    TriggerInfo,
-)
+from ophyd_async.core import DetectorTrigger, OnOff, TriggerInfo
 from ophyd_async.epics import adcore
 
-from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
+from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaTriggerSource
 
 TRIGGER_MODE = {
-    DetectorTrigger.INTERNAL: VimbaOnOff.OFF,
-    DetectorTrigger.CONSTANT_GATE: VimbaOnOff.ON,
-    DetectorTrigger.VARIABLE_GATE: VimbaOnOff.ON,
-    DetectorTrigger.EDGE_TRIGGER: VimbaOnOff.ON,
+    DetectorTrigger.INTERNAL: OnOff.OFF,
+    DetectorTrigger.CONSTANT_GATE: OnOff.ON,
+    DetectorTrigger.VARIABLE_GATE: OnOff.ON,
+    DetectorTrigger.EDGE_TRIGGER: OnOff.ON,
 }
 
 EXPOSE_OUT_MODE = {

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/advimba/_vimba_io.py

@@ -1,6 +1,6 @@
 from typing import Annotated as A
 
-from ophyd_async.core import SignalRW, StrictEnum
+from ophyd_async.core import OnOff, SignalRW, StrictEnum
 from ophyd_async.epics import adcore
 from ophyd_async.epics.core import PvSuffix
 
@@ -30,17 +30,10 @@ class VimbaTriggerSource(StrictEnum):
 class VimbaOverlap(StrictEnum):
     """Overlap modes for the Vimba detector."""
 
-    OFF = "Off"
+    OFF = OnOff.OFF
     PREV_FRAME = "PreviousFrame"
 
 
-class VimbaOnOff(StrictEnum):
-    """On/Off modes on the Vimba detector."""
-
-    ON = "On"
-    OFF = "Off"
-
-
 class VimbaExposeOutMode(StrictEnum):
     """Exposure control modes for Vimba detectors."""
 
@@ -55,6 +48,6 @@ class VimbaDriverIO(adcore.ADBaseIO):
         SignalRW[VimbaConvertFormat], PvSuffix("ConvertPixelFormat")
     ]
     trigger_source: A[SignalRW[VimbaTriggerSource], PvSuffix("TriggerSource")]
-    trigger_mode: A[SignalRW[VimbaOnOff], PvSuffix("TriggerMode")]
+    trigger_mode: A[SignalRW[OnOff], PvSuffix("TriggerMode")]
     trigger_overlap: A[SignalRW[VimbaOverlap], PvSuffix("TriggerOverlap")]
     exposure_mode: A[SignalRW[VimbaExposeOutMode], PvSuffix("ExposureMode")]

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/core/__init__.py

@@ -10,6 +10,7 @@ from ._signal import (
     epics_signal_w,
     epics_signal_x,
 )
+from ._util import stop_busy_record
 
 __all__ = [
     "PviDeviceConnector",
@@ -23,4 +24,5 @@ __all__ = [
     "epics_signal_rw_rbv",
     "epics_signal_w",
     "epics_signal_x",
+    "stop_busy_record",
 ]

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/core/_aioca.py

@@ -1,4 +1,5 @@
 import logging
+import os
 import sys
 import typing
 from collections.abc import Mapping, Sequence
@@ -40,6 +41,10 @@ from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 logger = logging.getLogger("ophyd_async")
 
 
+def _all_updates() -> bool:
+    return os.environ.get("OPHYD_ASYNC_EPICS_CA_KEEP_ALL_UPDATES", "True") == "True"
+
+
 def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
     def get_limits(limit: str) -> LimitsRange | None:
         low = getattr(value, f"lower_{limit}_limit", nan)
@@ -250,12 +255,11 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         datatype: type[SignalDatatypeT] | None,
         read_pv: str = "",
         write_pv: str = "",
-        all_updates: bool = True,
     ):
         self.converter: CaConverter = DisconnectedCaConverter(float, dbr.DBR_DOUBLE)
         self.initial_values: dict[str, AugmentedValue] = {}
         self.subscription: Subscription | None = None
-        self._all_updates = all_updates
+        self._all_updates = _all_updates()
         super().__init__(datatype, read_pv, write_pv)
 
     def source(self, name: str, read: bool):

{ophyd_async-0.12.2 → ophyd_async-0.13.0}/src/ophyd_async/epics/core/_util.py

@@ -4,13 +4,16 @@ from typing import Any, TypeVar, get_args, get_origin
 import numpy as np
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
     SignalBackend,
     SignalDatatypeT,
+    SignalRW,
     StrictEnum,
     SubsetEnum,
     SupersetEnum,
     get_dtype,
     get_enum_cls,
+    wait_for_value,
 )
 
 T = TypeVar("T")
@@ -76,3 +79,12 @@ class EpicsSignalBackend(SignalBackend[SignalDatatypeT]):
         self.read_pv = read_pv
         self.write_pv = write_pv
         super().__init__(datatype)
+
+
+async def stop_busy_record(
+    signal: SignalRW[SignalDatatypeT],
+    value: SignalDatatypeT,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> None:
+    await signal.set(value, wait=False)
+    await wait_for_value(signal, value, timeout=timeout)