ophyd-async 0.13.3__py3-none-any.whl → 0.13.5__py3-none-any.whl

ophyd_async/fastcs/jungfrau/__init__.py

@@ -1,4 +1,4 @@
-from ._controller import JungfrauController
+from ._controller import JUNGFRAU_DEADTIME_S, JungfrauController
 from ._jungfrau import Jungfrau
 from ._signals import (
     AcquisitionType,
@@ -26,4 +26,5 @@ __all__ = [
     "AcquisitionType",
     "GainMode",
     "PedestalMode",
+    "JUNGFRAU_DEADTIME_S",
 ]

ophyd_async/fastcs/jungfrau/_controller.py

@@ -113,20 +113,34 @@ class JungfrauController(DetectorController):
                     ]
                 )
             case AcquisitionType.PEDESTAL:
-                coros.extend(
-                    [
-                        self._driver.pedestal_mode_frames.set(
-                            trigger_info.exposures_per_event
-                        ),
-                        self._driver.pedestal_mode_loops.set(
-                            trigger_info.number_of_events
-                        ),
-                        self._driver.pedestal_mode_state.set(PedestalMode.ON),
-                    ]
-                )
+                if trigger_info.number_of_events % 2 == 0:
+                    coros.extend(
+                        [
+                            self._driver.pedestal_mode_frames.set(
+                                trigger_info.exposures_per_event
+                            ),
+                            # No. events is double the pedestal loops,
+                            # since pedestal scan does the entire loop
+                            # twice.
+                            self._driver.pedestal_mode_loops.set(
+                                int(trigger_info.number_of_events / 2)
+                            ),
+                        ]
+                    )
+                else:
+                    raise ValueError(
+                        f"Invalid trigger info for pedestal mode. "
+                        f"{trigger_info.number_of_events=} must be divisible by two. "
+                        f"Was create_jungfrau_pedestal_triggering_info used?"
+                    )
 
         await asyncio.gather(*coros)
 
+        # Setting signals once the detector is in pedestal mode can cause errors,
+        # so do this last
+        if acquisition_type == AcquisitionType.PEDESTAL:
+            await self._driver.pedestal_mode_state.set(PedestalMode.ON)
+
     async def arm(self):
         await self._driver.acquisition_start.trigger()
 
@@ -137,3 +151,7 @@ class JungfrauController(DetectorController):
 
     async def disarm(self):
         await self._driver.acquisition_stop.trigger()
+        await asyncio.gather(
+            self._driver.pedestal_mode_state.set(PedestalMode.OFF),
+            self._driver.acquisition_type.set(AcquisitionType.STANDARD),
+        )

ophyd_async/fastcs/jungfrau/_utils.py

@@ -2,6 +2,8 @@ from pydantic import PositiveInt
 
 from ophyd_async.core import DetectorTrigger, TriggerInfo
 
+from ._controller import JUNGFRAU_DEADTIME_S
+
 
 def create_jungfrau_external_triggering_info(
     total_triggers: PositiveInt,
@@ -11,7 +13,7 @@ def create_jungfrau_external_triggering_info(
 
     Uses parameters which more closely-align with Jungfrau terminology
     to create TriggerInfo. This device currently only supports one frame per trigger
-    when being externally triggered, but support for this can be added if needed
+    when being externally triggered.
 
     Args:
         total_triggers: Total external triggers expected before ending acquisition.
@@ -24,6 +26,7 @@ def create_jungfrau_external_triggering_info(
         number_of_events=total_triggers,
         trigger=DetectorTrigger.EDGE_TRIGGER,
         livetime=exposure_time_s,
+        deadtime=JUNGFRAU_DEADTIME_S,
     )
 
 
@@ -60,6 +63,11 @@ def create_jungfrau_pedestal_triggering_info(
     Uses parameters which more closely-align with Jungfrau terminology
     to create TriggerInfo.
 
+    When the Jungfrau is triggered in pedestal mode, it will run pedestal_frames-1
+    frames in dynamic gain mode, then one frame in gain mode 1, then repeat this for
+    pedelestal_loops number of times. This entire pattern is then repeated,
+    but gain mode 2 is used instead of gain mode 1 for the "one frame" part.
+
     NOTE: To trigger the jungfrau in pedestal mode, you must first set the
     jungfrau acquisition_type signal to AcquisitionType.PEDESTAL!
 
@@ -72,7 +80,7 @@ def create_jungfrau_pedestal_triggering_info(
         `TriggerInfo`
     """
     return TriggerInfo(
-        number_of_events=pedestal_loops,
+        number_of_events=pedestal_loops * 2,
         exposures_per_event=pedestal_frames,
         trigger=DetectorTrigger.INTERNAL,
         livetime=exposure_time_s,

ophyd_async/fastcs/panda/__init__.py

@@ -1,9 +1,11 @@
 from ._block import (
     CommonPandaBlocks,
     DataBlock,
+    InencBlock,
     PandaBitMux,
     PandaCaptureMode,
     PandaPcompDirection,
+    PandaPosMux,
     PandaTimeUnits,
     PcapBlock,
     PcompBlock,
@@ -20,6 +22,9 @@ from ._table import (
 )
 from ._trigger import (
     PcompInfo,
+    PosOutScaleOffset,
+    ScanSpecInfo,
+    ScanSpecSeqTableTriggerLogic,
     SeqTableInfo,
     StaticPcompTriggerLogic,
     StaticSeqTableTriggerLogic,
@@ -29,11 +34,13 @@ from ._writer import PandaHDFWriter
 __all__ = [
     "CommonPandaBlocks",
     "DataBlock",
+    "InencBlock",
     "PandaBitMux",
     "PandaCaptureMode",
     "PcapBlock",
     "PcompBlock",
     "PandaPcompDirection",
+    "PandaPosMux",
     "PulseBlock",
     "SeqBlock",
     "PandaTimeUnits",
@@ -48,4 +55,7 @@ __all__ = [
     "SeqTableInfo",
     "StaticPcompTriggerLogic",
     "StaticSeqTableTriggerLogic",
+    "ScanSpecInfo",
+    "ScanSpecSeqTableTriggerLogic",
+    "PosOutScaleOffset",
 ]

ophyd_async/fastcs/panda/_block.py

@@ -58,6 +58,12 @@ class PandaBitMux(SubsetEnum):
     ONE = "ONE"
 
 
+class PandaPosMux(SubsetEnum):
+    """Pos input in the PandA."""
+
+    ZERO = "ZERO"
+
+
 class PcompBlock(Device):
     """Position compare block in the PandA."""
 
@@ -88,6 +94,7 @@ class SeqBlock(Device):
     prescale: SignalRW[float]
     prescale_units: SignalRW[PandaTimeUnits]
     enable: SignalRW[PandaBitMux]
+    posa: SignalRW[PandaPosMux]
 
 
 class PcapBlock(Device):
@@ -97,6 +104,13 @@ class PcapBlock(Device):
     arm: SignalRW[bool]
 
 
+class InencBlock(Device):
+    """In encoder block in the PandA."""
+
+    val_scale: SignalRW[float]
+    val_offset: SignalRW[float]
+
+
 class CommonPandaBlocks(Device):
     """Pandablocks device with blocks which are common and required on introspection."""
 

ophyd_async/fastcs/panda/_trigger.py

@@ -1,17 +1,33 @@
+from __future__ import annotations
+
 import asyncio
+from dataclasses import dataclass
+from typing import cast
 
+import numpy as np
 from pydantic import Field
-
-from ophyd_async.core import ConfinedModel, FlyerController, wait_for_value
+from scanspec.core import Path
+from scanspec.specs import Spec
+
+from ophyd_async.core import (
+    ConfinedModel,
+    FlyerController,
+    SignalRW,
+    error_if_none,
+    wait_for_value,
+)
+from ophyd_async.epics.motor import Motor
 
 from ._block import (
+    CommonPandaBlocks,
     PandaBitMux,
     PandaPcompDirection,
+    PandaPosMux,
     PandaTimeUnits,
     PcompBlock,
     SeqBlock,
 )
-from ._table import SeqTable
+from ._table import SeqTable, SeqTrigger
 
 
 class SeqTableInfo(ConfinedModel):
@@ -22,6 +38,11 @@ class SeqTableInfo(ConfinedModel):
     prescale_as_us: float = Field(default=1, ge=0)  # microseconds
 
 
+class ScanSpecInfo(ConfinedModel):
+    spec: Spec[Motor]
+    deadtime: float
+
+
 class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
     """For controlling the PandA `SeqTable` when fly scanning."""
 
@@ -51,6 +72,105 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
         await wait_for_value(self.seq.active, False, timeout=1)
 
 
+@dataclass
+class PosOutScaleOffset:
+    name: str
+    scale: SignalRW[float]
+    offset: SignalRW[float]
+
+    @classmethod
+    def from_inenc(cls, panda: CommonPandaBlocks, number: int) -> PosOutScaleOffset:
+        inenc = panda.inenc[number]  # type: ignore
+        return cls(
+            name=f"INENC{number}.VAL",
+            scale=inenc.val_scale,  # type: ignore
+            offset=inenc.val_offset,  # type: ignore
+        )
+
+
+class ScanSpecSeqTableTriggerLogic(FlyerController[ScanSpecInfo]):
+    def __init__(
+        self,
+        seq: SeqBlock,
+        motor_pos_outs: dict[Motor, PosOutScaleOffset] | None = None,
+    ) -> None:
+        self.seq = seq
+        self.motor_pos_outs = motor_pos_outs or {}
+
+    async def prepare(self, value: ScanSpecInfo):
+        await self.seq.enable.set(PandaBitMux.ZERO)
+        slice = Path(value.spec.calculate()).consume()
+        slice_duration = error_if_none(slice.duration, "Slice must have duration")
+
+        # Start of window is where the is a gap to the previous point
+        window_start = np.nonzero(slice.gap)[0]
+        # End of window is either the next gap, or the end of the scan
+        window_end = np.append(window_start[1:], len(slice))
+        fast_axis = slice.axes()[-1]
+        pos_out = self.motor_pos_outs.get(fast_axis)
+        # If we have a motor to compare against, get its scale and offset
+        # otherwise don't connect POSA to anything
+        if pos_out is not None:
+            scale, offset = await asyncio.gather(
+                pos_out.scale.get_value(),
+                pos_out.offset.get_value(),
+            )
+            compare_pos_name = cast(PandaPosMux, pos_out.name)
+        else:
+            scale, offset = 1, 0
+            compare_pos_name = PandaPosMux.ZERO
+
+        rows = SeqTable.empty()
+        for start, end in zip(window_start, window_end, strict=True):
+            # GPIO goes low then high
+            rows += SeqTable.row(trigger=SeqTrigger.BITA_0)
+            rows += SeqTable.row(trigger=SeqTrigger.BITA_1)
+            # Wait for position if we are comparing against a motor
+            if pos_out is not None:
+                lower = (slice.lower[fast_axis][start] - offset) / scale
+                midpoint = (slice.midpoints[fast_axis][start] - offset) / scale
+                if midpoint > lower:
+                    trigger = SeqTrigger.POSA_GT
+                elif midpoint < lower:
+                    trigger = SeqTrigger.POSA_LT
+                else:
+                    trigger = None
+                if trigger is not None:
+                    rows += SeqTable.row(
+                        trigger=trigger,
+                        position=int(lower),
+                    )
+
+            # Time based Triggers
+            rows += SeqTable.row(
+                repeats=end - start,
+                trigger=SeqTrigger.IMMEDIATE,
+                time1=int((slice_duration[0] - value.deadtime) * 10**6),
+                time2=int(value.deadtime * 10**6),
+                outa1=True,
+                outa2=False,
+            )
+        # Need to do units before value for PandA, otherwise it scales the current value
+        await self.seq.prescale_units.set(PandaTimeUnits.US)
+        await asyncio.gather(
+            self.seq.posa.set(compare_pos_name),
+            self.seq.prescale.set(1.0),
+            self.seq.repeats.set(1),
+            self.seq.table.set(rows),
+        )
+
+    async def kickoff(self) -> None:
+        await self.seq.enable.set(PandaBitMux.ONE)
+        await wait_for_value(self.seq.active, True, timeout=1)
+
+    async def complete(self) -> None:
+        await wait_for_value(self.seq.active, False, timeout=None)
+
+    async def stop(self):
+        await self.seq.enable.set(PandaBitMux.ZERO)
+        await wait_for_value(self.seq.active, False, timeout=1)
+
+
 class PcompInfo(ConfinedModel):
     """Info for the PandA `PcompBlock` for fly scanning."""
 

ophyd_async/sim/_motor.py

@@ -82,8 +82,10 @@ class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float
         )
         return Location(setpoint=setpoint, readback=readback)
 
-    def subscribe(self, function: Callback[dict[str, Reading[float]]]) -> None:
-        self.user_readback.subscribe(function)
+    def subscribe_reading(self, function: Callback[dict[str, Reading[float]]]) -> None:
+        self.user_readback.subscribe_reading(function)
+
+    subscribe = subscribe_reading
 
     def clear_sub(self, function: Callback[dict[str, Reading[float]]]) -> None:
         self.user_readback.clear_sub(function)

ophyd_async/sim/_stage.py

@@ -1,3 +1,5 @@
+from bluesky.protocols import Reading
+
 from ophyd_async.core import StandardReadable
 from ophyd_async.sim._pattern_generator import PatternGenerator
 
@@ -16,15 +18,23 @@ class SimStage(StandardReadable):
         # Set name of device and child devices
         super().__init__(name=name)
 
+    def _set_x_from_reading(self, readings: dict[str, Reading[float]]):
+        (x_reading,) = readings.values()
+        self.pattern_generator.set_x(x_reading["value"])
+
+    def _set_y_from_reading(self, readings: dict[str, Reading[float]]):
+        (y_reading,) = readings.values()
+        self.pattern_generator.set_y(y_reading["value"])
+
     def stage(self):
         """Stage the motors and report the position to the pattern generator."""
         # Tell the pattern generator about the motor positions
-        self.x.user_readback.subscribe_value(self.pattern_generator.set_x)
-        self.y.user_readback.subscribe_value(self.pattern_generator.set_y)
+        self.x.user_readback.subscribe_reading(self._set_x_from_reading)
+        self.y.user_readback.subscribe_reading(self._set_y_from_reading)
         return super().stage()
 
     def unstage(self):
         """Unstage the motors and remove the position subscription."""
-        self.x.user_readback.clear_sub(self.pattern_generator.set_x)
-        self.y.user_readback.clear_sub(self.pattern_generator.set_y)
+        self.x.user_readback.clear_sub(self._set_x_from_reading)
+        self.y.user_readback.clear_sub(self._set_y_from_reading)
         return super().unstage()

ophyd_async/tango/core/__init__.py

@@ -12,24 +12,35 @@ from ._tango_readable import TangoReadable
 from ._tango_transport import (
     AttributeProxy,
     CommandProxy,
+    CommandProxyReadCharacter,
+    TangoDoubleStringTable,
+    TangoLongStringTable,
     TangoSignalBackend,
     ensure_proper_executor,
+    get_command_character,
     get_dtype_extended,
     get_python_type,
+    get_source_metadata,
     get_tango_trl,
-    get_trl_descriptor,
 )
-from ._utils import DevStateEnum, get_device_trl_and_attr, get_full_attr_trl
+from ._utils import (
+    DevStateEnum,
+    get_device_trl_and_attr,
+    get_full_attr_trl,
+    try_to_cast_as_float,
+)
 
 __all__ = [
     "AttributeProxy",
     "CommandProxy",
+    "CommandProxyReadCharacter",
     "DevStateEnum",
     "ensure_proper_executor",
     "TangoSignalBackend",
+    "get_command_character",
     "get_python_type",
     "get_dtype_extended",
-    "get_trl_descriptor",
+    "get_source_metadata",
     "get_tango_trl",
     "infer_python_type",
     "infer_signal_type",
@@ -42,6 +53,9 @@ __all__ = [
     "TangoReadable",
     "TangoPolling",
     "TangoDeviceConnector",
+    "TangoLongStringTable",
+    "TangoDoubleStringTable",
+    "try_to_cast_as_float",
     "get_device_trl_and_attr",
     "get_full_attr_trl",
 ]

ophyd_async/tango/core/_signal.py

@@ -3,13 +3,11 @@
 from __future__ import annotations
 
 import logging
-from enum import Enum, IntEnum
+from enum import IntEnum
 
 import numpy.typing as npt
 from tango import (
-    AttrDataFormat,
     AttrWriteType,
-    CmdArgType,
     DeviceProxy,
     DevState,
 )
@@ -25,7 +23,12 @@ from ophyd_async.core import (
     SignalX,
 )
 
-from ._tango_transport import TangoSignalBackend, get_python_type
+from ._tango_transport import (
+    CommandProxyReadCharacter,
+    TangoSignalBackend,
+    get_command_character,
+    get_python_type,
+)
 from ._utils import get_device_trl_and_attr
 
 logger = logging.getLogger("ophyd_async")
@@ -148,22 +151,13 @@ async def infer_python_type(
 
     if tr_name in dev_proxy.get_command_list():
         config = await dev_proxy.get_command_config(tr_name)
-        isarray, py_type, _ = get_python_type(config.in_type)
+        py_type = get_python_type(config)
     elif tr_name in dev_proxy.get_attribute_list():
         config = await dev_proxy.get_attribute_config(tr_name)
-        isarray, py_type, _ = get_python_type(config.data_type)
-        if py_type is Enum:
-            enum_dict = {label: i for i, label in enumerate(config.enum_labels)}
-            py_type = IntEnum("TangoEnum", enum_dict)
-        if config.data_format in [AttrDataFormat.SPECTRUM, AttrDataFormat.IMAGE]:
-            isarray = True
+        py_type = get_python_type(config)
     else:
         raise RuntimeError(f"Cannot find {tr_name} in {device_trl}")
-
-    if py_type is CmdArgType.DevState:
-        py_type = DevState
-
-    return npt.NDArray[py_type] if isarray else py_type
+    return py_type
 
 
 async def infer_signal_type(
@@ -190,11 +184,13 @@ async def infer_signal_type(
 
     if tr_name in dev_proxy.get_command_list():
         config = await dev_proxy.get_command_config(tr_name)
-        if config.in_type == CmdArgType.DevVoid:
-            return SignalX
-        elif config.in_type != config.out_type:
-            logger.debug("Commands with different in and out dtypes are not supported")
-            return None
-        else:
+        command_character = get_command_character(config)
+        if command_character == CommandProxyReadCharacter.READ:
+            return SignalR
+        elif command_character == CommandProxyReadCharacter.WRITE:
+            return SignalW
+        elif command_character == CommandProxyReadCharacter.READ_WRITE:
             return SignalRW
+        elif command_character == CommandProxyReadCharacter.EXECUTE:
+            return SignalX
     raise RuntimeError(f"Unable to infer signal character for {trl}")