ophyd-async 0.1.0__py3-none-any.whl → 0.3.0__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

@@ -0,0 +1,21 @@
+from .ad_base import (
+    ADBase,
+    ADBaseShapeProvider,
+    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

@@ -0,0 +1,107 @@
+import asyncio
+from enum import Enum
+from typing import FrozenSet, Sequence, Set
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    ShapeProvider,
+    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
+
+
+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
+#  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.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)
+
+
+async def start_acquiring_driver_and_ensure_status(
+    driver: ADBase,
+    good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES),
+    timeout: float = DEFAULT_TIMEOUT,
+) -> AsyncStatus:
+    """
+    Start acquiring driver, raising ValueError if the detector is in a bad state.
+
+    This sets driver.acquire to True, and waits for it to be True up to a timeout.
+    Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES, and otherwise
+    raises a ValueError.
+
+    Parameters
+    ----------
+    driver:
+        The driver to start acquiring. Must subclass ADBase.
+    good_states:
+        set of states defined in DetectorState enum which are considered good states.
+    timeout:
+        How long to wait for driver.acquire to readback True (i.e. acquiring).
+
+    Returns
+    -------
+    AsyncStatus:
+        An AsyncStatus that can be awaited to set driver.acquire to True and perform
+        subsequent raising (if applicable) due to detector state.
+    """
+
+    status = await set_and_wait_for_value(driver.acquire, True, timeout=timeout)
+
+    async def complete_acquisition() -> None:
+        """NOTE: possible race condition here between the callback from
+        set_and_wait_for_value and the detector state updating."""
+        await status
+        state = await driver.detector_state.get_value()
+        if state not in good_states:
+            raise ValueError(
+                f"Final detector state {state} not in valid end states: {good_states}"
+            )
+
+    return AsyncStatus(complete_acquisition())
+
+
+class ADBaseShapeProvider(ShapeProvider):
+    def __init__(self, driver: ADBase) -> None:
+        self._driver = driver
+
+    async def __call__(self) -> Sequence[int]:
+        shape = await asyncio.gather(
+            self._driver.array_size_y.get_value(),
+            self._driver.array_size_x.get_value(),
+        )
+        return shape

ophyd_async/epics/areadetector/drivers/aravis_driver.py

@@ -0,0 +1,38 @@
+from enum import Enum
+from typing import Literal
+
+from ophyd_async.epics.areadetector.drivers import ADBase
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+
+
+class AravisTriggerMode(str, Enum):
+    """GigEVision GenICAM standard: on=externally triggered"""
+
+    on = "On"
+    off = "Off"
+
+
+"""A minimal set of TriggerSources that must be supported by the underlying record.
+    To enable hardware triggered scanning, line_N must support each N in GPIO_NUMBER.
+    To enable software triggered scanning, freerun must be supported.
+    Other enumerated values may or may not be preset.
+    To prevent requiring one Enum class per possible configuration, we set as this Enum
+    but read from the underlying signal as a str.
+    """
+AravisTriggerSource = Literal["Freerun", "Line1", "Line2", "Line3", "Line4"]
+
+
+class AravisDriver(ADBase):
+    # If instantiating a new instance, ensure it is supported in the _deadtimes dict
+    """Generic Driver supporting the Manta and Mako drivers.
+    Fetches deadtime prior to use in a Streaming scan.
+    Requires driver firmware up to date:
+    - Model_RBV must be of the form "^(Mako|Manta) (model)$"
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.trigger_mode = epics_signal_rw_rbv(
+            AravisTriggerMode, prefix + "TriggerMode"
+        )
+        self.trigger_source = epics_signal_rw_rbv(str, prefix + "TriggerSource")
+        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

@@ -0,0 +1,21 @@
+from enum import Enum
+
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+
+from .ad_base import ADBase
+
+
+class PilatusTriggerMode(str, Enum):
+    internal = "Internal"
+    ext_enable = "Ext. Enable"
+    ext_trigger = "Ext. Trigger"
+    mult_trigger = "Mult. Trigger"
+    alignment = "Alignment"
+
+
+class PilatusDriver(ADBase):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        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

@@ -0,0 +1,45 @@
+from bluesky.protocols import Hints
+
+from ophyd_async.core import DirectoryProvider
+from ophyd_async.core.detector import StandardDetector
+from ophyd_async.epics.areadetector.controllers.pilatus_controller import (
+    PilatusController,
+)
+from ophyd_async.epics.areadetector.drivers.ad_base import ADBaseShapeProvider
+from ophyd_async.epics.areadetector.drivers.pilatus_driver import PilatusDriver
+from ophyd_async.epics.areadetector.writers.hdf_writer import HDFWriter
+from ophyd_async.epics.areadetector.writers.nd_file_hdf import NDFileHDF
+
+
+class PilatusDetector(StandardDetector):
+    """A Pilatus StandardDetector writing HDF files"""
+
+    _controller: PilatusController
+    _writer: HDFWriter
+
+    def __init__(
+        self,
+        prefix: str,
+        directory_provider: DirectoryProvider,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
+        name="",
+    ):
+        self.drv = PilatusDriver(prefix + drv_suffix)
+        self.hdf = NDFileHDF(prefix + hdf_suffix)
+
+        super().__init__(
+            PilatusController(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/single_trigger_det.py

@@ -3,29 +3,37 @@ 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 .ad_driver import ADDriver
-from .nd_plugin import NDPlugin
+from .drivers.ad_base import ADBase
 from .utils import ImageMode
+from .writers.nd_plugin import NDPluginBase
 
 
 class SingleTriggerDet(StandardReadable, Triggerable):
     def __init__(
         self,
-        drv: ADDriver,
+        drv: ADBase,
         read_uncached: Sequence[SignalR] = (),
         name="",
-        **plugins: NDPlugin,
+        **plugins: NDPluginBase,
     ) -> 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,17 +1,8 @@
 from enum import Enum
-from typing import Type
+from typing import Optional
+from xml.etree import cElementTree as ET
 
-from ophyd_async.core import SignalR, SignalRW, T
-
-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):
@@ -20,7 +11,94 @@ class FileWriteMode(str, Enum):
     stream = "Stream"
 
 
-class ImageMode(Enum):
+class ImageMode(str, Enum):
     single = "Single"
     multiple = "Multiple"
     continuous = "Continuous"
+
+
+class NDAttributeDataType(str, Enum):
+    INT = "INT"
+    DOUBLE = "DOUBLE"
+    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()
+
+
+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/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/__init__.py

@@ -0,0 +1,5 @@
+from .hdf_writer import HDFWriter
+from .nd_file_hdf import NDFileHDF
+from .nd_plugin import NDPluginBase, NDPluginStats
+
+__all__ = ["HDFWriter", "NDFileHDF", "NDPluginBase", "NDPluginStats"]

ophyd_async/epics/areadetector/writers/_hdfdataset.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from typing import Sequence
+
+
+@dataclass
+class _HDFDataset:
+    name: str
+    path: str
+    shape: Sequence[int]
+    multiplier: int