ophyd-async 0.1.0__py3-none-any.whl → 0.3a1__py3-none-any.whl

ophyd_async/epics/signal/signal.py

@@ -92,7 +92,7 @@ def epics_signal_x(write_pv: str) -> SignalX:
     Parameters
     ----------
     write_pv:
-        The PV to write its initial value to on execute
+        The PV to write its initial value to on trigger
     """
     backend: SignalBackend = _make_backend(None, write_pv, write_pv)
     return SignalX(backend)

ophyd_async/panda/__init__.py

@@ -1,21 +1,25 @@
-from .panda import (
-    PandA,
-    PcapBlock,
-    PulseBlock,
-    PVIEntry,
-    SeqBlock,
+from .panda import PandA, PcapBlock, PulseBlock, PVIEntry, SeqBlock, SeqTable
+from .panda_controller import PandaPcapController
+from .table import (
     SeqTable,
+    SeqTableRow,
     SeqTrigger,
-    pvi,
+    seq_table_from_arrays,
+    seq_table_from_rows,
 )
+from .utils import phase_sorter
 
 __all__ = [
     "PandA",
     "PcapBlock",
     "PulseBlock",
     "PVIEntry",
+    "seq_table_from_arrays",
+    "seq_table_from_rows",
     "SeqBlock",
     "SeqTable",
+    "SeqTableRow",
     "SeqTrigger",
-    "pvi",
+    "phase_sorter",
+    "PandaPcapController",
 ]

ophyd_async/panda/panda.py

@@ -1,28 +1,10 @@
 from __future__ import annotations
 
-import atexit
 import re
-from enum import Enum
-from typing import (
-    Callable,
-    Dict,
-    FrozenSet,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TypedDict,
-    cast,
-    get_args,
-    get_origin,
-    get_type_hints,
-)
-
-import numpy as np
-import numpy.typing as npt
-from p4p.client.thread import Context
+from typing import Dict, Optional, Tuple, cast, get_args, get_origin, get_type_hints
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
     Device,
     DeviceVector,
     Signal,
@@ -32,13 +14,8 @@ from ophyd_async.core import (
     SignalX,
     SimSignalBackend,
 )
-from ophyd_async.epics.signal import (
-    epics_signal_r,
-    epics_signal_rw,
-    epics_signal_w,
-    epics_signal_x,
-    pvi_get,
-)
+from ophyd_async.epics.pvi import PVIEntry, make_signal, pvi_get
+from ophyd_async.panda.table import SeqTable
 
 
 class PulseBlock(Device):
@@ -46,56 +23,14 @@ class PulseBlock(Device):
     width: SignalRW[float]
 
 
-class SeqTrigger(Enum):
-    IMMEDIATE = "Immediate"
-    BITA_0 = "BITA=0"
-    BITA_1 = "BITA=1"
-    BITB_0 = "BITB=0"
-    BITB_1 = "BITB=1"
-    BITC_0 = "BITC=0"
-    BITC_1 = "BITC=1"
-    POSA_GT = "POSA>=POSITION"
-    POSA_LT = "POSA<=POSITION"
-    POSB_GT = "POSB>=POSITION"
-    POSB_LT = "POSB<=POSITION"
-    POSC_GT = "POSC>=POSITION"
-    POSC_LT = "POSC<=POSITION"
-
-
-class SeqTable(TypedDict):
-    repeats: npt.NDArray[np.uint16]
-    trigger: Sequence[SeqTrigger]
-    position: npt.NDArray[np.int32]
-    time1: npt.NDArray[np.uint32]
-    outa1: npt.NDArray[np.bool_]
-    outb1: npt.NDArray[np.bool_]
-    outc1: npt.NDArray[np.bool_]
-    outd1: npt.NDArray[np.bool_]
-    oute1: npt.NDArray[np.bool_]
-    outf1: npt.NDArray[np.bool_]
-    time2: npt.NDArray[np.uint32]
-    outa2: npt.NDArray[np.bool_]
-    outb2: npt.NDArray[np.bool_]
-    outc2: npt.NDArray[np.bool_]
-    outd2: npt.NDArray[np.bool_]
-    oute2: npt.NDArray[np.bool_]
-    outf2: npt.NDArray[np.bool_]
-
-
 class SeqBlock(Device):
     table: SignalRW[SeqTable]
+    active: SignalRW[bool]
 
 
 class PcapBlock(Device):
     active: SignalR[bool]
-
-
-class PVIEntry(TypedDict, total=False):
-    d: str
-    r: str
-    rw: str
-    w: str
-    x: str
+    arm: SignalRW[bool]
 
 
 def _block_name_number(block_name: str) -> Tuple[str, Optional[int]]:
@@ -116,7 +51,7 @@ def _block_name_number(block_name: str) -> Tuple[str, Optional[int]]:
     return block_name, None
 
 
-def _remove_inconsistent_blocks(pvi_info: Dict[str, PVIEntry]) -> None:
+def _remove_inconsistent_blocks(pvi_info: Optional[Dict[str, PVIEntry]]) -> None:
     """Remove blocks from pvi information.
 
     This is needed because some pandas have 'pcap' and 'pcap1' blocks, which are
@@ -124,6 +59,8 @@ def _remove_inconsistent_blocks(pvi_info: Dict[str, PVIEntry]) -> None:
     for example.
 
     """
+    if pvi_info is None:
+        return
     pvi_keys = set(pvi_info.keys())
     for k in pvi_keys:
         kn = re.sub(r"\d*$", "", k)
@@ -131,44 +68,14 @@ def _remove_inconsistent_blocks(pvi_info: Dict[str, PVIEntry]) -> None:
             del pvi_info[k]
 
 
-async def pvi(pv: str, ctxt: Context, timeout: float = 5.0) -> Dict[str, PVIEntry]:
-    result = await pvi_get(pv, ctxt, timeout=timeout)
-    _remove_inconsistent_blocks(result)
-    return result
-
-
 class PandA(Device):
-    _ctxt: Optional[Context] = None
-
     pulse: DeviceVector[PulseBlock]
     seq: DeviceVector[SeqBlock]
     pcap: PcapBlock
 
-    def __init__(self, pv: str) -> None:
-        self._init_prefix = pv
-        self.pvi_mapping: Dict[FrozenSet[str], Callable[..., Signal]] = {
-            frozenset({"r", "w"}): lambda dtype, rpv, wpv: epics_signal_rw(
-                dtype, rpv, wpv
-            ),
-            frozenset({"rw"}): lambda dtype, rpv, wpv: epics_signal_rw(dtype, rpv, wpv),
-            frozenset({"r"}): lambda dtype, rpv, wpv: epics_signal_r(dtype, rpv),
-            frozenset({"w"}): lambda dtype, rpv, wpv: epics_signal_w(dtype, wpv),
-            frozenset({"x"}): lambda dtype, rpv, wpv: epics_signal_x(wpv),
-        }
-
-    @property
-    def ctxt(self) -> Context:
-        if PandA._ctxt is None:
-            PandA._ctxt = Context("pva", nt=False)
-
-            @atexit.register
-            def _del_ctxt():
-                # If we don't do this we get messages like this on close:
-                #   Error in sys.excepthook:
-                #   Original exception was:
-                PandA._ctxt = None
-
-        return PandA._ctxt
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(name)
+        self._prefix = prefix
 
     def verify_block(self, name: str, num: Optional[int]):
         """Given a block name and number, return information about a block."""
@@ -186,7 +93,12 @@ class PandA(Device):
         return block
 
     async def _make_block(
-        self, name: str, num: Optional[int], block_pv: str, sim: bool = False
+        self,
+        name: str,
+        num: Optional[int],
+        block_pv: str,
+        sim: bool = False,
+        timeout: float = DEFAULT_TIMEOUT,
     ):
         """Makes a block given a block name containing relevant signals.
 
@@ -196,7 +108,7 @@ class PandA(Device):
         block = self.verify_block(name, num)
 
         field_annos = get_type_hints(block, globalns=globals())
-        block_pvi = await pvi(block_pv, self.ctxt) if not sim else None
+        block_pvi = await pvi_get(block_pv, timeout=timeout) if not sim else None
 
         # finds which fields this class actually has, e.g. delay, width...
         for sig_name, sig_type in field_annos.items():
@@ -205,7 +117,6 @@ class PandA(Device):
 
             # if not in sim mode,
             if block_pvi:
-                block_pvi = cast(Dict[str, PVIEntry], block_pvi)
                 # try to get this block in the pvi.
                 entry: Optional[PVIEntry] = block_pvi.get(sig_name)
                 if entry is None:
@@ -214,7 +125,7 @@ class PandA(Device):
                         + f"an {sig_name} signal which has not been retrieved by PVI."
                     )
 
-                signal = self._make_signal(entry, args[0] if len(args) > 0 else None)
+                signal: Signal = make_signal(entry, args[0] if len(args) > 0 else None)
 
             else:
                 backend: SignalBackend = SimSignalBackend(
@@ -229,40 +140,26 @@ class PandA(Device):
             for attr, attr_pvi in block_pvi.items():
                 if not hasattr(block, attr):
                     # makes any extra signals
-                    signal = self._make_signal(attr_pvi)
-                    setattr(block, attr, signal)
+                    setattr(block, attr, make_signal(attr_pvi))
 
         return block
 
-    async def _make_untyped_block(self, block_pv: str):
+    async def _make_untyped_block(
+        self, block_pv: str, timeout: float = DEFAULT_TIMEOUT
+    ):
         """Populates a block using PVI information.
 
         This block is not typed as part of the PandA interface but needs to be
         included dynamically anyway.
         """
         block = Device()
-        block_pvi: Dict[str, PVIEntry] = await pvi(block_pv, self.ctxt)
+        block_pvi: Dict[str, PVIEntry] = await pvi_get(block_pv, timeout=timeout)
 
         for signal_name, signal_pvi in block_pvi.items():
-            signal = self._make_signal(signal_pvi)
-            setattr(block, signal_name, signal)
+            setattr(block, signal_name, make_signal(signal_pvi))
 
         return block
 
-    def _make_signal(self, signal_pvi: PVIEntry, dtype: Optional[Type] = None):
-        """Make a signal.
-
-        This assumes datatype is None so it can be used to create dynamic signals.
-        """
-        operations = frozenset(signal_pvi.keys())
-        pvs = [signal_pvi[i] for i in operations]  # type: ignore
-        signal_factory = self.pvi_mapping[operations]
-
-        write_pv = pvs[0]
-        read_pv = write_pv if len(pvs) == 1 else pvs[1]
-
-        return signal_factory(dtype, "pva://" + read_pv, "pva://" + write_pv)
-
     # TODO redo to set_panda_block? confusing name
     def set_attribute(self, name: str, num: Optional[int], block: Device):
         """Set a block on the panda.
@@ -279,7 +176,9 @@ class PandA(Device):
         else:
             setattr(self, name, block)
 
-    async def connect(self, sim=False) -> None:
+    async def connect(
+        self, sim: bool = False, timeout: float = DEFAULT_TIMEOUT
+    ) -> None:
         """Initialises all blocks and connects them.
 
         First, checks for pvi information. If it exists, make all blocks from this.
@@ -288,7 +187,11 @@ class PandA(Device):
         If there's no pvi information, that's because we're in sim mode. In that case,
         makes all required blocks.
         """
-        pvi_info = await pvi(self._init_prefix + ":PVI", self.ctxt) if not sim else None
+        pvi_info = (
+            await pvi_get(self._prefix + "PVI", timeout=timeout) if not sim else None
+        )
+        _remove_inconsistent_blocks(pvi_info)
+
         hints = {
             attr_name: attr_type
             for attr_name, attr_type in get_type_hints(self, globalns=globals()).items()
@@ -302,9 +205,13 @@ class PandA(Device):
                 name, num = _block_name_number(block_name)
 
                 if name in hints:
-                    block = await self._make_block(name, num, block_pvi["d"])
+                    block = await self._make_block(
+                        name, num, block_pvi["d"], timeout=timeout
+                    )
                 else:
-                    block = await self._make_untyped_block(block_pvi["d"])
+                    block = await self._make_untyped_block(
+                        block_pvi["d"], timeout=timeout
+                    )
 
                 self.set_attribute(name, num, block)
 
@@ -325,7 +232,9 @@ class PandA(Device):
                 ], f"Expected PandA to only contain blocks, got {entry}"
             else:
                 num = 1 if get_origin(hints[block_name]) == DeviceVector else None
-                block = await self._make_block(block_name, num, "sim://", sim=sim)
+                block = await self._make_block(
+                    block_name, num, "sim://", sim=sim, timeout=timeout
+                )
                 self.set_attribute(block_name, num, block)
 
         self.set_name(self.name)

ophyd_async/panda/panda_controller.py

@@ -0,0 +1,41 @@
+import asyncio
+from typing import Optional
+
+from ophyd_async.core import (
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+    wait_for_value,
+)
+
+from .panda import PcapBlock
+
+
+class PandaPcapController(DetectorControl):
+    def __init__(
+        self,
+        pcap: PcapBlock,
+    ) -> None:
+        self.pcap = pcap
+
+    def get_deadtime(self, exposure: float) -> float:
+        return 0.000000008
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.constant_gate,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        assert trigger in (
+            DetectorTrigger.constant_gate,
+            trigger == DetectorTrigger.variable_gate,
+        ), "Only constant_gate and variable_gate triggering is supported on the PandA"
+        await asyncio.gather(self.pcap.arm.set(True))
+        await wait_for_value(self.pcap.active, True, timeout=1)
+        return AsyncStatus(wait_for_value(self.pcap.active, False, timeout=None))
+
+    async def disarm(self):
+        await asyncio.gather(self.pcap.arm.set(False))
+        await wait_for_value(self.pcap.active, False, timeout=1)
+        return AsyncStatus(wait_for_value(self.pcap.active, False, timeout=None))

ophyd_async/panda/table.py

@@ -0,0 +1,158 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional, Sequence, Type, TypedDict, TypeVar
+
+import numpy as np
+import numpy.typing as npt
+
+
+class SeqTrigger(str, Enum):
+    IMMEDIATE = "Immediate"
+    BITA_0 = "BITA=0"
+    BITA_1 = "BITA=1"
+    BITB_0 = "BITB=0"
+    BITB_1 = "BITB=1"
+    BITC_0 = "BITC=0"
+    BITC_1 = "BITC=1"
+    POSA_GT = "POSA>=POSITION"
+    POSA_LT = "POSA<=POSITION"
+    POSB_GT = "POSB>=POSITION"
+    POSB_LT = "POSB<=POSITION"
+    POSC_GT = "POSC>=POSITION"
+    POSC_LT = "POSC<=POSITION"
+
+
+@dataclass
+class SeqTableRow:
+    repeats: int = 1
+    trigger: SeqTrigger = SeqTrigger.IMMEDIATE
+    position: int = 0
+    time1: int = 0
+    outa1: bool = False
+    outb1: bool = False
+    outc1: bool = False
+    outd1: bool = False
+    oute1: bool = False
+    outf1: bool = False
+    time2: int = 0
+    outa2: bool = False
+    outb2: bool = False
+    outc2: bool = False
+    outd2: bool = False
+    oute2: bool = False
+    outf2: bool = False
+
+
+class SeqTable(TypedDict):
+    repeats: npt.NDArray[np.uint16]
+    trigger: Sequence[SeqTrigger]
+    position: npt.NDArray[np.int32]
+    time1: npt.NDArray[np.uint32]
+    outa1: npt.NDArray[np.bool_]
+    outb1: npt.NDArray[np.bool_]
+    outc1: npt.NDArray[np.bool_]
+    outd1: npt.NDArray[np.bool_]
+    oute1: npt.NDArray[np.bool_]
+    outf1: npt.NDArray[np.bool_]
+    time2: npt.NDArray[np.uint32]
+    outa2: npt.NDArray[np.bool_]
+    outb2: npt.NDArray[np.bool_]
+    outc2: npt.NDArray[np.bool_]
+    outd2: npt.NDArray[np.bool_]
+    oute2: npt.NDArray[np.bool_]
+    outf2: npt.NDArray[np.bool_]
+
+
+def seq_table_from_rows(*rows: SeqTableRow):
+    """
+    Constructs a sequence table from a series of rows.
+    """
+    return seq_table_from_arrays(
+        repeats=np.array([row.repeats for row in rows], dtype=np.uint16),
+        trigger=[row.trigger for row in rows],
+        position=np.array([row.position for row in rows], dtype=np.int32),
+        time1=np.array([row.time1 for row in rows], dtype=np.uint32),
+        outa1=np.array([row.outa1 for row in rows], dtype=np.bool_),
+        outb1=np.array([row.outb1 for row in rows], dtype=np.bool_),
+        outc1=np.array([row.outc1 for row in rows], dtype=np.bool_),
+        outd1=np.array([row.outd1 for row in rows], dtype=np.bool_),
+        oute1=np.array([row.oute1 for row in rows], dtype=np.bool_),
+        outf1=np.array([row.outf1 for row in rows], dtype=np.bool_),
+        time2=np.array([row.time2 for row in rows], dtype=np.uint32),
+        outa2=np.array([row.outa2 for row in rows], dtype=np.bool_),
+        outb2=np.array([row.outb2 for row in rows], dtype=np.bool_),
+        outc2=np.array([row.outc2 for row in rows], dtype=np.bool_),
+        outd2=np.array([row.outd2 for row in rows], dtype=np.bool_),
+        oute2=np.array([row.oute2 for row in rows], dtype=np.bool_),
+        outf2=np.array([row.outf2 for row in rows], dtype=np.bool_),
+    )
+
+
+T = TypeVar("T", bound=np.generic)
+
+
+def seq_table_from_arrays(
+    *,
+    repeats: Optional[npt.NDArray[np.uint16]] = None,
+    trigger: Optional[Sequence[SeqTrigger]] = None,
+    position: Optional[npt.NDArray[np.int32]] = None,
+    time1: Optional[npt.NDArray[np.uint32]] = None,
+    outa1: Optional[npt.NDArray[np.bool_]] = None,
+    outb1: Optional[npt.NDArray[np.bool_]] = None,
+    outc1: Optional[npt.NDArray[np.bool_]] = None,
+    outd1: Optional[npt.NDArray[np.bool_]] = None,
+    oute1: Optional[npt.NDArray[np.bool_]] = None,
+    outf1: Optional[npt.NDArray[np.bool_]] = None,
+    time2: npt.NDArray[np.uint32],
+    outa2: Optional[npt.NDArray[np.bool_]] = None,
+    outb2: Optional[npt.NDArray[np.bool_]] = None,
+    outc2: Optional[npt.NDArray[np.bool_]] = None,
+    outd2: Optional[npt.NDArray[np.bool_]] = None,
+    oute2: Optional[npt.NDArray[np.bool_]] = None,
+    outf2: Optional[npt.NDArray[np.bool_]] = None,
+) -> SeqTable:
+    """
+    Constructs a sequence table from a series of columns as arrays.
+    time2 is the only required argument and must not be None.
+    All other provided arguments must be of equal length to time2.
+    If any other argument is not given, or else given as None or empty,
+    an array of length len(time2) filled with the following is defaulted:
+    repeats: 1
+    trigger: SeqTrigger.IMMEDIATE
+    all others: 0/False as appropriate
+    """
+    assert time2 is not None, "time2 must be provided"
+    length = len(time2)
+    assert 0 < length < 4096, f"Length {length} not in range"
+
+    def or_default(
+        value: Optional[npt.NDArray[T]], dtype: Type[T], default_value: int = 0
+    ) -> npt.NDArray[T]:
+        if value is None or len(value) == 0:
+            return np.full(length, default_value, dtype=dtype)
+        return value
+
+    table = SeqTable(
+        repeats=or_default(repeats, np.uint16, 1),
+        trigger=trigger or [SeqTrigger.IMMEDIATE] * length,
+        position=or_default(position, np.int32),
+        time1=or_default(time1, np.uint32),
+        outa1=or_default(outa1, np.bool_),
+        outb1=or_default(outb1, np.bool_),
+        outc1=or_default(outc1, np.bool_),
+        outd1=or_default(outd1, np.bool_),
+        oute1=or_default(oute1, np.bool_),
+        outf1=or_default(outf1, np.bool_),
+        time2=time2,
+        outa2=or_default(outa2, np.bool_),
+        outb2=or_default(outb2, np.bool_),
+        outc2=or_default(outc2, np.bool_),
+        outd2=or_default(outd2, np.bool_),
+        oute2=or_default(oute2, np.bool_),
+        outf2=or_default(outf2, np.bool_),
+    )
+    for k, v in table.items():
+        size = len(v)  # type: ignore
+        if size != length:
+            raise ValueError(f"{k}: has length {size} not {length}")
+    return table

ophyd_async/panda/utils.py

@@ -0,0 +1,15 @@
+from typing import Any, Dict, Sequence
+
+
+def phase_sorter(panda_signal_values: Dict[str, Any]) -> Sequence[Dict[str, Any]]:
+    # Panda has two load phases. If the signal name ends in the string "UNITS",
+    # it needs to be loaded first so put in first phase
+    phase_1, phase_2 = {}, {}
+
+    for key, value in panda_signal_values.items():
+        if key.endswith("units"):
+            phase_1[key] = value
+        else:
+            phase_2[key] = value
+
+    return [phase_1, phase_2]