ophyd-async 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

ophyd_async/epics/adcore/_core_io.py

@@ -22,18 +22,19 @@ class NDArrayBaseIO(Device):
         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 + "NDDataType_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_callback = epics_signal_rw_rbv(Callback, prefix + "EnableCallbacks")
+        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")
@@ -41,7 +42,30 @@ class NDPluginBaseIO(NDArrayBaseIO):
 
 
 class NDPluginStatsIO(NDPluginBaseIO):
-    pass
+    """
+    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):
@@ -110,5 +134,5 @@ class NDFileHDFIO(NDPluginBaseIO):
         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_dir_depth = epics_signal_rw(int, prefix + "CreateDirectory")
+        self.create_directory = epics_signal_rw(int, prefix + "CreateDirectory")
         super().__init__(prefix, name)

ophyd_async/epics/adcore/_core_logic.py

@@ -4,10 +4,11 @@ from typing import FrozenSet, Set
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
+    DatasetDescriber,
     DetectorControl,
-    ShapeProvider,
     set_and_wait_for_value,
 )
+from ophyd_async.epics.adcore._utils import convert_ad_dtype_to_np
 
 from ._core_io import ADBaseIO, DetectorState
 
@@ -18,15 +19,17 @@ DEFAULT_GOOD_STATES: FrozenSet[DetectorState] = frozenset(
 )
 
 
-class ADBaseShapeProvider(ShapeProvider):
+class ADBaseDatasetDescriber(DatasetDescriber):
     def __init__(self, driver: ADBaseIO) -> None:
         self._driver = driver
 
-    async def __call__(self) -> tuple:
+    async def np_datatype(self) -> str:
+        return convert_ad_dtype_to_np(await self._driver.data_type.get_value())
+
+    async def shape(self) -> tuple[int, int]:
         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/adcore/_hdf_writer.py

@@ -1,25 +1,30 @@
 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
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
+    DatasetDescriber,
     DetectorWriter,
     HDFDataset,
     HDFFile,
     NameProvider,
     PathProvider,
-    ShapeProvider,
     observe_value,
     set_and_wait_for_value,
     wait_for_value,
 )
 
-from ._core_io import NDFileHDFIO
-from ._utils import FileWriteMode, convert_ad_dtype_to_np
+from ._core_io import NDArrayBaseIO, NDFileHDFIO
+from ._utils import (
+    FileWriteMode,
+    convert_param_dtype_to_np,
+    convert_pv_dtype_to_np,
+)
 
 
 class ADHDFWriter(DetectorWriter):
@@ -28,14 +33,15 @@ class ADHDFWriter(DetectorWriter):
         hdf: NDFileHDFIO,
         path_provider: PathProvider,
         name_provider: NameProvider,
-        shape_provider: ShapeProvider,
-        **scalar_datasets_paths: str,
+        dataset_describer: DatasetDescriber,
+        *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._dataset_describer = dataset_describer
+
+        self._plugins = plugins
         self._capture_status: Optional[AsyncStatus] = None
         self._datasets: List[HDFDataset] = []
         self._file: Optional[HDFFile] = None
@@ -44,16 +50,19 @@ class ADHDFWriter(DetectorWriter):
     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
@@ -62,44 +71,54 @@ class ADHDFWriter(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)
         # Wait for it to start, stashing the status that tells us when it finishes
         self._capture_status = await set_and_wait_for_value(self.hdf.capture, True)
         name = self._name_provider()
-        detector_shape = tuple(await self._shape_provider())
+        detector_shape = await self._dataset_describer.shape()
+        np_dtype = await self._dataset_describer.np_datatype()
         self._multiplier = multiplier
         outer_shape = (multiplier,) if multiplier > 1 else ()
-        frame_shape = detector_shape[:-1] if len(detector_shape) > 0 else []
-        dtype_numpy = (
-            convert_ad_dtype_to_np(detector_shape[-1])
-            if len(detector_shape) > 0
-            else ""
-        )
 
         # Add the main data
         self._datasets = [
             HDFDataset(
                 data_key=name,
                 dataset="/entry/data/data",
-                shape=frame_shape,
-                dtype_numpy=dtype_numpy,
+                shape=detector_shape,
+                dtype_numpy=np_dtype,
                 multiplier=multiplier,
             )
         ]
         # 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(
@@ -133,7 +152,6 @@ class ADHDFWriter(DetectorWriter):
             if not self._file:
                 path = Path(await self.hdf.full_file_name.get_value())
                 self._file = HDFFile(
-                    self._path_provider(),
                     # See https://github.com/bluesky/ophyd-async/issues/122
                     path,
                     self._datasets,
@@ -149,8 +167,8 @@ class ADHDFWriter(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/adcore/_utils.py

@@ -1,8 +1,9 @@
+from dataclasses import dataclass
 from enum import Enum
 from typing import Optional
-from xml.etree import cElementTree as ET
 
 from ophyd_async.core import DEFAULT_TIMEOUT, SignalRW, T, wait_for_value
+from ophyd_async.core._signal import SignalR
 
 
 class ADBaseDataType(str, Enum):
@@ -34,6 +35,45 @@ def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
     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"
@@ -52,75 +92,34 @@ class NDAttributeDataType(str, Enum):
     STRING = "STRING"
 
 
-class NDAttributesXML:
-    """Helper to make NDAttributesFile XML for areaDetector"""
-
-    _dbr_types = {
-        None: "DBR_NATIVE",
-        NDAttributeDataType.INT: "DBR_LONG",
-        NDAttributeDataType.DOUBLE: "DBR_DOUBLE",
-        NDAttributeDataType.STRING: "DBR_STRING",
-    }
-
-    def __init__(self):
-        self._root = ET.Element("Attributes")
-
-    def add_epics_pv(
-        self,
-        name: str,
-        pv: str,
-        datatype: Optional[NDAttributeDataType] = None,
-        description: str = "",
-    ):
-        """Add a PV to the attribute list
-
-        Args:
-            name: The attribute name
-            pv: The pv to get from
-            datatype: An override datatype, otherwise will use native EPICS type
-            description: A description that appears in the HDF file as an attribute
-        """
-        ET.SubElement(
-            self._root,
-            "Attribute",
-            name=name,
-            type="EPICS_PV",
-            source=pv,
-            datatype=self._dbr_types[datatype],
-            description=description,
-        )
-
-    def add_param(
-        self,
-        name: str,
-        param: str,
-        datatype: NDAttributeDataType,
-        addr: int = 0,
-        description: str = "",
-    ):
-        """Add a driver or plugin parameter to the attribute list
-
-        Args:
-            name: The attribute name
-            param: The parameter string as seen in the INP link of the record
-            datatype: The datatype of the parameter
-            description: A description that appears in the HDF file as an attribute
-        """
-        ET.SubElement(
-            self._root,
-            "Attribute",
-            name=name,
-            type="PARAM",
-            source=param,
-            addr=str(addr),
-            datatype=datatype.value,
-            description=description,
-        )
-
-    def __str__(self) -> str:
-        """Output the XML pretty printed"""
-        ET.indent(self._root, space="    ", level=0)
-        return ET.tostring(self._root, xml_declaration=True, encoding="utf-8").decode()
+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(

ophyd_async/epics/adkinetix/_kinetix.py

@@ -33,7 +33,7 @@ class KinetixDetector(StandardDetector, HasHints):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/adkinetix/_kinetix_io.py

@@ -14,6 +14,7 @@ class KinetixReadoutMode(str, Enum):
     sensitivity = 1
     speed = 2
     dynamic_range = 3
+    sub_electron = 4
 
 
 class KinetixDriverIO(adcore.ADBaseIO):
@@ -24,5 +25,7 @@ class KinetixDriverIO(adcore.ADBaseIO):
         self.trigger_mode = epics_signal_rw_rbv(
             KinetixTriggerMode, prefix + "TriggerMode"
         )
-        self.mode = epics_signal_rw_rbv(KinetixReadoutMode, prefix + "ReadoutPortIdx")
+        self.readout_port_idx = epics_signal_rw_rbv(
+            KinetixReadoutMode, prefix + "ReadoutPortIdx"
+        )
         super().__init__(prefix, name)

ophyd_async/epics/adpilatus/_pilatus.py

@@ -47,7 +47,7 @@ class PilatusDetector(StandardDetector):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -54,7 +54,7 @@ class PilatusController(DetectorControl):
         # is actually ready. Should wait for that too or we risk dropping
         # a frame
         await wait_for_value(
-            self._drv.armed_for_triggers,
+            self._drv.armed,
             True,
             timeout=DEFAULT_TIMEOUT,
         )

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -19,5 +19,5 @@ class PilatusDriverIO(adcore.ADBaseIO):
         self.trigger_mode = epics_signal_rw_rbv(
             PilatusTriggerMode, prefix + "TriggerMode"
         )
-        self.armed_for_triggers = epics_signal_r(bool, prefix + "Armed")
+        self.armed = epics_signal_r(bool, prefix + "Armed")
         super().__init__(prefix, name)

ophyd_async/epics/adsimdetector/_sim.py

@@ -27,7 +27,7 @@ class SimDetector(StandardDetector):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=config_sigs,
             name=name,

ophyd_async/epics/advimba/_vimba.py

@@ -32,7 +32,7 @@ class VimbaDetector(StandardDetector, HasHints):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/advimba/_vimba_controller.py

@@ -39,7 +39,7 @@ class VimbaController(DetectorControl):
     ) -> AsyncStatus:
         await asyncio.gather(
             self._drv.trigger_mode.set(TRIGGER_MODE[trigger]),
-            self._drv.expose_mode.set(EXPOSE_OUT_MODE[trigger]),
+            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger]),
             self._drv.num_images.set(num),
             self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
@@ -49,9 +49,9 @@ class VimbaController(DetectorControl):
         ]:
             await self._drv.acquire_time.set(exposure)
         if trigger != DetectorTrigger.internal:
-            self._drv.trig_source.set(VimbaTriggerSource.line1)
+            self._drv.trigger_source.set(VimbaTriggerSource.line1)
         else:
-            self._drv.trig_source.set(VimbaTriggerSource.freerun)
+            self._drv.trigger_source.set(VimbaTriggerSource.freerun)
         return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
 
     async def disarm(self):

ophyd_async/epics/advimba/_vimba_io.py

@@ -50,15 +50,17 @@ class VimbaDriverIO(adcore.ADBaseIO):
 
     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(
+        self.convert_pixel_format = epics_signal_rw_rbv(
             VimbaConvertFormat, prefix + "ConvertPixelFormat"
         )  # Pixel format of data outputted to AD
-        self.trig_source = epics_signal_rw_rbv(
+        self.trigger_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(
+        self.trigger_overlap = epics_signal_rw_rbv(
+            VimbaOverlap, prefix + "TriggerOverlap"
+        )
+        self.exposure_mode = epics_signal_rw_rbv(
             VimbaExposeOutMode, prefix + "ExposureMode"
         )
         super().__init__(prefix, name)

ophyd_async/epics/eiger/__init__.py

@@ -0,0 +1,5 @@
+from ._eiger import EigerDetector, EigerTriggerInfo
+from ._eiger_controller import EigerController
+from ._eiger_io import EigerDriverIO
+
+__all__ = ["EigerDetector", "EigerController", "EigerDriverIO", "EigerTriggerInfo"]

ophyd_async/epics/eiger/_eiger.py

@@ -0,0 +1,43 @@
+from pydantic import Field
+
+from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector
+from ophyd_async.core._detector import TriggerInfo
+
+from ._eiger_controller import EigerController
+from ._eiger_io import EigerDriverIO
+from ._odin_io import Odin, OdinWriter
+
+
+class EigerTriggerInfo(TriggerInfo):
+    energy_ev: float = Field(gt=0)
+
+
+class EigerDetector(StandardDetector):
+    """
+    Ophyd-async implementation of an Eiger Detector.
+    """
+
+    _controller: EigerController
+    _writer: Odin
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix="-EA-EIGER-01:",
+        hdf_suffix="-EA-ODIN-01:",
+        name="",
+    ):
+        self.drv = EigerDriverIO(prefix + drv_suffix)
+        self.odin = Odin(prefix + hdf_suffix + "FP:")
+
+        super().__init__(
+            EigerController(self.drv),
+            OdinWriter(path_provider, lambda: self.name, self.odin),
+            name=name,
+        )
+
+    @AsyncStatus.wrap
+    async def prepare(self, value: EigerTriggerInfo) -> None:
+        await self._controller.set_energy(value.energy_ev)
+        await super().prepare(value)

ophyd_async/epics/eiger/_eiger_controller.py

@@ -0,0 +1,66 @@
+import asyncio
+from typing import Optional
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+    set_and_wait_for_other_value,
+)
+
+from ._eiger_io import EigerDriverIO, EigerTriggerMode
+
+EIGER_TRIGGER_MODE_MAP = {
+    DetectorTrigger.internal: EigerTriggerMode.internal,
+    DetectorTrigger.constant_gate: EigerTriggerMode.gate,
+    DetectorTrigger.variable_gate: EigerTriggerMode.gate,
+    DetectorTrigger.edge_trigger: EigerTriggerMode.edge,
+}
+
+
+class EigerController(DetectorControl):
+    def __init__(
+        self,
+        driver: EigerDriverIO,
+    ) -> None:
+        self._drv = driver
+
+    def get_deadtime(self, exposure: float) -> float:
+        # See https://media.dectris.com/filer_public/30/14/3014704e-5f3b-43ba-8ccf-8ef720e60d2a/240202_usermanual_eiger2.pdf
+        return 0.0001
+
+    async def set_energy(self, energy: float, tolerance: float = 0.1):
+        """Changing photon energy takes some time so only do so if the current energy is
+        outside the tolerance."""
+        current_energy = await self._drv.photon_energy.get_value()
+        if abs(current_energy - energy) > tolerance:
+            await self._drv.photon_energy.set(energy)
+
+    @AsyncStatus.wrap
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ):
+        coros = [
+            self._drv.trigger_mode.set(EIGER_TRIGGER_MODE_MAP[trigger].value),
+            self._drv.num_images.set(num),
+        ]
+        if exposure is not None:
+            coros.extend(
+                [
+                    self._drv.acquire_time.set(exposure),
+                    self._drv.acquire_period.set(exposure),
+                ]
+            )
+        await asyncio.gather(*coros)
+
+        # TODO: Detector state should be an enum see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
+        await set_and_wait_for_other_value(
+            self._drv.arm, 1, self._drv.state, "ready", timeout=DEFAULT_TIMEOUT
+        )
+
+    async def disarm(self):
+        await self._drv.disarm.set(1)