dls-dodal 1.31.1__py3-none-any.whl → 1.32.0__py3-none-any.whl

{dls_dodal-1.31.1.dist-info → dls_dodal-1.32.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.31.1
+Version: 1.32.0
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License: Apache License
@@ -216,7 +216,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click
 Requires-Dist: ophyd
-Requires-Dist: ophyd-async >=0.5.2
+Requires-Dist: ophyd-async <0.7,>=0.6
 Requires-Dist: bluesky
 Requires-Dist: pyepics
 Requires-Dist: dataclasses-json
@@ -232,6 +232,7 @@ Requires-Dist: numpy <2.0
 Requires-Dist: aiofiles
 Requires-Dist: aiohttp
 Requires-Dist: redis
+Requires-Dist: deepdiff
 Provides-Extra: dev
 Requires-Dist: black ; extra == 'dev'
 Requires-Dist: diff-cover ; extra == 'dev'

{dls_dodal-1.31.1.dist-info → dls_dodal-1.32.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
 dodal/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
 dodal/__main__.py,sha256=kP2S2RPitnOWpNGokjZ1Yq-1umOtp5sNOZk2B3tBPLM,111
-dodal/_version.py,sha256=PiWs-LuU4Z2lwlP2cmR1JpAL95YAAdwL2Jy98tsKfJ0,413
+dodal/_version.py,sha256=DJRUo3ZQOOrgoMbrpGNhypFaRgQ4TvlEoMxoldzMF6Y,413
 dodal/adsim.py,sha256=OW2dcS7ciD4Yq9WFw4PN_c5Bwccrmu7R-zr-u6ZCbQM,497
 dodal/cli.py,sha256=_crmaHchxphSW8eEJB58_XZIeK82aiUv9bV7tpz-LpA,2122
 dodal/log.py,sha256=0to7CRsbzbgVfAAfKRAMhsaUuKqF2-7CGdQc-z8Uhno,9499
-dodal/utils.py,sha256=VV-IQHehAdE95wxq3C4kIl5Dt5MTtmgzVaqKm-k3Q4I,11769
+dodal/utils.py,sha256=zlHPQjJOYeEvdC-UHPRvuTZaLt4hG6o9x2Vm4eHFBDU,11851
 dodal/beamline_specific_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/beamline_specific_utils/i03.py,sha256=eM6ZWZzpL0JYNBff8LhOnwFoZTJ5PDCY2XWI7ZKdtFY,276
 dodal/beamlines/README.md,sha256=K9MkL_GomxlsoTB7Mz-_dJA5NNSbmCfMiutchGg3C8o,404
 dodal/beamlines/__init__.py,sha256=CD0Dz2H1adLsqY4H3-_QxTdODPZD6mquMfsep5W5s0Q,3076
-dodal/beamlines/i03.py,sha256=VHfGk4-Smz5KviL4OpPVlnYGO4rbDAtnGwKtN20hxK0,17004
-dodal/beamlines/i04.py,sha256=JbpOssCBdpDd-TbElc0TfVOZ1tUnDjEFZkj5h1gR6Og,13767
+dodal/beamlines/i03.py,sha256=8Lra4u1kLjWUoboxuSx6Po92OymRaKaJjM9ERr9zeUI,17004
+dodal/beamlines/i04.py,sha256=pRVNIBaUn3oIgbxInCgBUwLqHtPirxf0fKfTfx4RcJ8,13877
 dodal/beamlines/i04_1.py,sha256=KDxSUQNhIs_NFiRaLY-Jiory0DeN7Y0ErvGuoTrwCDU,4731
 dodal/beamlines/i13_1.py,sha256=csXHrdwUh4sXTmb4X6ZiiSS_XxRkNShsVoBMxYI6rG0,1833
 dodal/beamlines/i20_1.py,sha256=MaPgONHqpoZuBtkiKEzYtViJnKBM2_ekeP4OdbmuXHE,1158
-dodal/beamlines/i22.py,sha256=ko3bo0WoZCFTSQkrNs9m_qDhvEpGWkSzEAZgpo0sRU0,9804
+dodal/beamlines/i22.py,sha256=YWTz2PjOMTEO7n3QRfrCerIEUMHd6JTHsd2dYe_4F7c,9915
 dodal/beamlines/i23.py,sha256=2j5qLoqE_hg9ETHqNkOVu7LLkVB8qalgXeORnVYKN_I,1075
 dodal/beamlines/i24.py,sha256=1XVCNWbzowQB6CWpJGSLp9Ih0zypktIzHxb64h-Xj6Y,6583
 dodal/beamlines/p38.py,sha256=mCDjRVpY6AIFIAAYCWe-jGABHadFwfJB7poa-dGMU6s,7940
@@ -35,24 +35,24 @@ dodal/devices/CTAB.py,sha256=MoExneblYUHg9Va8vAVx_p_Vw_HnqbhkzxxrX7Ic_wo,2000
 dodal/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/devices/adsim.py,sha256=dMU0TKIuiODHYFHQOH4_5UvB8iJtaJEtjqaEDGjcU-w,311
 dodal/devices/aperture.py,sha256=BLaroQ3n8yd7uZyacJ3KvDWZH8yhA_sJc8b49QMKg9o,585
-dodal/devices/aperturescatterguard.py,sha256=id2-h6VB9hMU2dmgkpFkTLOPKiqAktMHsLb7YY0LX-4,8428
+dodal/devices/aperturescatterguard.py,sha256=fOdwQl_qZLaUo1cI1-wz1t2OqncMoUm_uqeZNWyHn3M,8459
 dodal/devices/attenuator.py,sha256=viK1iccNekX6ZvR_ZmSwj5JdM1j2B8pcTg8qWDdmzhQ,2584
 dodal/devices/backlight.py,sha256=mOnptopsVOsT8JUIX_siDRgJ73CQPz_bm0Eb7oA81wc,1607
 dodal/devices/cryostream.py,sha256=CpNA2HGhN_PXkL9eqH_yAPsDxyOLIiehlUxEoNmXJVg,668
 dodal/devices/dcm.py,sha256=eZNMGjLM56Ll0siU14XomB77W_grLIdxIrMOQNmYFG8,1609
 dodal/devices/eiger.py,sha256=sR-Fr97Y0lzzq57fFOUTwUZw5E7asoj36A1JR1QUkLI,13985
 dodal/devices/eiger_odin.py,sha256=tDpEhOUY02YManYAMRI3TwSDDa3uITBxI0JHevaK7Rk,7010
-dodal/devices/fast_grid_scan.py,sha256=7u4YvaoR0CsKs9hgawi5p73v0dY_yJwC0_RlFz25R7Y,11922
+dodal/devices/fast_grid_scan.py,sha256=WQGeKR-82fbnY4zUD_MQBsQyJgyIiuRpJK5nn_mfR1E,11969
 dodal/devices/fluorescence_detector_motion.py,sha256=5IcyaVHXa9TXLFlLB0tfpQ1_ThgIRJNaFNw_uj6ahCA,501
 dodal/devices/flux.py,sha256=RtPStHw7Mad0igVKntKWVZfuZn2clokVJqH14HLix6M,198
-dodal/devices/focusing_mirror.py,sha256=Gx3diH-0VH457MR40HMCovXRjcAALSCO0q2np4l-dL4,5911
+dodal/devices/focusing_mirror.py,sha256=-jq2uqBfDjSgRVrV3-sqswPAND72cagBUQVvzd04diw,5901
 dodal/devices/hutch_shutter.py,sha256=_-hR3SJHM05YHV_fEtc0VYOLamYnpVGDE56AwJGJS48,3320
 dodal/devices/ipin.py,sha256=qsf8E3xrJYNDwzsacNLCCp3gaqsadqmN1b-Fvou8y8k,420
 dodal/devices/linkam3.py,sha256=3oYwPtaKSPvLKEat8m7tuhE4Wizz8mg8HMrEWPCYxn0,3820
 dodal/devices/logging_ophyd_device.py,sha256=dUVE-XhWA56WUXez0mrc4sf322CXY3MVLreTycO5j_A,668
 dodal/devices/motors.py,sha256=dYa9T6FDMTbr8GvTb-lXtk3v4QEqAWRuGmHIO20fazQ,1039
 dodal/devices/p45.py,sha256=jzBW2fGRhIbGzSRs5Fgupxro6aqE611n1RTcrTTG-yY,1047
-dodal/devices/robot.py,sha256=VaD2_ogt497myakfkCC1cGfBoz1I6QVdO8AXzFuGis4,4813
+dodal/devices/robot.py,sha256=yzRq-77fVrlhxaIqeORJLGkDHzGgLrHsFYTxmkG-b0w,5343
 dodal/devices/s4_slit_gaps.py,sha256=j3kgF9WfGFaU9xdUuiAh-QqI5u_vhiAftaDVINt91SM,243
 dodal/devices/scatterguard.py,sha256=jx03in9QgaThWxD4t1S8_Llent2kWrn_hThJ9KkUWTk,330
 dodal/devices/scintillator.py,sha256=PlD6cnJ39PTB_e7QrRspPliLYE4kL_K7ziJURzuxgdA,365
@@ -60,12 +60,12 @@ dodal/devices/slits.py,sha256=uOyVmbgeygiP6e5Z9t5zMPXLuVEWFfYg9GB3ZU76Tug,600
 dodal/devices/smargon.py,sha256=hX-tCftKumxk67eS5-_gQRmYOrjSyQ4s3mMJsTRuvCk,4706
 dodal/devices/status.py,sha256=hVrJS1yooQo6PRumRACoIEh-SKBUKxvBlQl-MtLFUMQ,327
 dodal/devices/synchrotron.py,sha256=QtTufJA_fCaBawHougSc7nxwu240oX46_y0P-4qIW8o,1960
-dodal/devices/tetramm.py,sha256=ofWhLYFZHCRopDK_WRs1eo-B1ra4bUhwq1MLaVKl4ys,8572
+dodal/devices/tetramm.py,sha256=EgtaExJBZWZC6lWgUEg0RcWQYmSKwRm20KjTZyhCjBk,8439
 dodal/devices/thawer.py,sha256=Gq-3f__KJUM6_Ds9OVxpZ5jC447HywJxQGXen6L33Lk,1616
 dodal/devices/turbo_slit.py,sha256=B6SPXqviMnG-U4PnUF1BdTO0LBKmTuwAUKRbxMiNJXo,1125
-dodal/devices/undulator.py,sha256=Uf7DpRjhtqkRcNWTqgtrRjoj6tLLgHEPgkxccWU6LE8,2073
-dodal/devices/undulator_dcm.py,sha256=qUMGKnRluO2jsfz6TuXx6ddN59MlLg1lBqloeBgYZIg,5134
-dodal/devices/webcam.py,sha256=znZHHmQjM0T0XSAYXJraCGlwPPGbt3PF6rWjTSbAikI,1394
+dodal/devices/undulator.py,sha256=udwAodxYM9XgtsQGH2PDBA6ehtel5dAFkjsK13nKp6Q,5160
+dodal/devices/undulator_dcm.py,sha256=5hn3UZeu4CYXmfUVSdIxjrcIpStgeA1S744p0iIFp4I,2725
+dodal/devices/webcam.py,sha256=EqdzUBov5wMCULzzkfnCfD-5TQMZFQLp-2nlDHezmPs,2332
 dodal/devices/xbpm_feedback.py,sha256=-1wbnahJ_oSljQR0Sjiwn3mytVP-VwsAy0a_YPjPM0Y,1168
 dodal/devices/zebra.py,sha256=iTHkKv8EP-gkr0Cl2gR9yxt2qTHT2Q4etS67Rshf83k,9327
 dodal/devices/zebra_controlled_shutter.py,sha256=w2ISASJ_sb3dbQGi63Yuj3ymTkjX73aSl_ZTYs8TyaI,1860
@@ -73,7 +73,7 @@ dodal/devices/areadetector/__init__.py,sha256=8IwLxuZMW0MOJpJp_ZDdlaE20hrtsH_PXW
 dodal/devices/areadetector/adaravis.py,sha256=Cqw_Mzrp_zODFxQ2LZBJzHp_DsZ6_dAITkZz8gYz_0w,3797
 dodal/devices/areadetector/adsim.py,sha256=cIc9PRbKnftBk7Ut8d8CU_TVrin8EwcKHObP2n9VxWM,1876
 dodal/devices/areadetector/adutils.py,sha256=4axFR3wtn-K-sjMVJyfTcu-8g35odf2cY8mTKv1gS-o,3093
-dodal/devices/areadetector/plugins/MJPG.py,sha256=MqxDbrgpTzM0ezjcEWuLlK80i4M_KLNfdknHCx7k_LM,4100
+dodal/devices/areadetector/plugins/MJPG.py,sha256=XztHFB1e7qHeZORYxvPgHfDMfkpXGKvfQYmej_hGVVc,4934
 dodal/devices/detector/__init__.py,sha256=-RdACL3tzc3lLArWOoGNje48UUlv2fElOmGOz9yOuO0,317
 dodal/devices/detector/det_dim_constants.py,sha256=LNrVMd0DbFEcnyNFmXosCP-VYaZ71Ajuv6inwo4Mg3U,2299
 dodal/devices/detector/det_dist_to_beam_converter.py,sha256=7keoqZYfvgayePVx97lHYpcFRTJnQOfAk_PYP4EZTZQ,1951
@@ -93,7 +93,7 @@ dodal/devices/i24/dcm.py,sha256=nP2qymTy5TrOu078XOY7h1TEwVfcgli5lTyxmwsG4O8,1990
 dodal/devices/i24/dual_backlight.py,sha256=Th-RKr28aFxE8LCT_mdN9KkRIVw0BHLGKkI0ienfRZU,2049
 dodal/devices/i24/i24_detector_motion.py,sha256=_HgdsZqFYY0tKqUgMzViHaPEUFXL3WlXXioGvDehRUw,364
 dodal/devices/i24/i24_vgonio.py,sha256=Igqs7687z6lyhGVeJEDtDmPachYxU48MUH2BF0RpK9Q,461
-dodal/devices/i24/pmac.py,sha256=suWoOIQKhCeQvgBJ8_htRAG6k0REN32viElwvs2nkEg,5224
+dodal/devices/i24/pmac.py,sha256=qug40tz00vjvmQox3W6GrEcorriEeGkNyP5m4u5CVHo,7201
 dodal/devices/oav/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/devices/oav/grid_overlay.py,sha256=kYs4sCvmo7yG75HQtptuI8jPzM7dR4fSqnOGL0D5j6g,5338
 dodal/devices/oav/microns_for_zoom_levels.json,sha256=kJTkbu2v6_Ccc_cDy7FRTX-gRhXxfYskjVqwBCZIqCQ,1209
@@ -120,15 +120,15 @@ dodal/devices/util/test_utils.py,sha256=VrSFFGLNKOcCAsWFMZOxwhng3wGR5kV8NqqnKfj8
 dodal/devices/xspress3/xspress3.py,sha256=JTx3ppAc8GwV9K-Gfqo81iGYH_L-ONyFWiPRs9XUs-w,4661
 dodal/devices/xspress3/xspress3_channel.py,sha256=yJRwseLmtkW2Vv6GB8sLdOFuBn3e4c9Q8fgPacMgl5w,1638
 dodal/devices/zocalo/__init__.py,sha256=oPhjFB39yf2NWkGD-MMcPFnnOVZ_RtdyBt2OLYn-Xa4,505
-dodal/devices/zocalo/zocalo_interaction.py,sha256=cc-OwjNsh9oMpMghceVWKW9gym_TFmP-mOYBd3H1H7Q,3379
-dodal/devices/zocalo/zocalo_results.py,sha256=L4bUc8xkYCmn5KCx_vcMKFBiBO5F9nhYEffv8fGUS48,9891
+dodal/devices/zocalo/zocalo_interaction.py,sha256=y8YKMaVwfsRPBofHGGLYmYsd4QwMvm7JIPEo6wrN_Xo,3493
+dodal/devices/zocalo/zocalo_results.py,sha256=MStx8iK--ITff-rT3AQu_RHnqKqNGLJDVyV3ewBwaKE,14316
 dodal/parameters/experiment_parameter_base.py,sha256=O7JamfuJ5cYHkPf9tsHJPqn-OMHTAGouigvM1cDFehE,313
 dodal/plans/check_topup.py,sha256=3gyLHfHNQBCgEWuAg4QE-ONx7y2Do1vVv5HP8ss0Z1I,5371
 dodal/plans/data_session_metadata.py,sha256=urexZ3mA0K6VWxVW3MlrcsB1Tyi09tFvpKBlaVil7TQ,1567
 dodal/plans/motor_util_plans.py,sha256=JT1K4DBB66MrzNqimxFgiL6mRsj11fF7xZXOz0udEeo,4522
-dls_dodal-1.31.1.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-dls_dodal-1.31.1.dist-info/METADATA,sha256=DcnbFBg6UX0o2covzHK0zCgw05wLGCXlzWN08tB6Cvg,16547
-dls_dodal-1.31.1.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-dls_dodal-1.31.1.dist-info/entry_points.txt,sha256=bycw_EKUzup_rxfCetOwcauXV4kLln_OPpPT8jEnr-I,94
-dls_dodal-1.31.1.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
-dls_dodal-1.31.1.dist-info/RECORD,,
+dls_dodal-1.32.0.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+dls_dodal-1.32.0.dist-info/METADATA,sha256=Y7XXnR4vFkIsqoZ6vXh9STdoUyc9cbudVRqzP30rHUM,16574
+dls_dodal-1.32.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+dls_dodal-1.32.0.dist-info/entry_points.txt,sha256=bycw_EKUzup_rxfCetOwcauXV4kLln_OPpPT8jEnr-I,94
+dls_dodal-1.32.0.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
+dls_dodal-1.32.0.dist-info/RECORD,,

{dls_dodal-1.31.1.dist-info → dls_dodal-1.32.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.2)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dodal/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.31.1'
-__version_tuple__ = version_tuple = (1, 31, 1)
+__version__ = version = '1.32.0'
+__version_tuple__ = version_tuple = (1, 32, 0)

dodal/beamlines/i03.py

@@ -316,6 +316,7 @@ def undulator(
         wait_for_connection,
         fake_with_ophyd_sim,
         bl_prefix=False,
+        id_gap_lookup_table_path="/dls_sw/i03/software/daq_configuration/lookup/BeamLine_Undulator_toGap.txt",
     )
 
 
@@ -334,7 +335,6 @@ def undulator_dcm(
         undulator=undulator(wait_for_connection, fake_with_ophyd_sim),
         dcm=dcm(wait_for_connection, fake_with_ophyd_sim),
         daq_configuration_path=DAQ_CONFIGURATION_PATH,
-        id_gap_lookup_table_path="/dls_sw/i03/software/daq_configuration/lookup/BeamLine_Undulator_toGap.txt",
     )
 
 

dodal/beamlines/i04.py

@@ -308,6 +308,7 @@ def undulator(
         wait_for_connection,
         fake_with_ophyd_sim,
         bl_prefix=False,
+        id_gap_lookup_table_path="/dls_sw/i04/software/gda/config/lookupTables/BeamLine_Undulator_toGap.txt",
     )
 
 

dodal/beamlines/i22.py

@@ -199,6 +199,7 @@ def undulator(
         bl_prefix=False,
         poles=80,
         length=2.0,
+        id_gap_lookup_table_path="/dls_sw/i22/software/daq_configuration/lookup/BeamLine_Undulator_toGap.txt",
     )
 
 

dodal/devices/aperturescatterguard.py

@@ -220,15 +220,15 @@ class ApertureScatterguard(StandardReadable, Movable):
                 self.aperture.y.set(aperture_y),
                 self.aperture.z.set(aperture_z),
             )
-            return
-        await asyncio.gather(
-            self.aperture.x.set(aperture_x),
-            self.aperture.y.set(aperture_y),
-            self.aperture.z.set(aperture_z),
-        )
+        else:
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
 
-        await asyncio.gather(
-            self.scatterguard.x.set(scatterguard_x),
-            self.scatterguard.y.set(scatterguard_y),
-        )
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )
         await self.selected_aperture.set(value)

dodal/devices/areadetector/plugins/MJPG.py

@@ -87,11 +87,12 @@ class MJPG(Device, ABC):
 
 
 class SnapshotWithBeamCentre(MJPG):
-    """A child of MJPG which, when triggered, draws a crosshair at the beam centre in the
-    image and saves the image to disk."""
+    """A child of MJPG which, when triggered, draws an outlined crosshair at the beam
+    centre in the image and saves the image to disk."""
 
     CROSSHAIR_LENGTH_PX = 20
-    CROSSHAIR_COLOUR = "Blue"
+    CROSSHAIR_OUTLINE_COLOUR = "Black"
+    CROSSHAIR_FILL_COLOUR = "White"
 
     def post_processing(self, image: Image.Image):
         assert (
@@ -100,15 +101,38 @@ class SnapshotWithBeamCentre(MJPG):
         beam_x = self.oav_params.beam_centre_i
         beam_y = self.oav_params.beam_centre_j
 
+        SnapshotWithBeamCentre.draw_crosshair(image, beam_x, beam_y)
+
+        self._save_image(image)
+
+    @classmethod
+    def draw_crosshair(cls, image: Image.Image, beam_x: int, beam_y: int):
         draw = ImageDraw.Draw(image)
-        HALF_LEN = self.CROSSHAIR_LENGTH_PX / 2
+        OUTLINE_WIDTH = 1
+        HALF_LEN = cls.CROSSHAIR_LENGTH_PX / 2
+        draw.rectangle(
+            [
+                beam_x - OUTLINE_WIDTH,
+                beam_y - HALF_LEN - OUTLINE_WIDTH,
+                beam_x + OUTLINE_WIDTH,
+                beam_y + HALF_LEN + OUTLINE_WIDTH,
+            ],
+            fill=cls.CROSSHAIR_OUTLINE_COLOUR,
+        )
+        draw.rectangle(
+            [
+                beam_x - HALF_LEN - OUTLINE_WIDTH,
+                beam_y - OUTLINE_WIDTH,
+                beam_x + HALF_LEN + OUTLINE_WIDTH,
+                beam_y + OUTLINE_WIDTH,
+            ],
+            fill=cls.CROSSHAIR_OUTLINE_COLOUR,
+        )
         draw.line(
             ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
-            fill=self.CROSSHAIR_COLOUR,
+            fill=cls.CROSSHAIR_FILL_COLOUR,
         )
         draw.line(
             ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
-            fill=self.CROSSHAIR_COLOUR,
+            fill=cls.CROSSHAIR_FILL_COLOUR,
         )
-
-        self._save_image(image)

dodal/devices/fast_grid_scan.py

@@ -3,6 +3,7 @@ from typing import Generic, TypeVar
 
 import numpy as np
 from bluesky.plan_stubs import mv
+from bluesky.protocols import Flyable
 from numpy import ndarray
 from ophyd_async.core import (
     AsyncStatus,
@@ -193,7 +194,7 @@ class ExpectedImages(SignalR[int]):
         return first_grid + second_grid
 
 
-class FastGridScanCommon(StandardReadable, ABC, Generic[ParamType]):
+class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
     """Device for a general fast grid scan
 
     When the motion program is started, the goniometer will move in a snake-like grid trajectory,

dodal/devices/focusing_mirror.py

@@ -76,7 +76,7 @@ class MirrorVoltageDevice(Device):
             LOGGER.debug(f"{setpoint_v.name} already at {value} - skipping set")
             return
 
-        LOGGER.debug(f"setting {setpoint_v.name} to {value}")
+        LOGGER.debug(f"Setting {setpoint_v.name} to {value}")
 
         # Register an observer up front to ensure we don't miss events after we
         # perform the set
@@ -85,16 +85,14 @@ class MirrorVoltageDevice(Device):
         )
         # discard the current value (OK) so we can await a subsequent change
         await anext(demand_accepted_iterator)
-        await setpoint_v.set(value)
+        set_status = setpoint_v.set(value, wait=False)
 
         # The set should always change to SLEW regardless of whether we are
         # already at the set point, then change back to OK/FAIL depending on
         # success
         accepted_value = await anext(demand_accepted_iterator)
         assert accepted_value == MirrorVoltageDemand.SLEW
-        LOGGER.debug(
-            f"Demand not accepted for {setpoint_v.name}, waiting for acceptance..."
-        )
+        LOGGER.debug(f"Waiting for {setpoint_v.name} to set")
         while MirrorVoltageDemand.SLEW == (
             accepted_value := await anext(demand_accepted_iterator)
         ):
@@ -104,6 +102,7 @@ class MirrorVoltageDevice(Device):
             raise AssertionError(
                 f"Voltage slew failed for {setpoint_v.name}, new state={accepted_value}"
             )
+        await set_status
 
 
 class VFMMirrorVoltages(StandardReadable):

dodal/devices/i24/pmac.py

@@ -1,16 +1,17 @@
+from asyncio import sleep
 from enum import Enum, IntEnum
-from typing import SupportsFloat
 
-from bluesky.protocols import Triggerable
+from bluesky.protocols import Flyable, Triggerable
 from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
-    CalculateTimeout,
     SignalBackend,
     SignalR,
     SignalRW,
     SoftSignalBackend,
     StandardReadable,
+    soft_signal_rw,
     wait_for_value,
 )
 from ophyd_async.epics.motor import Motor
@@ -89,7 +90,7 @@ class PMACStringLaser(SignalRW):
         self,
         value: LaserSettings,
         wait=True,
-        timeout=CalculateTimeout,
+        timeout=CALCULATE_TIMEOUT,
     ):
         await self.signal.set(value.value, wait, timeout)
 
@@ -112,13 +113,13 @@ class PMACStringEncReset(SignalRW):
         self,
         value: EncReset,
         wait=True,
-        timeout=CalculateTimeout,
+        timeout=CALCULATE_TIMEOUT,
     ):
         await self.signal.set(value.value, wait, timeout)
 
 
-class ProgramRunner(SignalRW):
-    """Trigger the collection by setting the program number on the PMAC string.
+class ProgramRunner(SignalRW, 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.
     This will only be true when the status becomes 0.
@@ -128,22 +129,73 @@ class ProgramRunner(SignalRW):
         self,
         pmac_str_sig: SignalRW,
         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.collection_time = collection_time_sig
+        self.KICKOFF_TIMEOUT = timeout
+
         super().__init__(backend, timeout, name)
 
+    async def _get_prog_number_string(self) -> str:
+        prog_num = await self.prog_num.get_value()
+        return f"&2b{prog_num}r"
+
+    @AsyncStatus.wrap
+    async def kickoff(self):
+        """Kick off the collection by sending a program number to the pmac_string and \
+            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 wait_for_value(
+            self.status,
+            ScanState.RUNNING,
+            timeout=self.KICKOFF_TIMEOUT,
+        )
+
+    @AsyncStatus.wrap
+    async def complete(self):
+        """Stop collecting when the scan status PV goes to 0.
+
+        Args:
+            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)
+
+
+class ProgramAbort(Triggerable):
+    """Abort a data collection by setting the PMAC string and then wait for the \
+        status value to go back to 0.
+    """
+
+    def __init__(
+        self,
+        pmac_str_sig: SignalRW,
+        status_sig: SignalR,
+    ) -> None:
+        self.signal = pmac_str_sig
+        self.status = status_sig
+
     @AsyncStatus.wrap
-    async def set(self, value: int, wait=True, timeout=None):
-        prog_str = f"&2b{value}r"
-        assert isinstance(timeout, SupportsFloat) or (
-            timeout is None
-        ), f"ProgramRunner does not support calculating timeout itself, {timeout=}"
-        await self.signal.set(prog_str, wait=wait)
-        await wait_for_value(self.status, ScanState.DONE, timeout)
+    async def trigger(self):
+        await self.signal.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 wait_for_value(
+            self.status,
+            ScanState.DONE,
+            timeout=DEFAULT_TIMEOUT,
+        )
 
 
 class PMAC(StandardReadable):
@@ -172,8 +224,18 @@ class PMAC(StandardReadable):
         self.scanstatus = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2401")
         self.counter = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2402")
 
+        # A couple of soft signals for running a collection: program number to send to
+        # the PMAC_STRING and expected collection time.
+        self.program_number = soft_signal_rw(int)
+        self.collection_time = soft_signal_rw(float, initial_value=600.0, units="s")
+
         self.run_program = ProgramRunner(
-            self.pmac_string, self.scanstatus, backend=SoftSignalBackend(str)
+            self.pmac_string,
+            self.scanstatus,
+            self.program_number,
+            self.collection_time,
+            backend=SoftSignalBackend(str),
         )
+        self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 
         super().__init__(name)

dodal/devices/robot.py

@@ -1,5 +1,5 @@
 import asyncio
-from asyncio import FIRST_COMPLETED, CancelledError, Task
+from asyncio import FIRST_COMPLETED, CancelledError, Task, wait_for
 from dataclasses import dataclass
 from enum import Enum
 
@@ -41,6 +41,9 @@ class PinMounted(str, Enum):
 class BartRobot(StandardReadable, Movable):
     """The sample changing robot."""
 
+    # How long to wait for the robot if it is busy soaking/drying
+    NOT_BUSY_TIMEOUT = 60
+    # How long to wait for the actual load to happen
     LOAD_TIMEOUT = 60
     NO_PIN_ERROR_CODE = 25
 
@@ -54,10 +57,15 @@ class BartRobot(StandardReadable, Movable):
     ) -> None:
         self.barcode = epics_signal_r(str, prefix + "BARCODE")
         self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
+
         self.next_pin = epics_signal_rw_rbv(float, prefix + "NEXT_PIN")
         self.next_puck = epics_signal_rw_rbv(float, prefix + "NEXT_PUCK")
+        self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
+        self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
+
         self.next_sample_id = epics_signal_rw_rbv(float, prefix + "NEXT_ID")
         self.sample_id = epics_signal_r(float, prefix + "CURRENT_ID_RBV")
+
         self.load = epics_signal_x(prefix + "LOAD.PROC")
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")
@@ -93,7 +101,7 @@ class BartRobot(StandardReadable, Movable):
             for task in finished:
                 await task
         except CancelledError:
-            # If the outer enclosing task cancels after LOAD_TIMEOUT, this causes CancelledError to be raised
+            # If the outer enclosing task cancels after a timeout, this causes CancelledError to be raised
             # in the current task, when it propagates to here we should cancel all pending tasks before bubbling up
             for task in tasks:
                 task.cancel()
@@ -105,7 +113,9 @@ class BartRobot(StandardReadable, Movable):
             LOGGER.info(
                 f"Waiting on robot to finish {await self.program_name.get_value()}"
             )
-            await wait_for_value(self.program_running, False, None)
+            await wait_for_value(
+                self.program_running, False, timeout=self.NOT_BUSY_TIMEOUT
+            )
         await asyncio.gather(
             set_and_wait_for_value(self.next_puck, sample_location.puck),
             set_and_wait_for_value(self.next_pin, sample_location.pin),
@@ -121,10 +131,12 @@ class BartRobot(StandardReadable, Movable):
     @AsyncStatus.wrap
     async def set(self, value: SampleLocation):
         try:
-            await asyncio.wait_for(
-                self._load_pin_and_puck(value), timeout=self.LOAD_TIMEOUT
+            await wait_for(
+                self._load_pin_and_puck(value),
+                timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
             )
-        except asyncio.TimeoutError as e:
+        except (asyncio.TimeoutError, TimeoutError) as e:
+            # Will only need to catch asyncio.TimeoutError after https://github.com/bluesky/ophyd-async/issues/572
             error_code = await self.error_code.get_value()
             error_string = await self.error_str.get_value()
             raise RobotLoadFailed(int(error_code), error_string) from e

dodal/devices/tetramm.py

@@ -3,13 +3,13 @@ from enum import Enum
 
 from bluesky.protocols import Hints
 from ophyd_async.core import (
-    AsyncStatus,
     DatasetDescriber,
     DetectorControl,
     DetectorTrigger,
     Device,
     PathProvider,
     StandardDetector,
+    TriggerInfo,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
 )
@@ -113,29 +113,24 @@ class TetrammController(DetectorControl):
         # 2 internal clock cycles. Best effort approximation
         return 2 / self.base_sample_rate
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.edge_trigger,
-        exposure: float | None = None,
-    ) -> AsyncStatus:
-        if exposure is None:
-            raise ValueError(
-                "Tetramm does not support arm without exposure time. "
-                "Is this a software scan? Tetramm only supports hardware scans."
-            )
-        self._validate_trigger(trigger)
+    async def prepare(self, trigger_info: TriggerInfo):
+        self._validate_trigger(trigger_info.trigger)
+        assert trigger_info.livetime is not None
 
         # trigger mode must be set first and on its own!
         await self._drv.trigger_mode.set(TetrammTrigger.ExtTrigger)
 
         await asyncio.gather(
-            self._drv.averaging_time.set(exposure), self.set_exposure(exposure)
+            self._drv.averaging_time.set(trigger_info.livetime),
+            self.set_exposure(trigger_info.livetime),
         )
 
-        status = await set_and_wait_for_value(self._drv.acquire, True)
+    async def arm(self):
+        self._arm_status = await set_and_wait_for_value(self._drv.acquire, True)
 
-        return status
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
 
     def _validate_trigger(self, trigger: DetectorTrigger) -> None:
         supported_trigger_types = {

dodal/devices/undulator.py

@@ -1,12 +1,35 @@
 from enum import Enum
 
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
+import numpy as np
+from bluesky.protocols import Movable
+from numpy import argmin, ndarray
+from ophyd_async.core import (
+    AsyncStatus,
+    ConfigSignal,
+    StandardReadable,
+    soft_signal_r_and_setter,
+)
 from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
+from dodal.log import LOGGER
+
+from .util.lookup_tables import energy_distance_table
+
+
+class AccessError(Exception):
+    pass
+
+
+# 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
+
+
 # The acceptable difference, in mm, between the undulator gap and the DCM
 # energy, when the latter is converted to mm using lookup tables
 UNDULATOR_DISCREPANCY_THRESHOLD_MM = 2e-3
+STATUS_TIMEOUT_S: float = 10.0
 
 
 class UndulatorGapAccess(str, Enum):
@@ -14,7 +37,15 @@ class UndulatorGapAccess(str, Enum):
     DISABLED = "DISABLED"
 
 
-class Undulator(StandardReadable):
+def _get_closest_gap_for_energy(
+    dcm_energy_ev: float, energy_to_distance_table: ndarray
+) -> float:
+    table = energy_to_distance_table.transpose()
+    idx = argmin(np.abs(table[0] - dcm_energy_ev))
+    return table[1][idx]
+
+
+class Undulator(StandardReadable, Movable):
     """
     An Undulator-type insertion device, used to control photon emission at a given
     beam energy.
@@ -23,6 +54,7 @@ class Undulator(StandardReadable):
     def __init__(
         self,
         prefix: str,
+        id_gap_lookup_table_path: str,
         name: str = "",
         poles: int | None = None,
         length: float | None = None,
@@ -36,6 +68,7 @@ class Undulator(StandardReadable):
             name (str, optional): Name for device. Defaults to "".
         """
 
+        self.id_gap_lookup_table_path = id_gap_lookup_table_path
         with self.add_children_as_readables():
             self.gap_motor = Motor(prefix + "BLGAPMTR")
             self.current_gap = epics_signal_r(float, prefix + "CURRGAPD")
@@ -63,3 +96,59 @@ class Undulator(StandardReadable):
                 self.length = None
 
         super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """
+        Set the undulator gap to a given energy in keV
+
+        Args:
+            value: energy in keV
+        """
+        await self._set_undulator_gap(value)
+
+    async def _set_undulator_gap(self, energy_kev: float) -> None:
+        access_level = await self.gap_access.get_value()
+        if access_level is UndulatorGapAccess.DISABLED and not TEST_MODE:
+            raise AccessError("Undulator gap access is disabled. Contact Control Room")
+        LOGGER.info(f"Setting undulator gap to {energy_kev:.2f} kev")
+        target_gap = await self._get_gap_to_match_energy(energy_kev)
+
+        # Check if undulator gap is close enough to the value from the DCM
+        current_gap = await self.current_gap.get_value()
+        tolerance = await self.gap_discrepancy_tolerance_mm.get_value()
+        difference = abs(target_gap - current_gap)
+        if difference > tolerance:
+            LOGGER.info(
+                f"Undulator gap mismatch. {difference:.3f}mm is outside tolerance.\
+                Moving gap to nominal value, {target_gap:.3f}mm"
+            )
+            if not TEST_MODE:
+                # Only move if the gap is sufficiently different to the value from the
+                # DCM lookup table AND we're not in TEST_MODE
+                await self.gap_motor.set(
+                    target_gap,
+                    timeout=STATUS_TIMEOUT_S,
+                )
+            else:
+                LOGGER.debug("In test mode, not moving ID gap")
+        else:
+            LOGGER.debug(
+                "Gap is already in the correct place for the new energy value "
+                f"{energy_kev}, no need to ask it to move"
+            )
+
+    async def _get_gap_to_match_energy(self, energy_kev: float) -> float:
+        """
+        get a 2d np.array from lookup table that
+        converts energies to undulator gap distance
+        """
+        energy_to_distance_table: np.ndarray = await energy_distance_table(
+            self.id_gap_lookup_table_path
+        )
+
+        # Use the lookup table to get the undulator gap associated with this dcm energy
+        return _get_closest_gap_for_energy(
+            energy_kev * 1000,
+            energy_to_distance_table,
+        )

dodal/devices/undulator_dcm.py

@@ -1,19 +1,14 @@
 import asyncio
 
-import numpy as np
 from bluesky.protocols import Movable
-from numpy import argmin, ndarray
 from ophyd_async.core import AsyncStatus, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
-from dodal.log import LOGGER
 
 from .dcm import DCM
 from .undulator import Undulator, UndulatorGapAccess
-from .util.lookup_tables import energy_distance_table
 
 ENERGY_TIMEOUT_S: float = 30.0
-STATUS_TIMEOUT_S: float = 10.0
 
 # Enable to allow testing when the beamline is down, do not change in production!
 TEST_MODE = False
@@ -23,14 +18,6 @@ class AccessError(Exception):
     pass
 
 
-def _get_closest_gap_for_energy(
-    dcm_energy_ev: float, energy_to_distance_table: ndarray
-) -> float:
-    table = energy_to_distance_table.transpose()
-    idx = argmin(np.abs(table[0] - dcm_energy_ev))
-    return table[1][idx]
-
-
 class UndulatorDCM(StandardReadable, Movable):
     """
     Composite device to handle changing beamline energies, wraps the Undulator and the
@@ -48,7 +35,6 @@ class UndulatorDCM(StandardReadable, Movable):
         self,
         undulator: Undulator,
         dcm: DCM,
-        id_gap_lookup_table_path: str,
         daq_configuration_path: str,
         prefix: str = "",
         name: str = "",
@@ -61,11 +47,10 @@ class UndulatorDCM(StandardReadable, Movable):
         self.dcm = dcm
 
         # These attributes are just used by hyperion for lookup purposes
-        self.id_gap_lookup_table_path = id_gap_lookup_table_path
-        self.dcm_pitch_converter_lookup_table_path = (
+        self.pitch_energy_table_path = (
             daq_configuration_path + "/lookup/BeamLineEnergy_DCM_Pitch_converter.txt"
         )
-        self.dcm_roll_converter_lookup_table_path = (
+        self.roll_energy_table_path = (
             daq_configuration_path + "/lookup/BeamLineEnergy_DCM_Roll_converter.txt"
         )
         # I03 configures the DCM Perp as a side effect of applying this fixed value to the DCM Offset after an energy change
@@ -78,7 +63,7 @@ class UndulatorDCM(StandardReadable, Movable):
     async def set(self, value: float):
         await asyncio.gather(
             self._set_dcm_energy(value),
-            self._set_undulator_gap_if_required(value),
+            self.undulator.set(value),
         )
 
     async def _set_dcm_energy(self, energy_kev: float) -> None:
@@ -90,42 +75,3 @@ class UndulatorDCM(StandardReadable, Movable):
             energy_kev,
             timeout=ENERGY_TIMEOUT_S,
         )
-
-    async def _set_undulator_gap_if_required(self, energy_kev: float) -> None:
-        LOGGER.info(f"Setting DCM energy to {energy_kev:.2f} kev")
-        gap_to_match_dcm_energy = await self._gap_to_match_dcm_energy(energy_kev)
-
-        # Check if undulator gap is close enough to the value from the DCM
-        current_gap = await self.undulator.current_gap.get_value()
-        tolerance = await self.undulator.gap_discrepancy_tolerance_mm.get_value()
-        if abs(gap_to_match_dcm_energy - current_gap) > tolerance:
-            LOGGER.info(
-                f"Undulator gap mismatch. {abs(gap_to_match_dcm_energy-current_gap):.3f}mm is outside tolerance.\
-                Moving gap to nominal value, {gap_to_match_dcm_energy:.3f}mm"
-            )
-            if not TEST_MODE:
-                # Only move if the gap is sufficiently different to the value from the
-                # DCM lookup table AND we're not in TEST_MODE
-                await self.undulator.gap_motor.set(
-                    gap_to_match_dcm_energy,
-                    timeout=STATUS_TIMEOUT_S,
-                )
-            else:
-                LOGGER.debug("In test mode, not moving ID gap")
-        else:
-            LOGGER.debug(
-                "Gap is already in the correct place for the new energy value "
-                f"{energy_kev}, no need to ask it to move"
-            )
-
-    async def _gap_to_match_dcm_energy(self, energy_kev: float) -> float:
-        # Get 2d np.array converting energies to undulator gap distance, from lookup table
-        energy_to_distance_table = await energy_distance_table(
-            self.id_gap_lookup_table_path
-        )
-
-        # Use the lookup table to get the undulator gap associated with this dcm energy
-        return _get_closest_gap_for_energy(
-            energy_kev * 1000,
-            energy_to_distance_table,
-        )

dodal/devices/webcam.py

@@ -1,12 +1,24 @@
+from collections.abc import ByteString
+from io import BytesIO
 from pathlib import Path
 
 import aiofiles
 from aiohttp import ClientSession
 from bluesky.protocols import Triggerable
 from ophyd_async.core import AsyncStatus, HintedSignal, StandardReadable, soft_signal_rw
+from PIL import Image
 
 from dodal.log import LOGGER
 
+PLACEHOLDER_IMAGE_SIZE = (1024, 768)
+IMAGE_FORMAT = "png"
+
+
+def create_placeholder_image() -> ByteString:
+    image = Image.new("RGB", PLACEHOLDER_IMAGE_SIZE)
+    image.save(buffer := BytesIO(), format=IMAGE_FORMAT)
+    return buffer.getbuffer()
+
 
 class Webcam(StandardReadable, Triggerable):
     def __init__(self, name, prefix, url):
@@ -18,19 +30,33 @@ class Webcam(StandardReadable, Triggerable):
         self.add_readables([self.last_saved_path], wrapper=HintedSignal)
         super().__init__(name=name)
 
-    async def _write_image(self, file_path: str):
+    async def _write_image(self, file_path: str, image: ByteString):
+        async with aiofiles.open(file_path, "wb") as file:
+            await file.write(image)
+
+    async def _get_and_write_image(self, file_path: str):
         async with ClientSession() as session:
             async with session.get(self.url) as response:
-                response.raise_for_status()
-                LOGGER.info(f"Saving webcam image from {self.url} to {file_path}")
-                async with aiofiles.open(file_path, "wb") as file:
-                    await file.write(await response.read())
+                if not response.ok:
+                    LOGGER.warning(
+                        f"Webcam responded with {response.status}: {response.reason}. Attempting to read anyway."
+                    )
+                try:
+                    data = await response.read()
+                    LOGGER.info(f"Saving webcam image from {self.url} to {file_path}")
+                except Exception as e:
+                    LOGGER.warning(
+                        f"Failed to read data from {self.url} ({e}). Using placeholder image."
+                    )
+                    data = create_placeholder_image()
+
+                await self._write_image(file_path, data)
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
         filename = await self.filename.get_value()
         directory = await self.directory.get_value()
 
-        file_path = Path(f"{directory}/{filename}.png").as_posix()
-        await self._write_image(file_path)
+        file_path = Path(f"{directory}/{filename}.{IMAGE_FORMAT}").as_posix()
+        await self._get_and_write_image(file_path)
         await self.last_saved_path.set(file_path)

dodal/devices/zocalo/zocalo_interaction.py

@@ -39,7 +39,12 @@ class ZocaloStartInfo:
 
 
 def _get_zocalo_headers() -> tuple[str, str]:
-    user = os.environ.get("ZOCALO_GO_USER", getpass.getuser())
+    user = os.environ.get("ZOCALO_GO_USER")
+
+    # cannot default as getuser() will throw when called from inside a container
+    if not user:
+        user = getpass.getuser()
+
     hostname = os.environ.get("ZOCALO_GO_HOSTNAME", socket.gethostname())
     return user, hostname
 

dodal/devices/zocalo/zocalo_results.py

@@ -10,6 +10,7 @@ import numpy as np
 import workflows.recipe
 import workflows.transport
 from bluesky.protocols import Descriptor, Triggerable
+from deepdiff import DeepDiff
 from numpy.typing import NDArray
 from ophyd_async.core import (
     AsyncStatus,
@@ -37,6 +38,11 @@ class SortKeys(str, Enum):
     n_voxels = "n_voxels"
 
 
+class ZocaloSource(str, Enum):
+    CPU = "CPU"
+    GPU = "GPU"
+
+
 DEFAULT_TIMEOUT = 180
 DEFAULT_SORT_KEY = SortKeys.max_count
 ZOCALO_READING_PLAN_NAME = "zocalo reading"
@@ -60,12 +66,50 @@ def bbox_size(result: XrcResult):
     ]
 
 
+def get_dict_differences(
+    dict1: dict, dict1_source: str, dict2: dict, dict2_source: str
+) -> str | None:
+    """Returns a string containing dict1 and dict2 if there are differences between them, greater than a
+    1e-5 tolerance. If dictionaries are identical, return None"""
+
+    diff = DeepDiff(dict1, dict2, math_epsilon=1e-5, ignore_numeric_type_changes=True)
+
+    if diff:
+        return f"Zocalo results from {dict1_source} and {dict2_source} are not identical.\n Results from {dict1_source}: {dict1}\n Results from {dict2_source}: {dict2}"
+
+
+def source_from_results(results):
+    return (
+        ZocaloSource.GPU.value
+        if results["recipe_parameters"].get("gpu")
+        else ZocaloSource.CPU.value
+    )
+
+
 class ZocaloResults(StandardReadable, Triggerable):
     """An ophyd device which can wait for results from a Zocalo job. These jobs should
     be triggered from a plan-subscribed callback using the run_start() and run_end()
     methods on dodal.devices.zocalo.ZocaloTrigger.
 
-    See https://github.com/DiamondLightSource/dodal/wiki/How-to-Interact-with-Zocalo"""
+    See https://diamondlightsource.github.io/dodal/main/how-to/zocalo.html
+
+    Args:
+        name (str): Name of the device
+
+        zocalo_environment (str): How zocalo is configured. Defaults to i03's development configuration
+
+        channel (str): Name for the results Queue
+
+        sort_key (str): How results are ranked. Defaults to sorting by highest counts
+
+        timeout_s (float): Maximum time to wait for the Queue to be filled by an object, starting
+        from when the ZocaloResults device is triggered
+
+        prefix (str): EPICS PV prefix for the device
+
+        use_cpu_and_gpu (bool): When True, ZocaloResults will wait for results from the CPU and the GPU, compare them, and provide a warning if the results differ. When False, ZocaloResults will only use results from the CPU
+
+    """
 
     def __init__(
         self,
@@ -75,6 +119,7 @@ class ZocaloResults(StandardReadable, Triggerable):
         sort_key: str = DEFAULT_SORT_KEY.value,
         timeout_s: float = DEFAULT_TIMEOUT,
         prefix: str = "",
+        use_cpu_and_gpu: bool = False,
     ) -> None:
         self.zocalo_environment = zocalo_environment
         self.sort_key = SortKeys[sort_key]
@@ -83,6 +128,7 @@ class ZocaloResults(StandardReadable, Triggerable):
         self._prefix = prefix
         self._raw_results_received: Queue = Queue()
         self.transport: CommonTransport | None = None
+        self.use_cpu_and_gpu = use_cpu_and_gpu
 
         self.results, self._results_setter = soft_signal_r_and_setter(
             list[XrcResult], name="results"
@@ -111,14 +157,14 @@ class ZocaloResults(StandardReadable, Triggerable):
         )
         super().__init__(name)
 
-    async def _put_results(self, results: Sequence[XrcResult], ispyb_ids):
+    async def _put_results(self, results: Sequence[XrcResult], recipe_parameters):
         self._results_setter(list(results))
         centres_of_mass = np.array([r["centre_of_mass"] for r in results])
         bbox_sizes = np.array([bbox_size(r) for r in results])
         self._com_setter(centres_of_mass)
         self._bbox_setter(bbox_sizes)
-        self._ispyb_dcid_setter(ispyb_ids["dcid"])
-        self._ispyb_dcgid_setter(ispyb_ids["dcgid"])
+        self._ispyb_dcid_setter(recipe_parameters["dcid"])
+        self._ispyb_dcgid_setter(recipe_parameters["dcgid"])
 
     def _clear_old_results(self):
         LOGGER.info("Clearing queue")
@@ -127,7 +173,7 @@ class ZocaloResults(StandardReadable, Triggerable):
     @AsyncStatus.wrap
     async def stage(self):
         """Stages the Zocalo device by: subscribing to the queue, doing a background
-        sleep for a few seconds to wait for any stale messages to be recieved, then
+        sleep for a few seconds to wait for any stale messages to be received, then
         clearing the queue. Plans using this device should wait on ZOCALO_STAGE_GROUP
         before triggering processing for the experiment"""
 
@@ -169,7 +215,57 @@ class ZocaloResults(StandardReadable, Triggerable):
             )
 
             raw_results = self._raw_results_received.get(timeout=self.timeout_s)
-            LOGGER.info(f"Zocalo: found {len(raw_results['results'])} crystals.")
+            source_of_first_results = source_from_results(raw_results)
+
+            # Wait for results from CPU and GPU, warn and continue if only GPU times out. Error if CPU times out
+            if self.use_cpu_and_gpu:
+                if source_of_first_results == ZocaloSource.CPU:
+                    LOGGER.warning("Received zocalo results from CPU before GPU")
+                raw_results_two_sources = [raw_results]
+                try:
+                    raw_results_two_sources.append(
+                        self._raw_results_received.get(timeout=self.timeout_s / 2)
+                    )
+                    source_of_second_results = source_from_results(
+                        raw_results_two_sources[1]
+                    )
+
+                    # Compare results from both sources and warn if they aren't the same
+                    differences_str = get_dict_differences(
+                        raw_results_two_sources[0]["results"][0],
+                        source_of_first_results,
+                        raw_results_two_sources[1]["results"][0],
+                        source_of_second_results,
+                    )
+                    if differences_str:
+                        LOGGER.warning(differences_str)
+
+                    # Always use CPU results
+                    raw_results = (
+                        raw_results_two_sources[0]
+                        if source_of_first_results == ZocaloSource.CPU
+                        else raw_results_two_sources[1]
+                    )
+
+                except Empty as err:
+                    source_of_missing_results = (
+                        ZocaloSource.CPU.value
+                        if source_of_first_results == ZocaloSource.GPU.value
+                        else ZocaloSource.GPU.value
+                    )
+                    if source_of_missing_results == ZocaloSource.GPU.value:
+                        LOGGER.warning(
+                            f"Zocalo results from {source_of_missing_results} timed out. Using results from {source_of_first_results}"
+                        )
+                    else:
+                        LOGGER.error(
+                            f"Zocalo results from {source_of_missing_results} timed out and GPU results not yet reliable"
+                        )
+                        raise err
+
+            LOGGER.info(
+                f"Zocalo results from {ZocaloSource.CPU.value} processing: found {len(raw_results['results'])} crystals."
+            )
             # Sort from strongest to weakest in case of multiple crystals
             await self._put_results(
                 sorted(
@@ -177,7 +273,7 @@ class ZocaloResults(StandardReadable, Triggerable):
                     key=lambda d: d[self.sort_key.value],
                     reverse=True,
                 ),
-                raw_results["ispyb_ids"],
+                raw_results["recipe_parameters"],
             )
         except Empty as timeout_exception:
             LOGGER.warning("Timed out waiting for zocalo results!")
@@ -241,9 +337,17 @@ class ZocaloResults(StandardReadable, Triggerable):
             self.transport.ack(header)  # type: ignore # we create transport here
 
             results = message.get("results", [])
-            self._raw_results_received.put(
-                {"results": results, "ispyb_ids": recipe_parameters}
-            )
+
+            if self.use_cpu_and_gpu:
+                self._raw_results_received.put(
+                    {"results": results, "recipe_parameters": recipe_parameters}
+                )
+            else:
+                # Only add to queue if results are from CPU
+                if not recipe_parameters.get("gpu"):
+                    self._raw_results_received.put(
+                        {"results": results, "recipe_parameters": recipe_parameters}
+                    )
 
         subscription = workflows.recipe.wrap_subscribe(
             self.transport,

dodal/utils.py

@@ -13,6 +13,7 @@ from os import environ
 from types import ModuleType
 from typing import (
     Any,
+    TypeGuard,
     TypeVar,
 )
 
@@ -259,7 +260,7 @@ def _is_device_skipped(func: AnyDeviceFactory) -> bool:
     return getattr(func, "__skip__", False)
 
 
-def is_v1_device_factory(func: Callable) -> bool:
+def is_v1_device_factory(func: Callable) -> TypeGuard[V1DeviceFactory]:
     try:
         return_type = signature(func).return_annotation
         return is_v1_device_type(return_type)
@@ -267,7 +268,7 @@ def is_v1_device_factory(func: Callable) -> bool:
         return False
 
 
-def is_v2_device_factory(func: Callable) -> bool:
+def is_v2_device_factory(func: Callable) -> TypeGuard[V2DeviceFactory]:
     try:
         return_type = signature(func).return_annotation
         return is_v2_device_type(return_type)
@@ -275,7 +276,7 @@ def is_v2_device_factory(func: Callable) -> bool:
         return False
 
 
-def is_any_device_factory(func: Callable) -> bool:
+def is_any_device_factory(func: Callable) -> TypeGuard[AnyDeviceFactory]:
     return is_v1_device_factory(func) or is_v2_device_factory(func)