ophyd-async 0.13.1__py3-none-any.whl → 0.13.2__py3-none-any.whl

ophyd_async/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.1'
-__version_tuple__ = version_tuple = (0, 13, 1)
+__version__ = version = '0.13.2'
+__version_tuple__ = version_tuple = (0, 13, 2)
 
 __commit_id__ = commit_id = None

ophyd_async/core/__init__.py

@@ -6,7 +6,7 @@ from ._derived_signal import (
     derived_signal_rw,
     derived_signal_w,
 )
-from ._derived_signal_backend import Transform
+from ._derived_signal_backend import Transform, merge_gathered_dicts
 from ._detector import (
     DetectorController,
     DetectorTrigger,
@@ -212,6 +212,7 @@ __all__ = [
     "derived_signal_w",
     "Transform",
     "DerivedSignalFactory",
+    "merge_gathered_dicts",
     # Back compat - delete before 1.0
     "ConfigSignal",
     "HintedSignal",

ophyd_async/core/_signal.py

@@ -121,6 +121,13 @@ class _SignalCache(Generic[SignalDatatypeT]):
         self._valid = asyncio.Event()
         self._reading: Reading[SignalDatatypeT] | None = None
         self.backend: SignalBackend[SignalDatatypeT] = backend
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError as e:
+            raise RuntimeError(
+                "Need a running event loop to subscribe to a signal, "
+                "are you trying to run subscribe outside a plan?"
+            ) from e
         signal.log.debug(f"Making subscription on source {signal.source}")
         backend.set_callback(self._callback)
 

ophyd_async/epics/core/_epics_connector.py

@@ -10,7 +10,20 @@ from ._signal import EpicsSignalBackend, get_signal_backend_type, split_protocol
 
 @dataclass
 class PvSuffix:
-    """Define the PV suffix to be appended to the device prefix."""
+    """Define the PV suffix to be appended to the device prefix.
+
+    For a SignalRW:
+    - If you use the same "Suffix" for the read and write PV then use PvSuffix("Suffix")
+    - If you have "Suffix" for the write PV and "Suffix_RBV" for the read PV then use
+      PvSuffix.rbv("Suffix")
+    - If you have "WriteSuffix" for the write PV and "ReadSuffix" for the read PV then
+      you use PvSuffix(read_suffix="ReadSuffix", write_suffix="WriteSuffix")
+
+    For a SignalR:
+    - If you have "Suffix" for the read PV then use PvSuffix("Suffix")
+    - If you have "Suffix_RBV" for the read PV then use PvSuffix("Suffix_RBV"), do not
+      use PvSuffix.rbv as that will try to connect to multiple PVs
+    """
 
     read_suffix: str
     write_suffix: str | None = None

ophyd_async/epics/motor.py

@@ -106,6 +106,24 @@ class Motor(
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
+    async def check_motor_limit(self, abs_start_pos: float, abs_end_pos: float):
+        """Check the motor limit with the absolute positions."""
+        motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
+            self.low_limit_travel.get_value(),
+            self.high_limit_travel.get_value(),
+            self.motor_egu.get_value(),
+        )
+        if (
+            not motor_upper_limit >= abs_start_pos >= motor_lower_limit
+            or not motor_upper_limit >= abs_end_pos >= motor_lower_limit
+        ):
+            raise MotorLimitsException(
+                f"Motor trajectory for requested fly/move is from "
+                f"{abs_start_pos}{egu} to "
+                f"{abs_end_pos}{egu} but motor limits are "
+                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+            )
+
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
         """Move to the beginning of a suitable run-up distance ready for a fly scan."""
@@ -126,22 +144,7 @@ class Motor(
         ramp_up_start_pos = value.ramp_up_start_pos(acceleration_time)
         ramp_down_end_pos = value.ramp_down_end_pos(acceleration_time)
 
-        motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
-            self.low_limit_travel.get_value(),
-            self.high_limit_travel.get_value(),
-            self.motor_egu.get_value(),
-        )
-
-        if (
-            not motor_upper_limit >= ramp_up_start_pos >= motor_lower_limit
-            or not motor_upper_limit >= ramp_down_end_pos >= motor_lower_limit
-        ):
-            raise MotorLimitsException(
-                f"Motor trajectory for requested fly is from "
-                f"{ramp_up_start_pos}{egu} to "
-                f"{ramp_down_end_pos}{egu} but motor limits are "
-                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
-            )
+        await self.check_motor_limit(ramp_up_start_pos, ramp_down_end_pos)
 
         # move to prepare position at maximum velocity
         await self.velocity.set(abs(max_speed))
@@ -199,6 +202,8 @@ class Motor(
                 msg = "Mover has zero velocity"
                 raise ValueError(msg) from error
 
+        await self.check_motor_limit(old_position, new_position)
+
         move_status = self.user_setpoint.set(new_position, wait=True, timeout=timeout)
         async for current_position in observe_value(
             self.user_readback, done_status=move_status

ophyd_async/epics/{eiger → odin}/_odin_io.py

@@ -90,11 +90,11 @@ class OdinWriter(DetectorWriter):
         self,
         path_provider: PathProvider,
         odin_driver: Odin,
-        eiger_bit_depth: SignalR[int],
+        detector_bit_depth: SignalR[int],
     ) -> None:
         self._drv = odin_driver
         self._path_provider = path_provider
-        self._eiger_bit_depth = Reference(eiger_bit_depth)
+        self._detector_bit_depth = Reference(detector_bit_depth)
         self._capture_status: AsyncStatus | None = None
         super().__init__()
 
@@ -103,7 +103,9 @@ class OdinWriter(DetectorWriter):
         self._exposures_per_event = exposures_per_event
 
         await asyncio.gather(
-            self._drv.data_type.set(f"UInt{await self._eiger_bit_depth().get_value()}"),
+            self._drv.data_type.set(
+                f"UInt{await self._detector_bit_depth().get_value()}"
+            ),
             self._drv.num_to_capture.set(0),
             self._drv.file_path.set(str(info.directory_path)),
             self._drv.file_name.set(info.filename),

ophyd_async/epics/pmac/__init__.py

@@ -1,8 +1,10 @@
 from ._pmac_io import PmacAxisAssignmentIO, PmacCoordIO, PmacIO, PmacTrajectoryIO
+from ._pmac_trajectory import PmacTrajectoryTriggerLogic
 
 __all__ = [
     "PmacAxisAssignmentIO",
     "PmacCoordIO",
     "PmacIO",
     "PmacTrajectoryIO",
+    "PmacTrajectoryTriggerLogic",
 ]

ophyd_async/epics/pmac/_pmac_io.py

@@ -72,7 +72,7 @@ class PmacCoordIO(Device):
         self.cs_port = epics_signal_r(str, f"{prefix}Port")
         self.cs_axis_setpoint = DeviceVector(
             {
-                i + 1: epics_signal_rw(np.float64, f"{prefix}M{i + 1}:DirectDemand")
+                i + 1: epics_signal_rw(float, f"{prefix}M{i + 1}:DirectDemand")
                 for i in range(len(CS_LETTERS))
             }
         )
@@ -93,7 +93,7 @@ class PmacIO(Device):
 
         self.assignment = DeviceVector(
             {
-                i: PmacAxisAssignmentIO(motor_prefix)
+                i: PmacAxisAssignmentIO(motor_prefix + ":")
                 for i, motor_prefix in enumerate(motor_prefixes)
             }
         )

ophyd_async/epics/pmac/_pmac_trajectory.py

@@ -0,0 +1,116 @@
+import asyncio
+
+import numpy as np
+from scanspec.core import Path
+from scanspec.specs import Spec
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    FlyerController,
+    set_and_wait_for_value,
+    wait_for_value,
+)
+from ophyd_async.epics.motor import Motor
+from ophyd_async.epics.pmac import PmacIO
+from ophyd_async.epics.pmac._pmac_io import CS_LETTERS
+from ophyd_async.epics.pmac._utils import (
+    _PmacMotorInfo,
+    _Trajectory,
+    calculate_ramp_position_and_duration,
+)
+
+
+class PmacTrajectoryTriggerLogic(FlyerController):
+    def __init__(self, pmac: PmacIO) -> None:
+        self.pmac = pmac
+        self.scantime: float | None = None
+
+    async def prepare(self, value: Spec[Motor]):
+        slice = Path(value.calculate()).consume()
+        motor_info = await _PmacMotorInfo.from_motors(self.pmac, slice.axes())
+        ramp_up_pos, ramp_up_time = calculate_ramp_position_and_duration(
+            slice, motor_info, True
+        )
+        ramp_down_pos, ramp_down_time = calculate_ramp_position_and_duration(
+            slice, motor_info, False
+        )
+        trajectory = _Trajectory.from_slice(slice, ramp_up_time, motor_info)
+        await asyncio.gather(
+            self._build_trajectory(
+                trajectory, motor_info, ramp_down_pos, ramp_down_time
+            ),
+            self._move_to_start(motor_info, ramp_up_pos),
+        )
+
+    async def kickoff(self):
+        if not self.scantime:
+            raise RuntimeError("Cannot kickoff. Must call prepare first.")
+        self.status = await self.pmac.trajectory.execute_profile.set(
+            True, timeout=self.scantime + 1
+        )
+
+    async def complete(self):
+        if not self.scantime:
+            raise RuntimeError("Cannot complete. Must call prepare first.")
+        await wait_for_value(
+            self.pmac.trajectory.execute_profile,
+            False,
+            timeout=self.scantime + DEFAULT_TIMEOUT,
+        )
+
+    async def stop(self):
+        await self.pmac.trajectory.abort_profile.set(True)
+
+    async def _build_trajectory(
+        self,
+        trajectory: _Trajectory,
+        motor_info: _PmacMotorInfo,
+        ramp_down_pos: dict[Motor, np.float64],
+        ramp_down_time: float,
+    ):
+        trajectory = trajectory.append_ramp_down(ramp_down_pos, ramp_down_time, 0)
+        self.scantime = np.sum(trajectory.durations)
+        use_axis = {axis + 1: False for axis in range(len(CS_LETTERS))}
+
+        size = 0
+        for motor, number in motor_info.motor_cs_index.items():
+            use_axis[number + 1] = True
+            await self.pmac.trajectory.positions[number + 1].set(
+                trajectory.positions[motor]
+            )
+            await self.pmac.trajectory.velocities[number + 1].set(
+                trajectory.velocities[motor]
+            )
+            size += len(trajectory.positions[motor])
+
+        coros = [
+            self.pmac.trajectory.profile_cs_name.set(motor_info.cs_port),
+            self.pmac.trajectory.time_array.set(trajectory.durations),
+            self.pmac.trajectory.user_array.set(trajectory.user_programs),
+            self.pmac.trajectory.points_to_build.set(size),
+            self.pmac.trajectory.calculate_velocities.set(False),
+        ] + [
+            self.pmac.trajectory.use_axis[number].set(use)
+            for number, use in use_axis.items()
+        ]
+        await asyncio.gather(*coros)
+        await self.pmac.trajectory.build_profile.set(True)
+
+    async def _move_to_start(
+        self, motor_info: _PmacMotorInfo, ramp_up_position: dict[Motor, np.float64]
+    ):
+        coord = self.pmac.coord[motor_info.cs_number]
+        coros = []
+        await coord.defer_moves.set(True)
+        for motor, position in ramp_up_position.items():
+            coros.append(
+                set_and_wait_for_value(
+                    coord.cs_axis_setpoint[motor_info.motor_cs_index[motor] + 1],
+                    position,
+                    set_timeout=10,
+                    wait_for_set_completion=False,
+                )
+            )
+        statuses = await asyncio.gather(*coros)
+        await coord.defer_moves.set(False)
+        await asyncio.gather(*statuses)