dls-dodal 1.39.0__py3-none-any.whl → 1.41.0__py3-none-any.whl

dodal/devices/fast_grid_scan.py

@@ -1,3 +1,4 @@
+import asyncio
 from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
@@ -9,9 +10,7 @@ from ophyd_async.core import (
     AsyncStatus,
     Device,
     Signal,
-    SignalR,
     SignalRW,
-    SoftSignalBackend,
     StandardReadable,
     wait_for_value,
 )
@@ -24,6 +23,7 @@ from ophyd_async.epics.core import (
 from pydantic import field_validator
 from pydantic.dataclasses import dataclass
 
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -170,21 +170,6 @@ class MotionProgram(Device):
         self.program_number = epics_signal_r(float, prefix + "CS1:PROG_NUM")
 
 
-class ExpectedImages(SignalR[int]):
-    def __init__(self, parent: "FastGridScanCommon") -> None:
-        super().__init__(SoftSignalBackend(int))
-        self.parent = parent
-
-    async def get_value(self, cached: bool | None = None):
-        assert isinstance(self.parent, FastGridScanCommon)
-        x = await self.parent.x_steps.get_value()
-        y = await self.parent.y_steps.get_value()
-        z = await self.parent.z_steps.get_value()
-        first_grid = x * y
-        second_grid = x * z
-        return first_grid + second_grid
-
-
 class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
     """Device for a general fast grid scan
 
@@ -215,9 +200,12 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.scan_invalid = epics_signal_r(float, f"{prefix}SCAN_INVALID")
 
         self.run_cmd = epics_signal_x(f"{prefix}RUN.PROC")
+        self.stop_cmd = epics_signal_x(f"{prefix}STOP.PROC")
         self.status = epics_signal_r(int, f"{prefix}SCAN_STATUS")
 
-        self.expected_images = ExpectedImages(parent=self)
+        self.expected_images = create_hardware_backed_soft_signal(
+            float, self._calculate_expected_images
+        )
 
         self.motion_program = MotionProgram(smargon_prefix)
 
@@ -243,6 +231,17 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         }
         super().__init__(name)
 
+    async def _calculate_expected_images(self):
+        x, y, z = await asyncio.gather(
+            self.x_steps.get_value(),
+            self.y_steps.get_value(),
+            self.z_steps.get_value(),
+        )
+        LOGGER.info(f"Reading num of images found {x, y, z} images in each axis")
+        first_grid = x * y
+        second_grid = x * z
+        return first_grid + second_grid
+
     @AsyncStatus.wrap
     async def kickoff(self):
         curr_prog = await self.motion_program.program_number.get_value()
@@ -259,7 +258,15 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
 
     @AsyncStatus.wrap
     async def complete(self):
-        await wait_for_value(self.status, 0, self.COMPLETE_STATUS)
+        try:
+            await wait_for_value(self.status, 0, self.COMPLETE_STATUS)
+        except asyncio.TimeoutError:
+            LOGGER.error(
+                "Hyperion timed out waiting for FGS motion to complete. This may have been caused by a goniometer stage getting stuck.\n\
+                Forcibly stopping the FGS motion program..."
+            )
+            await self.stop_cmd.trigger()
+            raise
 
     @abstractmethod
     def _create_position_counter(self, prefix: str) -> SignalRW[int]:

dodal/devices/hutch_shutter.py

@@ -8,9 +8,16 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_w
 
+from dodal.log import LOGGER
+
 HUTCH_SAFE_FOR_OPERATIONS = 0  # Hutch is locked and can't be entered
 
 
+# Enable to allow testing when the beamline is down, do not change in production!
+TEST_MODE = False
+# will be made more generic in https://github.com/DiamondLightSource/dodal/issues/754
+
+
 class ShutterNotSafeToOperateError(Exception):
     pass
 
@@ -48,7 +55,7 @@ class HutchInterlock(StandardReadable):
         return interlock_state == HUTCH_SAFE_FOR_OPERATIONS
 
 
-class HutchShutter(StandardReadable, Movable):
+class HutchShutter(StandardReadable, Movable[ShutterDemand]):
     """Device to operate the hutch shutter.
 
     When a demand is sent, the device should first check the hutch status \
@@ -64,8 +71,8 @@ class HutchShutter(StandardReadable, Movable):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.control = epics_signal_w(ShutterDemand, prefix + "CON")
-        self.status = epics_signal_r(ShutterState, prefix + "STA")
+        self.control = epics_signal_w(ShutterDemand, f"{prefix}CON")
+        self.status = epics_signal_r(ShutterState, f"{prefix}STA")
 
         bl_prefix = prefix.split("-")[0]
         self.interlock = HutchInterlock(bl_prefix)
@@ -75,18 +82,24 @@ class HutchShutter(StandardReadable, Movable):
     @AsyncStatus.wrap
     async def set(self, value: ShutterDemand):
         interlock_state = await self.interlock.shutter_safe_to_operate()
-        if not interlock_state:
+        if not interlock_state and not TEST_MODE:
+            # If not in test mode, fail. If in test mode, the optics hutch may be open.
             raise ShutterNotSafeToOperateError(
                 "The hutch has not been locked, not operating shutter."
             )
-        if value == ShutterDemand.OPEN:
-            await self.control.set(ShutterDemand.RESET, wait=True)
-            await self.control.set(value, wait=True)
-            return await wait_for_value(
-                self.status, match=ShutterState.OPEN, timeout=DEFAULT_TIMEOUT
-            )
+        if not TEST_MODE:
+            if value == ShutterDemand.OPEN:
+                await self.control.set(ShutterDemand.RESET, wait=True)
+                await self.control.set(value, wait=True)
+                return await wait_for_value(
+                    self.status, match=ShutterState.OPEN, timeout=DEFAULT_TIMEOUT
+                )
+            else:
+                await self.control.set(value, wait=True)
+                return await wait_for_value(
+                    self.status, match=ShutterState.CLOSED, timeout=DEFAULT_TIMEOUT
+                )
         else:
-            await self.control.set(value, wait=True)
-            return await wait_for_value(
-                self.status, match=ShutterState.CLOSED, timeout=DEFAULT_TIMEOUT
+            LOGGER.warning(
+                "Running in test mode, will not operate the experiment shutter."
             )

dodal/devices/i10/i10_apple2.py

@@ -175,7 +175,7 @@ class I10Apple2(Apple2):
         self._available_pol = list(self.lookup_tables["Gap"].keys())
 
 
-class I10Apple2PGM(StandardReadable, Movable):
+class I10Apple2PGM(StandardReadable, Movable[float]):
     """
     Compound device to set both ID and PGM energy at the sample time,poly_deg
 
@@ -211,7 +211,7 @@ class I10Apple2PGM(StandardReadable, Movable):
         )
 
 
-class I10Apple2Pol(StandardReadable, Movable):
+class I10Apple2Pol(StandardReadable, Movable[str]):
     """
     Compound device to set polorisation of ID.
     """
@@ -240,7 +240,7 @@ class I10Apple2Pol(StandardReadable, Movable):
         )  # Move id to new polarisation
 
 
-class LinearArbitraryAngle(StandardReadable, Movable):
+class LinearArbitraryAngle(StandardReadable, Movable[SupportsFloat]):
     """
     Device to set polorisation angle of the ID. Linear Arbitrary Angle (laa)
      is the direction of the magnetic field which can be change by varying the jaw_phase

dodal/devices/i10/rasor/rasor_scaler_cards.py

@@ -5,8 +5,8 @@ from dodal.devices.current_amplifiers import StruckScaler
 
 class RasorScalerCard1(Device):
     def __init__(self, prefix, name: str = "") -> None:
-        self.mon = StruckScaler(prefix=prefix, suffix=".16")
-        self.det = StruckScaler(prefix=prefix, suffix=".17")
-        self.fluo = StruckScaler(prefix=prefix, suffix=".18")
-        self.drain = StruckScaler(prefix=prefix, suffix=".19")
+        self.mon = StruckScaler(prefix=prefix, suffix=".S17")
+        self.det = StruckScaler(prefix=prefix, suffix=".S18")
+        self.fluo = StruckScaler(prefix=prefix, suffix=".S19")
+        self.drain = StruckScaler(prefix=prefix, suffix=".S20")
         super().__init__(name)

dodal/devices/i13_1/merlin.py

@@ -1,6 +1,7 @@
 from ophyd_async.core import PathProvider, StandardDetector
 from ophyd_async.epics import adcore
 
+from dodal.common.beamlines.device_helpers import CAM_SUFFIX, HDF5_SUFFIX
 from dodal.devices.i13_1.merlin_controller import MerlinController
 from dodal.devices.i13_1.merlin_io import MerlinDriverIO
 
@@ -13,12 +14,12 @@ class Merlin(StandardDetector):
         self,
         prefix: str,
         path_provider: PathProvider,
-        drv_suffix="CAM:",
-        hdf_suffix="HDF:",
+        drv_suffix=CAM_SUFFIX,
+        fileio_suffix=HDF5_SUFFIX,
         name: str = "",
     ):
         self.drv = MerlinDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + fileio_suffix)
 
         super().__init__(
             MerlinController(self.drv),

dodal/devices/i13_1/merlin_controller.py

@@ -4,15 +4,15 @@ import logging
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
-    DetectorController,
     TriggerInfo,
 )
 from ophyd_async.epics import adcore
+from ophyd_async.epics.adcore import ADBaseController
 
 from dodal.devices.i13_1.merlin_io import MerlinDriverIO, MerlinImageMode
 
 
-class MerlinController(DetectorController):
+class MerlinController(ADBaseController):
     def __init__(
         self,
         driver: MerlinDriverIO,
@@ -37,11 +37,6 @@ class MerlinController(DetectorController):
             self.driver.image_mode.set(MerlinImageMode.MULTIPLE),
         )
 
-    async def arm(self):
-        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
-            self.driver, good_states=self.good_states, timeout=self.frame_timeout
-        )
-
     async def wait_for_idle(self):
         if self._arm_status:
             await self._arm_status

dodal/devices/i18/KBMirror.py

@@ -0,0 +1,19 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+
+class KBMirror(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        self._prefix = prefix
+        with self.add_children_as_readables():
+            self.x = epics_signal_rw(float, prefix + "X")
+            self.y = epics_signal_rw(float, prefix + "Y")
+            self.bend1 = epics_signal_rw(float, prefix + "BEND1")
+            self.bend2 = epics_signal_rw(float, prefix + "BEND2")
+            self.curve = epics_signal_rw(float, prefix + "CURVE")
+            self.ellip = epics_signal_rw(float, prefix + "ELLIP")
+        super().__init__(name=name)

dodal/devices/i18/diode.py

@@ -0,0 +1,17 @@
+from ophyd_async.core import (
+    StandardReadable,
+)
+from ophyd_async.epics.core import epics_signal_r
+
+
+class Diode(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        self._prefix = prefix
+        with self.add_children_as_readables():
+            self.signal = epics_signal_r(float, prefix + "B:DIODE:I")
+
+        super().__init__(name=name)

dodal/devices/i18/table.py

@@ -0,0 +1,14 @@
+from ophyd_async.core import (
+    StandardReadable,
+)
+from ophyd_async.epics.motor import Motor
+
+
+class Table(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+            self.z = Motor(prefix + "Z")
+            self.theta = Motor(prefix + "THETA")
+        super().__init__(name=name)

dodal/devices/i18/thor_labs_stage.py

@@ -0,0 +1,12 @@
+from ophyd_async.core import (
+    StandardReadable,
+)
+from ophyd_async.epics.motor import Motor
+
+
+class ThorLabsStage(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+        super().__init__(name=name)

dodal/devices/i19/shutter.py

@@ -0,0 +1,57 @@
+from enum import Enum
+
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.epics.core import epics_signal_r
+
+from dodal.devices.hutch_shutter import HutchShutter, ShutterDemand
+from dodal.log import LOGGER
+
+
+class HutchInvalidError(Exception):
+    pass
+
+
+class HutchState(str, Enum):
+    EH1 = "EH1"
+    EH2 = "EH2"
+    INVALID = "INVALID"
+
+
+class HutchConditionalShutter(StandardReadable, Movable[ShutterDemand]):
+    """ I19-specific device to operate the hutch shutter.
+
+    This device evaluates the hutch state value to work out which of the two I19 \
+    hutches is in use and then implements the HutchShutter device to operate the \
+    experimental shutter.
+    As the two hutches are located in series, checking the hutch in use is necessary to \
+    avoid accidentally operating the shutter from one hutch while the other has beamtime.
+
+    The hutch name should be passed to the device upon instantiation. If this does not \
+    coincide with the current hutch in use, a warning will be logged and the shutter \
+    will not be operated. This is to allow for testing of plans.
+    An error will instead be raised if the hutch state reads as "INVALID".
+    """
+
+    def __init__(self, prefix: str, hutch: HutchState, name: str = "") -> None:
+        self.shutter = HutchShutter(prefix=prefix, name=name)
+        bl_prefix = prefix.split("-")[0]
+        self.hutch_state = epics_signal_r(str, f"{bl_prefix}-OP-STAT-01:EHStatus.VALA")
+        self.hutch_request = hutch
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: ShutterDemand):
+        hutch_in_use = await self.hutch_state.get_value()
+        LOGGER.info(f"Current hutch in use: {hutch_in_use}")
+        if hutch_in_use == HutchState.INVALID:
+            raise HutchInvalidError(
+                "The hutch state is invalid. Contact the beamline staff."
+            )
+        if hutch_in_use != self.hutch_request:
+            # NOTE Warn but don't fail
+            LOGGER.warning(
+                f"{self.hutch_request} is not the hutch in use. Shutter will not be operated."
+            )
+        else:
+            await self.shutter.set(value)

dodal/devices/i22/nxsas.py

@@ -103,7 +103,7 @@ class NXSasPilatus(PilatusDetector):
         prefix: str,
         path_provider: PathProvider,
         drv_suffix: str,
-        hdf_suffix: str,
+        fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
     ):
@@ -116,7 +116,7 @@ class NXSasPilatus(PilatusDetector):
             prefix,
             path_provider,
             drv_suffix=drv_suffix,
-            hdf_suffix=hdf_suffix,
+            fileio_suffix=fileio_suffix,
             name=name,
         )
         self._metadata_holder = metadata_holder
@@ -146,7 +146,7 @@ class NXSasOAV(AravisDetector):
         prefix: str,
         path_provider: PathProvider,
         drv_suffix: str,
-        hdf_suffix: str,
+        fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
         gpio_number: AravisController.GPIO_NUMBER = 1,
@@ -160,7 +160,7 @@ class NXSasOAV(AravisDetector):
             prefix,
             path_provider,
             drv_suffix=drv_suffix,
-            hdf_suffix=hdf_suffix,
+            fileio_suffix=fileio_suffix,
             name=name,
             gpio_number=gpio_number,
         )

dodal/devices/i24/pmac.py

@@ -71,7 +71,7 @@ class PMACStringMove(Triggerable):
         await self.signal_ref().set(self.cmd_string, wait=True)
 
 
-class PMACStringLaser(Device, Movable):
+class PMACStringLaser(Device, Movable[LaserSettings]):
     """Set the pmac_string to control the laser."""
 
     def __init__(
@@ -90,7 +90,7 @@ class PMACStringLaser(Device, Movable):
         await self._signal_ref().set(value.value)
 
 
-class PMACStringEncReset(Device, Movable):
+class PMACStringEncReset(Device, Movable[EncReset]):
     """Set a pmac_string to control the encoder channels in the controller."""
 
     def __init__(

dodal/devices/motors.py

@@ -19,10 +19,10 @@ class XYZPositioner(StandardReadable):
     Notes
     -----
     Example usage::
-        async with DeviceCollector():
+        async with init_devices():
             xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:")
     Or::
-        with DeviceCollector():
+        with init_devices():
             xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:", infix = ("A", "B", "C"))
 
     """

dodal/devices/oav/oav_detector.py

@@ -1,6 +1,12 @@
 from enum import IntEnum
 
-from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, LazyMock, StandardReadable
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    LazyMock,
+    StandardReadable,
+)
 from ophyd_async.epics.core import epics_signal_rw
 
 from dodal.common.signal_utils import create_hardware_backed_soft_signal
@@ -8,12 +14,6 @@ from dodal.devices.areadetector.plugins.CAM import Cam
 from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
 from dodal.devices.oav.snapshots.snapshot_with_beam_centre import SnapshotWithBeamCentre
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
-from dodal.log import LOGGER
-
-
-class ZoomLevelNotFoundError(Exception):
-    def __init__(self, errmsg):
-        LOGGER.error(errmsg)
 
 
 class Coords(IntEnum):
@@ -29,7 +29,7 @@ def _get_correct_zoom_string(zoom: str) -> str:
     return zoom
 
 
-class ZoomController(StandardReadable):
+class ZoomController(StandardReadable, Movable[str]):
     """
     Device to control the zoom level. This should be set like
         o = OAV(name="oav")
@@ -46,18 +46,9 @@ class ZoomController(StandardReadable):
         self.level = epics_signal_rw(str, f"{prefix}MP:SELECT")
         super().__init__(name=name)
 
-    async def _get_allowed_zoom_levels(self) -> list:
-        zoom_levels = await self.level.describe()
-        return zoom_levels[self.level.name]["choices"]  # type: ignore
-
     @AsyncStatus.wrap
-    async def set(self, level_to_set: str):
-        allowed_zoom_levels = await self._get_allowed_zoom_levels()
-        if level_to_set not in allowed_zoom_levels:
-            raise ZoomLevelNotFoundError(
-                f"{level_to_set} not found, expected one of {allowed_zoom_levels}"
-            )
-        await self.level.set(level_to_set, wait=True)
+    async def set(self, value: str):
+        await self.level.set(value, wait=True)
 
 
 class OAV(StandardReadable):

dodal/devices/pressure_jump_cell.py

@@ -41,8 +41,8 @@ class ValveControlRequest(StrictEnum):
 
 
 class ValveOpenSeqRequest(StrictEnum):
-    INACTIVE = 0
-    OPEN_SEQ = 1
+    INACTIVE = "0"
+    OPEN_SEQ = "1"
 
 
 class PumpMotorDirectionState(StrictEnum):
@@ -76,7 +76,7 @@ class AllValvesControlState:
     valve_6: FastValveControlRequest | None = None
 
 
-class AllValvesControl(StandardReadable, Movable):
+class AllValvesControl(StandardReadable, Movable[AllValvesControlState]):
     """
     valves 2, 4, 7, 8 are not controlled by the IOC,
     as they are under manual control.
@@ -151,11 +151,13 @@ class AllValvesControl(StandardReadable, Movable):
         )
 
 
-class ValveControl(StandardReadable):
+class ValveControl(
+    StandardReadable, Movable[ValveControlRequest | ValveOpenSeqRequest]
+):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             self.close = epics_signal_rw(ValveControlRequest, prefix + ":CON")
-            self.open = epics_signal_rw(ValveOpenSeqRequest, prefix + ":OPENSEQ")
+            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
 
         super().__init__(name)
 
@@ -165,16 +167,18 @@ class ValveControl(StandardReadable):
         if isinstance(value, ValveControlRequest):
             set_status = self.close.set(value)
         elif isinstance(value, ValveOpenSeqRequest):
-            set_status = self.open.set(value)
+            set_status = self.open.set(value.value)
 
         return set_status
 
 
-class FastValveControl(StandardReadable):
+class FastValveControl(
+    StandardReadable, Movable[FastValveControlRequest | ValveOpenSeqRequest]
+):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             self.close = epics_signal_rw(FastValveControlRequest, prefix + ":CON")
-            self.open = epics_signal_rw(ValveOpenSeqRequest, prefix + ":OPENSEQ")
+            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
 
         super().__init__(name)
 
@@ -184,7 +188,7 @@ class FastValveControl(StandardReadable):
         if isinstance(value, FastValveControlRequest):
             set_status = self.close.set(value)
         elif isinstance(value, ValveOpenSeqRequest):
-            set_status = self.open.set(value)
+            set_status = self.open.set(value.value)
 
         return set_status
 
@@ -219,21 +223,27 @@ class PressureTransducer(StandardReadable):
         self,
         prefix: str,
         cell_prefix: str,
-        number: int,
+        transducer_number: int,
+        ethercat_channel_number: int,
         name: str = "",
         full_different_prefix_adc: str = "",
     ) -> None:
         final_prefix = f"{prefix}{cell_prefix}"
         with self.add_children_as_readables():
             self.omron_pressure = epics_signal_r(
-                float, f"{final_prefix}PP{number}:PRES"
+                float, f"{final_prefix}PP{transducer_number}:PRES"
+            )
+            self.omron_voltage = epics_signal_r(
+                float, f"{final_prefix}PP{transducer_number}:RAW"
             )
-            self.omron_voltage = epics_signal_r(float, f"{final_prefix}PP{number}:RAW")
             self.beckhoff_pressure = epics_signal_r(
-                float, f"{final_prefix}STATP{number}:MeanValue_RBV"
+                float, f"{final_prefix}STATP{transducer_number}:MeanValue_RBV"
             )
+            # P1 beckhoff voltage = BL38P-EA-ADC-02:CH1
+            # P2 beckhoff voltage = BL38P-EA-ADC-01:CH2
+            # P3 beckhoff voltage = BL38P-EA-ADC-01:CH1
             self.slow_beckhoff_voltage_readout = epics_signal_r(
-                float, f"{full_different_prefix_adc}CH1"
+                float, f"{full_different_prefix_adc}CH{ethercat_channel_number}"
             )
 
         super().__init__(name)
@@ -284,13 +294,27 @@ class PressureJumpCell(StandardReadable):
         with self.add_children_as_readables():
             self.pressure_transducers: DeviceVector[PressureTransducer] = DeviceVector(
                 {
-                    i: PressureTransducer(
+                    1: PressureTransducer(
+                        prefix=prefix,
+                        cell_prefix=cell_prefix,
+                        transducer_number=1,
+                        full_different_prefix_adc=f"{prefix}{adc_prefix}-02:",
+                        ethercat_channel_number=1,
+                    ),
+                    2: PressureTransducer(
+                        prefix=prefix,
+                        cell_prefix=cell_prefix,
+                        transducer_number=2,
+                        full_different_prefix_adc=f"{prefix}{adc_prefix}-01:",
+                        ethercat_channel_number=2,
+                    ),
+                    3: PressureTransducer(
                         prefix=prefix,
-                        number=i,
                         cell_prefix=cell_prefix,
-                        full_different_prefix_adc=f"{prefix}{adc_prefix}-0{i}:",
-                    )
-                    for i in [1, 2, 3]
+                        transducer_number=3,
+                        full_different_prefix_adc=f"{prefix}{adc_prefix}-01:",
+                        ethercat_channel_number=1,
+                    ),
                 }
             )