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

ophyd_async/epics/{areadetector/drivers/pilatus_driver.py → adpilatus/_pilatus_io.py}

@@ -1,7 +1,7 @@
 from enum import Enum
 
-from ...signal import epics_signal_r, epics_signal_rw_rbv
-from .ad_base import ADBase
+from ophyd_async.epics import adcore
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv
 
 
 class PilatusTriggerMode(str, Enum):
@@ -12,7 +12,9 @@ class PilatusTriggerMode(str, Enum):
     alignment = "Alignment"
 
 
-class PilatusDriver(ADBase):
+class PilatusDriverIO(adcore.ADBaseIO):
+    """This mirrors the interface provided by ADPilatus/db/pilatus.template."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         self.trigger_mode = epics_signal_rw_rbv(
             PilatusTriggerMode, prefix + "TriggerMode"

ophyd_async/epics/adsimdetector/__init__.py

@@ -0,0 +1,7 @@
+from ._sim import SimDetector
+from ._sim_controller import SimController
+
+__all__ = [
+    "SimDetector",
+    "SimController",
+]

ophyd_async/epics/{demo/demo_ad_sim_detector.py → adsimdetector/_sim.py}

@@ -1,20 +1,19 @@
 from typing import Sequence
 
 from ophyd_async.core import PathProvider, SignalR, StandardDetector
+from ophyd_async.epics import adcore
 
-from ..areadetector.controllers import ADSimController
-from ..areadetector.drivers import ADBase, ADBaseShapeProvider
-from ..areadetector.writers import HDFWriter, NDFileHDF
+from ._sim_controller import SimController
 
 
-class DemoADSimDetector(StandardDetector):
-    _controller: ADSimController
-    _writer: HDFWriter
+class SimDetector(StandardDetector):
+    _controller: SimController
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
-        drv: ADBase,
-        hdf: NDFileHDF,
+        drv: adcore.ADBaseIO,
+        hdf: adcore.NDFileHDFIO,
         path_provider: PathProvider,
         name: str = "",
         config_sigs: Sequence[SignalR] = (),
@@ -23,12 +22,12 @@ class DemoADSimDetector(StandardDetector):
         self.hdf = hdf
 
         super().__init__(
-            ADSimController(self.drv),
-            HDFWriter(
+            SimController(self.drv),
+            adcore.ADHDFWriter(
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=config_sigs,
             name=name,

ophyd_async/epics/{areadetector/controllers/ad_sim_controller.py → adsimdetector/_sim_controller.py}

@@ -7,20 +7,14 @@ from ophyd_async.core import (
     DetectorControl,
     DetectorTrigger,
 )
-
-from ..drivers.ad_base import (
-    DEFAULT_GOOD_STATES,
-    ADBase,
-    DetectorState,
-    ImageMode,
-    start_acquiring_driver_and_ensure_status,
-)
-from ..utils import stop_busy_record
+from ophyd_async.epics import adcore
 
 
-class ADSimController(DetectorControl):
+class SimController(DetectorControl):
     def __init__(
-        self, driver: ADBase, good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES)
+        self,
+        driver: adcore.ADBaseIO,
+        good_states: Set[adcore.DetectorState] = set(adcore.DEFAULT_GOOD_STATES),
     ) -> None:
         self.driver = driver
         self.good_states = good_states
@@ -40,13 +34,13 @@ class ADSimController(DetectorControl):
         frame_timeout = DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
         await asyncio.gather(
             self.driver.num_images.set(num),
-            self.driver.image_mode.set(ImageMode.multiple),
+            self.driver.image_mode.set(adcore.ImageMode.multiple),
         )
-        return await start_acquiring_driver_and_ensure_status(
+        return await adcore.start_acquiring_driver_and_ensure_status(
             self.driver, good_states=self.good_states, timeout=frame_timeout
         )
 
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock
-        await stop_busy_record(self.driver.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self.driver.acquire, False, timeout=1)

ophyd_async/epics/advimba/__init__.py

@@ -0,0 +1,9 @@
+from ._vimba import VimbaDetector
+from ._vimba_controller import VimbaController
+from ._vimba_io import VimbaDriverIO
+
+__all__ = [
+    "VimbaDetector",
+    "VimbaController",
+    "VimbaDriverIO",
+]

ophyd_async/epics/{areadetector/vimba.py → advimba/_vimba.py}

@@ -1,10 +1,10 @@
 from bluesky.protocols import HasHints, Hints
 
 from ophyd_async.core import PathProvider, 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
+from ophyd_async.epics import adcore
+
+from ._vimba_controller import VimbaController
+from ._vimba_io import VimbaDriverIO
 
 
 class VimbaDetector(StandardDetector, HasHints):
@@ -13,7 +13,7 @@ class VimbaDetector(StandardDetector, HasHints):
     """
 
     _controller: VimbaController
-    _writer: HDFWriter
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
@@ -23,16 +23,16 @@ class VimbaDetector(StandardDetector, HasHints):
         hdf_suffix="HDF1:",
         name="",
     ):
-        self.drv = VimbaDriver(prefix + drv_suffix)
-        self.hdf = NDFileHDF(prefix + hdf_suffix)
+        self.drv = VimbaDriverIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             VimbaController(self.drv),
-            HDFWriter(
+            adcore.ADHDFWriter(
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/{areadetector/controllers/vimba_controller.py → advimba/_vimba_controller.py}

@@ -2,17 +2,9 @@ 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 ophyd_async.epics import adcore
 
-from ..drivers.vimba_driver import (
-    VimbaDriver,
-    VimbaExposeOutMode,
-    VimbaOnOff,
-    VimbaTriggerSource,
-)
-from ..utils import ImageMode, stop_busy_record
+from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
 
 TRIGGER_MODE = {
     DetectorTrigger.internal: VimbaOnOff.off,
@@ -32,7 +24,7 @@ EXPOSE_OUT_MODE = {
 class VimbaController(DetectorControl):
     def __init__(
         self,
-        driver: VimbaDriver,
+        driver: VimbaDriverIO,
     ) -> None:
         self._drv = driver
 
@@ -49,7 +41,7 @@ class VimbaController(DetectorControl):
             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),
+            self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
         if exposure is not None and trigger not in [
             DetectorTrigger.variable_gate,
@@ -60,7 +52,7 @@ class VimbaController(DetectorControl):
             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)
+        return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/{areadetector/drivers/vimba_driver.py → advimba/_vimba_io.py}

@@ -1,8 +1,7 @@
 from enum import Enum
 
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
-
-from .ad_base import ADBase
+from ophyd_async.epics import adcore
+from ophyd_async.epics.signal import epics_signal_rw_rbv
 
 
 class VimbaPixelFormat(str, Enum):
@@ -46,7 +45,9 @@ class VimbaExposeOutMode(str, Enum):
     trigger_width = "TriggerWidth"  # Expose for length of high signal
 
 
-class VimbaDriver(ADBase):
+class VimbaDriverIO(adcore.ADBaseIO):
+    """This mirrors the interface provided by ADVimba/db/vimba.template."""
+
     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(

ophyd_async/epics/demo/__init__.py

@@ -1,145 +1,22 @@
 """Demo EPICS Devices for the tutorial"""
 
-import asyncio
 import atexit
 import random
 import string
 import subprocess
 import sys
-from enum import Enum
 from pathlib import Path
 
-import numpy as np
-from bluesky.protocols import Movable, Stoppable
+from ._mover import Mover, SampleStage
+from ._sensor import EnergyMode, Sensor, SensorGroup
 
-from ophyd_async.core import (
-    ConfigSignal,
-    Device,
-    DeviceVector,
-    HintedSignal,
-    StandardReadable,
-    WatchableAsyncStatus,
-    observe_value,
-)
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.utils import (
-    DEFAULT_TIMEOUT,
-    CalculatableTimeout,
-    CalculateTimeout,
-    WatcherUpdate,
-)
-
-from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
-
-
-class EnergyMode(str, Enum):
-    """Energy mode for `Sensor`"""
-
-    #: Low energy mode
-    low = "Low Energy"
-    #: High energy mode
-    high = "High Energy"
-
-
-class Sensor(StandardReadable):
-    """A demo sensor that produces a scalar value based on X and Y Movers"""
-
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some signals
-        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.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
-
-        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)
-
-    @WatchableAsyncStatus.wrap
-    async def set(
-        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
-    ):
-        self._set_success = True
-        old_position, units, precision, velocity = await asyncio.gather(
-            self.setpoint.get_value(),
-            self.units.get_value(),
-            self.precision.get_value(),
-            self.velocity.get_value(),
-        )
-        if timeout is CalculateTimeout:
-            assert velocity > 0, "Mover has zero velocity"
-            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
-        # Make an Event that will be set on completion, and a Status that will
-        # error if not done in time
-        done = asyncio.Event()
-        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))
-        # Wait for the value to set, but don't wait for put completion callback
-        await self.setpoint.set(new_position, wait=False)
-        async for current_position in observe_value(
-            self.readback, done_status=done_status
-        ):
-            yield WatcherUpdate(
-                current=current_position,
-                initial=old_position,
-                target=new_position,
-                name=self.name,
-                unit=units,
-                precision=precision,
-            )
-            if np.isclose(current_position, new_position):
-                done.set()
-                break
-        if not self._set_success:
-            raise RuntimeError("Motor was stopped")
-
-    async def stop(self, success=True):
-        self._set_success = success
-        status = self.stop_.trigger()
-        await status
-
-
-class SampleStage(Device):
-    """A demo sample stage with X and Y movables"""
-
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some child Devices
-        self.x = Mover(prefix + "X:")
-        self.y = Mover(prefix + "Y:")
-        # Set name of device and child devices
-        super().__init__(name=name)
+__all__ = [
+    "Mover",
+    "SampleStage",
+    "EnergyMode",
+    "Sensor",
+    "SensorGroup",
+]
 
 
 def start_ioc_subprocess() -> str:

ophyd_async/epics/demo/_mover.py

@@ -0,0 +1,97 @@
+import asyncio
+
+import numpy as np
+from bluesky.protocols import Movable, Stoppable
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    CalculatableTimeout,
+    CalculateTimeout,
+    ConfigSignal,
+    Device,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+    WatcherUpdate,
+    observe_value,
+)
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+
+
+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.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
+
+        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)
+
+    @WatchableAsyncStatus.wrap
+    async def set(
+        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
+    ):
+        self._set_success = True
+        old_position, units, precision, velocity = await asyncio.gather(
+            self.setpoint.get_value(),
+            self.units.get_value(),
+            self.precision.get_value(),
+            self.velocity.get_value(),
+        )
+        if timeout is CalculateTimeout:
+            assert velocity > 0, "Mover has zero velocity"
+            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
+        # Make an Event that will be set on completion, and a Status that will
+        # error if not done in time
+        done = asyncio.Event()
+        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))
+        # Wait for the value to set, but don't wait for put completion callback
+        await self.setpoint.set(new_position, wait=False)
+        async for current_position in observe_value(
+            self.readback, done_status=done_status
+        ):
+            yield WatcherUpdate(
+                current=current_position,
+                initial=old_position,
+                target=new_position,
+                name=self.name,
+                unit=units,
+                precision=precision,
+            )
+            if np.isclose(current_position, new_position):
+                done.set()
+                break
+        if not self._set_success:
+            raise RuntimeError("Motor was stopped")
+
+    async def stop(self, success=True):
+        self._set_success = success
+        status = self.stop_.trigger()
+        await status
+
+
+class SampleStage(Device):
+    """A demo sample stage with X and Y movables"""
+
+    def __init__(self, prefix: str, name="") -> None:
+        # Define some child Devices
+        self.x = Mover(prefix + "X:")
+        self.y = Mover(prefix + "Y:")
+        # Set name of device and child devices
+        super().__init__(name=name)

ophyd_async/epics/demo/_sensor.py

@@ -0,0 +1,36 @@
+from enum import Enum
+
+from ophyd_async.core import ConfigSignal, DeviceVector, HintedSignal, StandardReadable
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+
+
+class EnergyMode(str, Enum):
+    """Energy mode for `Sensor`"""
+
+    #: Low energy mode
+    low = "Low Energy"
+    #: High energy mode
+    high = "High Energy"
+
+
+class Sensor(StandardReadable):
+    """A demo sensor that produces a scalar value based on X and Y Movers"""
+
+    def __init__(self, prefix: str, name="") -> None:
+        # Define some signals
+        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)

ophyd_async/epics/{motion/motor.py → motor.py}

@@ -5,21 +5,18 @@ from bluesky.protocols import Flyable, Movable, Preparable, Stoppable
 from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    CalculatableTimeout,
+    CalculateTimeout,
     ConfigSignal,
     HintedSignal,
     StandardReadable,
     WatchableAsyncStatus,
-)
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.signal import observe_value
-from ophyd_async.core.utils import (
-    DEFAULT_TIMEOUT,
-    CalculatableTimeout,
-    CalculateTimeout,
     WatcherUpdate,
+    observe_value,
 )
-
-from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
 
 class MotorLimitsException(Exception):
@@ -116,6 +113,7 @@ class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
         )
 
         await self.set(fly_prepared_position)
+        await self.velocity.set(fly_velocity)
 
     @AsyncStatus.wrap
     async def kickoff(self):
@@ -182,7 +180,7 @@ class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
     async def _prepare_velocity(
         self, start_position: float, end_position: float, time_for_move: float
     ) -> float:
-        fly_velocity = (start_position - end_position) / time_for_move
+        fly_velocity = (end_position - start_position) / time_for_move
         max_speed, egu = await asyncio.gather(
             self.max_velocity.get_value(), self.motor_egu.get_value()
         )
@@ -191,7 +189,8 @@ class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
                 f"Motor speed of {abs(fly_velocity)} {egu}/s was requested for a motor "
                 f" with max speed of {max_speed} {egu}/s"
             )
-        await self.velocity.set(abs(fly_velocity))
+        # move to prepare position at maximum velocity
+        await self.velocity.set(abs(max_speed))
         return fly_velocity
 
     async def _prepare_motor_path(
@@ -199,7 +198,9 @@ class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
     ) -> float:
         # Distance required for motor to accelerate from stationary to fly_velocity, and
         # distance required for motor to decelerate from fly_velocity to stationary
-        run_up_distance = (await self.acceleration_time.get_value()) * fly_velocity
+        run_up_distance = (
+            (await self.acceleration_time.get_value()) * fly_velocity * 0.5
+        )
 
         self._fly_completed_position = end_position + run_up_distance
 

ophyd_async/epics/pvi/__init__.py

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