Bimorph mirrors

src/dodal/devices/bimorph_mirror.py

@@ -103,7 +103,7 @@ def __init__(self, prefix: str, number_of_channels: int, name=""):
         super().__init__(name=name)
 
     @AsyncStatus.wrap
-    async def set(self, value: Mapping[int, float], tolerance: float = 0.0001) -> None:
+    async def set(self, value: Mapping[int, float]) -> None:
         """Sets bimorph voltages in parrallel via target voltage and all proc.
 
         Args:
@@ -118,22 +118,27 @@ async def set(self, value: Mapping[int, float], tolerance: float = 0.0001) -> No
             )
 
         # Write target voltages:
-        await asyncio.gather(
-            *[
-                self.channels[i].target_voltage.set(target, wait=True)
-                for i, target in value.items()
-            ]
-        )
+        for i, target in value.items():
+            await wait_for_value(
+                self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
+            )
+            await self.channels[i].target_voltage.set(target, wait=True)
+            await wait_for_value(
+                self.status, BimorphMirrorStatus.BUSY, timeout=DEFAULT_TIMEOUT
+            )
 
         # Trigger set target voltages:
+        await wait_for_value(
+            self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
+        )
         await self.commit_target_voltages.trigger()
 
         # Wait for values to propogate to voltage out rbv:
         await asyncio.gather(
             *[
                 wait_for_value(
                     self.channels[i].output_voltage,
-                    tolerance_func_builder(tolerance, target),
+                    target,
                     timeout=DEFAULT_TIMEOUT,
                 )
                 for i, target in value.items()
@@ -142,10 +147,3 @@ async def set(self, value: Mapping[int, float], tolerance: float = 0.0001) -> No
                 self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
             ),
         )
-
-
-def tolerance_func_builder(tolerance: float, target_value: float):
-    def is_within_value(x):
-        return abs(x - target_value) <= tolerance
-
-    return is_within_value

tests/devices/unit_tests/test_bimorph_mirror.py

@@ -1,9 +1,10 @@
+import asyncio
 from unittest.mock import ANY, call, patch
 
 import pytest
 from bluesky.run_engine import RunEngine
-from ophyd_async.core import DeviceCollector
-from ophyd_async.testing import get_mock_put
+from ophyd_async.core import DeviceCollector, walk_rw_signals
+from ophyd_async.testing import callback_on_mock_put, get_mock_put, set_mock_value
 
 from dodal.devices.bimorph_mirror import BimorphMirror, BimorphMirrorStatus
 
@@ -29,20 +30,35 @@ def valid_bimorph_values(mirror: BimorphMirror) -> dict[int, float]:
 
 
 @pytest.fixture
-def mock_vtrgt_vout_propogation(mirror: BimorphMirror):
+def bimorph_functionality(mirror: BimorphMirror):
+    async def busy_idle():
+        await asyncio.sleep(0)
+        set_mock_value(mirror.status, BimorphMirrorStatus.BUSY)
+        await asyncio.sleep(0)
+        set_mock_value(mirror.status, BimorphMirrorStatus.IDLE)
+
+    async def status(*_, **__):
+        asyncio.create_task(busy_idle())
+
+    for signal in walk_rw_signals(mirror).values():
+        callback_on_mock_put(signal, status)
+
     for channel in mirror.channels.values():
 
-        def effect(value: float, wait=False, signal=channel.output_voltage):
+        def vout_propogation_and_status(
+            value: float, wait=False, signal=channel.output_voltage
+        ):
             signal.set(value, wait=wait)
+            asyncio.create_task(busy_idle())
 
-        get_mock_put(channel.target_voltage).side_effect = effect
+        callback_on_mock_put(channel.target_voltage, vout_propogation_and_status)
 
 
 @pytest.mark.parametrize("mirror", VALID_BIMORPH_CHANNELS, indirect=True)
 async def test_set_channels_waits_for_readback(
     mirror: BimorphMirror,
     valid_bimorph_values: dict[int, float],
-    mock_vtrgt_vout_propogation,
+    bimorph_functionality,
 ):
     await mirror.set(valid_bimorph_values)
 
@@ -56,7 +72,7 @@ async def test_set_channels_waits_for_readback(
 async def test_set_channels_triggers_alltrgt_proc(
     mirror: BimorphMirror,
     valid_bimorph_values: dict[int, float],
-    mock_vtrgt_vout_propogation,
+    bimorph_functionality,
 ):
     mock_alltrgt_proc = get_mock_put(mirror.commit_target_voltages)
 
@@ -71,7 +87,7 @@ async def test_set_channels_triggers_alltrgt_proc(
 async def test_set_channels_waits_for_vout_readback(
     mirror: BimorphMirror,
     valid_bimorph_values: dict[int, float],
-    mock_vtrgt_vout_propogation,
+    bimorph_functionality,
 ):
     with patch("dodal.devices.bimorph_mirror.wait_for_value") as mock_wait_for_value:
         mock_wait_for_value.assert_not_called()
@@ -82,29 +98,14 @@ async def test_set_channels_waits_for_vout_readback(
             call(mirror.channels[i].output_voltage, ANY, timeout=ANY)
             for i, val in valid_bimorph_values.items()
         ]
-        expected_call_arg_list.append(
-            call(mirror.status, BimorphMirrorStatus.IDLE, timeout=ANY)
-        )
-        assert expected_call_arg_list == mock_wait_for_value.call_args_list
 
-
-@pytest.mark.parametrize("mirror", VALID_BIMORPH_CHANNELS, indirect=True)
-async def test_set_channels_allows_tolerance(
-    mirror: BimorphMirror,
-    valid_bimorph_values: dict[int, float],
-):
-    for channel in mirror.channels.values():
-
-        def out_by_a_little(value: float, wait=False, signal=channel.output_voltage):
-            signal.set(value + 0.00001, wait=wait)
-
-        get_mock_put(channel.target_voltage).side_effect = out_by_a_little
-
-    await mirror.set(valid_bimorph_values)
+        assert all(
+            c in mock_wait_for_value.call_args_list for c in expected_call_arg_list
+        )
 
 
 @pytest.mark.parametrize("mirror", VALID_BIMORPH_CHANNELS, indirect=True)
-async def test_set_one_channel(mirror: BimorphMirror, mock_vtrgt_vout_propogation):
+async def test_set_one_channel(mirror: BimorphMirror, bimorph_functionality):
     values = {1: 1}
 
     await mirror.set(values)
@@ -124,7 +125,7 @@ async def test_set_one_channel(mirror: BimorphMirror, mock_vtrgt_vout_propogatio
 async def test_read(
     mirror: BimorphMirror,
     valid_bimorph_values: dict[int, float],
-    mock_vtrgt_vout_propogation,
+    bimorph_functionality,
 ):
     await mirror.set(valid_bimorph_values)