ophyd-async 0.8.0a6__py3-none-any.whl → 0.9.0a1__py3-none-any.whl

ophyd_async/epics/adcore/_core_logic.py

@@ -14,7 +14,7 @@ from ._core_io import ADBaseIO, DetectorState
 # Default set of states that we should consider "good" i.e. the acquisition
 #  is complete and went well
 DEFAULT_GOOD_STATES: frozenset[DetectorState] = frozenset(
-    [DetectorState.Idle, DetectorState.Aborted]
+    [DetectorState.IDLE, DetectorState.ABORTED]
 )
 
 
@@ -102,7 +102,8 @@ async def start_acquiring_driver_and_ensure_status(
         state = await driver.detector_state.get_value()
         if state not in good_states:
             raise ValueError(
-                f"Final detector state {state} not in valid end states: {good_states}"
+                f"Final detector state {state.value} not in valid end "
+                f"states: {good_states}"
             )
 
     return AsyncStatus(complete_acquisition())

ophyd_async/epics/adcore/_hdf_writer.py

@@ -20,7 +20,7 @@ from ophyd_async.core import (
     wait_for_value,
 )
 
-from ._core_io import NDArrayBaseIO, NDFileHDFIO
+from ._core_io import Callback, NDArrayBaseIO, NDFileHDFIO
 from ._utils import (
     FileWriteMode,
     convert_param_dtype_to_np,
@@ -67,10 +67,11 @@ class ADHDFWriter(DetectorWriter):
             self.hdf.file_path.set(str(info.directory_path)),
             self.hdf.file_name.set(info.filename),
             self.hdf.file_template.set("%s/%s.h5"),
-            self.hdf.file_write_mode.set(FileWriteMode.stream),
+            self.hdf.file_write_mode.set(FileWriteMode.STREAM),
             # Never use custom xml layout file but use the one defined
             # in the source code file NDFileHDF5LayoutXML.cpp
             self.hdf.xml_file_name.set(""),
+            self.hdf.enable_callbacks.set(Callback.ENABLE),
         )
 
         assert (
@@ -80,7 +81,9 @@ class ADHDFWriter(DetectorWriter):
         # Overwrite num_capture to go forever
         await self.hdf.num_capture.set(0)
         # Wait for it to start, stashing the status that tells us when it finishes
-        self._capture_status = await set_and_wait_for_value(self.hdf.capture, True)
+        self._capture_status = await set_and_wait_for_value(
+            self.hdf.capture, True, wait_for_set_completion=False
+        )
         name = self._name_provider()
         detector_shape = await self._dataset_describer.shape()
         np_dtype = await self._dataset_describer.np_datatype()

ophyd_async/epics/adcore/_single_trigger.py

@@ -34,7 +34,7 @@ class SingleTriggerDetector(StandardReadable, Triggerable):
     @AsyncStatus.wrap
     async def stage(self) -> None:
         await asyncio.gather(
-            self.drv.image_mode.set(ImageMode.single),
+            self.drv.image_mode.set(ImageMode.SINGLE),
             self.drv.wait_for_plugins.set(True),
         )
         await super().stage()

ophyd_async/epics/adcore/_utils.py

@@ -11,42 +11,42 @@ from ophyd_async.core import (
 
 
 class ADBaseDataType(StrictEnum):
-    Int8 = "Int8"
-    UInt8 = "UInt8"
-    Int16 = "Int16"
-    UInt16 = "UInt16"
-    Int32 = "Int32"
-    UInt32 = "UInt32"
-    Int64 = "Int64"
-    UInt64 = "UInt64"
-    Float32 = "Float32"
-    Float64 = "Float64"
+    INT8 = "Int8"
+    UINT8 = "UInt8"
+    INT16 = "Int16"
+    UINT16 = "UInt16"
+    INT32 = "Int32"
+    UINT32 = "UInt32"
+    INT64 = "Int64"
+    UINT64 = "UInt64"
+    FLOAT32 = "Float32"
+    FLOAT64 = "Float64"
 
 
 def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
     ad_dtype_to_np_dtype = {
-        ADBaseDataType.Int8: "|i1",
-        ADBaseDataType.UInt8: "|u1",
-        ADBaseDataType.Int16: "<i2",
-        ADBaseDataType.UInt16: "<u2",
-        ADBaseDataType.Int32: "<i4",
-        ADBaseDataType.UInt32: "<u4",
-        ADBaseDataType.Int64: "<i8",
-        ADBaseDataType.UInt64: "<u8",
-        ADBaseDataType.Float32: "<f4",
-        ADBaseDataType.Float64: "<f8",
+        ADBaseDataType.INT8: "|i1",
+        ADBaseDataType.UINT8: "|u1",
+        ADBaseDataType.INT16: "<i2",
+        ADBaseDataType.UINT16: "<u2",
+        ADBaseDataType.INT32: "<i4",
+        ADBaseDataType.UINT32: "<u4",
+        ADBaseDataType.INT64: "<i8",
+        ADBaseDataType.UINT64: "<u8",
+        ADBaseDataType.FLOAT32: "<f4",
+        ADBaseDataType.FLOAT64: "<f8",
     }
     return ad_dtype_to_np_dtype[ad_dtype]
 
 
 def convert_pv_dtype_to_np(datatype: str) -> str:
     _pvattribute_to_ad_datatype = {
-        "DBR_SHORT": ADBaseDataType.Int16,
-        "DBR_ENUM": ADBaseDataType.Int16,
-        "DBR_INT": ADBaseDataType.Int32,
-        "DBR_LONG": ADBaseDataType.Int32,
-        "DBR_FLOAT": ADBaseDataType.Float32,
-        "DBR_DOUBLE": ADBaseDataType.Float64,
+        "DBR_SHORT": ADBaseDataType.INT16,
+        "DBR_ENUM": ADBaseDataType.INT16,
+        "DBR_INT": ADBaseDataType.INT32,
+        "DBR_LONG": ADBaseDataType.INT32,
+        "DBR_FLOAT": ADBaseDataType.FLOAT32,
+        "DBR_DOUBLE": ADBaseDataType.FLOAT64,
     }
     if datatype in ["DBR_STRING", "DBR_CHAR"]:
         np_datatype = "s40"
@@ -62,9 +62,9 @@ def convert_pv_dtype_to_np(datatype: str) -> str:
 
 def convert_param_dtype_to_np(datatype: str) -> str:
     _paramattribute_to_ad_datatype = {
-        "INT": ADBaseDataType.Int32,
-        "INT64": ADBaseDataType.Int64,
-        "DOUBLE": ADBaseDataType.Float64,
+        "INT": ADBaseDataType.INT32,
+        "INT64": ADBaseDataType.INT64,
+        "DOUBLE": ADBaseDataType.FLOAT64,
     }
     if datatype in ["STRING"]:
         np_datatype = "s40"
@@ -79,15 +79,15 @@ def convert_param_dtype_to_np(datatype: str) -> str:
 
 
 class FileWriteMode(StrictEnum):
-    single = "Single"
-    capture = "Capture"
-    stream = "Stream"
+    SINGLE = "Single"
+    CAPTURE = "Capture"
+    STREAM = "Stream"
 
 
 class ImageMode(StrictEnum):
-    single = "Single"
-    multiple = "Multiple"
-    continuous = "Continuous"
+    SINGLE = "Single"
+    MULTIPLE = "Multiple"
+    CONTINUOUS = "Continuous"
 
 
 class NDAttributeDataType(StrictEnum):

ophyd_async/epics/adkinetix/_kinetix_controller.py

@@ -11,10 +11,10 @@ from ophyd_async.epics import adcore
 from ._kinetix_io import KinetixDriverIO, KinetixTriggerMode
 
 KINETIX_TRIGGER_MODE_MAP = {
-    DetectorTrigger.internal: KinetixTriggerMode.internal,
-    DetectorTrigger.constant_gate: KinetixTriggerMode.gate,
-    DetectorTrigger.variable_gate: KinetixTriggerMode.gate,
-    DetectorTrigger.edge_trigger: KinetixTriggerMode.edge,
+    DetectorTrigger.INTERNAL: KinetixTriggerMode.INTERNAL,
+    DetectorTrigger.CONSTANT_GATE: KinetixTriggerMode.GATE,
+    DetectorTrigger.VARIABLE_GATE: KinetixTriggerMode.GATE,
+    DetectorTrigger.EDGE_TRIGGER: KinetixTriggerMode.EDGE,
 }
 
 
@@ -33,11 +33,11 @@ class KinetixController(DetectorController):
         await asyncio.gather(
             self._drv.trigger_mode.set(KINETIX_TRIGGER_MODE_MAP[trigger_info.trigger]),
             self._drv.num_images.set(trigger_info.total_number_of_triggers),
-            self._drv.image_mode.set(adcore.ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
-            DetectorTrigger.variable_gate,
-            DetectorTrigger.constant_gate,
+            DetectorTrigger.VARIABLE_GATE,
+            DetectorTrigger.CONSTANT_GATE,
         ]:
             await self._drv.acquire_time.set(trigger_info.livetime)
 

ophyd_async/epics/adkinetix/_kinetix_io.py

@@ -4,16 +4,16 @@ from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class KinetixTriggerMode(StrictEnum):
-    internal = "Internal"
-    edge = "Rising Edge"
-    gate = "Exp. Gate"
+    INTERNAL = "Internal"
+    EDGE = "Rising Edge"
+    GATE = "Exp. Gate"
 
 
 class KinetixReadoutMode(StrictEnum):
-    sensitivity = 1
-    speed = 2
-    dynamic_range = 3
-    sub_electron = 4
+    SENSITIVITY = 1
+    SPEED = 2
+    DYNAMIC_RANGE = 3
+    SUB_ELECTRON = 4
 
 
 class KinetixDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adpilatus/_pilatus.py

@@ -17,10 +17,10 @@ class PilatusReadoutTime(float, Enum):
     """Pilatus readout time per model in ms"""
 
     # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
-    pilatus2 = 2.28e-3
+    PILATUS2 = 2.28e-3
 
     # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
-    pilatus3 = 0.95e-3
+    PILATUS3 = 0.95e-3
 
 
 class PilatusDetector(StandardDetector):
@@ -33,7 +33,7 @@ class PilatusDetector(StandardDetector):
         self,
         prefix: str,
         path_provider: PathProvider,
-        readout_time: PilatusReadoutTime = PilatusReadoutTime.pilatus3,
+        readout_time: PilatusReadoutTime = PilatusReadoutTime.PILATUS3,
         drv_suffix: str = "cam1:",
         hdf_suffix: str = "HDF1:",
         name: str = "",

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -15,9 +15,9 @@ from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 class PilatusController(DetectorController):
     _supported_trigger_types = {
-        DetectorTrigger.internal: PilatusTriggerMode.internal,
-        DetectorTrigger.constant_gate: PilatusTriggerMode.ext_enable,
-        DetectorTrigger.variable_gate: PilatusTriggerMode.ext_enable,
+        DetectorTrigger.INTERNAL: PilatusTriggerMode.INTERNAL,
+        DetectorTrigger.CONSTANT_GATE: PilatusTriggerMode.EXT_ENABLE,
+        DetectorTrigger.VARIABLE_GATE: PilatusTriggerMode.EXT_ENABLE,
     }
 
     def __init__(
@@ -44,7 +44,7 @@ class PilatusController(DetectorController):
                 if trigger_info.total_number_of_triggers == 0
                 else trigger_info.total_number_of_triggers
             ),
-            self._drv.image_mode.set(adcore.ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
 
     async def arm(self):

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -4,11 +4,11 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv
 
 
 class PilatusTriggerMode(StrictEnum):
-    internal = "Internal"
-    ext_enable = "Ext. Enable"
-    ext_trigger = "Ext. Trigger"
-    mult_trigger = "Mult. Trigger"
-    alignment = "Alignment"
+    INTERNAL = "Internal"
+    EXT_ENABLE = "Ext. Enable"
+    EXT_TRIGGER = "Ext. Trigger"
+    MULT_TRIGGER = "Mult. Trigger"
+    ALIGNMENT = "Alignment"
 
 
 class PilatusDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adsimdetector/_sim_controller.py

@@ -26,14 +26,14 @@ class SimController(DetectorController):
 
     async def prepare(self, trigger_info: TriggerInfo):
         assert (
-            trigger_info.trigger == DetectorTrigger.internal
+            trigger_info.trigger == DetectorTrigger.INTERNAL
         ), "fly scanning (i.e. external triggering) is not supported for this device"
         self.frame_timeout = (
             DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
         )
         await asyncio.gather(
             self.driver.num_images.set(trigger_info.total_number_of_triggers),
-            self.driver.image_mode.set(adcore.ImageMode.multiple),
+            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
 
     async def arm(self):

ophyd_async/epics/advimba/_vimba_controller.py

@@ -11,17 +11,17 @@ from ophyd_async.epics import adcore
 from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
 
 TRIGGER_MODE = {
-    DetectorTrigger.internal: VimbaOnOff.off,
-    DetectorTrigger.constant_gate: VimbaOnOff.on,
-    DetectorTrigger.variable_gate: VimbaOnOff.on,
-    DetectorTrigger.edge_trigger: VimbaOnOff.on,
+    DetectorTrigger.INTERNAL: VimbaOnOff.OFF,
+    DetectorTrigger.CONSTANT_GATE: VimbaOnOff.ON,
+    DetectorTrigger.VARIABLE_GATE: VimbaOnOff.ON,
+    DetectorTrigger.EDGE_TRIGGER: VimbaOnOff.ON,
 }
 
 EXPOSE_OUT_MODE = {
-    DetectorTrigger.internal: VimbaExposeOutMode.timed,
-    DetectorTrigger.constant_gate: VimbaExposeOutMode.trigger_width,
-    DetectorTrigger.variable_gate: VimbaExposeOutMode.trigger_width,
-    DetectorTrigger.edge_trigger: VimbaExposeOutMode.timed,
+    DetectorTrigger.INTERNAL: VimbaExposeOutMode.TIMED,
+    DetectorTrigger.CONSTANT_GATE: VimbaExposeOutMode.TRIGGER_WIDTH,
+    DetectorTrigger.VARIABLE_GATE: VimbaExposeOutMode.TRIGGER_WIDTH,
+    DetectorTrigger.EDGE_TRIGGER: VimbaExposeOutMode.TIMED,
 }
 
 
@@ -41,17 +41,17 @@ class VimbaController(DetectorController):
             self._drv.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
             self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
             self._drv.num_images.set(trigger_info.total_number_of_triggers),
-            self._drv.image_mode.set(adcore.ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
-            DetectorTrigger.variable_gate,
-            DetectorTrigger.constant_gate,
+            DetectorTrigger.VARIABLE_GATE,
+            DetectorTrigger.CONSTANT_GATE,
         ]:
             await self._drv.acquire_time.set(trigger_info.livetime)
-        if trigger_info.trigger != DetectorTrigger.internal:
-            self._drv.trigger_source.set(VimbaTriggerSource.line1)
+        if trigger_info.trigger != DetectorTrigger.INTERNAL:
+            self._drv.trigger_source.set(VimbaTriggerSource.LINE1)
         else:
-            self._drv.trigger_source.set(VimbaTriggerSource.freerun)
+            self._drv.trigger_source.set(VimbaTriggerSource.FREERUN)
 
     async def arm(self):
         self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(

ophyd_async/epics/advimba/_vimba_io.py

@@ -4,44 +4,44 @@ from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class VimbaPixelFormat(StrictEnum):
-    internal = "Mono8"
-    ext_enable = "Mono12"
-    ext_trigger = "Ext. Trigger"
-    mult_trigger = "Mult. Trigger"
-    alignment = "Alignment"
+    INTERNAL = "Mono8"
+    EXT_ENABLE = "Mono12"
+    EXT_TRIGGER = "Ext. Trigger"
+    MULT_TRIGGER = "Mult. Trigger"
+    ALIGNMENT = "Alignment"
 
 
 class VimbaConvertFormat(StrictEnum):
-    none = "None"
-    mono8 = "Mono8"
-    mono16 = "Mono16"
-    rgb8 = "RGB8"
-    rgb16 = "RGB16"
+    NONE = "None"
+    MONO8 = "Mono8"
+    MONO16 = "Mono16"
+    RGB8 = "RGB8"
+    RGB16 = "RGB16"
 
 
 class VimbaTriggerSource(StrictEnum):
-    freerun = "Freerun"
-    line1 = "Line1"
-    line2 = "Line2"
-    fixed_rate = "FixedRate"
-    software = "Software"
-    action0 = "Action0"
-    action1 = "Action1"
+    FREERUN = "Freerun"
+    LINE1 = "Line1"
+    LINE2 = "Line2"
+    FIXED_RATE = "FixedRate"
+    SOFTWARE = "Software"
+    ACTION0 = "Action0"
+    ACTION1 = "Action1"
 
 
 class VimbaOverlap(StrictEnum):
-    off = "Off"
-    prev_frame = "PreviousFrame"
+    OFF = "Off"
+    PREV_FRAME = "PreviousFrame"
 
 
 class VimbaOnOff(StrictEnum):
-    on = "On"
-    off = "Off"
+    ON = "On"
+    OFF = "Off"
 
 
 class VimbaExposeOutMode(StrictEnum):
-    timed = "Timed"  # Use ExposureTime PV
-    trigger_width = "TriggerWidth"  # Expose for length of high signal
+    TIMED = "Timed"  # Use ExposureTime PV
+    TRIGGER_WIDTH = "TriggerWidth"  # Expose for length of high signal
 
 
 class VimbaDriverIO(adcore.ADBaseIO):

ophyd_async/epics/core/_p4p.py

@@ -94,6 +94,22 @@ class PvaConverter(Generic[SignalDatatypeT]):
         return value
 
 
+class PvaLongStringConverter(PvaConverter[str]):
+    def __init__(self):
+        super().__init__(str)
+
+    def value(self, value: Any) -> Any:
+        # Value here is a null terminated array of ascii codes.
+        # We strip out the null terminator, and convert each code
+        # to the corresponding char, joining into a string
+        return value["value"].tobytes().rstrip(b"\0").decode()
+
+    def write_value(self, value: Any) -> Any:
+        # Inverse of reading - convert each character into it's ascii code,
+        # put into a list, and add null terminator.
+        return np.frombuffer(str(value).encode() + b"\0", dtype=np.int8)
+
+
 class DisconnectedPvaConverter(PvaConverter):
     def __getattribute__(self, __name: str) -> Any:
         raise NotImplementedError("No PV has been set as connect() has not been called")
@@ -252,6 +268,9 @@ def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverte
     elif datatype in (None, inferred_datatype):
         # If datatype matches what we are given then allow it and use inferred converter
         return converter_cls(inferred_datatype)
+    # Allow waveforms with FTVL=CHAR to be treated as str when requested
+    elif datatype is str and inferred_datatype == Array1D[np.int8]:
+        return PvaLongStringConverter()
     raise TypeError(
         f"{pv} with inferred datatype {format_datatype(inferred_datatype)}"
         f" from {typeid=} {specifier=}"

ophyd_async/epics/core/_pvi_connector.py

@@ -32,10 +32,11 @@ def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
 
 
 class PviDeviceConnector(DeviceConnector):
-    def __init__(self, prefix: str = "") -> None:
+    def __init__(self, prefix: str = "", error_hint: str = "") -> None:
         # TODO: what happens if we get a leading "pva://" here?
         self.prefix = prefix
         self.pvi_pv = prefix + "PVI"
+        self.error_hint = error_hint
 
     def create_children_from_annotations(self, device: Device):
         if not hasattr(self, "filler"):
@@ -85,7 +86,8 @@ class PviDeviceConnector(DeviceConnector):
                     if e:
                         self._fill_child(name, e, i)
         # Check that all the requested children have been filled
-        self.filler.check_filled(f"{self.pvi_pv}: {entries}")
+        suffix = f"\n{self.error_hint}" if self.error_hint else ""
+        self.filler.check_filled(f"{self.pvi_pv}: {entries}{suffix}")
         # Set the name of the device to name all children
         device.set_name(device.name)
         return await super().connect_real(device, timeout, force_reconnect)

ophyd_async/epics/core/_signal.py

@@ -14,7 +14,7 @@ from ophyd_async.core import (
     get_unique,
 )
 
-from ._util import EpicsSignalBackend
+from ._util import EpicsSignalBackend, get_pv_basename_and_field
 
 
 class EpicsProtocol(Enum):
@@ -124,7 +124,14 @@ def epics_signal_rw_rbv(
     read_suffix:
         Append this suffix to the write pv to create the readback pv
     """
-    return epics_signal_rw(datatype, f"{write_pv}{read_suffix}", write_pv, name)
+
+    base_pv, field = get_pv_basename_and_field(write_pv)
+    if field is not None:
+        read_pv = f"{base_pv}{read_suffix}.{field}"
+    else:
+        read_pv = f"{write_pv}{read_suffix}"
+
+    return epics_signal_rw(datatype, read_pv, write_pv, name)
 
 
 def epics_signal_r(

ophyd_async/epics/core/_util.py

@@ -12,6 +12,15 @@ from ophyd_async.core import (
 )
 
 
+def get_pv_basename_and_field(pv: str) -> tuple[str, str | None]:
+    """Simple utility function for extracting base pv name without field"""
+
+    if "." in pv:
+        return (pv.split(".", -1)[0], pv.split(".", -1)[1])
+    else:
+        return (pv, None)
+
+
 def get_supported_values(
     pv: str,
     datatype: type,

ophyd_async/epics/demo/_mover.py

@@ -37,8 +37,8 @@ class Mover(StandardReadable, Movable, Stoppable):
 
         super().__init__(name=name)
 
-    def set_name(self, name: str):
-        super().set_name(name)
+    def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
+        super().set_name(name, child_name_separator=child_name_separator)
         # Readback should be named the same as its parent in read()
         self.readback.set_name(name)
 

ophyd_async/epics/demo/_sensor.py

@@ -15,9 +15,9 @@ class EnergyMode(StrictEnum):
     """Energy mode for `Sensor`"""
 
     #: Low energy mode
-    low = "Low Energy"
+    LOW = "Low Energy"
     #: High energy mode
-    high = "High Energy"
+    HIGH = "High Energy"
 
 
 class Sensor(StandardReadable, EpicsDevice):

ophyd_async/epics/eiger/_eiger_controller.py

@@ -11,10 +11,10 @@ from ophyd_async.core import (
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
 
 EIGER_TRIGGER_MODE_MAP = {
-    DetectorTrigger.internal: EigerTriggerMode.internal,
-    DetectorTrigger.constant_gate: EigerTriggerMode.gate,
-    DetectorTrigger.variable_gate: EigerTriggerMode.gate,
-    DetectorTrigger.edge_trigger: EigerTriggerMode.edge,
+    DetectorTrigger.INTERNAL: EigerTriggerMode.INTERNAL,
+    DetectorTrigger.CONSTANT_GATE: EigerTriggerMode.GATE,
+    DetectorTrigger.VARIABLE_GATE: EigerTriggerMode.GATE,
+    DetectorTrigger.EDGE_TRIGGER: EigerTriggerMode.EDGE,
 }
 
 

ophyd_async/epics/eiger/_eiger_io.py

@@ -3,9 +3,9 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_si
 
 
 class EigerTriggerMode(StrictEnum):
-    internal = "ints"
-    edge = "exts"
-    gate = "exte"
+    INTERNAL = "ints"
+    EDGE = "exts"
+    GATE = "exte"
 
 
 class EigerDriverIO(Device):

ophyd_async/epics/motor.py

@@ -20,7 +20,7 @@ from ophyd_async.core import (
     observe_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
 
 class MotorLimitsException(Exception):
@@ -76,7 +76,10 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         self.low_limit_travel = epics_signal_rw(float, prefix + ".LLM")
         self.high_limit_travel = epics_signal_rw(float, prefix + ".HLM")
 
-        self.motor_stop = epics_signal_x(prefix + ".STOP")
+        # 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
 
@@ -91,8 +94,8 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
 
         super().__init__(name=name)
 
-    def set_name(self, name: str):
-        super().set_name(name)
+    def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
+        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)
 
@@ -178,7 +181,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         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
-        await self.motor_stop.trigger(wait=False)
+        await self.motor_stop.set(1, wait=False)
 
     async def _prepare_velocity(
         self, start_position: float, end_position: float, time_for_move: float

ophyd_async/epics/testing/_example_ioc.py

@@ -23,9 +23,9 @@ PVA_RECORDS = str(Path(__file__).parent / "test_records_pva.db")
 
 
 class ExampleEnum(StrictEnum):
-    a = "Aaa"
-    b = "Bbb"
-    c = "Ccc"
+    A = "Aaa"
+    B = "Bbb"
+    C = "Ccc"
 
 
 class ExampleTable(Table):
@@ -40,6 +40,8 @@ class ExampleCaDevice(EpicsDevice):
     my_int: A[SignalRW[int], PvSuffix("int")]
     my_float: A[SignalRW[float], PvSuffix("float")]
     my_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")]

ophyd_async/epics/testing/test_records.db

@@ -150,3 +150,9 @@ record(lsi, "$(device)longstr2") {
   field(INP, {const:"a string that is just longer than forty characters"})
   field(PINI, "YES")
 }
+
+record(calc, "$(device)ticking") {
+  field(INPA, "$(device)ticking")
+  field(CALC, "A+1")
+  field(SCAN, ".1 second")
+}