DAQ/GUI: Add front/back light

src/aare/common/models.py

@@ -682,7 +682,8 @@ class AutofocusSettings(BaseModel):
 class BeamlineStatus(BaseModel):
     name: str
     ring_current_mA: float
-    light: Annotated[float, Field(ge=0.0, le=100.0)]
+    front_light: Annotated[float, Field(ge=0.0, le=100.0)]
+    back_light: Annotated[float, Field(ge=0.0, le=100.0)]
     cryojet_K: float
     shutter_open: bool
     exp_shutter_open: bool | None

src/aare/daq/daq.py

@@ -198,6 +198,7 @@ class AareDAQ:
 
     def __omega(self, val: float):
         self.__saved_box = None
+        print(f"Set omega to {val}")
         if -2000 < val < 2000:
             try:
                 self.__devs.aerotech_omega = val
@@ -236,7 +237,7 @@ class AareDAQ:
             self.__cfg.zoom_mode = ZoomModeEnum.User
 
     @property
-    def light(self) -> float:
+    def front_light(self) -> float:
         val = self.__devs.lamp_light
         if val <= 1.0:
             return 0
@@ -245,12 +246,28 @@ class AareDAQ:
         else:
             return (val - 1.0) / 1.5 * 100.0
 
-    @light.setter
-    def light(self, f: float):
+    @front_light.setter
+    def front_light(self, f: float):
         conv = (f / 100.0 * 1.5) + 1.0
         print(f"Light {f} -> {conv}")
         self.__devs.lamp_light = conv
 
+    @property
+    def back_light(self) -> float:
+        val = self.__devs.back_light
+        if val <= 0.0:
+            return 0.0
+        elif val <= 3.0:
+            return val / 3.0 * 100.0
+        else:
+            return 100.0
+
+    @back_light.setter
+    def back_light(self, f: float):
+        conv = f / 100.0 * 3.0
+        print(f"Backlight {f} -> {conv}")
+        self.__devs.back_light = conv
+
     @property
     def sample(self) -> SampleShortInfo | None:
         if self.__cfg.current_sample is not None and self.__cfg.current_sample.location is None:
@@ -1206,7 +1223,8 @@ class AareDAQ:
     def beamline_status(self) -> BeamlineStatus:
         return BeamlineStatus(
             ring_current_mA=self.__devs.ring_current,
-            light=self.light,
+            front_light=self.front_light,
+            back_light=self.back_light,
             cryojet_K=self.__devs.cryojet_temp,
             shutter_open=self.__devs.shutter,
             exp_shutter_open=self.__devs.shutter,

src/aare/daq/server.py

@@ -102,13 +102,19 @@ async def omega(val: float, token: str = Depends(oauth2_scheme)):
     daq.omega_rel(val)
     return "OK"
 
-@app.put("/beamline/light")
-async def light(val: float, token: str = Depends(oauth2_scheme)):
+@app.put("/beamline/front_light")
+async def front_light(val: float, token: str = Depends(oauth2_scheme)):
     logger.debug(f"Setting light to {val}")
     auth.check_jwt_rw(cfg, auth.parse_token(token))
-    daq.light = val
+    daq.front_light = val
     return "OK"
 
+@app.put("/beamline/back_light")
+async def back_light(val: float, token: str = Depends(oauth2_scheme)):
+    logger.debug(f"Setting back light to {val}")
+    auth.check_jwt_rw(cfg, auth.parse_token(token))
+    daq.back_light = val
+    return "OK"
 
 @app.put("/beamline/zoom")
 async def zoom(val: float, token: str = Depends(oauth2_scheme)):

src/aare/gui/main_window.py

@@ -232,7 +232,9 @@ class MainWindow(QMainWindow):
         self.beamline.omega_panel.set_omega.connect(self.daq.set_omega)
         self.sample_camera.set_omega.connect(self.daq.set_omega)
         self.beamline.zoom_panel.zoom.connect(self.daq.zoom)
-        self.beamline.illumination_panel.light.connect(self.daq.light)
+        self.beamline.illumination_panel.front_light.connect(self.daq.front_light)
+        self.beamline.illumination_panel.back_light.connect(self.daq.back_light)
+
         if self.__decoded_token.staff:
             self.beamline.abr_tweak.abr_tweak.connect(self.daq.abr_tweak)
             self.beamline.abr_tweak.abr_save.connect(self.daq.abr_save)

src/aare/gui/panels/illumination_panel.py

@@ -1,38 +1,57 @@
 from PySide6.QtCore import Qt, Signal, Slot
-from PySide6.QtWidgets import QWidget, QGridLayout, QSlider
+from PySide6.QtWidgets import QWidget, QGridLayout, QSlider, QLabel
 from aare.common.models import DAQStatusModel
 
 from aare.gui.widgets.title_label import TitleLabel
 
 
 class IlluminationPanel(QWidget):
-    light = Signal(int)
+    front_light = Signal(int)
+    back_light = Signal(int)
 
     def __init__(self, parent=None):
         super().__init__(parent)
         grid_layout = QGridLayout(self)
 
-        grid_layout.addWidget(TitleLabel("Front light", self), 0, 0, 1, 2)
+        grid_layout.addWidget(TitleLabel("Light", self), 0, 0, 1, 2)
 
+        front_label = QLabel("Front light", parent=self)
+        front_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        grid_layout.addWidget(front_label, 1, 0, 1, 2)
         self.is_sliding = False
 
-        self.slider = QSlider(orientation=Qt.Orientation.Horizontal, parent=self)
-        self.slider.setRange(0, 100)
-        self.slider.sliderPressed.connect(self.on_slider_pressed)
-        self.slider.sliderReleased.connect(self.on_slider_released)
+        self.front_light_slider = QSlider(orientation=Qt.Orientation.Horizontal, parent=self)
+        self.front_light_slider.setRange(0, 100)
+        self.front_light_slider.sliderPressed.connect(self.on_slider_pressed)
+        self.front_light_slider.sliderReleased.connect(self.on_front_slider_released)
+        grid_layout.addWidget(self.front_light_slider, 2, 0, 1, 2)
 
-        grid_layout.addWidget(self.slider, 1, 0, 1, 2)
+        back_label = QLabel("Back light", parent=self)
+        back_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        grid_layout.addWidget(back_label, 3, 0, 1, 2)
+
+        self.back_light_slider = QSlider(orientation=Qt.Orientation.Horizontal, parent=self)
+        self.back_light_slider.setRange(0, 100)
+        self.back_light_slider.sliderPressed.connect(self.on_slider_pressed)
+        self.back_light_slider.sliderReleased.connect(self.on_back_slider_released)
+        grid_layout.addWidget(self.back_light_slider, 4, 0, 1, 2)
 
     @Slot()
     def on_slider_pressed(self):
         self.is_sliding = True
 
     @Slot()
-    def on_slider_released(self):
+    def on_front_slider_released(self):
         self.is_sliding = False
-        self.light.emit(self.slider.value())
+        self.front_light.emit(self.front_light_slider.value())
+
+    @Slot()
+    def on_back_slider_released(self):
+        self.is_sliding = False
+        self.back_light.emit(self.back_light_slider.value())
 
     @Slot(DAQStatusModel)
     def update_daq_status(self, s: DAQStatusModel):
         if not self.is_sliding:  # Update only if not sliding
-            self.slider.setValue(round(s.bl.light))
+            self.front_light_slider.setValue(round(s.bl.front_light))
+            self.back_light_slider.setValue(round(s.bl.back_light))

src/aare/gui/threads/daq_worker.py

@@ -195,8 +195,12 @@ class DAQWorker(QObject):
         self.generic_put(f"beamline/zoom?val={f:.3f}")
 
     @Slot(int)
-    def light(self, v: int):
-        self.generic_put(f"beamline/light?val={v:d}")
+    def front_light(self, v: int):
+        self.generic_put(f"beamline/front_light?val={v:d}")
+
+    @Slot(int)
+    def back_light(self, v: int):
+        self.generic_put(f"beamline/back_light?val={v:d}")
 
     @Slot()
     def close_shutter(self):