ophyd-async 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

ophyd_async/epics/adcore/_core_io.py

@@ -0,0 +1,138 @@
+from enum import Enum
+
+from ophyd_async.core import Device
+from ophyd_async.epics.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+)
+
+from ._utils import ADBaseDataType, FileWriteMode, ImageMode
+
+
+class Callback(str, Enum):
+    Enable = "Enable"
+    Disable = "Disable"
+
+
+class NDArrayBaseIO(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.unique_id = epics_signal_r(int, prefix + "UniqueId_RBV")
+        self.nd_attributes_file = epics_signal_rw(str, prefix + "NDAttributesFile")
+        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
+        self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
+        self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
+        self.data_type = epics_signal_r(ADBaseDataType, prefix + "DataType_RBV")
+        self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
+        # There is no _RBV for this one
+        self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")
+        super().__init__(name=name)
+
+
+class NDPluginBaseIO(NDArrayBaseIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.nd_array_port = epics_signal_rw_rbv(str, prefix + "NDArrayPort")
+        self.enable_callbacks = epics_signal_rw_rbv(
+            Callback, prefix + "EnableCallbacks"
+        )
+        self.nd_array_address = epics_signal_rw_rbv(int, prefix + "NDArrayAddress")
+        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0_RBV")
+        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1_RBV")
+        super().__init__(prefix, name)
+
+
+class NDPluginStatsIO(NDPluginBaseIO):
+    """
+    Plugin for computing statistics from an image or region of interest within an image.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        # Basic statistics
+        self.compute_statistics = epics_signal_rw(bool, prefix + "ComputeStatistics")
+        self.bgd_width = epics_signal_rw(int, prefix + "BgdWidth")
+        self.total_array = epics_signal_rw(float, prefix + "TotalArray")
+        # Centroid statistics
+        self.compute_centroid = epics_signal_rw(bool, prefix + "ComputeCentroid")
+        self.centroid_threshold = epics_signal_rw(float, prefix + "CentroidThreshold")
+        # X and Y Profiles
+        self.compute_profiles = epics_signal_rw(bool, prefix + "ComputeProfiles")
+        self.profile_size_x = epics_signal_rw(int, prefix + "ProfileSizeX")
+        self.profile_size_y = epics_signal_rw(int, prefix + "ProfileSizeY")
+        self.cursor_x = epics_signal_rw(int, prefix + "CursorX")
+        self.cursor_y = epics_signal_rw(int, prefix + "CursorY")
+        # Array Histogram
+        self.compute_histogram = epics_signal_rw(bool, prefix + "ComputeHistogram")
+        self.hist_size = epics_signal_rw(int, prefix + "HistSize")
+        self.hist_min = epics_signal_rw(float, prefix + "HistMin")
+        self.hist_max = epics_signal_rw(float, prefix + "HistMax")
+        super().__init__(prefix, name)
+
+
+class DetectorState(str, Enum):
+    """
+    Default set of states of an AreaDetector driver.
+    See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore
+    """
+
+    Idle = "Idle"
+    Acquire = "Acquire"
+    Readout = "Readout"
+    Correct = "Correct"
+    Saving = "Saving"
+    Aborting = "Aborting"
+    Error = "Error"
+    Waiting = "Waiting"
+    Initializing = "Initializing"
+    Disconnected = "Disconnected"
+    Aborted = "Aborted"
+
+
+class ADBaseIO(NDArrayBaseIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        # Define some signals
+        self.acquire_time = epics_signal_rw_rbv(float, prefix + "AcquireTime")
+        self.acquire_period = epics_signal_rw_rbv(float, prefix + "AcquirePeriod")
+        self.num_images = epics_signal_rw_rbv(int, prefix + "NumImages")
+        self.image_mode = epics_signal_rw_rbv(ImageMode, prefix + "ImageMode")
+        self.detector_state = epics_signal_r(
+            DetectorState, prefix + "DetectorState_RBV"
+        )
+        super().__init__(prefix, name=name)
+
+
+class Compression(str, Enum):
+    none = "None"
+    nbit = "N-bit"
+    szip = "szip"
+    zlib = "zlib"
+    blosc = "Blosc"
+    bslz4 = "BSLZ4"
+    lz4 = "LZ4"
+    jpeg = "JPEG"
+
+
+class NDFileHDFIO(NDPluginBaseIO):
+    def __init__(self, prefix: str, name="") -> None:
+        # Define some signals
+        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.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
+        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0")
+        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1")
+        self.create_directory = epics_signal_rw(int, prefix + "CreateDirectory")
+        super().__init__(prefix, name)

ophyd_async/epics/{areadetector/drivers/ad_base.py → adcore/_core_logic.py}

@@ -1,5 +1,4 @@
 import asyncio
-from enum import Enum
 from typing import FrozenSet, Set
 
 from ophyd_async.core import (
@@ -10,53 +9,31 @@ from ophyd_async.core import (
     set_and_wait_for_value,
 )
 
-from ...signal.signal import epics_signal_r, epics_signal_rw_rbv
-from ..utils import ImageMode
-from ..writers.nd_plugin import NDArrayBase
+from ._core_io import ADBaseIO, DetectorState
 
-
-class DetectorState(str, Enum):
-    """
-    Default set of states of an AreaDetector driver.
-    See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore
-    """
-
-    Idle = "Idle"
-    Acquire = "Acquire"
-    Readout = "Readout"
-    Correct = "Correct"
-    Saving = "Saving"
-    Aborting = "Aborting"
-    Error = "Error"
-    Waiting = "Waiting"
-    Initializing = "Initializing"
-    Disconnected = "Disconnected"
-    Aborted = "Aborted"
-
-
-#: Default set of states that we should consider "good" i.e. the acquisition
+# Default set of states that we should consider "good" i.e. the acquisition
 #  is complete and went well
 DEFAULT_GOOD_STATES: FrozenSet[DetectorState] = frozenset(
     [DetectorState.Idle, DetectorState.Aborted]
 )
 
 
-class ADBase(NDArrayBase):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        # Define some signals
-        self.acquire_time = epics_signal_rw_rbv(float, prefix + "AcquireTime")
-        self.acquire_period = epics_signal_rw_rbv(float, prefix + "AcquirePeriod")
-        self.num_images = epics_signal_rw_rbv(int, prefix + "NumImages")
-        self.image_mode = epics_signal_rw_rbv(ImageMode, prefix + "ImageMode")
-        self.detector_state = epics_signal_r(
-            DetectorState, prefix + "DetectorState_RBV"
+class ADBaseShapeProvider(ShapeProvider):
+    def __init__(self, driver: ADBaseIO) -> None:
+        self._driver = driver
+
+    async def __call__(self) -> tuple:
+        shape = await asyncio.gather(
+            self._driver.array_size_y.get_value(),
+            self._driver.array_size_x.get_value(),
+            self._driver.data_type.get_value(),
         )
-        super().__init__(prefix, name=name)
+        return shape
 
 
 async def set_exposure_time_and_acquire_period_if_supplied(
     controller: DetectorControl,
-    driver: ADBase,
+    driver: ADBaseIO,
     exposure: float | None = None,
     timeout: float = DEFAULT_TIMEOUT,
 ) -> None:
@@ -70,7 +47,7 @@ async def set_exposure_time_and_acquire_period_if_supplied(
     controller:
         Controller that can supply a deadtime.
     driver:
-        The driver to start acquiring. Must subclass ADBase.
+        The driver to start acquiring. Must subclass ADBaseIO.
     exposure:
         Desired exposure time, this is a noop if it is None.
     timeout:
@@ -85,7 +62,7 @@ async def set_exposure_time_and_acquire_period_if_supplied(
 
 
 async def start_acquiring_driver_and_ensure_status(
-    driver: ADBase,
+    driver: ADBaseIO,
     good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES),
     timeout: float = DEFAULT_TIMEOUT,
 ) -> AsyncStatus:
@@ -99,7 +76,7 @@ async def start_acquiring_driver_and_ensure_status(
     Parameters
     ----------
     driver:
-        The driver to start acquiring. Must subclass ADBase.
+        The driver to start acquiring. Must subclass ADBaseIO.
     good_states:
         set of states defined in DetectorState enum which are considered good states.
     timeout:
@@ -125,16 +102,3 @@ async def start_acquiring_driver_and_ensure_status(
             )
 
     return AsyncStatus(complete_acquisition())
-
-
-class ADBaseShapeProvider(ShapeProvider):
-    def __init__(self, driver: ADBase) -> None:
-        self._driver = driver
-
-    async def __call__(self) -> tuple:
-        shape = await asyncio.gather(
-            self._driver.array_size_y.get_value(),
-            self._driver.array_size_x.get_value(),
-            self._driver.data_type.get_value(),
-        )
-        return shape

ophyd_async/epics/{areadetector/writers/hdf_writer.py → adcore/_hdf_writer.py}

@@ -1,6 +1,7 @@
 import asyncio
 from pathlib import Path
 from typing import AsyncGenerator, AsyncIterator, Dict, List, Optional
+from xml.etree import ElementTree as ET
 
 from bluesky.protocols import DataKey, Hints, StreamAsset
 
@@ -8,51 +9,61 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     DetectorWriter,
+    HDFDataset,
+    HDFFile,
     NameProvider,
     PathProvider,
     ShapeProvider,
+    observe_value,
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.core.signal import observe_value
 
-from .general_hdffile import _HDFDataset, _HDFFile
-from .nd_file_hdf import FileWriteMode, NDFileHDF
-from .nd_plugin import convert_ad_dtype_to_np
+from ._core_io import NDArrayBaseIO, NDFileHDFIO
+from ._utils import (
+    FileWriteMode,
+    convert_ad_dtype_to_np,
+    convert_param_dtype_to_np,
+    convert_pv_dtype_to_np,
+)
 
 
-class HDFWriter(DetectorWriter):
+class ADHDFWriter(DetectorWriter):
     def __init__(
         self,
-        hdf: NDFileHDF,
+        hdf: NDFileHDFIO,
         path_provider: PathProvider,
         name_provider: NameProvider,
         shape_provider: ShapeProvider,
-        **scalar_datasets_paths: str,
+        *plugins: NDArrayBaseIO,
     ) -> None:
         self.hdf = hdf
         self._path_provider = path_provider
         self._name_provider = name_provider
         self._shape_provider = shape_provider
-        self._scalar_datasets_paths = scalar_datasets_paths
+
+        self._plugins = plugins
         self._capture_status: Optional[AsyncStatus] = None
-        self._datasets: List[_HDFDataset] = []
-        self._file: Optional[_HDFFile] = None
+        self._datasets: List[HDFDataset] = []
+        self._file: Optional[HDFFile] = None
         self._multiplier = 1
 
     async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         self._file = None
         info = self._path_provider(device_name=self.hdf.name)
-        file_path = str(info.root / info.resource_dir)
+
+        # Set the directory creation depth first, since dir creation callback happens
+        # when directory path PV is processed.
+        await self.hdf.create_directory.set(info.create_dir_depth)
+
         await asyncio.gather(
             self.hdf.num_extra_dims.set(0),
             self.hdf.lazy_open.set(True),
             self.hdf.swmr_mode.set(True),
             # See https://github.com/bluesky/ophyd-async/issues/122
-            self.hdf.file_path.set(file_path),
+            self.hdf.file_path.set(str(info.directory_path)),
             self.hdf.file_name.set(info.filename),
             self.hdf.file_template.set("%s/%s.h5"),
-            self.hdf.create_dir_depth.set(info.create_dir_depth),
             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
@@ -61,7 +72,7 @@ class HDFWriter(DetectorWriter):
 
         assert (
             await self.hdf.file_path_exists.get_value()
-        ), f"File path {file_path} for hdf plugin does not exist"
+        ), f"File path {info.directory_path} for hdf plugin does not exist"
 
         # Overwrite num_capture to go forever
         await self.hdf.num_capture.set(0)
@@ -80,7 +91,7 @@ class HDFWriter(DetectorWriter):
 
         # Add the main data
         self._datasets = [
-            _HDFDataset(
+            HDFDataset(
                 data_key=name,
                 dataset="/entry/data/data",
                 shape=frame_shape,
@@ -89,16 +100,31 @@ class HDFWriter(DetectorWriter):
             )
         ]
         # And all the scalar datasets
-        for ds_name, ds_path in self._scalar_datasets_paths.items():
-            self._datasets.append(
-                _HDFDataset(
-                    f"{name}-{ds_name}",
-                    f"/entry/instrument/NDAttributes/{ds_path}",
-                    (),
-                    "",
-                    multiplier,
-                )
-            )
+        for plugin in self._plugins:
+            maybe_xml = await plugin.nd_attributes_file.get_value()
+            # This is the check that ADCore does to see if it is an XML string
+            # rather than a filename to parse
+            if "<Attributes>" in maybe_xml:
+                root = ET.fromstring(maybe_xml)
+                for child in root:
+                    datakey = child.attrib["name"]
+                    if child.attrib.get("type", "EPICS_PV") == "EPICS_PV":
+                        np_datatype = convert_pv_dtype_to_np(
+                            child.attrib.get("dbrtype", "DBR_NATIVE")
+                        )
+                    else:
+                        np_datatype = convert_param_dtype_to_np(
+                            child.attrib.get("datatype", "INT")
+                        )
+                    self._datasets.append(
+                        HDFDataset(
+                            datakey,
+                            f"/entry/instrument/NDAttributes/{datakey}",
+                            (),
+                            np_datatype,
+                            multiplier,
+                        )
+                    )
 
         describe = {
             ds.data_key: DataKey(
@@ -131,8 +157,7 @@ class HDFWriter(DetectorWriter):
         if indices_written:
             if not self._file:
                 path = Path(await self.hdf.full_file_name.get_value())
-                self._file = _HDFFile(
-                    self._path_provider(),
+                self._file = HDFFile(
                     # See https://github.com/bluesky/ophyd-async/issues/122
                     path,
                     self._datasets,
@@ -148,8 +173,8 @@ class HDFWriter(DetectorWriter):
 
     async def close(self):
         # Already done a caput callback in _capture_status, so can't do one here
-        await self.hdf.capture.set(0, wait=False)
-        await wait_for_value(self.hdf.capture, 0, DEFAULT_TIMEOUT)
+        await self.hdf.capture.set(False, wait=False)
+        await wait_for_value(self.hdf.capture, False, DEFAULT_TIMEOUT)
         if self._capture_status:
             # We kicked off an open, so wait for it to return
             await self._capture_status

ophyd_async/epics/{areadetector/single_trigger_det.py → adcore/_single_trigger.py}

@@ -11,18 +11,17 @@ from ophyd_async.core import (
     StandardReadable,
 )
 
-from .drivers.ad_base import ADBase
-from .utils import ImageMode
-from .writers.nd_plugin import NDPluginBase
+from ._core_io import ADBaseIO, NDPluginBaseIO
+from ._utils import ImageMode
 
 
-class SingleTriggerDet(StandardReadable, Triggerable):
+class SingleTriggerDetector(StandardReadable, Triggerable):
     def __init__(
         self,
-        drv: ADBase,
+        drv: ADBaseIO,
         read_uncached: Sequence[SignalR] = (),
         name="",
-        **plugins: NDPluginBase,
+        **plugins: NDPluginBaseIO,
     ) -> None:
         self.drv = drv
         self.__dict__.update(plugins)

ophyd_async/epics/adcore/_utils.py

@@ -0,0 +1,132 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+from ophyd_async.core import DEFAULT_TIMEOUT, SignalRW, T, wait_for_value
+from ophyd_async.core._signal import SignalR
+
+
+class ADBaseDataType(str, Enum):
+    Int8 = "Int8"
+    UInt8 = "UInt8"
+    Int16 = "Int16"
+    UInt16 = "UInt16"
+    Int32 = "Int32"
+    UInt32 = "UInt32"
+    Int64 = "Int64"
+    UInt64 = "UInt64"
+    Float32 = "Float32"
+    Float64 = "Float64"
+
+
+def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
+    ad_dtype_to_np_dtype = {
+        ADBaseDataType.Int8: "|i1",
+        ADBaseDataType.UInt8: "|u1",
+        ADBaseDataType.Int16: "<i2",
+        ADBaseDataType.UInt16: "<u2",
+        ADBaseDataType.Int32: "<i4",
+        ADBaseDataType.UInt32: "<u4",
+        ADBaseDataType.Int64: "<i8",
+        ADBaseDataType.UInt64: "<u8",
+        ADBaseDataType.Float32: "<f4",
+        ADBaseDataType.Float64: "<f8",
+    }
+    return ad_dtype_to_np_dtype[ad_dtype]
+
+
+def convert_pv_dtype_to_np(datatype: str) -> str:
+    _pvattribute_to_ad_datatype = {
+        "DBR_SHORT": ADBaseDataType.Int16,
+        "DBR_ENUM": ADBaseDataType.Int16,
+        "DBR_INT": ADBaseDataType.Int32,
+        "DBR_LONG": ADBaseDataType.Int32,
+        "DBR_FLOAT": ADBaseDataType.Float32,
+        "DBR_DOUBLE": ADBaseDataType.Float64,
+    }
+    if datatype in ["DBR_STRING", "DBR_CHAR"]:
+        np_datatype = "s40"
+    elif datatype == "DBR_NATIVE":
+        raise ValueError("Don't support DBR_NATIVE yet")
+    else:
+        try:
+            np_datatype = convert_ad_dtype_to_np(_pvattribute_to_ad_datatype[datatype])
+        except KeyError:
+            raise ValueError(f"Invalid dbr type {datatype}")
+    return np_datatype
+
+
+def convert_param_dtype_to_np(datatype: str) -> str:
+    _paramattribute_to_ad_datatype = {
+        "INT": ADBaseDataType.Int32,
+        "INT64": ADBaseDataType.Int64,
+        "DOUBLE": ADBaseDataType.Float64,
+    }
+    if datatype in ["STRING"]:
+        np_datatype = "s40"
+    else:
+        try:
+            np_datatype = convert_ad_dtype_to_np(
+                _paramattribute_to_ad_datatype[datatype]
+            )
+        except KeyError:
+            raise ValueError(f"Invalid datatype {datatype}")
+    return np_datatype
+
+
+class FileWriteMode(str, Enum):
+    single = "Single"
+    capture = "Capture"
+    stream = "Stream"
+
+
+class ImageMode(str, Enum):
+    single = "Single"
+    multiple = "Multiple"
+    continuous = "Continuous"
+
+
+class NDAttributeDataType(str, Enum):
+    INT = "INT"
+    DOUBLE = "DOUBLE"
+    STRING = "STRING"
+
+
+class NDAttributePvDbrType(str, Enum):
+    DBR_SHORT = "DBR_SHORT"
+    DBR_ENUM = "DBR_ENUM"
+    DBR_INT = "DBR_INT"
+    DBR_LONG = "DBR_LONG"
+    DBR_FLOAT = "DBR_FLOAT"
+    DBR_DOUBLE = "DBR_DOUBLE"
+    DBR_STRING = "DBR_STRING"
+    DBR_CHAR = "DBR_CHAR"
+
+
+@dataclass
+class NDAttributePv:
+    name: str  # name of attribute stamped on array, also scientifically useful name
+    # when appended to device.name
+    signal: SignalR  # caget the pv given by signal.source and attach to each frame
+    dbrtype: NDAttributePvDbrType
+    description: str = ""  # A description that appears in the HDF file as an attribute
+
+
+@dataclass
+class NDAttributeParam:
+    name: str  # name of attribute stamped on array, also scientifically useful name
+    # when appended to device.name
+    param: str  # The parameter string as seen in the INP link of the record
+    datatype: NDAttributeDataType  # The datatype of the parameter
+    addr: int = 0  # The address as seen in the INP link of the record
+    description: str = ""  # A description that appears in the HDF file as an attribute
+
+
+async def stop_busy_record(
+    signal: SignalRW[T],
+    value: T,
+    timeout: float = DEFAULT_TIMEOUT,
+    status_timeout: Optional[float] = None,
+) -> None:
+    await signal.set(value, wait=False, timeout=status_timeout)
+    await wait_for_value(signal, value, timeout=timeout)

ophyd_async/epics/adkinetix/__init__.py

@@ -0,0 +1,9 @@
+from ._kinetix import KinetixDetector
+from ._kinetix_controller import KinetixController
+from ._kinetix_io import KinetixDriverIO
+
+__all__ = [
+    "KinetixDetector",
+    "KinetixController",
+    "KinetixDriverIO",
+]

ophyd_async/epics/{areadetector/kinetix.py → adkinetix/_kinetix.py}

@@ -1,12 +1,10 @@
 from bluesky.protocols import HasHints, Hints
 
 from ophyd_async.core import PathProvider, 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
+from ophyd_async.epics import adcore
+
+from ._kinetix_controller import KinetixController
+from ._kinetix_io import KinetixDriverIO
 
 
 class KinetixDetector(StandardDetector, HasHints):
@@ -16,7 +14,7 @@ class KinetixDetector(StandardDetector, HasHints):
     """
 
     _controller: KinetixController
-    _writer: HDFWriter
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
@@ -26,16 +24,16 @@ class KinetixDetector(StandardDetector, HasHints):
         hdf_suffix="HDF1:",
         name="",
     ):
-        self.drv = KinetixDriver(prefix + drv_suffix)
-        self.hdf = NDFileHDF(prefix + hdf_suffix)
+        self.drv = KinetixDriverIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             KinetixController(self.drv),
-            HDFWriter(
+            adcore.ADHDFWriter(
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/{areadetector/controllers/kinetix_controller.py → adkinetix/_kinetix_controller.py}

@@ -2,12 +2,9 @@ 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 ophyd_async.epics import adcore
 
-from ..drivers.kinetix_driver import KinetixDriver, KinetixTriggerMode
-from ..utils import ImageMode, stop_busy_record
+from ._kinetix_io import KinetixDriverIO, KinetixTriggerMode
 
 KINETIX_TRIGGER_MODE_MAP = {
     DetectorTrigger.internal: KinetixTriggerMode.internal,
@@ -20,7 +17,7 @@ KINETIX_TRIGGER_MODE_MAP = {
 class KinetixController(DetectorControl):
     def __init__(
         self,
-        driver: KinetixDriver,
+        driver: KinetixDriverIO,
     ) -> None:
         self._drv = driver
 
@@ -36,14 +33,14 @@ class KinetixController(DetectorControl):
         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),
+            self._drv.image_mode.set(adcore.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)
+        return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)