ophyd-async 0.9.0a1__py3-none-any.whl → 0.10.0a1__py3-none-any.whl

ophyd_async/epics/motor.py

@@ -1,3 +1,8 @@
+"""Support for EPICS motor record.
+
+https://github.com/epics-modules/motor
+"""
+
 import asyncio
 
 from bluesky.protocols import (
@@ -5,7 +10,9 @@ from bluesky.protocols import (
     Locatable,
     Location,
     Preparable,
+    Reading,
     Stoppable,
+    Subscribable,
 )
 from pydantic import BaseModel, Field
 
@@ -14,7 +21,9 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
+    Callback,
     StandardReadable,
+    StrictEnum,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
@@ -22,47 +31,61 @@ from ophyd_async.core import (
 from ophyd_async.core import StandardReadableFormat as Format
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
+__all__ = ["MotorLimitsException", "FlyMotorInfo", "Motor"]
 
-class MotorLimitsException(Exception):
-    pass
 
+class MotorLimitsException(Exception):
+    """Exception for invalid motor limits."""
 
-class InvalidFlyMotorException(Exception):
     pass
 
 
-DEFAULT_MOTOR_FLY_TIMEOUT = 60
-DEFAULT_WATCHER_UPDATE_FREQUENCY = 0.2
-
-
 class FlyMotorInfo(BaseModel):
-    """Minimal set of information required to fly a motor:"""
+    """Minimal set of information required to fly a motor."""
 
-    #: Absolute position of the motor once it finishes accelerating to desired
-    #: velocity, in motor EGUs
     start_position: float = Field(frozen=True)
+    """Absolute position of the motor once it finishes accelerating to desired
+    velocity, in motor EGUs"""
 
-    #: Absolute position of the motor once it begins decelerating from desired
-    #: velocity, in EGUs
     end_position: float = Field(frozen=True)
+    """Absolute position of the motor once it begins decelerating from desired
+    velocity, in EGUs"""
 
-    #: Time taken for the motor to get from start_position to end_position, excluding
-    #: run-up and run-down, in seconds.
     time_for_move: float = Field(frozen=True, gt=0)
+    """Time taken for the motor to get from start_position to end_position, excluding
+    run-up and run-down, in seconds."""
 
-    #: Maximum time for the complete motor move, including run up and run down.
-    #: Defaults to `time_for_move` + run up and run down times + 10s.
     timeout: CalculatableTimeout = Field(frozen=True, default=CALCULATE_TIMEOUT)
+    """Maximum time for the complete motor move, including run up and run down.
+    Defaults to `time_for_move` + run up and run down times + 10s."""
+
+
+class OffsetMode(StrictEnum):
+    VARIABLE = "Variable"
+    FROZEN = "Frozen"
 
 
-class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
-    """Device that moves a motor record"""
+class UseSetMode(StrictEnum):
+    USE = "Use"
+    SET = "Set"
+
+
+class Motor(
+    StandardReadable,
+    Locatable[float],
+    Stoppable,
+    Flyable,
+    Preparable,
+    Subscribable[float],
+):
+    """Device that moves a motor record."""
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
         with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.motor_egu = epics_signal_r(str, prefix + ".EGU")
             self.velocity = epics_signal_rw(float, prefix + ".VELO")
+            self.offset = epics_signal_rw(float, prefix + ".OFF")
 
         with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.user_readback = epics_signal_r(float, prefix + ".RBV")
@@ -75,11 +98,16 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         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.offset_freeze_switch = epics_signal_rw(OffsetMode, prefix + ".FOFF")
+        self.high_limit_switch = epics_signal_r(int, prefix + ".HLS")
+        self.low_limit_switch = epics_signal_r(int, prefix + ".LLS")
+        self.set_use_switch = epics_signal_rw(UseSetMode, prefix + ".SET")
 
         # Note:cannot use epics_signal_x here, as the motor record specifies that
         # we must write 1 to stop the motor. Simply processing the record is not
         # sufficient.
         self.motor_stop = epics_signal_w(int, prefix + ".STOP")
+
         # Whether set() should complete successfully or not
         self._set_success = True
 
@@ -95,15 +123,14 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         super().__init__(name=name)
 
     def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
+        """Set name of the motor and its children."""
         super().set_name(name, child_name_separator=child_name_separator)
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
-        """Calculate required velocity and run-up distance, then if motor limits aren't
-        breached, move to start position minus run-up distance"""
-
+        """Move to the beginning of a suitable run-up distance ready for a flyscan."""
         self._fly_timeout = value.timeout
 
         # Velocity, at which motor travels from start_position to end_position, in motor
@@ -125,9 +152,9 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
     @AsyncStatus.wrap
     async def kickoff(self):
         """Begin moving motor from prepared position to final position."""
-        assert (
-            self._fly_completed_position
-        ), "Motor must be prepared before attempting to kickoff"
+        if not self._fly_completed_position:
+            msg = "Motor must be prepared before attempting to kickoff"
+            raise RuntimeError(msg)
 
         self._fly_status = self.set(
             self._fly_completed_position, timeout=self._fly_timeout
@@ -135,12 +162,16 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
 
     def complete(self) -> WatchableAsyncStatus:
         """Mark as complete once motor reaches completed position."""
-        assert self._fly_status, "kickoff not called"
+        if not self._fly_status:
+            msg = "kickoff not called"
+            raise RuntimeError(msg)
         return self._fly_status
 
     @WatchableAsyncStatus.wrap
-    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
-        new_position = value
+    async def set(  # type: ignore
+        self, new_position: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT
+    ):
+        """Move motor to the given value."""
         self._set_success = True
         (
             old_position,
@@ -155,13 +186,18 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
             self.velocity.get_value(),
             self.acceleration_time.get_value(),
         )
+
         if timeout is CALCULATE_TIMEOUT:
-            assert velocity > 0, "Motor has zero velocity"
-            timeout = (
-                abs(new_position - old_position) / velocity
-                + 2 * acceleration_time
-                + DEFAULT_TIMEOUT
-            )
+            try:
+                timeout = (
+                    abs((new_position - old_position) / velocity)
+                    + 2 * acceleration_time
+                    + DEFAULT_TIMEOUT
+                )
+            except ZeroDivisionError as error:
+                msg = "Mover has zero velocity"
+                raise ValueError(msg) from error
+
         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
@@ -178,6 +214,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
             raise RuntimeError("Motor was stopped")
 
     async def stop(self, success=False):
+        """Request to stop moving and return immediately."""
         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
@@ -200,11 +237,19 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         return fly_velocity
 
     async def locate(self) -> Location[float]:
-        location: Location = {
-            "setpoint": await self.user_setpoint.get_value(),
-            "readback": await self.user_readback.get_value(),
-        }
-        return location
+        """Return the current setpoint and readback of the motor."""
+        setpoint, readback = await asyncio.gather(
+            self.user_setpoint.get_value(), self.user_readback.get_value()
+        )
+        return Location(setpoint=setpoint, readback=readback)
+
+    def subscribe(self, function: Callback[dict[str, Reading[float]]]) -> None:
+        """Subscribe."""
+        self.user_readback.subscribe(function)
+
+    def clear_sub(self, function: Callback[dict[str, Reading[float]]]) -> None:
+        """Unsubscribe."""
+        self.user_readback.clear_sub(function)
 
     async def _prepare_motor_path(
         self, fly_velocity: float, start_position: float, end_position: float

ophyd_async/epics/signal.py

@@ -1,4 +1,5 @@
-# back compat
+"""Back compat."""
+
 import warnings
 
 from .core import *  # noqa: F403
@@ -9,3 +10,5 @@ warnings.warn(
     ),
     stacklevel=2,
 )
+
+__all__ = []

ophyd_async/epics/testing/__init__.py

@@ -1,24 +1,24 @@
 from ._example_ioc import (
     CA_PVA_RECORDS,
     PVA_RECORDS,
-    ExampleCaDevice,
-    ExampleEnum,
-    ExamplePvaDevice,
-    ExampleTable,
-    connect_example_device,
-    get_example_ioc,
+    EpicsTestCaDevice,
+    EpicsTestEnum,
+    EpicsTestIocAndDevices,
+    EpicsTestPvaDevice,
+    EpicsTestSubsetEnum,
+    EpicsTestTable,
 )
-from ._utils import TestingIOC, generate_random_PV_prefix
+from ._utils import TestingIOC, generate_random_pv_prefix
 
 __all__ = [
     "CA_PVA_RECORDS",
     "PVA_RECORDS",
-    "ExampleCaDevice",
-    "ExampleEnum",
-    "ExamplePvaDevice",
-    "ExampleTable",
-    "connect_example_device",
-    "get_example_ioc",
+    "EpicsTestCaDevice",
+    "EpicsTestEnum",
+    "EpicsTestSubsetEnum",
+    "EpicsTestPvaDevice",
+    "EpicsTestTable",
+    "EpicsTestIocAndDevices",
     "TestingIOC",
-    "generate_random_PV_prefix",
+    "generate_random_pv_prefix",
 ]

ophyd_async/epics/testing/_example_ioc.py

@@ -1,50 +1,57 @@
 from collections.abc import Sequence
 from pathlib import Path
 from typing import Annotated as A
-from typing import Literal
 
 import numpy as np
 
-from ophyd_async.core import (
-    Array1D,
-    SignalRW,
-    StrictEnum,
-    Table,
-)
-from ophyd_async.epics.core import (
-    EpicsDevice,
-    PvSuffix,
-)
+from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, Table
+from ophyd_async.core._utils import SubsetEnum
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
-from ._utils import TestingIOC
+from ._utils import TestingIOC, generate_random_pv_prefix
 
-CA_PVA_RECORDS = str(Path(__file__).parent / "test_records.db")
-PVA_RECORDS = str(Path(__file__).parent / "test_records_pva.db")
+CA_PVA_RECORDS = Path(__file__).parent / "test_records.db"
+PVA_RECORDS = Path(__file__).parent / "test_records_pva.db"
 
 
-class ExampleEnum(StrictEnum):
+class EpicsTestEnum(StrictEnum):
+    """For testing strict enum values in test IOCs."""
+
     A = "Aaa"
     B = "Bbb"
     C = "Ccc"
 
 
-class ExampleTable(Table):
-    bool: Array1D[np.bool_]
-    int: Array1D[np.int32]
-    float: Array1D[np.float64]
-    str: Sequence[str]
-    enum: Sequence[ExampleEnum]
+class EpicsTestSubsetEnum(SubsetEnum):
+    """For testing subset enum values in test IOCs."""
+
+    A = "Aaa"
+    B = "Bbb"
+
+
+class EpicsTestTable(Table):
+    a_bool: Array1D[np.bool_]
+    a_int: Array1D[np.int32]
+    a_float: Array1D[np.float64]
+    a_str: Sequence[str]
+    a_enum: Sequence[EpicsTestEnum]
 
 
-class ExampleCaDevice(EpicsDevice):
-    my_int: A[SignalRW[int], PvSuffix("int")]
-    my_float: A[SignalRW[float], PvSuffix("float")]
-    my_str: A[SignalRW[str], PvSuffix("str")]
+class EpicsTestCaDevice(EpicsDevice):
+    """Device for use in a channel access test IOC."""
+
+    a_int: A[SignalRW[int], PvSuffix("int")]
+    """A thing"""
+    a_float: A[SignalRW[float], PvSuffix("float")]
+    float_prec_0: A[SignalRW[int], PvSuffix("float_prec_0")]
+    a_str: A[SignalRW[str], PvSuffix("str")]
     longstr: A[SignalRW[str], PvSuffix("longstr")]
-    longstr2: A[SignalRW[str], PvSuffix("longstr2")]
-    my_bool: A[SignalRW[bool], PvSuffix("bool")]
-    enum: A[SignalRW[ExampleEnum], PvSuffix("enum")]
-    enum2: A[SignalRW[ExampleEnum], PvSuffix("enum2")]
+    longstr2: A[SignalRW[str], PvSuffix("longstr2.VAL$")]
+    a_bool: A[SignalRW[bool], PvSuffix("bool")]
+    enum: A[SignalRW[EpicsTestEnum], PvSuffix("enum")]
+    enum2: A[SignalRW[EpicsTestEnum], PvSuffix("enum2")]
+    subset_enum: A[SignalRW[EpicsTestSubsetEnum], PvSuffix("subset_enum")]
+    enum_str_fallback: A[SignalRW[str], PvSuffix("enum_str_fallback")]
     bool_unnamed: A[SignalRW[bool], PvSuffix("bool_unnamed")]
     partialint: A[SignalRW[int], PvSuffix("partialint")]
     lessint: A[SignalRW[int], PvSuffix("lessint")]
@@ -56,52 +63,40 @@ class ExampleCaDevice(EpicsDevice):
     stra: A[SignalRW[Sequence[str]], PvSuffix("stra")]
 
 
-class ExamplePvaDevice(ExampleCaDevice):  # pva can support all signal types that ca can
+class EpicsTestPvaDevice(EpicsTestCaDevice):
+    """Device for use in a pv access test IOC."""
+
+    # pva can support all signal types that ca can
     int8a: A[SignalRW[Array1D[np.int8]], PvSuffix("int8a")]
     uint16a: A[SignalRW[Array1D[np.uint16]], PvSuffix("uint16a")]
     uint32a: A[SignalRW[Array1D[np.uint32]], PvSuffix("uint32a")]
     int64a: A[SignalRW[Array1D[np.int64]], PvSuffix("int64a")]
     uint64a: A[SignalRW[Array1D[np.uint64]], PvSuffix("uint64a")]
-    table: A[SignalRW[ExampleTable], PvSuffix("table")]
-    ntndarray_data: A[SignalRW[Array1D[np.int64]], PvSuffix("ntndarray:data")]
-
-
-async def connect_example_device(
-    ioc: TestingIOC, protocol: Literal["ca", "pva"]
-) -> ExamplePvaDevice | ExampleCaDevice:
-    """Helper function to return a connected example device.
-
-    Parameters
-    ----------
-
-    ioc: TestingIOC
-        TestingIOC configured to provide the records needed for the device
-
-    protocol: Literal["ca", "pva"]
-        The transport protocol of the device
-
-    Returns
-    -------
-    ExamplePvaDevice | ExampleCaDevice
-        a connected EpicsDevice with signals of many EPICS record types
-    """
-    device_cls = ExamplePvaDevice if protocol == "pva" else ExampleCaDevice
-    device = device_cls(f"{protocol}://{ioc.prefix_for(device_cls)}")
-    await device.connect()
-    return device
-
-
-def get_example_ioc() -> TestingIOC:
-    """Get TestingIOC instance with the example databases loaded.
-
-    Returns
-    -------
-    TestingIOC
-        instance with test_records.db loaded for ExampleCaDevice and
-        test_records.db and test_records_pva.db loaded for ExamplePvaDevice.
-    """
-    ioc = TestingIOC()
-    ioc.database_for(PVA_RECORDS, ExamplePvaDevice)
-    ioc.database_for(CA_PVA_RECORDS, ExamplePvaDevice)
-    ioc.database_for(CA_PVA_RECORDS, ExampleCaDevice)
-    return ioc
+    table: A[SignalRW[EpicsTestTable], PvSuffix("table")]
+    ntndarray: A[SignalR[np.ndarray], PvSuffix("ntndarray")]
+
+
+class EpicsTestIocAndDevices:
+    """Test IOC with ca and pva devices."""
+
+    def __init__(self):
+        self.prefix = generate_random_pv_prefix()
+        self.ioc = TestingIOC()
+        # Create supporting records and ExampleCaDevice
+        ca_prefix = f"{self.prefix}ca:"
+        self.ioc.add_database(CA_PVA_RECORDS, device=ca_prefix)
+        self.ca_device = EpicsTestCaDevice(f"ca://{ca_prefix}")
+        # Create supporting records and ExamplePvaDevice
+        pva_prefix = f"{self.prefix}pva:"
+        self.ioc.add_database(CA_PVA_RECORDS, device=pva_prefix)
+        self.ioc.add_database(PVA_RECORDS, device=pva_prefix)
+        self.pva_device = EpicsTestPvaDevice(f"pva://{pva_prefix}")
+
+    def get_device(self, protocol: str) -> EpicsTestCaDevice | EpicsTestPvaDevice:
+        return getattr(self, f"{protocol}_device")
+
+    def get_signal(self, protocol: str, name: str) -> SignalRW:
+        return getattr(self.get_device(protocol), name)
+
+    def get_pv(self, protocol: str, name: str) -> str:
+        return f"{protocol}://{self.prefix}{protocol}:{name}"

ophyd_async/epics/testing/_utils.py

@@ -5,50 +5,31 @@ import sys
 import time
 from pathlib import Path
 
-from aioca import purge_channel_caches
 
-from ophyd_async.core import Device
-
-
-def generate_random_PV_prefix() -> str:
+def generate_random_pv_prefix() -> str:
+    """For generating random PV names in test devices."""
     return "".join(random.choice(string.ascii_lowercase) for _ in range(12)) + ":"
 
 
 class TestingIOC:
-    _dbs: dict[type[Device], list[Path]] = {}
-    _prefixes: dict[type[Device], str] = {}
-
-    @classmethod
-    def with_database(cls, db: Path | str):  # use as a decorator
-        def inner(device_cls: type[Device]):
-            cls.database_for(db, device_cls)
-            return device_cls
-
-        return inner
+    """For initialising an IOC in tests."""
 
-    @classmethod
-    def database_for(cls, db, device_cls):
-        path = Path(db)
-        if not path.is_file():
-            raise OSError(f"{path} is not a file.")
-        if device_cls not in cls._dbs:
-            cls._dbs[device_cls] = []
-        cls._dbs[device_cls].append(path)
+    def __init__(self):
+        self._db_macros: list[tuple[Path, dict[str, str]]] = []
+        self.output = ""
 
-    def prefix_for(self, device_cls):
-        # generate random prefix, return existing if already generated
-        return self._prefixes.setdefault(device_cls, generate_random_PV_prefix())
+    def add_database(self, db: Path | str, /, **macros: str):
+        self._db_macros.append((Path(db), macros))
 
-    def start_ioc(self):
+    def start(self):
         ioc_args = [
             sys.executable,
             "-m",
             "epicscorelibs.ioc",
         ]
-        for device_cls, dbs in self._dbs.items():
-            prefix = self.prefix_for(device_cls)
-            for db in dbs:
-                ioc_args += ["-m", f"device={prefix}", "-d", str(db)]
+        for db, macros in self._db_macros:
+            macro_str = ",".join(f"{k}={v}" for k, v in macros.items())
+            ioc_args += ["-m", macro_str, "-d", str(db)]
         self._process = subprocess.Popen(
             ioc_args,
             stdin=subprocess.PIPE,
@@ -56,23 +37,17 @@ class TestingIOC:
             stderr=subprocess.STDOUT,
             universal_newlines=True,
         )
+        assert self._process.stdout  # noqa: S101 # this is to make Pylance happy
         start_time = time.monotonic()
-        while "iocRun: All initialization complete" not in (
-            self._process.stdout.readline().strip()  # type: ignore
-        ):
+        while "iocRun: All initialization complete" not in self.output:
             if time.monotonic() - start_time > 10:
-                try:
-                    print(self._process.communicate("exit()")[0])
-                except ValueError:
-                    # Someone else already called communicate
-                    pass
-                raise TimeoutError("IOC did not start in time")
+                self.stop()
+                raise TimeoutError(f"IOC did not start in time:\n{self.output}")
+            self.output += self._process.stdout.readline()
 
-    def stop_ioc(self):
-        # close backend caches before the event loop
-        purge_channel_caches()
+    def stop(self):
         try:
-            print(self._process.communicate("exit()")[0])
+            self.output += self._process.communicate("exit()")[0]
         except ValueError:
             # Someone else already called communicate
             pass

ophyd_async/epics/testing/test_records.db

@@ -96,6 +96,22 @@ record(mbbo, "$(device)enum2") {
   field(PINI, "YES")
 }
 
+record(mbbo, "$(device)subset_enum") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(mbbo, "$(device)enum_str_fallback") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
 record(waveform, "$(device)uint8a") {
   field(NELM, "3")
   field(FTVL, "UCHAR")

ophyd_async/epics/testing/test_records_pva.db

@@ -1,36 +1,37 @@
 record(waveform, "$(device)int8a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "CHAR")
-  field(INP, {const:[-128, 127]})
+  field(INP, {const:[-128, 127, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
 record(waveform, "$(device)uint16a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "USHORT")
-  field(INP, {const:[0, 65535]})
+  field(INP, {const:[0, 65535, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
 record(waveform, "$(device)uint32a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "ULONG")
-  field(INP, {const:[0, 4294967295]})
+  field(INP, {const:[0, 4294967295, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
 record(waveform, "$(device)int64a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "INT64")
-  # Can't do 64-bit int with JSON numbers in a const link...
-  field(INP, {const:[-2147483649, 2147483648]})
+  # limit of range appears to be +/-(2^63 - 1)
+  field(INP, {const:[-9223372036854775807, 9223372036854775807, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
 record(waveform, "$(device)uint64a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "UINT64")
-  field(INP, {const:[0, 4294967297]})
+  # limit of range appears to be 0 to +(2^63 - 1)
+  field(INP, {const:[0, 9223372036854775807, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
@@ -58,7 +59,7 @@ record(waveform, "$(device)table:bool")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.bool": {
+            "value.a_bool": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 1
@@ -75,7 +76,7 @@ record(waveform, "$(device)table:int")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.int": {
+            "value.a_int": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 2
@@ -92,7 +93,7 @@ record(waveform, "$(device)table:float")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.float": {
+            "value.a_float": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 3
@@ -109,7 +110,7 @@ record(waveform, "$(device)table:str")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.str": {
+            "value.a_str": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 4
@@ -126,7 +127,7 @@ record(waveform, "$(device)table:enum")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.enum": {
+            "value.a_enum": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 5,

ophyd_async/fastcs/__init__.py

@@ -0,0 +1 @@
+"""FastCS support for Signals via EPICS or Tango, and Devices that use them."""