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

ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,8 +1,6 @@
 import asyncio
 
 from ophyd_async.core import (
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
 )
@@ -11,56 +9,44 @@ 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,
 }
 
 
-class VimbaController(DetectorController):
+class VimbaController(adcore.ADBaseController[VimbaDriverIO]):
     def __init__(
         self,
         driver: VimbaDriverIO,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
-        self._drv = driver
-        self._arm_status: AsyncStatus | None = None
+        super().__init__(driver, good_states=good_states)
 
     def get_deadtime(self, exposure: float | None) -> float:
         return 0.001
 
     async def prepare(self, trigger_info: TriggerInfo):
         await asyncio.gather(
-            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.driver.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
+            self.driver.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.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)
+            await self.driver.acquire_time.set(trigger_info.livetime)
+        if trigger_info.trigger != DetectorTrigger.INTERNAL:
+            self.driver.trigger_source.set(VimbaTriggerSource.LINE1)
         else:
-            self._drv.trigger_source.set(VimbaTriggerSource.freerun)
-
-    async def arm(self):
-        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
-            self._drv
-        )
-
-    async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
-
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)
+            self.driver.trigger_source.set(VimbaTriggerSource.FREERUN)

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/_aioca.py

@@ -35,12 +35,14 @@ from ophyd_async.core import (
 
 from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
+logger = logging.getLogger("ophyd_async")
+
 
 def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
     def get_limits(limit: str) -> LimitsRange | None:
         low = getattr(value, f"lower_{limit}_limit", nan)
         high = getattr(value, f"upper_{limit}_limit", nan)
-        if not (isnan(low) and isnan(high)):
+        if not (isnan(low) and isnan(high)) and not high == low == 0:
             return LimitsRange(
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
@@ -59,14 +61,20 @@ def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
 
 
 def _metadata_from_augmented_value(
-    value: AugmentedValue, metadata: SignalMetadata
+    datatype: type[SignalDatatypeT] | None,
+    value: AugmentedValue,
+    metadata: SignalMetadata,
 ) -> SignalMetadata:
     metadata = metadata.copy()
-    if hasattr(value, "units"):
+    if hasattr(value, "units") and datatype not in (str, bool):
         metadata["units"] = value.units
-    if hasattr(value, "precision") and not isnan(value.precision):
+    if (
+        hasattr(value, "precision")
+        and not isnan(value.precision)
+        and datatype is not int
+    ):
         metadata["precision"] = value.precision
-    if limits := _limits_from_augmented_value(value):
+    if (limits := _limits_from_augmented_value(value)) and datatype is not bool:
         metadata["limits"] = limits
     return metadata
 
@@ -100,6 +108,11 @@ class DisconnectedCaConverter(CaConverter):
         raise NotImplementedError("No PV has been set as connect() has not been called")
 
 
+class CaIntConverter(CaConverter[int]):
+    def value(self, value: AugmentedValue) -> int:
+        return int(value)  # type: ignore
+
+
 class CaArrayConverter(CaConverter[np.ndarray]):
     def value(self, value: AugmentedValue) -> np.ndarray:
         # A less expensive conversion
@@ -202,7 +215,7 @@ def make_converter(
         and get_unique({k: v.precision for k, v in values.items()}, "precision") == 0
     ):
         # Allow int signals to represent float records when prec is 0
-        return CaConverter(int, pv_dbr)
+        return CaIntConverter(int, pv_dbr)
     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, pv_dbr)
@@ -247,7 +260,7 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
                 pv, format=FORMAT_CTRL, timeout=timeout
             )
         except CANothing as exc:
-            logging.debug(f"signal ca://{pv} timed out")
+            logger.debug(f"signal ca://{pv} timed out")
             raise NotConnected(f"ca://{pv}") from exc
 
     async def connect(self, timeout: float):
@@ -280,17 +293,33 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
             write_value = self.initial_values[self.write_pv]
         else:
             write_value = self.converter.write_value(value)
-        await caput(
-            self.write_pv,
-            write_value,
-            datatype=self.converter.write_dbr,
-            wait=wait,
-            timeout=None,
-        )
+        try:
+            await caput(
+                self.write_pv,
+                write_value,
+                datatype=self.converter.write_dbr,
+                wait=wait,
+                timeout=None,
+            )
+        except CANothing as exc:
+            # If we ran into a write error, check to see if there is a list
+            # of valid choices, and if the value we tried to write is in that list.
+            valid_choices = self.converter.metadata.get("choices")
+            if valid_choices:
+                if value not in valid_choices:
+                    msg = (
+                        f"{value} is not a valid choice for {self.write_pv}, "
+                        f"valid choices: {self.converter.metadata.get('choices')}"
+                    )
+                    raise ValueError(msg) from exc
+                raise
+            raise
 
     async def get_datakey(self, source: str) -> DataKey:
         value = await self._caget(self.read_pv, FORMAT_CTRL)
-        metadata = _metadata_from_augmented_value(value, self.converter.metadata)
+        metadata = _metadata_from_augmented_value(
+            self.datatype, value, self.converter.metadata
+        )
         return make_datakey(
             self.converter.datatype, self.converter.value(value), source, metadata
         )
@@ -308,16 +337,18 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         return self.converter.value(value)
 
     def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
+        if callback and self.subscription:
+            msg = "Cannot set a callback when one is already set"
+            raise RuntimeError(msg)
+
+        if self.subscription:
+            self.subscription.close()
+            self.subscription = None
+
         if callback:
-            assert (
-                not self.subscription
-            ), "Cannot set a callback when one is already set"
             self.subscription = camonitor(
                 self.read_pv,
                 lambda v: callback(self._make_reading(v)),
                 datatype=self.converter.read_dbr,
                 format=FORMAT_TIME,
             )
-        elif self.subscription:
-            self.subscription.close()
-            self.subscription = None

ophyd_async/epics/core/_p4p.py

@@ -31,6 +31,8 @@ from ophyd_async.core import (
 
 from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
+logger = logging.getLogger("ophyd_async")
+
 
 def _limits_from_value(value: Any) -> Limits:
     def get_limits(
@@ -39,7 +41,7 @@ def _limits_from_value(value: Any) -> Limits:
         substructure = getattr(value, substucture_name, None)
         low = getattr(substructure, low_name, nan)
         high = getattr(substructure, high_name, nan)
-        if not (isnan(low) and isnan(high)):
+        if not (isnan(low) and isnan(high)) and not low == high == 0:
             return LimitsRange(
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
@@ -60,12 +62,22 @@ def _limits_from_value(value: Any) -> Limits:
 def _metadata_from_value(datatype: type[SignalDatatype], value: Any) -> SignalMetadata:
     metadata = SignalMetadata()
     value_data: Any = getattr(value, "value", None)
+    specifier = _get_specifier(value)
     display_data: Any = getattr(value, "display", None)
-    if hasattr(display_data, "units"):
+    if (
+        hasattr(display_data, "units")
+        and specifier[-1] in _number_specifiers
+        and datatype is not str
+    ):
         metadata["units"] = display_data.units
-    if hasattr(display_data, "precision") and not isnan(display_data.precision):
+    if (
+        hasattr(display_data, "precision")
+        and not isnan(display_data.precision)
+        and specifier[-1] in _float_specifiers
+        and datatype is not int
+    ):
         metadata["precision"] = display_data.precision
-    if limits := _limits_from_value(value):
+    if (limits := _limits_from_value(value)) and specifier[-1] in _number_specifiers:
         metadata["limits"] = limits
     # Get choices from display or value
     if datatype is str or issubclass(datatype, StrictEnum):
@@ -84,9 +96,7 @@ class PvaConverter(Generic[SignalDatatypeT]):
         self.datatype = datatype
 
     def value(self, value: Any) -> SignalDatatypeT:
-        # for channel access ca_xxx classes, this
-        # invokes __pos__ operator to return an instance of
-        # the builtin base class
+        # Normally the value will be of the correct python type
         return value["value"]
 
     def write_value(self, value: Any) -> Any:
@@ -94,6 +104,31 @@ class PvaConverter(Generic[SignalDatatypeT]):
         return value
 
 
+class PvaIntConverter(PvaConverter[int]):
+    def __init__(self):
+        super().__init__(int)
+
+    def value(self, value: Any) -> int:
+        # Convert to an int
+        return int(value["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")
@@ -158,6 +193,9 @@ class PvaTableConverter(PvaConverter[Table]):
 
 
 # https://mdavidsaver.github.io/p4p/values.html
+_float_specifiers = {"f", "d"}
+_int_specifiers = {"b", "B", "h", "H", "i", "I", "l", "L"}
+_number_specifiers = _float_specifiers.union(_int_specifiers)
 _datatype_converter_from_typeid: dict[
     tuple[str, str], tuple[type[SignalDatatype], type[PvaConverter]]
 ] = {
@@ -192,7 +230,7 @@ _datatype_converter_from_typeid: dict[
 }
 
 
-def _get_specifier(value: Value):
+def _get_specifier(value: Value) -> str:
     typ = value.type("value").aspy()
     if isinstance(typ, tuple):
         return typ[0]
@@ -242,7 +280,7 @@ def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverte
         == 0
     ):
         # Allow int signals to represent float records when prec is 0
-        return PvaConverter(int)
+        return PvaIntConverter()
     elif inferred_datatype is str and (enum_cls := get_enum_cls(datatype)):
         # Allow strings to be used as enums until QSRV supports this
         return PvaConverter(str)
@@ -252,6 +290,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=}"
@@ -282,7 +323,7 @@ async def pvget_with_timeout(pv: str, timeout: float) -> Any:
     try:
         return await asyncio.wait_for(context().get(pv), timeout=timeout)
     except asyncio.TimeoutError as exc:
-        logging.debug(f"signal pva://{pv} timed out", exc_info=True)
+        logger.debug(f"signal pva://{pv} timed out", exc_info=True)
         raise NotConnected(f"pva://{pv}") from exc
 
 
@@ -364,10 +405,15 @@ class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         return self.converter.value(value)
 
     def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
+        if callback and self.subscription:
+            msg = "Cannot set a callback when one is already set"
+            raise RuntimeError(msg)
+
+        if self.subscription:
+            self.subscription.close()
+            self.subscription = None
+
         if callback:
-            assert (
-                not self.subscription
-            ), "Cannot set a callback when one is already set"
 
             async def async_callback(v):
                 callback(self._make_reading(v))
@@ -378,6 +424,3 @@ class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
             self.subscription = context().monitor(
                 self.read_pv, async_callback, request=request
             )
-        elif self.subscription:
-            self.subscription.close()
-            self.subscription = None

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,
@@ -38,7 +47,7 @@ def get_supported_values(
 
 
 def format_datatype(datatype: Any) -> str:
-    if get_origin(datatype) is np.ndarray and get_args(datatype)[0] == tuple[int]:
+    if get_origin(datatype) is np.ndarray and get_args(datatype):
         dtype = get_dtype(datatype)
         return f"Array1D[np.{dtype.name}]"
     elif get_origin(datatype) is Sequence:

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):
@@ -63,6 +63,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         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")
@@ -76,7 +77,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 +95,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)
 
@@ -122,9 +126,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
@@ -132,7 +136,9 @@ 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
@@ -152,13 +158,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,7 +189,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