Split out common AD file plugin logic into core writer class, create ADTiffWriter

src/ophyd_async/epics/adaravis/_aravis.py

@@ -1,24 +1,21 @@
-from typing import get_args
+from collections.abc import Sequence
+from typing import cast, get_args
 
-from bluesky.protocols import HasHints, Hints
-
-from ophyd_async.core import PathProvider, StandardDetector
+from ophyd_async.core import PathProvider
+from ophyd_async.core._signal import SignalR
 from ophyd_async.epics import adcore
 
 from ._aravis_controller import AravisController
 from ._aravis_io import AravisDriverIO
 
 
-class AravisDetector(StandardDetector, HasHints):
+class AravisDetector(adcore.AreaDetector):
     """
     Ophyd-async implementation of an ADAravis Detector.
     The detector may be configured for an external trigger on a GPIO port,
     which must be done prior to preparing the detector
     """
 
-    _controller: AravisController
-    _writer: adcore.ADHDFWriter
-
     def __init__(
         self,
         prefix: str,
@@ -27,24 +24,28 @@ def __init__(
         hdf_suffix="HDF1:",
         name="",
         gpio_number: AravisController.GPIO_NUMBER = 1,
+        config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = AravisDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
-
         super().__init__(
-            AravisController(self.drv, gpio_number=gpio_number),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_time,),
+            prefix,
+            path_provider,
+            adcore.ADHDFWriter,
+            hdf_suffix,
+            AravisController,
+            AravisDriverIO,
+            drv_suffix=drv_suffix,
             name=name,
+            config_sigs=config_sigs,
+            gpio_number=gpio_number,
         )
+        self.hdf = self._fileio
+
+    @property
+    def controller(self) -> AravisController:
+        return cast(AravisController, self._controller)
 
     def get_external_trigger_gpio(self):
-        return self._controller.gpio_number
+        return self.controller.gpio_number
 
     def set_external_trigger_gpio(self, gpio_number: AravisController.GPIO_NUMBER):
         supported_gpio_numbers = get_args(AravisController.GPIO_NUMBER)
@@ -54,8 +55,36 @@ def set_external_trigger_gpio(self, gpio_number: AravisController.GPIO_NUMBER):
                 f"indices: {supported_gpio_numbers} but was asked to "
                 f"use {gpio_number}"
             )
-        self._controller.gpio_number = gpio_number
+        self.controller.gpio_number = gpio_number
 
-    @property
-    def hints(self) -> Hints:
-        return self._writer.hints
+
+class AravisDetectorTIFF(adcore.AreaDetector):
+    """
+    Ophyd-async implementation of an ADAravis Detector.
+    The detector may be configured for an external trigger on a GPIO port,
+    which must be done prior to preparing the detector
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
+        name="",
+        gpio_number: AravisController.GPIO_NUMBER = 1,
+        config_sigs: Sequence[SignalR] = (),
+    ):
+        super().__init__(
+            prefix,
+            path_provider,
+            adcore.ADTIFFWriter,
+            hdf_suffix,
+            AravisController,
+            AravisDriverIO,
+            drv_suffix=drv_suffix,
+            name=name,
+            config_sigs=config_sigs,
+            gpio_number=gpio_number,
+        )
+        self.tiff = self._fileio

src/ophyd_async/epics/adaravis/_aravis_controller.py

@@ -1,13 +1,10 @@
 import asyncio
-from typing import Literal
+from typing import Literal, cast
 
 from ophyd_async.core import (
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
-    set_and_wait_for_value,
 )
-from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
@@ -18,13 +15,16 @@
 _HIGHEST_POSSIBLE_DEADTIME = 1961e-6
 
 
-class AravisController(DetectorController):
+class AravisController(adcore.ADBaseController):
     GPIO_NUMBER = Literal[1, 2, 3, 4]
 
     def __init__(self, driver: AravisDriverIO, gpio_number: GPIO_NUMBER) -> None:
-        self._drv = driver
+        super().__init__(driver)
         self.gpio_number = gpio_number
-        self._arm_status: AsyncStatus | None = None
+
+    @property
+    def driver(self) -> AravisDriverIO:
+        return cast(AravisDriverIO, self._driver)
 
     def get_deadtime(self, exposure: float | None) -> float:
         return _HIGHEST_POSSIBLE_DEADTIME
@@ -35,25 +35,18 @@ async def prepare(self, trigger_info: TriggerInfo):
         else:
             image_mode = adcore.ImageMode.multiple
         if (exposure := trigger_info.livetime) is not None:
-            await self._drv.acquire_time.set(exposure)
+            await self.driver.acquire_time.set(exposure)
 
         trigger_mode, trigger_source = self._get_trigger_info(trigger_info.trigger)
         # trigger mode must be set first and on it's own!
-        await self._drv.trigger_mode.set(trigger_mode)
+        await self.driver.trigger_mode.set(trigger_mode)
 
         await asyncio.gather(
-            self._drv.trigger_source.set(trigger_source),
-            self._drv.num_images.set(trigger_info.total_number_of_triggers),
-            self._drv.image_mode.set(image_mode),
+            self.driver.trigger_source.set(trigger_source),
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.image_mode.set(image_mode),
         )
 
-    async def arm(self):
-        self._arm_status = await set_and_wait_for_value(self._drv.acquire, True)
-
-    async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
-
     def _get_trigger_info(
         self, trigger: DetectorTrigger
     ) -> tuple[AravisTriggerMode, AravisTriggerSource]:
@@ -72,6 +65,3 @@ def _get_trigger_info(
             return AravisTriggerMode.off, "Freerun"
         else:
             return (AravisTriggerMode.on, f"Line{self.gpio_number}")  # type: ignore
-
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

src/ophyd_async/epics/adcore/__init__.py

@@ -1,18 +1,17 @@
+from ._core_detector import AreaDetector
 from ._core_io import (
     ADBaseIO,
     DetectorState,
     NDArrayBaseIO,
     NDFileHDFIO,
+    NDFileIO,
     NDPluginStatsIO,
 )
-from ._core_logic import (
-    DEFAULT_GOOD_STATES,
-    ADBaseDatasetDescriber,
-    set_exposure_time_and_acquire_period_if_supplied,
-    start_acquiring_driver_and_ensure_status,
-)
+from ._core_logic import DEFAULT_GOOD_STATES, ADBaseController, ADBaseDatasetDescriber
+from ._core_writer import ADWriter
 from ._hdf_writer import ADHDFWriter
 from ._single_trigger import SingleTriggerDetector
+from ._tiff_writer import ADTIFFWriter
 from ._utils import (
     ADBaseDataType,
     FileWriteMode,
@@ -28,13 +27,16 @@
     "ADBaseIO",
     "DetectorState",
     "NDArrayBaseIO",
+    "NDFileIO",
     "NDFileHDFIO",
     "NDPluginStatsIO",
     "DEFAULT_GOOD_STATES",
     "ADBaseDatasetDescriber",
-    "set_exposure_time_and_acquire_period_if_supplied",
-    "start_acquiring_driver_and_ensure_status",
+    "ADBaseController",
+    "AreaDetector",
+    "ADWriter",
     "ADHDFWriter",
+    "ADTIFFWriter",
     "SingleTriggerDetector",
     "ADBaseDataType",
     "FileWriteMode",

src/ophyd_async/epics/adcore/_core_detector.py

@@ -0,0 +1,66 @@
+from collections.abc import Sequence
+from typing import cast
+
+from bluesky.protocols import HasHints, Hints
+
+from ophyd_async.core import PathProvider, SignalR, StandardDetector
+
+from ._core_io import ADBaseIO, NDFileHDFIO, NDFileIO
+from ._core_logic import ADBaseController, ADBaseDatasetDescriber
+from ._core_writer import ADWriter
+from ._hdf_writer import ADHDFWriter
+from ._tiff_writer import ADTIFFWriter
+
+
+def get_io_class_for_writer(writer_class: type[ADWriter]):
+    writer_to_io_map = {
+        ADWriter: NDFileIO,
+        ADHDFWriter: NDFileHDFIO,
+        ADTIFFWriter: NDFileIO,
+    }
+    return writer_to_io_map[writer_class]
+
+
+class AreaDetector(StandardDetector, HasHints):
+    _controller: ADBaseController
+    _writer: ADWriter
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        writer_class: type[ADWriter] = ADWriter,
+        writer_suffix: str = "",
+        controller_class: type[ADBaseController] = ADBaseController,
+        drv_class: type[ADBaseIO] = ADBaseIO,
+        drv_suffix: str = "cam1:",
+        name: str = "",
+        config_sigs: Sequence[SignalR] = (),
+        **kwargs,
+    ):
+        self.drv = drv_class(prefix + drv_suffix)
+        self._fileio = get_io_class_for_writer(writer_class)(prefix + writer_suffix)
+
+        super().__init__(
+            controller_class(self.drv, **kwargs),
+            writer_class(
+                self._fileio,
+                path_provider,
+                lambda: self.name,
+                ADBaseDatasetDescriber(self.drv),
+            ),
+            config_sigs=(self.drv.acquire_period, self.drv.acquire_time, *config_sigs),
+            name=name,
+        )
+
+    @property
+    def controller(self) -> ADBaseController:
+        return cast(ADBaseController, self._controller)
+
+    @property
+    def writer(self) -> ADWriter:
+        return cast(ADWriter, self._writer)
+
+    @property
+    def hints(self) -> Hints:
+        return self._writer.hints

src/ophyd_async/epics/adcore/_core_io.py

@@ -10,11 +10,6 @@
 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")
@@ -32,9 +27,7 @@ def __init__(self, prefix: str, name: str = "") -> None:
 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.enable_callbacks = epics_signal_rw_rbv(bool, 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")
@@ -111,30 +104,36 @@ class Compression(str, Enum):
     jpeg = "JPEG"
 
 
-class NDFileHDFIO(NDPluginBaseIO):
+class NDFileIO(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_number = epics_signal_rw(int, prefix + "FileNumber")
+        self.auto_increment = epics_signal_rw(bool, prefix + "AutoIncrement")
         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)
+
+
+class NDFileHDFIO(NDFileIO):
+    def __init__(self, prefix: str, name="") -> None:
+        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.swmr_mode = epics_signal_rw_rbv(bool, prefix + "SWMRMode")
+        self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
+        self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
         self.num_frames_chunks = epics_signal_r(int, prefix + "NumFramesChunks_RBV")
         self.chunk_size_auto = epics_signal_rw_rbv(bool, prefix + "ChunkSizeAuto")
+        self.lazy_open = epics_signal_rw_rbv(bool, prefix + "LazyOpen")
         super().__init__(prefix, name)