dls-dodal 1.34.1__py3-none-any.whl → 1.36.0__py3-none-any.whl

dodal/devices/focusing_mirror.py

@@ -1,21 +1,19 @@
-from enum import Enum
-
 from ophyd_async.core import (
     AsyncStatus,
-    ConfigSignal,
     Device,
     DeviceVector,
-    HintedSignal,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
     observe_value,
     soft_signal_r_and_setter,
 )
-from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_x,
 )
+from ophyd_async.epics.motor import Motor
 
 from dodal.log import LOGGER
 
@@ -25,20 +23,20 @@ VOLTAGE_POLLING_DELAY_S = 0.5
 DEFAULT_SETTLE_TIME_S = 60
 
 
-class MirrorType(str, Enum):
+class MirrorType(StrictEnum):
     """See https://manual.nexusformat.org/classes/base_classes/NXmirror.html"""
 
     SINGLE = "single"
     MULTI = "multi"
 
 
-class MirrorStripe(str, Enum):
+class MirrorStripe(StrictEnum):
     RHODIUM = "Rhodium"
     BARE = "Bare"
     PLATINUM = "Platinum"
 
 
-class MirrorVoltageDemand(str, Enum):
+class MirrorVoltageDemand(StrictEnum):
     N_A = "N/A"
     OK = "OK"
     FAIL = "FAIL"
@@ -151,8 +149,11 @@ class FocusingMirror(StandardReadable):
         # regardless of orientation of the mirror
         self.incident_angle = Motor(prefix + "PITCH")
 
-        self.add_readables([self.incident_angle.user_readback], wrapper=HintedSignal)
-        self.add_readables([self.type], wrapper=ConfigSignal)
+        self.add_readables(
+            [self.incident_angle.user_readback],
+            format=StandardReadableFormat.HINTED_SIGNAL,
+        )
+        self.add_readables([self.type], format=StandardReadableFormat.CONFIG_SIGNAL)
         super().__init__(name)
 
 

dodal/devices/hutch_shutter.py

@@ -1,13 +1,12 @@
-from enum import Enum
-
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     StandardReadable,
+    StrictEnum,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_w
+from ophyd_async.epics.core import epics_signal_r, epics_signal_w
 
 HUTCH_SAFE_FOR_OPERATIONS = 0  # Hutch is locked and can't be entered
 
@@ -16,13 +15,13 @@ class ShutterNotSafeToOperateError(Exception):
     pass
 
 
-class ShutterDemand(str, Enum):
+class ShutterDemand(StrictEnum):
     OPEN = "Open"
     CLOSE = "Close"
     RESET = "Reset"
 
 
-class ShutterState(str, Enum):
+class ShutterState(StrictEnum):
     FAULT = "Fault"
     OPEN = "Open"
     OPENING = "Opening"

dodal/devices/i10/i10_apple2.py

@@ -2,14 +2,15 @@ import asyncio
 import csv
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, SupportsFloat
 
 import numpy as np
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
-    HintedSignal,
+    Reference,
     StandardReadable,
+    StandardReadableFormat,
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
@@ -118,14 +119,15 @@ class I10Apple2(Apple2):
             name=name,
         )
         with self.add_children_as_readables():
-            self.id_jaw_phase = id_jaw_phase
+            self.id_jaw_phase = Reference(id_jaw_phase)
 
     @AsyncStatus.wrap
-    async def set(self, value: float) -> None:
+    async def set(self, value: SupportsFloat) -> None:
         """
         Check polarisation state and use it together with the energy(value)
         to calculate the required gap and phases before setting it.
         """
+        value = float(value)
         if self.pol is None:
             LOGGER.warning("Polarisation not set attempting to read from hardware")
             pol, phase = await self.determinePhaseFromHardware()
@@ -146,8 +148,8 @@ class I10Apple2(Apple2):
         LOGGER.info(f"Setting polarisation to {self.pol}, with {id_set_val}")
         await self._set(value=id_set_val, energy=value)
         if self.pol != "la":
-            await self.id_jaw_phase.set(0)
-            await self.id_jaw_phase.set_move.set(1)
+            await self.id_jaw_phase().set(0)
+            await self.id_jaw_phase().set_move.set(1)
 
     def update_lookuptable(self):
         """
@@ -195,18 +197,17 @@ class I10Apple2PGM(StandardReadable, Movable):
             New device name.
         """
         super().__init__(name=name)
-        with self.add_children_as_readables():
-            self.id = id
-            self.pgm = pgm
-        with self.add_children_as_readables(HintedSignal):
+        self.id_ref = Reference(id)
+        self.pgm_ref = Reference(pgm)
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.energy_offset = soft_signal_rw(float, initial_value=0)
 
     @AsyncStatus.wrap
     async def set(self, value: float) -> None:
         LOGGER.info(f"Moving f{self.name} energy to {value}.")
         await asyncio.gather(
-            self.id.set(value=value + await self.energy_offset.get_value()),
-            self.pgm.energy.set(value),
+            self.id_ref().set(value=value + await self.energy_offset.get_value()),
+            self.pgm_ref().energy.set(value),
         )
 
 
@@ -273,22 +274,22 @@ class LinearArbitraryAngle(StandardReadable, Movable):
             polynomial parameters highest power first.
         """
         super().__init__(name=name)
-        with self.add_children_as_readables():
-            self.id = id
+        self.id_ref = Reference(id)
         self.jaw_phase_from_angle = np.poly1d(jaw_phase_poly_param)
         self.angle_threshold_deg = angle_threshold_deg
         self.jaw_phase_limit = jaw_phase_limit
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.angle, self._angle_set = soft_signal_r_and_setter(
                 float, initial_value=None
             )
 
     @AsyncStatus.wrap
-    async def set(self, value: float) -> None:
-        pol = self.id.pol
+    async def set(self, value: SupportsFloat) -> None:
+        value = float(value)
+        pol = self.id_ref().pol
         if pol != "la":
             raise RuntimeError(
-                f"Angle control is not available in polarisation {pol} with {self.id.name}"
+                f"Angle control is not available in polarisation {pol} with {self.id_ref().name}"
             )
         # Moving to real angle which is 210 to 30.
         alpha_real = value if value > self.angle_threshold_deg else value + ALPHA_OFFSET
@@ -298,7 +299,7 @@ class LinearArbitraryAngle(StandardReadable, Movable):
                 f"jaw_phase position for angle ({value}) is outside permitted range"
                 f" [-{self.jaw_phase_limit}, {self.jaw_phase_limit}]"
             )
-        await self.id.id_jaw_phase.set(jaw_phase)
+        await self.id_ref().id_jaw_phase().set(jaw_phase)
         self._angle_set(value)
 
 

dodal/devices/i10/i10_setting_data.py

@@ -1,7 +1,7 @@
-from enum import Enum
+from ophyd_async.core import StrictEnum
 
 
-class I10Grating(str, Enum):
+class I10Grating(StrictEnum):
     Au400 = "400 line/mm Au"
     Si400 = "400 line/mm Si"
     Au1200 = "1200 line/mm Au"

dodal/devices/i22/dcm.py

@@ -1,32 +1,24 @@
 import time
-from collections.abc import Sequence
-from dataclasses import dataclass
-from typing import Literal
 
+import numpy as np
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
+from ophyd_async.core import (
+    Array1D,
+    StandardReadable,
+    StandardReadableFormat,
+    soft_signal_r_and_setter,
+)
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
+
+from dodal.common.crystal_metadata import CrystalMetadata
 
 # Conversion constant for energy and wavelength, taken from the X-Ray data booklet
 # Converts between energy in KeV and wavelength in angstrom
 _CONVERSION_CONSTANT = 12.3984
 
 
-@dataclass(frozen=True, unsafe_hash=True)
-class CrystalMetadata:
-    """
-    Metadata used in the NeXus format,
-    see https://manual.nexusformat.org/classes/base_classes/NXcrystal.html
-    """
-
-    usage: Literal["Bragg", "Laue"] | None = None
-    type: str | None = None
-    reflection: tuple[int, int, int] | None = None
-    d_spacing: tuple[float, str] | None = None
-
-
 class DoubleCrystalMonochromator(StandardReadable):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
@@ -40,8 +32,8 @@ class DoubleCrystalMonochromator(StandardReadable):
     def __init__(
         self,
         temperature_prefix: str,
-        crystal_1_metadata: CrystalMetadata | None = None,
-        crystal_2_metadata: CrystalMetadata | None = None,
+        crystal_1_metadata: CrystalMetadata,
+        crystal_2_metadata: CrystalMetadata,
         prefix: str = "",
         name: str = "",
     ) -> None:
@@ -69,61 +61,37 @@ class DoubleCrystalMonochromator(StandardReadable):
 
         # Soft metadata
         # If supplied include crystal details in output of read_configuration
-        crystal_1_metadata = crystal_1_metadata or CrystalMetadata()
-        crystal_2_metadata = crystal_2_metadata or CrystalMetadata()
-        with self.add_children_as_readables(ConfigSignal):
-            if crystal_1_metadata.usage is not None:
-                self.crystal_1_usage, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_1_metadata.usage
-                )
-            else:
-                self.crystal_1_usage = None
-            if crystal_1_metadata.type is not None:
-                self.crystal_1_type, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_1_metadata.type
-                )
-            else:
-                self.crystal_1_type = None
-            if crystal_1_metadata.reflection is not None:
-                self.crystal_1_reflection, _ = soft_signal_r_and_setter(
-                    Sequence[int], initial_value=list(crystal_1_metadata.reflection)
-                )
-            else:
-                self.crystal_1_reflection = None
-            if crystal_1_metadata.d_spacing is not None:
-                self.crystal_1_d_spacing, _ = soft_signal_r_and_setter(
-                    float,
-                    initial_value=crystal_1_metadata.d_spacing[0],
-                    units=crystal_1_metadata.d_spacing[1],
-                )
-            else:
-                self.crystal_1_d_spacing = None
-            if crystal_2_metadata.usage is not None:
-                self.crystal_2_usage, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_2_metadata.usage
-                )
-            else:
-                self.crystal_2_usage = None
-            if crystal_2_metadata.type is not None:
-                self.crystal_2_type, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_2_metadata.type
-                )
-            else:
-                self.crystal_2_type = None
-            if crystal_2_metadata.reflection is not None:
-                self.crystal_2_reflection, _ = soft_signal_r_and_setter(
-                    Sequence[int], initial_value=list(crystal_2_metadata.reflection)
-                )
-            else:
-                self.crystal_2_reflection = None
-            if crystal_2_metadata.d_spacing is not None:
-                self.crystal_2_d_spacing, _ = soft_signal_r_and_setter(
-                    float,
-                    initial_value=crystal_2_metadata.d_spacing[0],
-                    units=crystal_2_metadata.d_spacing[1],
-                )
-            else:
-                self.crystal_2_d_spacing = None
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.crystal_1_usage, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_1_metadata.usage
+            )
+            self.crystal_1_type, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_1_metadata.type
+            )
+            self.crystal_1_reflection, _ = soft_signal_r_and_setter(
+                Array1D[np.int32],
+                initial_value=np.array(crystal_1_metadata.reflection),
+            )
+            self.crystal_1_d_spacing, _ = soft_signal_r_and_setter(
+                float,
+                initial_value=crystal_1_metadata.d_spacing[0],
+                units=crystal_1_metadata.d_spacing[1],
+            )
+            self.crystal_2_usage, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_2_metadata.usage
+            )
+            self.crystal_2_type, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_2_metadata.type
+            )
+            self.crystal_2_reflection, _ = soft_signal_r_and_setter(
+                Array1D[np.int32],
+                initial_value=np.array(crystal_2_metadata.reflection),
+            )
+            self.crystal_2_d_spacing, _ = soft_signal_r_and_setter(
+                float,
+                initial_value=crystal_2_metadata.d_spacing[0],
+                units=crystal_2_metadata.d_spacing[1],
+            )
 
         super().__init__(name)
 

dodal/devices/i22/fswitch.py

@@ -1,19 +1,19 @@
 import asyncio
 import time
-from enum import Enum
 
 from bluesky.protocols import Reading
 from event_model import DataKey
 from ophyd_async.core import (
-    ConfigSignal,
     DeviceVector,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
     soft_signal_r_and_setter,
 )
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.epics.core import epics_signal_r
 
 
-class FilterState(str, Enum):
+class FilterState(StrictEnum):
     """
     Note that the in/out here refers to the internal rocker
     position so a PV value of IN implies a filter OUT of beam
@@ -54,7 +54,7 @@ class FSwitch(StandardReadable):
                 for i in range(FSwitch.NUM_FILTERS)
             }
         )
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             if lens_geometry is not None:
                 self.lens_geometry, _ = soft_signal_r_and_setter(
                     str, initial_value=lens_geometry

dodal/devices/i24/aperture.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
-from ophyd_async.core import StandardReadable
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_rw
 
 
-class AperturePositions(str, Enum):
+class AperturePositions(StrictEnum):
     IN = "In"
     OUT = "Out"
     ROBOT = "Robot"

dodal/devices/i24/beamstop.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
-from ophyd_async.core import StandardReadable
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_rw
 
 
-class BeamstopPositions(str, Enum):
+class BeamstopPositions(StrictEnum):
     CHECK_BEAM = "CheckBeam"
     DATA_COLLECTION = "Data Collection"
     DATA_COLLECTION_FAR = "Data Collection Far"

dodal/devices/i24/dcm.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 
 class DCM(StandardReadable):

dodal/devices/i24/dual_backlight.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 
-from ophyd_async.core import AsyncStatus, StandardReadable
-from ophyd_async.epics.signal import epics_signal_rw
 
-
-class BacklightPositions(str, Enum):
+class BacklightPositions(StrictEnum):
     OUT = "Out"
     IN = "In"
     LOAD_CHECK = "LoadCheck"
@@ -12,7 +10,7 @@ class BacklightPositions(str, Enum):
     DIODE = "Diode"
 
 
-class LEDStatus(str, Enum):
+class LEDStatus(StrictEnum):
     OFF = "OFF"
     ON = "ON"
 

dodal/devices/i24/pmac.py

@@ -1,21 +1,20 @@
 from asyncio import sleep
 from enum import Enum, IntEnum
 
-from bluesky.protocols import Flyable, Triggerable
+from bluesky.protocols import Flyable, Movable, Triggerable
 from ophyd_async.core import (
-    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
-    SignalBackend,
+    Device,
+    Reference,
     SignalR,
     SignalRW,
-    SoftSignalBackend,
     StandardReadable,
     soft_signal_rw,
     wait_for_value,
 )
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 HOME_STR = r"\#1hmz\#2hmz\#3hmz"  # Command to home the PMAC motors
 ZERO_STR = "!x0y0z0"  # Command to blend any ongoing move into new position
@@ -64,61 +63,53 @@ class PMACStringMove(Triggerable):
         pmac_str_sig: SignalRW,
         string_to_send: str,
     ) -> None:
-        self.signal = pmac_str_sig
+        self.signal_ref = Reference(pmac_str_sig)
         self.cmd_string = string_to_send
 
     @AsyncStatus.wrap
     async def trigger(self):
-        await self.signal.set(self.cmd_string, wait=True)
+        await self.signal_ref().set(self.cmd_string, wait=True)
 
 
-class PMACStringLaser(SignalRW):
+class PMACStringLaser(Device, Movable):
     """Set the pmac_string to control the laser."""
 
     def __init__(
         self,
         pmac_str_sig: SignalRW,
-        backend: SignalBackend,
-        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        self.signal = pmac_str_sig
-        super().__init__(backend, timeout, name)
+        self._signal_ref = Reference(pmac_str_sig)
+        super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(
         self,
         value: LaserSettings,
-        wait=True,
-        timeout=CALCULATE_TIMEOUT,
     ):
-        await self.signal.set(value.value, wait, timeout)
+        await self._signal_ref().set(value.value)
 
 
-class PMACStringEncReset(SignalRW):
+class PMACStringEncReset(Device, Movable):
     """Set a pmac_string to control the encoder channels in the controller."""
 
     def __init__(
         self,
         pmac_str_sig: SignalRW,
-        backend: SignalBackend,
-        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        self.signal = pmac_str_sig
-        super().__init__(backend, timeout, name)
+        self._signal_ref = Reference(pmac_str_sig)
+        super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(
         self,
         value: EncReset,
-        wait=True,
-        timeout=CALCULATE_TIMEOUT,
     ):
-        await self.signal.set(value.value, wait, timeout)
+        await self._signal_ref().set(value.value)
 
 
-class ProgramRunner(SignalRW, Flyable):
+class ProgramRunner(Device, Flyable):
     """Run the collection by setting the program number on the PMAC string.
 
     Once the program number has been set, wait for the collection to be complete.
@@ -131,21 +122,18 @@ class ProgramRunner(SignalRW, Flyable):
         status_sig: SignalR,
         prog_num_sig: SignalRW,
         collection_time_sig: SignalRW,
-        backend: SignalBackend,
-        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        self.signal = pmac_str_sig
-        self.status = status_sig
-        self.prog_num = prog_num_sig
+        self._signal_ref = Reference(pmac_str_sig)
+        self._status_ref = Reference(status_sig)
+        self._prog_num_ref = Reference(prog_num_sig)
 
-        self.collection_time = collection_time_sig
-        self.KICKOFF_TIMEOUT = timeout
+        self._collection_time_ref = Reference(collection_time_sig)
 
-        super().__init__(backend, timeout, name)
+        super().__init__(name)
 
     async def _get_prog_number_string(self) -> str:
-        prog_num = await self.prog_num.get_value()
+        prog_num = await self._prog_num_ref().get_value()
         return f"&2b{prog_num}r"
 
     @AsyncStatus.wrap
@@ -154,11 +142,11 @@ class ProgramRunner(SignalRW, Flyable):
             wait for the scan status PV to go to 1.
         """
         prog_num_str = await self._get_prog_number_string()
-        await self.signal.set(prog_num_str, wait=True)
+        await self._signal_ref().set(prog_num_str, wait=True)
         await wait_for_value(
-            self.status,
+            self._status_ref(),
             ScanState.RUNNING,
-            timeout=self.KICKOFF_TIMEOUT,
+            timeout=DEFAULT_TIMEOUT,
         )
 
     @AsyncStatus.wrap
@@ -169,8 +157,10 @@ class ProgramRunner(SignalRW, Flyable):
             complete_time (float): total time required by the collection to \
             finish correctly.
         """
-        scan_complete_time = await self.collection_time.get_value()
-        await wait_for_value(self.status, ScanState.DONE, timeout=scan_complete_time)
+        scan_complete_time = await self._collection_time_ref().get_value()
+        await wait_for_value(
+            self._status_ref(), ScanState.DONE, timeout=scan_complete_time
+        )
 
 
 class ProgramAbort(Triggerable):
@@ -183,16 +173,16 @@ class ProgramAbort(Triggerable):
         pmac_str_sig: SignalRW,
         status_sig: SignalR,
     ) -> None:
-        self.signal = pmac_str_sig
-        self.status = status_sig
+        self._signal_ref = Reference(pmac_str_sig)
+        self._status_ref = Reference(status_sig)
 
     @AsyncStatus.wrap
     async def trigger(self):
-        await self.signal.set("A", wait=True)
+        await self._signal_ref().set("A", wait=True)
         await sleep(1.0)  # TODO Check with scientist what this sleep is really for.
-        await self.signal.set("P2401=0", wait=True)
+        await self._signal_ref().set("P2401=0", wait=True)
         await wait_for_value(
-            self.status,
+            self._status_ref(),
             ScanState.DONE,
             timeout=DEFAULT_TIMEOUT,
         )
@@ -209,10 +199,10 @@ class PMAC(StandardReadable):
         )
         self.to_xyz_zero = PMACStringMove(self.pmac_string, ZERO_STR)
 
-        self.laser = PMACStringLaser(self.pmac_string, backend=SoftSignalBackend(str))
+        self.laser = PMACStringLaser(self.pmac_string)
 
         self.enc_reset = PMACStringEncReset(
-            self.pmac_string, backend=SoftSignalBackend(str)
+            self.pmac_string,
         )
 
         self.x = Motor(prefix + "X")
@@ -234,7 +224,6 @@ class PMAC(StandardReadable):
             self.scanstatus,
             self.program_number,
             self.collection_time,
-            backend=SoftSignalBackend(str),
         )
         self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 

dodal/devices/i24/vgonio.py

@@ -0,0 +1,16 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class VerticalGoniometer(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.x = Motor(prefix + "PINX")
+        self.z = Motor(prefix + "PINZ")
+        self.yh = Motor(prefix + "PINYH")
+        self.omega = Motor(prefix + "OMEGA")
+
+        self.real_x = Motor(prefix + "PINXS")
+        self.real_z = Motor(prefix + "PINZS")
+        self.fast_y = Motor(prefix + "PINYS")
+
+        super().__init__(name)