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

ophyd_async/epics/areadetector/drivers/vimba_driver.py

@@ -0,0 +1,58 @@
+from enum import Enum
+
+from ..utils import ad_rw
+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 = ad_rw(PixelFormat, prefix + "PixelFormat")
+        self.convert_format = ad_rw(
+            VimbaConvertFormat, prefix + "ConvertPixelFormat"
+        )  # Pixel format of data outputted to AD
+        self.trig_source = ad_rw(VimbaTriggerSource, prefix + "TriggerSource")
+        self.trigger_mode = ad_rw(VimbaOnOff, prefix + "TriggerMode")
+        self.overlap = ad_rw(VimbaOverlap, prefix + "TriggerOverlap")
+        self.expose_mode = ad_rw(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,7 +3,13 @@ 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 .drivers.ad_base import ADBase
 from .utils import ImageMode
@@ -20,12 +26,14 @@ class SingleTriggerDet(StandardReadable, Triggerable):
     ) -> 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/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/_hdffile.py

@@ -44,10 +44,10 @@ class _HDFFile:
     def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
         # Indices are relative to resource
         if indices_written > self._last_emitted:
-            indices = dict(
-                start=self._last_emitted,
-                stop=indices_written,
-            )
+            indices = {
+                "start": self._last_emitted,
+                "stop": indices_written,
+            }
             self._last_emitted = indices_written
             for bundle in self._bundles:
                 yield bundle.compose_stream_datum(indices)

ophyd_async/epics/areadetector/writers/hdf_writer.py

@@ -2,7 +2,7 @@ import asyncio
 from pathlib import Path
 from typing import AsyncGenerator, AsyncIterator, Dict, List, Optional
 
-from bluesky.protocols import Descriptor, Hints, StreamAsset
+from bluesky.protocols import DataKey, Hints, StreamAsset
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -40,7 +40,7 @@ class HDFWriter(DetectorWriter):
         self._file: Optional[_HDFFile] = None
         self._multiplier = 1
 
-    async def open(self, multiplier: int = 1) -> Dict[str, Descriptor]:
+    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         self._file = None
         info = self._directory_provider()
         await asyncio.gather(
@@ -52,6 +52,9 @@ class HDFWriter(DetectorWriter):
             self.hdf.file_name.set(f"{info.prefix}{self.hdf.name}{info.suffix}"),
             self.hdf.file_template.set("%s/%s.h5"),
             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
+            self.hdf.xml_file_name.set(""),
         )
 
         assert (
@@ -81,7 +84,7 @@ class HDFWriter(DetectorWriter):
                 )
             )
         describe = {
-            ds.name: Descriptor(
+            ds.name: DataKey(
                 source=self.hdf.full_file_name.source,
                 shape=outer_shape + tuple(ds.shape),
                 dtype="array" if ds.shape else "number",
@@ -109,12 +112,17 @@ class HDFWriter(DetectorWriter):
         await self.hdf.flush_now.set(True)
         if indices_written:
             if not self._file:
+                path = Path(await self.hdf.full_file_name.get_value())
                 self._file = _HDFFile(
                     self._directory_provider(),
                     # See https://github.com/bluesky/ophyd-async/issues/122
-                    Path(await self.hdf.full_file_name.get_value()),
+                    path,
                     self._datasets,
                 )
+                # stream resource says "here is a dataset",
+                # stream datum says "here are N frames in that stream resource",
+                # you get one stream resource and many stream datums per scan
+
                 for doc in self._file.stream_resources():
                     yield "stream_resource", doc
             for doc in self._file.stream_data(indices_written):

ophyd_async/epics/areadetector/writers/nd_file_hdf.py

@@ -36,4 +36,5 @@ class NDFileHDF(NDPluginBase):
         self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
         self.array_size0 = ad_r(int, prefix + "ArraySize0")
         self.array_size1 = ad_r(int, prefix + "ArraySize1")
+        self.xml_file_name = ad_rw(str, prefix + "XMLFileName")
         super().__init__(prefix, name)

ophyd_async/epics/demo/__init__.py

@@ -14,7 +14,15 @@ from typing import Callable, List, Optional
 import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import AsyncStatus, Device, StandardReadable, observe_value
+from ophyd_async.core import (
+    AsyncStatus,
+    ConfigSignal,
+    Device,
+    DeviceVector,
+    HintedSignal,
+    StandardReadable,
+    observe_value,
+)
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -33,35 +41,43 @@ class Sensor(StandardReadable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        self.value = epics_signal_r(float, prefix + "Value")
-        self.mode = epics_signal_rw(EnergyMode, prefix + "Mode")
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.value],
-            config=[self.mode],
-        )
+        with self.add_children_as_readables(HintedSignal):
+            self.value = epics_signal_r(float, prefix + "Value")
+        with self.add_children_as_readables(ConfigSignal):
+            self.mode = epics_signal_rw(EnergyMode, prefix + "Mode")
+
         super().__init__(name=name)
 
 
+class SensorGroup(StandardReadable):
+    def __init__(self, prefix: str, name: str = "", sensor_count: int = 3) -> None:
+        with self.add_children_as_readables():
+            self.sensors = DeviceVector(
+                {i: Sensor(f"{prefix}{i}:") for i in range(1, sensor_count + 1)}
+            )
+
+        super().__init__(name)
+
+
 class Mover(StandardReadable, Movable, Stoppable):
     """A demo movable that moves based on velocity"""
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
+        with self.add_children_as_readables(HintedSignal):
+            self.readback = epics_signal_r(float, prefix + "Readback")
+
+        with self.add_children_as_readables(ConfigSignal):
+            self.velocity = epics_signal_rw(float, prefix + "Velocity")
+            self.units = epics_signal_r(str, prefix + "Readback.EGU")
+
         self.setpoint = epics_signal_rw(float, prefix + "Setpoint")
-        self.readback = epics_signal_r(float, prefix + "Readback")
-        self.velocity = epics_signal_rw(float, prefix + "Velocity")
-        self.units = epics_signal_r(str, prefix + "Readback.EGU")
         self.precision = epics_signal_r(int, prefix + "Readback.PREC")
         # Signals that collide with standard methods should have a trailing underscore
         self.stop_ = epics_signal_x(prefix + "Stop.PROC")
         # Whether set() should complete successfully or not
         self._set_success = True
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.readback],
-            config=[self.velocity, self.units],
-        )
+
         super().__init__(name=name)
 
     def set_name(self, name: str):
@@ -135,11 +151,22 @@ def start_ioc_subprocess() -> str:
     pv_prefix = "".join(random.choice(string.ascii_uppercase) for _ in range(12)) + ":"
     here = Path(__file__).absolute().parent
     args = [sys.executable, "-m", "epicscorelibs.ioc"]
+
+    # Create standalone sensor
     args += ["-m", f"P={pv_prefix}"]
     args += ["-d", str(here / "sensor.db")]
-    for suff in "XY":
-        args += ["-m", f"P={pv_prefix}{suff}:"]
+
+    # Create sensor group
+    for suffix in ["1", "2", "3"]:
+        args += ["-m", f"P={pv_prefix}{suffix}:"]
+        args += ["-d", str(here / "sensor.db")]
+
+    # Create X and Y motors
+    for suffix in ["X", "Y"]:
+        args += ["-m", f"P={pv_prefix}{suffix}:"]
         args += ["-d", str(here / "mover.db")]
+
+    # Start IOC
     process = subprocess.Popen(
         args,
         stdin=subprocess.PIPE,

ophyd_async/epics/motion/motor.py

@@ -4,7 +4,7 @@ from typing import Callable, List, Optional
 
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.core import AsyncStatus, ConfigSignal, HintedSignal, StandardReadable
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -14,33 +14,38 @@ class Motor(StandardReadable, Movable, Stoppable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        self.setpoint = epics_signal_rw(float, prefix + ".VAL")
-        self.readback = epics_signal_r(float, prefix + ".RBV")
-        self.velocity = epics_signal_rw(float, prefix + ".VELO")
-        self.units = epics_signal_r(str, prefix + ".EGU")
+        with self.add_children_as_readables(ConfigSignal):
+            self.motor_egu = epics_signal_r(str, prefix + ".EGU")
+            self.velocity = epics_signal_rw(float, prefix + ".VELO")
+
+        with self.add_children_as_readables(HintedSignal):
+            self.user_readback = epics_signal_r(float, prefix + ".RBV")
+
+        self.user_setpoint = epics_signal_rw(float, prefix + ".VAL")
+        self.max_velocity = epics_signal_r(float, prefix + ".VMAX")
+        self.acceleration_time = epics_signal_rw(float, prefix + ".ACCL")
         self.precision = epics_signal_r(int, prefix + ".PREC")
-        # Signals that collide with standard methods should have a trailing underscore
-        self.stop_ = epics_signal_x(prefix + ".STOP")
+        self.deadband = epics_signal_r(float, prefix + ".RDBD")
+        self.motor_done_move = epics_signal_r(int, prefix + ".DMOV")
+        self.low_limit_travel = epics_signal_rw(float, prefix + ".LLM")
+        self.high_limit_travel = epics_signal_rw(float, prefix + ".HLM")
+
+        self.motor_stop = epics_signal_x(prefix + ".STOP")
         # Whether set() should complete successfully or not
         self._set_success = True
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.readback],
-            config=[self.velocity, self.units],
-        )
         super().__init__(name=name)
 
     def set_name(self, name: str):
         super().set_name(name)
         # Readback should be named the same as its parent in read()
-        self.readback.set_name(name)
+        self.user_readback.set_name(name)
 
     async def _move(self, new_position: float, watchers: List[Callable] = []):
         self._set_success = True
         start = time.monotonic()
         old_position, units, precision = await asyncio.gather(
-            self.setpoint.get_value(),
-            self.units.get_value(),
+            self.user_setpoint.get_value(),
+            self.motor_egu.get_value(),
             self.precision.get_value(),
         )
 
@@ -56,11 +61,11 @@ class Motor(StandardReadable, Movable, Stoppable):
                     time_elapsed=time.monotonic() - start,
                 )
 
-        self.readback.subscribe_value(update_watchers)
+        self.user_readback.subscribe_value(update_watchers)
         try:
-            await self.setpoint.set(new_position)
+            await self.user_setpoint.set(new_position)
         finally:
-            self.readback.clear_sub(update_watchers)
+            self.user_readback.clear_sub(update_watchers)
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
 
@@ -81,5 +86,5 @@ class Motor(StandardReadable, Movable, Stoppable):
         self._set_success = success
         # Put with completion will never complete as we are waiting for completion on
         # the move above, so need to pass wait=False
-        status = self.stop_.trigger(wait=False)
+        status = self.motor_stop.trigger(wait=False)
         await status

ophyd_async/epics/pvi/__init__.py

@@ -0,0 +1,3 @@
+from .pvi import PVIEntry, create_children_from_annotations, fill_pvi_entries
+
+__all__ = ["PVIEntry", "fill_pvi_entries", "create_children_from_annotations"]