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

ophyd_async/core/utils.py

@@ -132,7 +132,7 @@ def get_unique(values: Dict[str, T], types: str) -> T:
 
 
 async def merge_gathered_dicts(
-    coros: Iterable[Awaitable[Dict[str, T]]]
+    coros: Iterable[Awaitable[Dict[str, T]]],
 ) -> Dict[str, T]:
     """Merge dictionaries produced by a sequence of coroutines.
 
@@ -148,3 +148,20 @@ async def merge_gathered_dicts(
 
 async def gather_list(coros: Iterable[Awaitable[T]]) -> List[T]:
     return await asyncio.gather(*coros)
+
+
+def in_micros(t: float) -> int:
+    """
+    Converts between a positive number of seconds and an equivalent
+    number of microseconds.
+
+    Args:
+        t (float): A time in seconds
+    Raises:
+        ValueError: if t < 0
+    Returns:
+        t (int): A time in microseconds, rounded up to the nearest whole microsecond,
+    """
+    if t < 0:
+        raise ValueError(f"Expected a positive time in seconds, got {t!r}")
+    return int(np.ceil(t * 1e6))

ophyd_async/epics/_backend/_aioca.py

@@ -52,14 +52,14 @@ class CaConverter:
         return value
 
     def reading(self, value: AugmentedValue):
-        return dict(
-            value=self.value(value),
-            timestamp=value.timestamp,
-            alarm_severity=-1 if value.severity > 2 else value.severity,
-        )
+        return {
+            "value": self.value(value),
+            "timestamp": value.timestamp,
+            "alarm_severity": -1 if value.severity > 2 else value.severity,
+        }
 
     def descriptor(self, source: str, value: AugmentedValue) -> Descriptor:
-        return dict(source=source, dtype=dbr_to_dtype[value.datatype], shape=[])
+        return {"source": source, "dtype": dbr_to_dtype[value.datatype], "shape": []}
 
 
 class CaLongStrConverter(CaConverter):
@@ -74,7 +74,7 @@ class CaLongStrConverter(CaConverter):
 
 class CaArrayConverter(CaConverter):
     def descriptor(self, source: str, value: AugmentedValue) -> Descriptor:
-        return dict(source=source, dtype="array", shape=[len(value)])
+        return {"source": source, "dtype": "array", "shape": [len(value)]}
 
 
 @dataclass
@@ -92,7 +92,7 @@ class CaEnumConverter(CaConverter):
 
     def descriptor(self, source: str, value: AugmentedValue) -> Descriptor:
         choices = [e.value for e in self.enum_class]
-        return dict(source=source, dtype="string", shape=[], choices=choices)
+        return {"source": source, "dtype": "string", "shape": [], "choices": choices}
 
 
 class DisconnectedCaConverter(CaConverter):
@@ -170,9 +170,11 @@ class CaSignalBackend(SignalBackend[T]):
         self.write_pv = write_pv
         self.initial_values: Dict[str, AugmentedValue] = {}
         self.converter: CaConverter = DisconnectedCaConverter(None, None)
-        self.source = f"ca://{self.read_pv}"
         self.subscription: Optional[Subscription] = None
 
+    def source(self, name: str):
+        return f"ca://{self.read_pv}"
+
     async def _store_initial_value(self, pv, timeout: float = DEFAULT_TIMEOUT):
         try:
             self.initial_values[pv] = await caget(
@@ -216,9 +218,9 @@ class CaSignalBackend(SignalBackend[T]):
             timeout=None,
         )
 
-    async def get_descriptor(self) -> Descriptor:
+    async def get_descriptor(self, source: str) -> Descriptor:
         value = await self._caget(FORMAT_CTRL)
-        return self.converter.descriptor(self.source, value)
+        return self.converter.descriptor(source, value)
 
     async def get_reading(self) -> Reading:
         value = await self._caget(FORMAT_TIME)

ophyd_async/epics/_backend/_p4p.py

@@ -49,15 +49,15 @@ class PvaConverter:
     def reading(self, value):
         ts = value["timeStamp"]
         sv = value["alarm"]["severity"]
-        return dict(
-            value=self.value(value),
-            timestamp=ts["secondsPastEpoch"] + ts["nanoseconds"] * 1e-9,
-            alarm_severity=-1 if sv > 2 else sv,
-        )
+        return {
+            "value": self.value(value),
+            "timestamp": ts["secondsPastEpoch"] + ts["nanoseconds"] * 1e-9,
+            "alarm_severity": -1 if sv > 2 else sv,
+        }
 
     def descriptor(self, source: str, value) -> Descriptor:
         dtype = specifier_to_dtype[value.type().aspy("value")]
-        return dict(source=source, dtype=dtype, shape=[])
+        return {"source": source, "dtype": dtype, "shape": []}
 
     def metadata_fields(self) -> List[str]:
         """
@@ -74,7 +74,7 @@ class PvaConverter:
 
 class PvaArrayConverter(PvaConverter):
     def descriptor(self, source: str, value) -> Descriptor:
-        return dict(source=source, dtype="array", shape=[len(value["value"])])
+        return {"source": source, "dtype": "array", "shape": [len(value["value"])]}
 
 
 class PvaNDArrayConverter(PvaConverter):
@@ -98,7 +98,7 @@ class PvaNDArrayConverter(PvaConverter):
 
     def descriptor(self, source: str, value) -> Descriptor:
         dims = self._get_dimensions(value)
-        return dict(source=source, dtype="array", shape=dims)
+        return {"source": source, "dtype": "array", "shape": dims}
 
     def write_value(self, value):
         # No clear use-case for writing directly to an NDArray, and some
@@ -122,7 +122,7 @@ class PvaEnumConverter(PvaConverter):
 
     def descriptor(self, source: str, value) -> Descriptor:
         choices = [e.value for e in self.enum_class]
-        return dict(source=source, dtype="string", shape=[], choices=choices)
+        return {"source": source, "dtype": "string", "shape": [], "choices": choices}
 
 
 class PvaEnumBoolConverter(PvaConverter):
@@ -130,7 +130,7 @@ class PvaEnumBoolConverter(PvaConverter):
         return value["value"]["index"]
 
     def descriptor(self, source: str, value) -> Descriptor:
-        return dict(source=source, dtype="integer", shape=[])
+        return {"source": source, "dtype": "integer", "shape": []}
 
 
 class PvaTableConverter(PvaConverter):
@@ -139,7 +139,7 @@ class PvaTableConverter(PvaConverter):
 
     def descriptor(self, source: str, value) -> Descriptor:
         # This is wrong, but defer until we know how to actually describe a table
-        return dict(source=source, dtype="object", shape=[])  # type: ignore
+        return {"source": source, "dtype": "object", "shape": []}  # type: ignore
 
 
 class PvaDictConverter(PvaConverter):
@@ -147,7 +147,7 @@ class PvaDictConverter(PvaConverter):
         ts = time.time()
         value = value.todict()
         # Alarm severity is vacuously 0 for a table
-        return dict(value=value, timestamp=ts, alarm_severity=0)
+        return {"value": value, "timestamp": ts, "alarm_severity": 0}
 
     def value(self, value: Value):
         return value.todict()
@@ -236,9 +236,12 @@ class PvaSignalBackend(SignalBackend[T]):
         self.write_pv = write_pv
         self.initial_values: Dict[str, Any] = {}
         self.converter: PvaConverter = DisconnectedPvaConverter()
-        self.source = f"pva://{self.read_pv}"
         self.subscription: Optional[Subscription] = None
 
+    @property
+    def source(self, name: str):
+        return f"pva://{self.read_pv}"
+
     @property
     def ctxt(self) -> Context:
         if PvaSignalBackend._ctxt is None:
@@ -279,7 +282,7 @@ class PvaSignalBackend(SignalBackend[T]):
             write_value = self.initial_values[self.write_pv]
         else:
             write_value = self.converter.write_value(value)
-        coro = self.ctxt.put(self.write_pv, dict(value=write_value), wait=wait)
+        coro = self.ctxt.put(self.write_pv, {"value": write_value}, wait=wait)
         try:
             await asyncio.wait_for(coro, timeout)
         except asyncio.TimeoutError as exc:
@@ -290,9 +293,9 @@ class PvaSignalBackend(SignalBackend[T]):
             )
             raise NotConnected(f"pva://{self.write_pv}") from exc
 
-    async def get_descriptor(self) -> Descriptor:
+    async def get_descriptor(self, source: str) -> Descriptor:
         value = await self.ctxt.get(self.read_pv)
-        return self.converter.descriptor(self.source, value)
+        return self.converter.descriptor(source, value)
 
     def _pva_request_string(self, fields: List[str]) -> str:
         """

ophyd_async/epics/_backend/common.py

@@ -7,14 +7,19 @@ def get_supported_enum_class(
     datatype: Optional[Type[Enum]],
     pv_choices: Tuple[Any, ...],
 ) -> Type[Enum]:
-    if datatype:
-        if not issubclass(datatype, Enum):
-            raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
-        if not issubclass(datatype, str):
-            raise TypeError(f"{pv} has type Enum but doesn't inherit from String")
-        choices = tuple(v.value for v in datatype)
-        if set(choices).difference(pv_choices):
-            raise TypeError(f"{pv} has choices {pv_choices}: not all in {choices}")
-    return Enum(
-        "GeneratedChoices", {x or "_": x for x in pv_choices}, type=str
-    )  # type: ignore
+    if not datatype:
+        return Enum("GeneratedChoices", {x or "_": x for x in pv_choices}, type=str)  # type: ignore
+
+    if not issubclass(datatype, Enum):
+        raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
+    if not issubclass(datatype, str):
+        raise TypeError(f"{pv} has type Enum but doesn't inherit from String")
+    choices = tuple(v.value for v in datatype)
+    if set(choices) != set(pv_choices):
+        raise TypeError(
+            (
+                f"{pv} has choices {pv_choices}, "
+                f"which do not match {datatype}, which has {choices}"
+            )
+        )
+    return datatype

ophyd_async/epics/areadetector/__init__.py

@@ -1,3 +1,5 @@
+from .aravis import AravisDetector
+from .pilatus import PilatusDetector
 from .single_trigger_det import SingleTriggerDet
 from .utils import (
     FileWriteMode,
@@ -9,6 +11,7 @@ from .utils import (
 )
 
 __all__ = [
+    "AravisDetector",
     "SingleTriggerDet",
     "FileWriteMode",
     "ImageMode",
@@ -16,4 +19,5 @@ __all__ = [
     "ad_rw",
     "NDAttributeDataType",
     "NDAttributesXML",
+    "PilatusDetector",
 ]

ophyd_async/epics/areadetector/aravis.py

@@ -0,0 +1,69 @@
+from typing import get_args
+
+from bluesky.protocols import HasHints, Hints
+
+from ophyd_async.core import DirectoryProvider, StandardDetector, TriggerInfo
+from ophyd_async.epics.areadetector.controllers.aravis_controller import (
+    AravisController,
+)
+from ophyd_async.epics.areadetector.drivers import ADBaseShapeProvider
+from ophyd_async.epics.areadetector.drivers.aravis_driver import AravisDriver
+from ophyd_async.epics.areadetector.writers import HDFWriter, NDFileHDF
+
+
+class AravisDetector(StandardDetector, HasHints):
+    """
+    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: HDFWriter
+
+    def __init__(
+        self,
+        name: str,
+        directory_provider: DirectoryProvider,
+        driver: AravisDriver,
+        hdf: NDFileHDF,
+        gpio_number: AravisController.GPIO_NUMBER = 1,
+        **scalar_sigs: str,
+    ):
+        # Must be child of Detector to pick up connect()
+        self.drv = driver
+        self.hdf = hdf
+
+        super().__init__(
+            AravisController(self.drv, gpio_number=gpio_number),
+            HDFWriter(
+                self.hdf,
+                directory_provider,
+                lambda: self.name,
+                ADBaseShapeProvider(self.drv),
+                **scalar_sigs,
+            ),
+            config_sigs=(self.drv.acquire_time, self.drv.acquire),
+            name=name,
+        )
+
+    async def _prepare(self, value: TriggerInfo) -> None:
+        await self.drv.fetch_deadtime()
+        await super()._prepare(value)
+
+    def get_external_trigger_gpio(self):
+        return self._controller.gpio_number
+
+    def set_external_trigger_gpio(self, gpio_number: AravisController.GPIO_NUMBER):
+        supported_gpio_numbers = get_args(AravisController.GPIO_NUMBER)
+        if gpio_number not in supported_gpio_numbers:
+            raise ValueError(
+                f"{self.__class__.__name__} only supports the following GPIO "
+                f"indices: {supported_gpio_numbers} but was asked to "
+                f"use {gpio_number}"
+            )
+        self._controller.gpio_number = gpio_number
+
+    @property
+    def hints(self) -> Hints:
+        return self._writer.hints

ophyd_async/epics/areadetector/controllers/aravis_controller.py

@@ -0,0 +1,73 @@
+import asyncio
+from typing import Literal, Optional, Tuple
+
+from ophyd_async.core import (
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+    set_and_wait_for_value,
+)
+from ophyd_async.epics.areadetector.drivers.aravis_driver import (
+    AravisDriver,
+    AravisTriggerMode,
+    AravisTriggerSource,
+)
+from ophyd_async.epics.areadetector.utils import ImageMode, stop_busy_record
+
+
+class AravisController(DetectorControl):
+    GPIO_NUMBER = Literal[1, 2, 3, 4]
+
+    def __init__(self, driver: AravisDriver, gpio_number: GPIO_NUMBER) -> None:
+        self._drv = driver
+        self.gpio_number = gpio_number
+
+    def get_deadtime(self, exposure: float) -> float:
+        return self._drv.dead_time or 0
+
+    async def arm(
+        self,
+        num: int = 0,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        if num == 0:
+            image_mode = ImageMode.continuous
+        else:
+            image_mode = ImageMode.multiple
+        if exposure is not None:
+            await self._drv.acquire_time.set(exposure)
+
+        trigger_mode, trigger_source = self._get_trigger_info(trigger)
+        # trigger mode must be set first and on it's own!
+        await self._drv.trigger_mode.set(trigger_mode)
+
+        await asyncio.gather(
+            self._drv.trigger_source.set(trigger_source),
+            self._drv.num_images.set(num),
+            self._drv.image_mode.set(image_mode),
+        )
+
+        status = await set_and_wait_for_value(self._drv.acquire, True)
+        return status
+
+    def _get_trigger_info(
+        self, trigger: DetectorTrigger
+    ) -> Tuple[AravisTriggerMode, AravisTriggerSource]:
+        supported_trigger_types = (
+            DetectorTrigger.constant_gate,
+            DetectorTrigger.edge_trigger,
+        )
+        if trigger not in supported_trigger_types:
+            raise ValueError(
+                f"{self.__class__.__name__} only supports the following trigger "
+                f"types: {supported_trigger_types} but was asked to "
+                f"use {trigger}"
+            )
+        if trigger == DetectorTrigger.internal:
+            return AravisTriggerMode.off, "Freerun"
+        else:
+            return (AravisTriggerMode.on, f"Line{self.gpio_number}")
+
+    async def disarm(self):
+        await stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/areadetector/controllers/pilatus_controller.py

@@ -1,34 +1,36 @@
 import asyncio
-from typing import Optional, Set
+from typing import Optional
 
-from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
+from ophyd_async.core.async_status import AsyncStatus
+from ophyd_async.core.detector import DetectorControl, DetectorTrigger
 from ophyd_async.epics.areadetector.drivers.ad_base import (
-    DEFAULT_GOOD_STATES,
-    DetectorState,
     start_acquiring_driver_and_ensure_status,
 )
-
-from ..drivers.pilatus_driver import PilatusDriver, TriggerMode
-from ..utils import ImageMode, stop_busy_record
-
-TRIGGER_MODE = {
-    DetectorTrigger.internal: TriggerMode.internal,
-    DetectorTrigger.constant_gate: TriggerMode.ext_enable,
-    DetectorTrigger.variable_gate: TriggerMode.ext_enable,
-}
+from ophyd_async.epics.areadetector.drivers.pilatus_driver import (
+    PilatusDriver,
+    PilatusTriggerMode,
+)
+from ophyd_async.epics.areadetector.utils import ImageMode, stop_busy_record
 
 
 class PilatusController(DetectorControl):
+    _supported_trigger_types = {
+        DetectorTrigger.internal: PilatusTriggerMode.internal,
+        DetectorTrigger.constant_gate: PilatusTriggerMode.ext_enable,
+        DetectorTrigger.variable_gate: PilatusTriggerMode.ext_enable,
+    }
+
     def __init__(
         self,
         driver: PilatusDriver,
-        good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES),
     ) -> None:
-        self.driver = driver
-        self.good_states = good_states
+        self._drv = driver
 
     def get_deadtime(self, exposure: float) -> float:
-        return 0.001
+        # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+        """The required minimum time difference between ExpPeriod and ExpTime
+        (readout time) is 2.28 ms"""
+        return 2.28e-3
 
     async def arm(
         self,
@@ -36,14 +38,24 @@ class PilatusController(DetectorControl):
         trigger: DetectorTrigger = DetectorTrigger.internal,
         exposure: Optional[float] = None,
     ) -> AsyncStatus:
+        if exposure is not None:
+            await self._drv.acquire_time.set(exposure)
         await asyncio.gather(
-            self.driver.trigger_mode.set(TRIGGER_MODE[trigger]),
-            self.driver.num_images.set(999_999 if num == 0 else num),
-            self.driver.image_mode.set(ImageMode.multiple),
-        )
-        return await start_acquiring_driver_and_ensure_status(
-            self.driver, good_states=self.good_states
+            self._drv.trigger_mode.set(self._get_trigger_mode(trigger)),
+            self._drv.num_images.set(999_999 if num == 0 else num),
+            self._drv.image_mode.set(ImageMode.multiple),
         )
+        return await start_acquiring_driver_and_ensure_status(self._drv)
+
+    @classmethod
+    def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:
+        if trigger not in cls._supported_trigger_types.keys():
+            raise ValueError(
+                f"{cls.__name__} only supports the following trigger "
+                f"types: {cls._supported_trigger_types.keys()} but was asked to "
+                f"use {trigger}"
+            )
+        return cls._supported_trigger_types[trigger]
 
     async def disarm(self):
-        await stop_busy_record(self.driver.acquire, False, timeout=1)
+        await stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/areadetector/drivers/aravis_driver.py

@@ -0,0 +1,154 @@
+from enum import Enum
+from typing import Callable, Dict, Literal, Optional, Tuple
+
+from ophyd_async.epics.areadetector.drivers import ADBase
+from ophyd_async.epics.areadetector.utils import ad_r, ad_rw
+
+
+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"]
+
+
+def _reverse_lookup(
+    model_deadtimes: Dict[float, Tuple[str, ...]],
+) -> Callable[[str], float]:
+    def inner(pixel_format: str, model_name: str) -> float:
+        for deadtime, pixel_formats in model_deadtimes.items():
+            if pixel_format in pixel_formats:
+                return deadtime
+        raise ValueError(
+            f"Model {model_name} does not have a defined deadtime "
+            f"for pixel format {pixel_format}"
+        )
+
+    return inner
+
+
+_deadtimes: Dict[str, Callable[[str, str], float]] = {
+    # cite: https://cdn.alliedvision.com/fileadmin/content/documents/products/cameras/Manta/techman/Manta_TechMan.pdf retrieved 2024-04-05  # noqa: E501
+    "Manta G-125": lambda _, __: 63e-6,
+    "Manta G-145": lambda _, __: 106e-6,
+    "Manta G-235": _reverse_lookup(
+        {
+            118e-6: (
+                "Mono8",
+                "Mono12Packed",
+                "BayerRG8",
+                "BayerRG12",
+                "BayerRG12Packed",
+                "YUV411Packed",
+            ),
+            256e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
+            390e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
+        }
+    ),
+    "Manta G-895": _reverse_lookup(
+        {
+            404e-6: (
+                "Mono8",
+                "Mono12Packed",
+                "BayerRG8",
+                "BayerRG12Packed",
+                "YUV411Packed",
+            ),
+            542e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
+            822e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
+        }
+    ),
+    "Manta G-2460": _reverse_lookup(
+        {
+            979e-6: (
+                "Mono8",
+                "Mono12Packed",
+                "BayerRG8",
+                "BayerRG12Packed",
+                "YUV411Packed",
+            ),
+            1304e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
+            1961e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
+        }
+    ),
+    # cite: https://cdn.alliedvision.com/fileadmin/content/documents/products/cameras/various/appnote/GigE/GigE-Cameras_AppNote_PIV-Min-Time-Between-Exposures.pdf retrieved 2024-04-05  # noqa: E501
+    "Manta G-609": lambda _, __: 47e-6,
+    # cite: https://cdn.alliedvision.com/fileadmin/content/documents/products/cameras/Mako/techman/Mako_TechMan_en.pdf retrieved 2024-04-05  # noqa: E501
+    "Mako G-040": _reverse_lookup(
+        {
+            101e-6: (
+                "Mono8",
+                "Mono12Packed",
+                "BayerRG8",
+                "BayerRG12Packed",
+                "YUV411Packed",
+            ),
+            140e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
+            217e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
+        }
+    ),
+    "Mako G-125": lambda _, __: 70e-6,
+    # Assume 12 bits: 10 bits = 275e-6
+    "Mako G-234": _reverse_lookup(
+        {
+            356e-6: (
+                "Mono8",
+                "BayerRG8",
+                "BayerRG12",
+                "BayerRG12Packed",
+                "YUV411Packed",
+                "YUV422Packed",
+            ),
+            # Assume 12 bits: 10 bits = 563e-6
+            726e-6: ("RGB8Packed", "BRG8Packed", "YUV444Packed"),
+        }
+    ),
+    "Mako G-507": _reverse_lookup(
+        {
+            270e-6: (
+                "Mono8",
+                "Mono12Packed",
+                "BayerRG8",
+                "BayerRG12Packed",
+                "YUV411Packed",
+            ),
+            363e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
+            554e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
+        }
+    ),
+}
+
+
+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 = ad_rw(AravisTriggerMode, prefix + "TriggerMode")
+        self.trigger_source = ad_rw(str, prefix + "TriggerSource")
+        self.model = ad_r(str, prefix + "Model")
+        self.pixel_format = ad_rw(str, prefix + "PixelFormat")
+        self.dead_time: Optional[float] = None
+        super().__init__(prefix, name=name)
+
+    async def fetch_deadtime(self) -> None:
+        # All known in-use version B/C have same deadtime as non-B/C
+        model: str = (await self.model.get_value()).removesuffix("B").removesuffix("C")
+        if model not in _deadtimes:
+            raise ValueError(f"Model {model} does not have defined deadtimes")
+        pixel_format: str = await self.pixel_format.get_value()
+        self.dead_time = _deadtimes.get(model)(pixel_format, model)

ophyd_async/epics/areadetector/drivers/pilatus_driver.py

@@ -4,7 +4,7 @@ from ..utils import ad_rw
 from .ad_base import ADBase
 
 
-class TriggerMode(str, Enum):
+class PilatusTriggerMode(str, Enum):
     internal = "Internal"
     ext_enable = "Ext. Enable"
     ext_trigger = "Ext. Trigger"
@@ -13,6 +13,6 @@ class TriggerMode(str, Enum):
 
 
 class PilatusDriver(ADBase):
-    def __init__(self, prefix: str) -> None:
-        self.trigger_mode = ad_rw(TriggerMode, prefix + "TriggerMode")
-        super().__init__(prefix)
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.trigger_mode = ad_rw(PilatusTriggerMode, prefix + "TriggerMode")
+        super().__init__(prefix, name)