ophyd-async 0.3a2__py3-none-any.whl → 0.3a4__py3-none-any.whl

ophyd_async/epics/areadetector/controllers/vimba_controller.py

@@ -0,0 +1,66 @@
+import asyncio
+from typing import Optional
+
+from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
+from ophyd_async.epics.areadetector.drivers.ad_base import (
+    start_acquiring_driver_and_ensure_status,
+)
+
+from ..drivers.vimba_driver import (
+    VimbaDriver,
+    VimbaExposeOutMode,
+    VimbaOnOff,
+    VimbaTriggerSource,
+)
+from ..utils import ImageMode, stop_busy_record
+
+TRIGGER_MODE = {
+    DetectorTrigger.internal: VimbaOnOff.off,
+    DetectorTrigger.constant_gate: VimbaOnOff.on,
+    DetectorTrigger.variable_gate: VimbaOnOff.on,
+    DetectorTrigger.edge_trigger: VimbaOnOff.on,
+}
+
+EXPOSE_OUT_MODE = {
+    DetectorTrigger.internal: VimbaExposeOutMode.timed,
+    DetectorTrigger.constant_gate: VimbaExposeOutMode.trigger_width,
+    DetectorTrigger.variable_gate: VimbaExposeOutMode.trigger_width,
+    DetectorTrigger.edge_trigger: VimbaExposeOutMode.timed,
+}
+
+
+class VimbaController(DetectorControl):
+    def __init__(
+        self,
+        driver: VimbaDriver,
+    ) -> None:
+        self._drv = driver
+
+    def get_deadtime(self, exposure: float) -> float:
+        return 0.001
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        await asyncio.gather(
+            self._drv.trigger_mode.set(TRIGGER_MODE[trigger]),
+            self._drv.expose_mode.set(EXPOSE_OUT_MODE[trigger]),
+            self._drv.num_images.set(num),
+            self._drv.image_mode.set(ImageMode.multiple),
+        )
+        if exposure is not None and trigger not in [
+            DetectorTrigger.variable_gate,
+            DetectorTrigger.constant_gate,
+        ]:
+            await self._drv.acquire_time.set(exposure)
+        if trigger != DetectorTrigger.internal:
+            self._drv.trig_source.set(VimbaTriggerSource.line1)
+        else:
+            self._drv.trig_source.set(VimbaTriggerSource.freerun)
+        return await start_acquiring_driver_and_ensure_status(self._drv)
+
+    async def disarm(self):
+        await stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/areadetector/drivers/__init__.py

@@ -4,12 +4,18 @@ from .ad_base import (
     DetectorState,
     start_acquiring_driver_and_ensure_status,
 )
+from .aravis_driver import AravisDriver
+from .kinetix_driver import KinetixDriver
 from .pilatus_driver import PilatusDriver
+from .vimba_driver import VimbaDriver
 
 __all__ = [
     "ADBase",
     "ADBaseShapeProvider",
     "PilatusDriver",
+    "AravisDriver",
+    "KinetixDriver",
+    "VimbaDriver",
     "start_acquiring_driver_and_ensure_status",
     "DetectorState",
 ]

ophyd_async/epics/areadetector/drivers/ad_base.py

@@ -9,8 +9,8 @@ from ophyd_async.core import (
     set_and_wait_for_value,
 )
 
-from ...signal.signal import epics_signal_rw
-from ..utils import ImageMode, ad_r, ad_rw
+from ...signal.signal import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
+from ..utils import ImageMode
 from ..writers.nd_plugin import NDArrayBase
 
 
@@ -43,14 +43,16 @@ DEFAULT_GOOD_STATES: FrozenSet[DetectorState] = frozenset(
 class ADBase(NDArrayBase):
     def __init__(self, prefix: str, name: str = "") -> None:
         # Define some signals
-        self.acquire = ad_rw(bool, prefix + "Acquire")
-        self.acquire_time = ad_rw(float, prefix + "AcquireTime")
-        self.num_images = ad_rw(int, prefix + "NumImages")
-        self.image_mode = ad_rw(ImageMode, prefix + "ImageMode")
-        self.array_counter = ad_rw(int, prefix + "ArrayCounter")
-        self.array_size_x = ad_r(int, prefix + "ArraySizeX")
-        self.array_size_y = ad_r(int, prefix + "ArraySizeY")
-        self.detector_state = ad_r(DetectorState, prefix + "DetectorState")
+        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
+        self.acquire_time = epics_signal_rw_rbv(float, prefix + "AcquireTime")
+        self.num_images = epics_signal_rw_rbv(int, prefix + "NumImages")
+        self.image_mode = epics_signal_rw_rbv(ImageMode, prefix + "ImageMode")
+        self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
+        self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
+        self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
+        self.detector_state = epics_signal_r(
+            DetectorState, prefix + "DetectorState_RBV"
+        )
         # There is no _RBV for this one
         self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")
         super().__init__(prefix, name=name)

ophyd_async/epics/areadetector/drivers/aravis_driver.py

@@ -2,7 +2,7 @@ from enum import Enum
 from typing import Callable, Dict, Literal, Optional, Tuple
 
 from ophyd_async.epics.areadetector.drivers import ADBase
-from ophyd_async.epics.areadetector.utils import ad_r, ad_rw
+from ophyd_async.epics.signal.signal import epics_signal_r, epics_signal_rw_rbv
 
 
 class AravisTriggerMode(str, Enum):
@@ -138,10 +138,12 @@ class AravisDriver(ADBase):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.trigger_mode = ad_rw(AravisTriggerMode, prefix + "TriggerMode")
-        self.trigger_source = ad_rw(str, prefix + "TriggerSource")
-        self.model = ad_r(str, prefix + "Model")
-        self.pixel_format = ad_rw(str, prefix + "PixelFormat")
+        self.trigger_mode = epics_signal_rw_rbv(
+            AravisTriggerMode, prefix + "TriggerMode"
+        )
+        self.trigger_source = epics_signal_rw_rbv(str, prefix + "TriggerSource")
+        self.model = epics_signal_r(str, prefix + "Model_RBV")
+        self.pixel_format = epics_signal_rw_rbv(str, prefix + "PixelFormat")
         self.dead_time: Optional[float] = None
         super().__init__(prefix, name=name)
 

ophyd_async/epics/areadetector/drivers/kinetix_driver.py

@@ -0,0 +1,27 @@
+from enum import Enum
+
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+
+from .ad_base import ADBase
+
+
+class KinetixTriggerMode(str, Enum):
+    internal = "Internal"
+    edge = "Rising Edge"
+    gate = "Exp. Gate"
+
+
+class KinetixReadoutMode(str, Enum):
+    sensitivity = 1
+    speed = 2
+    dynamic_range = 3
+
+
+class KinetixDriver(ADBase):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
+        self.trigger_mode = epics_signal_rw_rbv(
+            KinetixTriggerMode, prefix + "TriggerMode"
+        )
+        self.mode = epics_signal_rw_rbv(KinetixReadoutMode, prefix + "ReadoutPortIdx")
+        super().__init__(prefix, name)

ophyd_async/epics/areadetector/drivers/pilatus_driver.py

@@ -1,6 +1,7 @@
 from enum import Enum
 
-from ..utils import ad_rw
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+
 from .ad_base import ADBase
 
 
@@ -14,5 +15,7 @@ class PilatusTriggerMode(str, Enum):
 
 class PilatusDriver(ADBase):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.trigger_mode = ad_rw(PilatusTriggerMode, prefix + "TriggerMode")
+        self.trigger_mode = epics_signal_rw_rbv(
+            PilatusTriggerMode, prefix + "TriggerMode"
+        )
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/drivers/vimba_driver.py

@@ -0,0 +1,63 @@
+from enum import Enum
+
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+
+from .ad_base import ADBase
+
+
+class VimbaPixelFormat(str, Enum):
+    internal = "Mono8"
+    ext_enable = "Mono12"
+    ext_trigger = "Ext. Trigger"
+    mult_trigger = "Mult. Trigger"
+    alignment = "Alignment"
+
+
+class VimbaConvertFormat(str, Enum):
+    none = "None"
+    mono8 = "Mono8"
+    mono16 = "Mono16"
+    rgb8 = "RGB8"
+    rgb16 = "RGB16"
+
+
+class VimbaTriggerSource(str, Enum):
+    freerun = "Freerun"
+    line1 = "Line1"
+    line2 = "Line2"
+    fixed_rate = "FixedRate"
+    software = "Software"
+    action0 = "Action0"
+    action1 = "Action1"
+
+
+class VimbaOverlap(str, Enum):
+    off = "Off"
+    prev_frame = "PreviousFrame"
+
+
+class VimbaOnOff(str, Enum):
+    on = "On"
+    off = "Off"
+
+
+class VimbaExposeOutMode(str, Enum):
+    timed = "Timed"  # Use ExposureTime PV
+    trigger_width = "TriggerWidth"  # Expose for length of high signal
+
+
+class VimbaDriver(ADBase):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
+        self.convert_format = epics_signal_rw_rbv(
+            VimbaConvertFormat, prefix + "ConvertPixelFormat"
+        )  # Pixel format of data outputted to AD
+        self.trig_source = epics_signal_rw_rbv(
+            VimbaTriggerSource, prefix + "TriggerSource"
+        )
+        self.trigger_mode = epics_signal_rw_rbv(VimbaOnOff, prefix + "TriggerMode")
+        self.overlap = epics_signal_rw_rbv(VimbaOverlap, prefix + "TriggerOverlap")
+        self.expose_mode = epics_signal_rw_rbv(
+            VimbaExposeOutMode, prefix + "ExposureMode"
+        )
+        super().__init__(prefix, name)

ophyd_async/epics/areadetector/kinetix.py

@@ -0,0 +1,46 @@
+from bluesky.protocols import HasHints, Hints
+
+from ophyd_async.core import DirectoryProvider, StandardDetector
+from ophyd_async.epics.areadetector.controllers.kinetix_controller import (
+    KinetixController,
+)
+from ophyd_async.epics.areadetector.drivers import ADBaseShapeProvider
+from ophyd_async.epics.areadetector.drivers.kinetix_driver import KinetixDriver
+from ophyd_async.epics.areadetector.writers import HDFWriter, NDFileHDF
+
+
+class KinetixDetector(StandardDetector, HasHints):
+    """
+    Ophyd-async implementation of an ADKinetix Detector.
+    https://github.com/NSLS-II/ADKinetix
+    """
+
+    _controller: KinetixController
+    _writer: HDFWriter
+
+    def __init__(
+        self,
+        prefix: str,
+        directory_provider: DirectoryProvider,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
+        name="",
+    ):
+        self.drv = KinetixDriver(prefix + drv_suffix)
+        self.hdf = NDFileHDF(prefix + hdf_suffix)
+
+        super().__init__(
+            KinetixController(self.drv),
+            HDFWriter(
+                self.hdf,
+                directory_provider,
+                lambda: self.name,
+                ADBaseShapeProvider(self.drv),
+            ),
+            config_sigs=(self.drv.acquire_time,),
+            name=name,
+        )
+
+    @property
+    def hints(self) -> Hints:
+        return self._writer.hints

ophyd_async/epics/areadetector/pilatus.py

@@ -1,10 +1,7 @@
-from typing import Optional, Sequence
-
 from bluesky.protocols import Hints
 
 from ophyd_async.core import DirectoryProvider
 from ophyd_async.core.detector import StandardDetector
-from ophyd_async.core.signal import SignalR
 from ophyd_async.epics.areadetector.controllers.pilatus_controller import (
     PilatusController,
 )
@@ -22,15 +19,14 @@ class PilatusDetector(StandardDetector):
 
     def __init__(
         self,
-        name: str,
+        prefix: str,
         directory_provider: DirectoryProvider,
-        driver: PilatusDriver,
-        hdf: NDFileHDF,
-        config_sigs: Optional[Sequence[SignalR]] = None,
-        **scalar_sigs: str,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
+        name="",
     ):
-        self.drv = driver
-        self.hdf = hdf
+        self.drv = PilatusDriver(prefix + drv_suffix)
+        self.hdf = NDFileHDF(prefix + hdf_suffix)
 
         super().__init__(
             PilatusController(self.drv),
@@ -39,9 +35,8 @@ class PilatusDetector(StandardDetector):
                 directory_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
-                **scalar_sigs,
             ),
-            config_sigs=config_sigs or (self.drv.acquire_time,),
+            config_sigs=(self.drv.acquire_time,),
             name=name,
         )
 

ophyd_async/epics/areadetector/single_trigger_det.py

@@ -3,7 +3,13 @@ from typing import Sequence
 
 from bluesky.protocols import Triggerable
 
-from ophyd_async.core import AsyncStatus, SignalR, StandardReadable
+from ophyd_async.core import (
+    AsyncStatus,
+    ConfigSignal,
+    HintedSignal,
+    SignalR,
+    StandardReadable,
+)
 
 from .drivers.ad_base import ADBase
 from .utils import ImageMode
@@ -20,12 +26,14 @@ class SingleTriggerDet(StandardReadable, Triggerable):
     ) -> None:
         self.drv = drv
         self.__dict__.update(plugins)
-        self.set_readable_signals(
-            # Can't subscribe to read signals as race between monitor coming back and
-            # caput callback on acquire
-            read_uncached=[self.drv.array_counter] + list(read_uncached),
-            config=[self.drv.acquire_time],
+
+        self.add_readables(
+            [self.drv.array_counter, *read_uncached],
+            wrapper=HintedSignal.uncached,
         )
+
+        self.add_readables([self.drv.acquire_time], wrapper=ConfigSignal)
+
         super().__init__(name=name)
 
     @AsyncStatus.wrap

ophyd_async/epics/areadetector/utils.py

@@ -1,18 +1,8 @@
 from enum import Enum
-from typing import Optional, Type
+from typing import Optional
 from xml.etree import cElementTree as ET
 
-from ophyd_async.core import DEFAULT_TIMEOUT, SignalR, SignalRW, T, wait_for_value
-
-from ..signal.signal import epics_signal_r, epics_signal_rw
-
-
-def ad_rw(datatype: Type[T], prefix: str) -> SignalRW[T]:
-    return epics_signal_rw(datatype, prefix + "_RBV", prefix)
-
-
-def ad_r(datatype: Type[T], prefix: str) -> SignalR[T]:
-    return epics_signal_r(datatype, prefix + "_RBV")
+from ophyd_async.core import DEFAULT_TIMEOUT, SignalRW, T, wait_for_value
 
 
 class FileWriteMode(str, Enum):

ophyd_async/epics/areadetector/vimba.py

@@ -0,0 +1,43 @@
+from bluesky.protocols import HasHints, Hints
+
+from ophyd_async.core import DirectoryProvider, StandardDetector
+from ophyd_async.epics.areadetector.controllers.vimba_controller import VimbaController
+from ophyd_async.epics.areadetector.drivers import ADBaseShapeProvider
+from ophyd_async.epics.areadetector.drivers.vimba_driver import VimbaDriver
+from ophyd_async.epics.areadetector.writers import HDFWriter, NDFileHDF
+
+
+class VimbaDetector(StandardDetector, HasHints):
+    """
+    Ophyd-async implementation of an ADVimba Detector.
+    """
+
+    _controller: VimbaController
+    _writer: HDFWriter
+
+    def __init__(
+        self,
+        prefix: str,
+        directory_provider: DirectoryProvider,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
+        name="",
+    ):
+        self.drv = VimbaDriver(prefix + drv_suffix)
+        self.hdf = NDFileHDF(prefix + hdf_suffix)
+
+        super().__init__(
+            VimbaController(self.drv),
+            HDFWriter(
+                self.hdf,
+                directory_provider,
+                lambda: self.name,
+                ADBaseShapeProvider(self.drv),
+            ),
+            config_sigs=(self.drv.acquire_time,),
+            name=name,
+        )
+
+    @property
+    def hints(self) -> Hints:
+        return self._writer.hints

ophyd_async/epics/areadetector/writers/hdf_writer.py

@@ -2,7 +2,7 @@ import asyncio
 from pathlib import Path
 from typing import AsyncGenerator, AsyncIterator, Dict, List, Optional
 
-from bluesky.protocols import Descriptor, Hints, StreamAsset
+from bluesky.protocols import DataKey, Hints, StreamAsset
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -40,7 +40,7 @@ class HDFWriter(DetectorWriter):
         self._file: Optional[_HDFFile] = None
         self._multiplier = 1
 
-    async def open(self, multiplier: int = 1) -> Dict[str, Descriptor]:
+    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         self._file = None
         info = self._directory_provider()
         await asyncio.gather(
@@ -52,6 +52,9 @@ class HDFWriter(DetectorWriter):
             self.hdf.file_name.set(f"{info.prefix}{self.hdf.name}{info.suffix}"),
             self.hdf.file_template.set("%s/%s.h5"),
             self.hdf.file_write_mode.set(FileWriteMode.stream),
+            # Never use custom xml layout file but use the one defined
+            # in the source code file NDFileHDF5LayoutXML.cpp
+            self.hdf.xml_file_name.set(""),
         )
 
         assert (
@@ -81,7 +84,7 @@ class HDFWriter(DetectorWriter):
                 )
             )
         describe = {
-            ds.name: Descriptor(
+            ds.name: DataKey(
                 source=self.hdf.full_file_name.source,
                 shape=outer_shape + tuple(ds.shape),
                 dtype="array" if ds.shape else "number",

ophyd_async/epics/areadetector/writers/nd_file_hdf.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
-from ...signal.signal import epics_signal_rw
-from ..utils import FileWriteMode, ad_r, ad_rw
+from ...signal.signal import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
+from ..utils import FileWriteMode
 from .nd_plugin import NDPluginBase
 
 
@@ -19,21 +19,24 @@ class Compression(str, Enum):
 class NDFileHDF(NDPluginBase):
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        self.position_mode = ad_rw(bool, prefix + "PositionMode")
-        self.compression = ad_rw(Compression, prefix + "Compression")
-        self.num_extra_dims = ad_rw(int, prefix + "NumExtraDims")
-        self.file_path = ad_rw(str, prefix + "FilePath")
-        self.file_name = ad_rw(str, prefix + "FileName")
-        self.file_path_exists = ad_r(bool, prefix + "FilePathExists")
-        self.file_template = ad_rw(str, prefix + "FileTemplate")
-        self.full_file_name = ad_r(str, prefix + "FullFileName")
-        self.file_write_mode = ad_rw(FileWriteMode, prefix + "FileWriteMode")
-        self.num_capture = ad_rw(int, prefix + "NumCapture")
-        self.num_captured = ad_r(int, prefix + "NumCaptured")
-        self.swmr_mode = ad_rw(bool, prefix + "SWMRMode")
-        self.lazy_open = ad_rw(bool, prefix + "LazyOpen")
-        self.capture = ad_rw(bool, prefix + "Capture")
+        self.position_mode = epics_signal_rw_rbv(bool, prefix + "PositionMode")
+        self.compression = epics_signal_rw_rbv(Compression, prefix + "Compression")
+        self.num_extra_dims = epics_signal_rw_rbv(int, prefix + "NumExtraDims")
+        self.file_path = epics_signal_rw_rbv(str, prefix + "FilePath")
+        self.file_name = epics_signal_rw_rbv(str, prefix + "FileName")
+        self.file_path_exists = epics_signal_r(bool, prefix + "FilePathExists_RBV")
+        self.file_template = epics_signal_rw_rbv(str, prefix + "FileTemplate")
+        self.full_file_name = epics_signal_r(str, prefix + "FullFileName_RBV")
+        self.file_write_mode = epics_signal_rw_rbv(
+            FileWriteMode, prefix + "FileWriteMode"
+        )
+        self.num_capture = epics_signal_rw_rbv(int, prefix + "NumCapture")
+        self.num_captured = epics_signal_r(int, prefix + "NumCaptured_RBV")
+        self.swmr_mode = epics_signal_rw_rbv(bool, prefix + "SWMRMode")
+        self.lazy_open = epics_signal_rw_rbv(bool, prefix + "LazyOpen")
+        self.capture = epics_signal_rw_rbv(bool, prefix + "Capture")
         self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
-        self.array_size0 = ad_r(int, prefix + "ArraySize0")
-        self.array_size1 = ad_r(int, prefix + "ArraySize1")
+        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0_RBV")
+        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1_RBV")
+        self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/writers/nd_plugin.py

@@ -2,8 +2,7 @@ from enum import Enum
 
 from ophyd_async.core import Device
 from ophyd_async.epics.signal import epics_signal_rw
-
-from ..utils import ad_r, ad_rw
+from ophyd_async.epics.signal.signal import epics_signal_r, epics_signal_rw_rbv
 
 
 class Callback(str, Enum):
@@ -13,16 +12,16 @@ class Callback(str, Enum):
 
 class NDArrayBase(Device):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.unique_id = ad_r(int, prefix + "UniqueId")
+        self.unique_id = epics_signal_r(int, prefix + "UniqueId_RBV")
         self.nd_attributes_file = epics_signal_rw(str, prefix + "NDAttributesFile")
-        super().__init__(name)
+        super().__init__(name=name)
 
 
 class NDPluginBase(NDArrayBase):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.nd_array_port = ad_rw(str, prefix + "NDArrayPort")
-        self.enable_callback = ad_rw(Callback, prefix + "EnableCallbacks")
-        self.nd_array_address = ad_rw(int, prefix + "NDArrayAddress")
+        self.nd_array_port = epics_signal_rw_rbv(str, prefix + "NDArrayPort")
+        self.enable_callback = epics_signal_rw_rbv(Callback, prefix + "EnableCallbacks")
+        self.nd_array_address = epics_signal_rw_rbv(int, prefix + "NDArrayAddress")
         super().__init__(prefix, name)
 
 

ophyd_async/epics/demo/__init__.py

@@ -16,8 +16,10 @@ from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
     AsyncStatus,
+    ConfigSignal,
     Device,
     DeviceVector,
+    HintedSignal,
     StandardReadable,
     observe_value,
 )
@@ -39,26 +41,21 @@ class Sensor(StandardReadable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        self.value = epics_signal_r(float, prefix + "Value")
-        self.mode = epics_signal_rw(EnergyMode, prefix + "Mode")
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.value],
-            config=[self.mode],
-        )
+        with self.add_children_as_readables(HintedSignal):
+            self.value = epics_signal_r(float, prefix + "Value")
+        with self.add_children_as_readables(ConfigSignal):
+            self.mode = epics_signal_rw(EnergyMode, prefix + "Mode")
+
         super().__init__(name=name)
 
 
 class SensorGroup(StandardReadable):
     def __init__(self, prefix: str, name: str = "", sensor_count: int = 3) -> None:
-        self.sensors = DeviceVector(
-            {i: Sensor(f"{prefix}{i}:") for i in range(1, sensor_count + 1)}
-        )
+        with self.add_children_as_readables():
+            self.sensors = DeviceVector(
+                {i: Sensor(f"{prefix}{i}:") for i in range(1, sensor_count + 1)}
+            )
 
-        # Makes read() produce the values of all sensors
-        self.set_readable_signals(
-            read=[sensor.value for sensor in self.sensors.values()],
-        )
         super().__init__(name)
 
 
@@ -67,20 +64,20 @@ class Mover(StandardReadable, Movable, Stoppable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
+        with self.add_children_as_readables(HintedSignal):
+            self.readback = epics_signal_r(float, prefix + "Readback")
+
+        with self.add_children_as_readables(ConfigSignal):
+            self.velocity = epics_signal_rw(float, prefix + "Velocity")
+            self.units = epics_signal_r(str, prefix + "Readback.EGU")
+
         self.setpoint = epics_signal_rw(float, prefix + "Setpoint")
-        self.readback = epics_signal_r(float, prefix + "Readback")
-        self.velocity = epics_signal_rw(float, prefix + "Velocity")
-        self.units = epics_signal_r(str, prefix + "Readback.EGU")
         self.precision = epics_signal_r(int, prefix + "Readback.PREC")
         # Signals that collide with standard methods should have a trailing underscore
         self.stop_ = epics_signal_x(prefix + "Stop.PROC")
         # Whether set() should complete successfully or not
         self._set_success = True
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.readback],
-            config=[self.velocity, self.units],
-        )
+
         super().__init__(name=name)
 
     def set_name(self, name: str):