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

ophyd_async/epics/_backend/_p4p.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Dict, List, Optional, Sequence, Type, Union
 
-from bluesky.protocols import Descriptor, Dtype, Reading
+from bluesky.protocols import DataKey, Dtype, Reading
 from p4p import Value
 from p4p.client.asyncio import Context, Subscription
 
@@ -55,7 +55,7 @@ class PvaConverter:
             "alarm_severity": -1 if sv > 2 else sv,
         }
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         dtype = specifier_to_dtype[value.type().aspy("value")]
         return {"source": source, "dtype": dtype, "shape": []}
 
@@ -73,7 +73,7 @@ class PvaConverter:
 
 
 class PvaArrayConverter(PvaConverter):
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         return {"source": source, "dtype": "array", "shape": [len(value["value"])]}
 
 
@@ -96,7 +96,7 @@ class PvaNDArrayConverter(PvaConverter):
         dims = self._get_dimensions(value)
         return value["value"].reshape(dims)
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         dims = self._get_dimensions(value)
         return {"source": source, "dtype": "array", "shape": dims}
 
@@ -120,7 +120,7 @@ class PvaEnumConverter(PvaConverter):
     def value(self, value):
         return list(self.enum_class)[value["value"]["index"]]
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         choices = [e.value for e in self.enum_class]
         return {"source": source, "dtype": "string", "shape": [], "choices": choices}
 
@@ -129,7 +129,7 @@ class PvaEnumBoolConverter(PvaConverter):
     def value(self, value):
         return value["value"]["index"]
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         return {"source": source, "dtype": "integer", "shape": []}
 
 
@@ -137,7 +137,7 @@ class PvaTableConverter(PvaConverter):
     def value(self, value):
         return value["value"].todict()
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         # This is wrong, but defer until we know how to actually describe a table
         return {"source": source, "dtype": "object", "shape": []}  # type: ignore
 
@@ -152,7 +152,7 @@ class PvaDictConverter(PvaConverter):
     def value(self, value: Value):
         return value.todict()
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         raise NotImplementedError("Describing Dict signals not currently supported")
 
     def metadata_fields(self) -> List[str]:
@@ -216,7 +216,13 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
         )
         return PvaEnumConverter(get_supported_enum_class(pv, datatype, pv_choices))
     elif "NTScalar" in typeid:
-        if datatype and not issubclass(typ, datatype):
+        if (
+            datatype
+            and not issubclass(typ, datatype)
+            and not (
+                typ is float and datatype is int
+            )  # Allow float -> int since prec can be 0
+        ):
             raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
         return PvaConverter()
     elif "NTTable" in typeid:
@@ -293,9 +299,9 @@ class PvaSignalBackend(SignalBackend[T]):
             )
             raise NotConnected(f"pva://{self.write_pv}") from exc
 
-    async def get_descriptor(self, source: str) -> Descriptor:
+    async def get_datakey(self, source: str) -> DataKey:
         value = await self.ctxt.get(self.read_pv)
-        return self.converter.descriptor(source, value)
+        return self.converter.get_datakey(source, value)
 
     def _pva_request_string(self, fields: List[str]) -> str:
         """

ophyd_async/epics/areadetector/__init__.py

@@ -1,4 +1,5 @@
 from .aravis import AravisDetector
+from .kinetix import KinetixDetector
 from .pilatus import PilatusDetector
 from .single_trigger_det import SingleTriggerDet
 from .utils import (
@@ -9,9 +10,12 @@ from .utils import (
     ad_r,
     ad_rw,
 )
+from .vimba import VimbaDetector
 
 __all__ = [
     "AravisDetector",
+    "KinetixDetector",
+    "VimbaDetector",
     "SingleTriggerDet",
     "FileWriteMode",
     "ImageMode",

ophyd_async/epics/areadetector/aravis.py

@@ -23,16 +23,15 @@ class AravisDetector(StandardDetector, HasHints):
 
     def __init__(
         self,
-        name: str,
+        prefix: str,
         directory_provider: DirectoryProvider,
-        driver: AravisDriver,
-        hdf: NDFileHDF,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
+        name="",
         gpio_number: AravisController.GPIO_NUMBER = 1,
-        **scalar_sigs: str,
     ):
-        # Must be child of Detector to pick up connect()
-        self.drv = driver
-        self.hdf = hdf
+        self.drv = AravisDriver(prefix + drv_suffix)
+        self.hdf = NDFileHDF(prefix + hdf_suffix)
 
         super().__init__(
             AravisController(self.drv, gpio_number=gpio_number),
@@ -41,9 +40,8 @@ class AravisDetector(StandardDetector, HasHints):
                 directory_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
-                **scalar_sigs,
             ),
-            config_sigs=(self.drv.acquire_time, self.drv.acquire),
+            config_sigs=(self.drv.acquire_time,),
             name=name,
         )
 

ophyd_async/epics/areadetector/controllers/__init__.py

@@ -1,4 +1,5 @@
 from .ad_sim_controller import ADSimController
+from .aravis_controller import AravisController
 from .pilatus_controller import PilatusController
 
-__all__ = ["PilatusController", "ADSimController"]
+__all__ = ["PilatusController", "ADSimController", "AravisController"]

ophyd_async/epics/areadetector/controllers/kinetix_controller.py

@@ -0,0 +1,49 @@
+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.kinetix_driver import KinetixDriver, KinetixTriggerMode
+from ..utils import ImageMode, stop_busy_record
+
+KINETIX_TRIGGER_MODE_MAP = {
+    DetectorTrigger.internal: KinetixTriggerMode.internal,
+    DetectorTrigger.constant_gate: KinetixTriggerMode.gate,
+    DetectorTrigger.variable_gate: KinetixTriggerMode.gate,
+    DetectorTrigger.edge_trigger: KinetixTriggerMode.edge,
+}
+
+
+class KinetixController(DetectorControl):
+    def __init__(
+        self,
+        driver: KinetixDriver,
+    ) -> 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(KINETIX_TRIGGER_MODE_MAP[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)
+        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/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/kinetix_driver.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+from ..utils import ad_rw
+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 = ad_rw(PixelFormat, prefix + "PixelFormat")
+        self.trigger_mode = ad_rw(KinetixTriggerMode, prefix + "TriggerMode")
+        self.mode = ad_rw(KinetixReadoutMode, prefix + "ReadoutPortIdx")
+        super().__init__(prefix, name)

ophyd_async/epics/areadetector/drivers/vimba_driver.py

@@ -0,0 +1,58 @@
+from enum import Enum
+
+from ..utils import ad_rw
+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 = ad_rw(PixelFormat, prefix + "PixelFormat")
+        self.convert_format = ad_rw(
+            VimbaConvertFormat, prefix + "ConvertPixelFormat"
+        )  # Pixel format of data outputted to AD
+        self.trig_source = ad_rw(VimbaTriggerSource, prefix + "TriggerSource")
+        self.trigger_mode = ad_rw(VimbaOnOff, prefix + "TriggerMode")
+        self.overlap = ad_rw(VimbaOverlap, prefix + "TriggerOverlap")
+        self.expose_mode = ad_rw(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/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

@@ -36,4 +36,5 @@ class NDFileHDF(NDPluginBase):
         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.xml_file_name = ad_rw(str, prefix + "XMLFileName")
         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):