Sending updates to external screen + RGB LCD

orchestrateur/rgb_lcd_manager.py

@@ -0,0 +1,138 @@
+"""
+Manages the RGB LCD display with the current state of the microwaves and cloud connectivity.
+
+The display switches content every x seconds between microwaves, external screens, 
+and cloud connectivity state using a background thread.
+"""
+
+import threading
+import time
+
+SCREEN_SWITCH_INTERVAL = 5  # seconds
+DEFAULT_BRIGHTNESS = 0.3  # Constant brightness (range 0.0 to 1.0)
+
+
+class RGBLCDManager:
+    def __init__(self, rgb_lcd, interval=SCREEN_SWITCH_INTERVAL, brightness=DEFAULT_BRIGHTNESS, auto_start=True):
+        self.rgb_lcd = rgb_lcd
+        self.interval = interval
+        self.brightness = max(0.0, min(1.0, float(brightness)))
+
+        # Internal state store
+        self._microwave_count = "N/A"
+        self._external_screen_count = "N/A"
+        self._cloud_alert = None
+
+        # Screen rotation sequence
+        self.screens = [
+            self.display_microwave_state,
+            self.display_external_screens,
+            self.display_cloud_connectivity,
+        ]
+        self.current_screen_idx = 0
+
+        # Threading controls
+        self._thread = None
+        self._running = False
+        self._stop_event = threading.Event()
+
+        if auto_start:
+            self.start()
+
+    # --- SETTER METHODS ---
+
+    def set_brightness(self, brightness):
+        """Dynamically adjust backlight brightness (0.0 to 1.0)."""
+        self.brightness = max(0.0, min(1.0, float(brightness)))
+
+    def set_microwave_count(self, count):
+        """Set the number of connected microwaves."""
+        self._microwave_count = count
+
+    def set_external_screen_count(self, count):
+        """Set the number of connected external screens."""
+        self._external_screen_count = count
+
+    def set_cloud_alert(self, status: bool):
+        """Set cloud connectivity status."""
+        self._cloud_alert = status
+
+    def set_data(self, microwave_count=None, external_screen_count=None, cloud_alert=None):
+        """Convenience method to update all state variables at once."""
+        if microwave_count is not None:
+            self.set_microwave_count(microwave_count)
+        if external_screen_count is not None:
+            self.set_external_screen_count(external_screen_count)
+        if cloud_alert is not None:
+            self.set_cloud_alert(cloud_alert)
+
+    # --- DISPLAY RENDERERS ---
+
+    def display_microwave_state(self):
+        """Display the number of connected microwaves."""
+        text = f"Microwaves:\nConnected: {self._microwave_count}"
+        self.rgb_lcd.setText(text)
+        self.rgb_lcd.setRGB(255, 255, 255, brightness=self.brightness)
+
+    def display_external_screens(self):
+        """Display the number of connected external screens."""
+        text = f"Screens:\nConnected: {self._external_screen_count}"
+        self.rgb_lcd.setText(text)
+        self.rgb_lcd.setRGB(255, 255, 255, brightness=self.brightness)
+
+    def display_cloud_connectivity(self):
+        """Display cloud connectivity status with brightness-scaled backlight color."""
+        status_str = None
+    
+        # Base RGB colors
+        if self._cloud_alert is True:
+            rgb = (255, 0, 0)      # Red
+            status_str = "Disconnected"
+        elif self._cloud_alert is False:
+            rgb = (0, 255, 0)      # Green
+            status_str = "Connected"
+        else:
+            rgb = (255, 165, 0)    # Orange
+            status_str = "N/A"
+
+        self.rgb_lcd.setRGB(rgb[0], rgb[1], rgb[2], brightness=self.brightness)
+        self.rgb_lcd.setText(f"Cloud Status:\n{status_str}")
+
+    # --- BACKGROUND THREAD LOGIC ---
+
+    def _display_loop(self):
+        """Background loop that switches screens at regular intervals."""
+        while not self._stop_event.is_set():
+            try:
+                self.screens[self.current_screen_idx]()
+                self.current_screen_idx = (self.current_screen_idx + 1) % len(self.screens)
+            except Exception as e:
+                print(f"[RGBLCDManager] Error updating LCD: {e}")
+
+            sleep_ticks = int(self.interval * 10)
+            for _ in range(sleep_ticks):
+                if self._stop_event.is_set():
+                    break
+                time.sleep(0.1)
+
+    def start(self):
+        """Start the display background thread."""
+        if not self._running:
+            self._running = True
+            self._stop_event.clear()
+            self._thread = threading.Thread(target=self._display_loop, daemon=True)
+            self._thread.start()
+
+    def stop(self):
+        """Stop the display loop and turn off the LCD backlight."""
+        if self._running:
+            self._stop_event.set()
+            if self._thread and self._thread.is_alive():
+                self._thread.join(timeout=2.0)
+            self._running = False
+
+        try:
+            self.rgb_lcd.setText("Bye !")
+            self.rgb_lcd.setRGB(0, 0, 0)
+        except Exception as e:
+            print(f"[RGBLCDManager] Error clearing LCD: {e}")