Fix: Manually adding missing python source files

pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "reachy-mini-sentry"
+version = "0.1.2"
+description = "Sentry Mode for Reachy Mini: Face tracking and intruder alerts!"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+  {name = "Eric Rolph", email = "ericrolph@gmail.com"},
+]
+dependencies = [
+    "reachy-mini",
+    "opencv-python",
+    "mediapipe"
+]
+
+[project.entry-points.reachy_mini_apps]
+reachy-mini-sentry = "reachy_mini_sentry.main:ReachyMiniSentry"
+
+[tools.hatch.build.targets.wheel]
+packages = ["reachy_mini_sentry"]
+include = ["reachy_mini_sentry/sounds/*.wav", "reachy_mini_sentry/static/*"]

reachy_mini_sentry/main.py

@@ -0,0 +1,436 @@
+"""Guardian Laser Mode App for Reachy Mini.
+
+A fun security application where Reachy acts as a guardian that:
+- Smoothly patrols (scans) left-right when no threats detected
+- When faces are spotted: zaps each one in sequence with laser!
+- Choice of sounds via the web interface.
+"""
+
+import threading
+import time
+import os
+import io
+import math
+
+import cv2
+from fastapi import FastAPI, Body
+from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from reachy_mini import ReachyMiniApp
+from reachy_mini.reachy_mini import ReachyMini
+from reachy_mini.utils import create_head_pose
+
+from reachy_mini.utils import create_head_pose
+from scipy.spatial.transform import Rotation as R
+from scipy.spatial.transform import Rotation as Rot
+
+try:
+    from reachy_mini_dances_library import DanceMove
+    DANCE_AVAILABLE = True
+except ImportError:
+    DANCE_AVAILABLE = False
+
+from .patrol import Patrol
+from .tracker import FaceTracker
+
+
+class ReachyMiniSentry(ReachyMiniApp):
+    custom_app_url = "http://0.0.0.0:8044"
+    dont_start_webserver = True
+
+    def __init__(self):
+        super().__init__()
+        self.latest_frame = None
+        self.frame_lock = threading.Lock()
+        self.detected_faces = []
+        self.is_running = False
+        
+        # Sound configuration
+        self.sounds_dir = os.path.join(os.path.dirname(__file__), 'sounds')
+        self.available_sounds = {
+            "Alarm 1": {"file": "alarm_1.wav", "duration": None},
+            "Alarm 2": {"file": "alarm_2.wav", "duration": None},
+            "Alarm 3": {"file": "alarm_3.wav", "duration": None},
+            "Alarm 4": {"file": "alarm_4.wav", "duration": 4.2},
+            "Alarm 5": {"file": "alarm_5.wav", "duration": 4.0},
+            "Alarm 6": {"file": "alarm_6.wav", "duration": 4.0},
+            "Alarm 7": {"file": "alarm_7.wav", "duration": 14.0},
+        }
+        self.selected_sound_key = "Alarm 2"
+        
+        # Smooth Tracking State (Degrees)
+        self.cur_yaw = 0.0
+        self.cur_pitch = 0.0
+        self.cur_body_yaw = 0.0
+        self.tracking_active = False
+        self.smooth_dx = 0.0
+        self.smooth_dy = 0.0
+        
+        # Dancing State (Easter Egg for Alarm 7)
+        self.dancing = False
+        self.dance_start_time = 0.0
+        self.dance_move = None
+        self.dance_reachy = None
+
+    def run(self, reachy: ReachyMini, stop_event: threading.Event):
+        print("🚨 Sentry Mode Activated!")
+        
+        # Start web server
+        self._start_web_server(stop_event)
+        
+        patrol = Patrol(reachy)
+        tracker = FaceTracker()
+        
+        faces_zapped_count = 0
+        faces_visible_last_frame = 0
+        last_face_seen_time = 0.0
+        
+        # Tracking state
+        self.target_face_id = None
+        self.is_running = True
+        
+        try:
+            while not stop_event.is_set():
+                frame = reachy.media.get_frame()
+                if frame is None:
+                    time.sleep(0.1)
+                    continue
+                
+                h, w = frame.shape[:2]
+                all_faces = tracker.detect_all(frame)
+                num_faces = len(all_faces)
+                
+                with self.frame_lock:
+                    self.latest_frame = frame.copy()
+                    self.detected_faces = list(all_faces)
+                
+                if num_faces == 0:
+                    # NO FACES - Smoothly drift back toward neutral or continue scan
+                    time_since_last = time.time() - last_face_seen_time
+                    
+                    if faces_visible_last_frame > 0 and time_since_last > 0.5:
+                        print("👋 Target lost. Returning to idle...")
+                        self.tracking_active = False
+                    if faces_visible_last_frame > 0 and time_since_last > 0.5:
+                        print(f"?? Lost visual. Holding position (Grace period)...")
+                        self.tracking_active = False
+                        faces_visible_last_frame = 0
+                    
+                    # Only reset zaps and start patrol after a 2-second grace period
+                    if time_since_last > 2.0:
+                        # Grace period over - Relax back to center
+                        self.cur_yaw *= 0.95
+                        self.cur_pitch *= 0.95
+                        self.cur_body_yaw *= 0.95
+                    
+                        faces_zapped_count = 0
+                        if abs(self.cur_yaw) < 5 and abs(self.cur_pitch) < 5:
+                            patrol.step()
+                    
+                else:
+                    # FACES DETECTED!
+                    last_face_seen_time = time.time()
+                    self.tracking_active = True
+                    primary_face = all_faces[0]
+                    
+                    # Use look_at_image to compute the TARGET POSE (like conversation app!)
+                    x, y, w_face, h_face = primary_face
+                    # Face center in pixel coordinates
+                    face_cx = x + w_face / 2
+                    face_cy = y + h_face / 2
+                    
+                    move_duration = 0.0  # Use 0 for immediate updates (set_target) to avoid stop-start jerkiness
+
+                    # Visual Servoing: Use pixel error to drive the head directly.
+                    try:
+                        raw_x_err, raw_y_err = tracker.get_face_center(primary_face, w, h)
+                        
+                        # Apply Smoothing
+                        alpha = 0.5
+                        if not hasattr(self, 'smooth_x_err'):
+                            self.smooth_x_err = raw_x_err
+                            self.smooth_y_err = raw_y_err
+                        else:
+                            self.smooth_x_err = alpha * raw_x_err + (1 - alpha) * self.smooth_x_err
+                            self.smooth_y_err = alpha * raw_y_err + (1 - alpha) * self.smooth_y_err
+                        
+                        # Target Offset: Target VERY HIGH (-0.6).
+                        # User wants face near the top of the frame.
+                        TARGET_Y_OFFSET = -0.6
+                        
+                        eff_x_err = self.smooth_x_err
+                        eff_y_err = self.smooth_y_err - TARGET_Y_OFFSET
+
+                        # Gains (Aggressive)
+                        K_YAW = 5.0
+                        K_PITCH = 5.0
+                        
+                        # Update state (Standard Logic: Positive Error means face low -> Look Down -> Add Pitch)
+                        self.cur_yaw -= K_YAW * eff_x_err
+                        self.cur_pitch += K_PITCH * eff_y_err
+                        
+                        # Debug Print 
+                        print(f"TRACK: y_err={raw_y_err:.2f}, eff={eff_y_err:.2f}, pitch={self.cur_pitch:.1f}")
+                        
+                    except Exception as e:
+                        print(f"TRACKING ERROR: {e}")
+                    
+                    # Hardware Safety Limits - Expanded to 60 degrees (some robots can go further)
+                    self.cur_pitch = max(min(self.cur_pitch, 60), -60) 
+                    self.cur_yaw = max(min(self.cur_yaw, 55), -55)
+                    self.cur_body_yaw = max(min(self.cur_body_yaw, 45), -45)
+                    
+                    # Simple antenna pointing
+                    antenna_goal = [0.0, 0.0]
+                    if num_faces > faces_zapped_count:
+                        print(f"🎯 ALERT! Targeting new face #{faces_zapped_count + 1}")
+                        
+                        # Trigger alarm sound
+                        sound_info = self.available_sounds.get(self.selected_sound_key)
+                        if sound_info:
+                            sound_path = os.path.join(self.sounds_dir, sound_info["file"])
+                            if os.path.exists(sound_path):
+                                reachy.media.play_sound(sound_path)
+                                
+                                # Easter Egg: Alarm 7 triggers dance mode!
+                                if self.selected_sound_key == "Alarm 7":
+                                    self.dancing = True
+                                    self.dance_start_time = time.time()
+                                    print(f"🕺🕺🕺 DANCE MODE ACTIVATED! Time: {self.dance_start_time} 🕺🕺🕺")
+                                else:
+                                    print(f"Playing sound: {self.selected_sound_key}")
+                                
+                        faces_zapped_count = num_faces
+                    
+                    # 7. Execute Movement (Or Dance!)
+                    
+                    if self.dancing:
+                        # DANCE MODE: Override EVERYTHING.
+                        # No tracking, no safety limits (we set safe dance moves), no fighting.
+                        dance_elapsed = time.time() - self.dance_start_time
+                        
+                        if dance_elapsed > 14.0:
+                            self.dancing = False  # Party's over
+                            print("💃 Dance complete! Resuming Sentry Mode.")
+                            # Reset to safe pose
+                            self.cur_yaw = 0.0
+                            self.cur_pitch = 0.0
+                            
+                        else:
+                            # 100 BPM = 1.666 Hz.
+                            # We want a continuous, energetic headbob.
+                            # Pitch: Center (0) to Down (25) and Up (-10)? Or just Up/Down around 0?
+                            # "Up and down movement". Let's go +/- 20 degrees.
+                            # sin(2*pi*f*t) -> -1 to 1.
+                            
+                            beat_freq = 100.0 / 60.0 # ~1.67 Hz
+                            
+                            # Phase shift to start going DOWN first (usually on beat 1)
+                            # sin starts 0 -> up (negative pitch).
+                            # We want to go DOWN (positive pitch) first? Or down on the beat?
+                            # Let's just use cos. cos(0)=1 (Down 20), cos(pi)=-1 (Up 20).
+                            bob = math.cos(2 * math.pi * beat_freq * dance_elapsed)
+                            
+                            # Map to Pitch: +/- 20 degrees
+                            target_pitch = 20.0 * bob
+                            
+                            # Yaw: Keep centered or sway slightly? 
+                            # User said "continuous headbob up and down". 
+                            # Let's keep Yaw fixed at 0 for pure bob.
+                            target_yaw = 0.0
+                            target_body_yaw = 0.0
+                            
+                            # Antennas: Wave
+                            # sin wave offset
+                            wave = math.sin(2 * math.pi * beat_freq * dance_elapsed)
+                            target_antennas = [0.6 * wave, -0.6 * wave]
+                            
+                            reachy.goto_target(
+                                head=create_head_pose(yaw=target_yaw, pitch=target_pitch, degrees=True, mm=True),
+                                body_yaw=math.radians(target_body_yaw),
+                                antennas=target_antennas,
+                                duration=0.0 # Instant update
+                            )
+                            
+                            # Skip the standard goto_target below
+                            continue
+
+                    # Use set_target for smoother, non-blocking updates (requires duration=0 in goto or direct call)
+                    # goto_target with duration=0 effectively calls set_target
+                    reachy.goto_target(
+                        head=create_head_pose(yaw=self.cur_yaw, pitch=self.cur_pitch, degrees=True, mm=True),
+                        body_yaw=float(math.radians(self.cur_body_yaw)),
+                        antennas=antenna_goal,
+                        duration=0.0 # Instant update
+                    )
+                    
+                    faces_visible_last_frame = num_faces
+                
+                # 30Hz loop (to match camera/interpolation rate)
+                time.sleep(0.03)
+                
+        except Exception as e:
+            print(f"Guardian Error: {e}")
+        finally:
+            self.is_running = False
+            tracker.close()
+            print("🔫 Guardian Laser Mode Deactivated.")
+
+    def _run_dance_routine(self, reachy):
+        """Execute dance moves from the dance library synced to 100 BPM music."""
+        try:
+            if not DANCE_AVAILABLE:
+                return
+                
+            print("🕺 DANCE MODE ACTIVATED!")
+            
+            # Wait for the 2-second intro ("IN-TRU-DER. Alert!")
+            time.sleep(2.0)
+            
+            # Now the music starts - 12 seconds of 100 BPM beats
+            # We'll cycle through different dance moves
+            
+            # Dance sequence: 4 moves, 3 seconds each = 12 seconds total
+            dance_moves = [
+                ("headbanger_combo", 3.0),
+                ("chicken_peck", 3.0),
+                ("groovy_sway_and_roll", 3.0),
+                ("headbanger_combo", 3.0),
+            ]
+            
+            for move_name, duration in dance_moves:
+                if not self.dancing:
+                    break
+                try:
+                    # Create dance move with 100 BPM
+                    move = DanceMove(move_name)
+                    move.default_bpm = 100.0
+                    # Play for the specified duration
+                    move.play_on(reachy, repeat=int(duration * (100.0/60.0)))
+                except Exception as e:
+                    print(f"Dance move '{move_name}' failed: {e}")
+                    time.sleep(duration)
+            
+            print("💃 Dance routine complete!")
+            self.dancing = False
+            
+        except Exception as e:
+            print(f"Dance routine error: {e}")
+            self.dancing = False
+
+    def _start_web_server(self, stop_event):
+        import uvicorn
+        from urllib.parse import urlparse
+        
+        app = FastAPI()
+        
+        @app.get("/")
+        async def index():
+            sound_options = "".join([f'<option value="{k}" {"selected" if k == self.selected_sound_key else ""}>{k}</option>' 
+                                    for k in self.available_sounds.keys()])
+            html = f"""
+<!DOCTYPE html>
+<html>
+<head>
+    <title>🚨 Sentry Mode</title>
+    <style>
+        body {{ font-family: 'Segoe UI', Arial, sans-serif; background: #1a1a2e; color: #eee; margin: 0; padding: 20px; text-align: center; }}
+        .container {{ max-width: 800px; margin: 0 auto; }}
+        h1 {{ color: #70a1ff; text-shadow: 0 0 20px rgba(112,161,255,0.5); }}
+        .video-container {{ background: #000; border-radius: 15px; overflow: hidden; margin-bottom: 20px; border: 3px solid #333; }}
+        .video-container img {{ width: 100%; display: block; }}
+        .controls {{ background: rgba(255,255,255,0.05); padding: 20px; border-radius: 10px; margin-top: 20px; }}
+        select {{ background: #16213e; color: white; padding: 10px; border-radius: 5px; border: 1px solid #70a1ff; width: 100%; max-width: 300px; font-size: 1em; }}
+        label {{ display: block; margin-bottom: 10px; color: #70a1ff; font-weight: bold; }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🚨 Sentry Mode</h1>
+        <div class="video-container">
+            <img src="/video" alt="Live Feed">
+        </div>
+        <div class="controls">
+            <label for="sound-select">Choose Alarm Sound:</label>
+            <select id="sound-select" onchange="updateSound(this.value)">
+                {sound_options}
+            </select>
+        </div>
+    </div>
+    <script>
+        function updateSound(val) {{
+            fetch('/set_sound', {{
+                method: 'POST',
+                headers: {{ 'Content-Type': 'application/json' }},
+                body: JSON.stringify({{ sound: val }})
+            }});
+        }}
+    </script>
+</body>
+</html>
+            """
+            return HTMLResponse(content=html)
+        
+        @app.get("/video")
+        async def video_feed():
+            def generate():
+                while self.is_running:
+                    with self.frame_lock:
+                        if self.latest_frame is None:
+                            time.sleep(0.05)
+                            continue
+                        frame = self.latest_frame.copy()
+                        faces = list(self.detected_faces)
+                    for i, (x, y, w, h) in enumerate(faces):
+                        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 3)
+                        cx, cy = x + w//2, y + h//2
+                        cv2.circle(frame, (cx, cy), 30, (0, 255, 0), 2)
+                        cv2.putText(frame, f"TARGET #{i+1}", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                    
+                    # DEBUG OVERLAY: Show Tracking State
+                    # This helps verify if the robot is *trying* to move and hitting limits, or moving wrong way.
+                    if self.tracking_active:
+                        debug_text = f"PITCH: {self.cur_pitch:.1f} | YAW: {self.cur_yaw:.1f}"
+                        # If detecting, show error
+                        if len(self.detected_faces) > 0:
+                            # Re-calculate error for display (approximation)
+                            # We don't have safe access to 'tracker' here easily without passing it or globals
+                            # But we can assume detecting logic works.
+                            cv2.putText(frame, debug_text, (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 255), 2)
+                        else:
+                            cv2.putText(frame, f"{debug_text} (Idle)", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (200, 200, 200), 2)
+
+                    _, jpeg = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 70])
+                    yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + jpeg.tobytes() + b'\r\n')
+                    time.sleep(0.05)
+            return StreamingResponse(generate(), media_type='multipart/x-mixed-replace; boundary=frame')
+
+        @app.post("/set_sound")
+        async def set_sound(data: dict = Body(...)):
+            new_sound = data.get("sound")
+            if new_sound in self.available_sounds:
+                self.selected_sound_key = new_sound
+                print(f"🔊 Sound changed to: {new_sound}")
+                return {{"status": "ok"}}
+            return JSONResponse(status_code=400, content={{"error": "Invalid sound"}})
+
+        url = urlparse(self.custom_app_url)
+        config = uvicorn.Config(app, host=url.hostname, port=url.port, log_level="warning")
+        server = uvicorn.Server(config)
+        
+        def run_server():
+            import asyncio
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(server.serve())
+        
+        threading.Thread(target=run_server, daemon=True).start()
+
+
+if __name__ == "__main__":
+    app = ReachyMiniSentry()
+    try:
+        app.wrapped_run()
+    except KeyboardInterrupt:
+        app.stop()

reachy_mini_sentry/patrol.py

@@ -0,0 +1,97 @@
+import math
+import time
+import random
+from reachy_mini.utils import create_head_pose
+
+
+class Patrol:
+    """Human-realistic organic patrol/scanning behavior.
+    
+    Instead of a mechanical sine wave, this mimics human behavior:
+    1. Pick a random point of interest.
+    2. Move there smoothly.
+    3. Pause and 'scan' (micro-movements).
+    4. Repeat.
+    """
+    
+    def __init__(self, reachy):
+        self.reachy = reachy
+        self.last_move_finish_time = 0
+        self.current_state = "IDLE"  # IDLE, MOVING, SCANNING
+        self.next_action_time = 0
+        
+        # State targets
+        self.target_head_yaw = 0
+        self.target_body_yaw = 0
+        self.target_pitch = 0
+    
+    def reset(self):
+        """Reset patrol state."""
+        self.current_state = "IDLE"
+        self.next_action_time = time.time()
+        
+    def step(self):
+        """Update patrol behavior."""
+        now = time.time()
+        
+        # If we are waiting for the next action...
+        if now < self.next_action_time:
+            return
+
+        # DECISION LOGIC
+        if self.current_state == "IDLE" or self.current_state == "SCANNING":
+            # Pick a new point of interest to look at
+            self.current_state = "MOVING"
+            
+            # WIDE SCAN: Maximize Head + Body limits
+            # Head: +/- 55, Body: +/- 45. Total: +/- 100 degrees from center.
+            # We want to use the full range to simulate "300 degree scan" (or as close as possible).
+            
+            # Pick a random "Sector" to ensure we look around widely
+            # 0=Center, 1=Far Left, 2=Far Right, 3=Random Up/Down
+            sector = random.choice([0, 1, 1, 2, 2, 3]) 
+            
+            if sector == 0: # Centerish
+                self.target_head_yaw = random.uniform(-20, 20)
+                self.target_body_yaw = random.uniform(-10, 10)
+                self.target_pitch = random.uniform(-10, 15)
+                move_duration = random.uniform(1.5, 2.5)
+            elif sector == 1: # Far Left
+                self.target_head_yaw = random.uniform(30, 50) # Positive is Left
+                self.target_body_yaw = random.uniform(20, 40)
+                self.target_pitch = random.uniform(-10, 10) # Look up/down
+                move_duration = random.uniform(2.0, 3.5)
+            elif sector == 2: # Far Right
+                self.target_head_yaw = random.uniform(-50, -30) # Negative is Right
+                self.target_body_yaw = random.uniform(-40, -20)
+                self.target_pitch = random.uniform(-10, 10)
+                move_duration = random.uniform(2.0, 3.5)
+            else: # Random Up/Down Check (Ceiling/Floor)
+                self.target_head_yaw = random.uniform(-30, 30)
+                self.target_body_yaw = random.uniform(-20, 20)
+                self.target_pitch = random.choice([random.uniform(15, 25), random.uniform(-20, -10)]) # Distinct look up or down
+                move_duration = random.uniform(1.5, 2.5)
+
+            # Execution
+            target_pose = create_head_pose(
+                yaw=self.target_head_yaw, 
+                pitch=self.target_pitch, 
+                degrees=True, mm=True
+            )
+            
+            # Antenna "Interest" - Perking up
+            ant_pos = [random.uniform(-0.5, 0.5), random.uniform(-0.5, 0.5)]
+
+            self.reachy.goto_target(
+                head=target_pose,
+                body_yaw=math.radians(self.target_body_yaw),
+                antennas=ant_pos,
+                duration=move_duration
+            )
+            
+            # Next state: Pause and stare for a bit
+            self.current_state = "SCANNING"
+            # Wait for move to finish + a pause time (0.5s to 2.0s)
+            self.next_action_time = now + move_duration + random.uniform(0.5, 2.0)
+            
+            print(f"👀 Patrol: Looking at sector {sector} (H:{self.target_head_yaw:.0f}, B:{self.target_body_yaw:.0f}, P:{self.target_pitch:.0f})")

reachy_mini_sentry/static/index.html

@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>🚨 Reachy Sentry</title>
+    <link rel="stylesheet" href="style.css">
+    <!-- Use Google Fonts for a premium feel -->
+    <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;500;700&display=swap" rel="stylesheet">
+</head>
+
+<body>
+    <div class="container sentry-container">
+        <header>
+            <h1>Sentry Mode</h1>
+            <p id="status-text">System is Active</p>
+        </header>
+
+        <div class="status-display">
+            <div class="radar">
+                <div class="sweep"></div>
+            </div>
+            <p id="log">Scanning Area...</p>
+        </div>
+
+        <div class="controls">
+            <button id="btn-toggle" class="btn primary" onclick="toggleSentry()">Deactivate System</button>
+        </div>
+    </div>
+
+    <script>
+        let isActive = true;
+
+        function toggleSentry() {
+            isActive = !isActive;
+            const btn = document.getElementById('btn-toggle');
+            const status = document.getElementById('status-text');
+            const log = document.getElementById('log');
+
+            if (isActive) {
+                document.body.className = 'mode-active';
+                btn.textContent = "Deactivate System";
+                btn.className = "btn primary";
+                status.textContent = "System is Active";
+                log.textContent = "Scanning Area...";
+            } else {
+                document.body.className = 'mode-inactive';
+                btn.textContent = "Activate System";
+                btn.className = "btn secondary";
+                status.textContent = "System is Offline";
+                log.textContent = "Standby";
+            }
+        }
+    </script>
+</body>
+
+</html>

reachy_mini_sentry/static/style.css

@@ -0,0 +1,105 @@
+:root {
+    --bg-color: #0f172a;
+    --text-color: #ffffff;
+    --primary-color: #ef4444;
+    /* Red 500 */
+    --secondary-color: #3b82f6;
+    /* Blue 500 */
+    --font-main: 'Outfit', sans-serif;
+}
+
+body {
+    background-color: #111;
+    color: var(--text-color);
+    font-family: var(--font-main);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    height: 100vh;
+    margin: 0;
+    transition: background-color 0.5s;
+}
+
+body.mode-active {
+    background: radial-gradient(circle, #330000 0%, #000000 100%);
+}
+
+body.mode-inactive {
+    background-color: #0f172a;
+}
+
+.container {
+    background: rgba(20, 20, 20, 0.8);
+    backdrop-filter: blur(10px);
+    padding: 3rem;
+    border-radius: 12px;
+    box-shadow: 0 0 50px rgba(255, 0, 0, 0.2);
+    text-align: center;
+    width: 350px;
+    border: 1px solid rgba(255, 0, 0, 0.3);
+}
+
+h1 {
+    font-weight: 700;
+    margin-bottom: 0.5rem;
+    text-transform: uppercase;
+    letter-spacing: 2px;
+}
+
+.radar {
+    width: 150px;
+    height: 150px;
+    border: 2px solid #ef4444;
+    border-radius: 50%;
+    margin: 2rem auto;
+    position: relative;
+    background:
+        radial-gradient(circle, transparent 20%, #ef4444 20%, #ef4444 21%, transparent 21%),
+        radial-gradient(circle, transparent 50%, #ef4444 50%, #ef4444 51%, transparent 51%),
+        radial-gradient(circle, transparent 80%, #ef4444 80%, #ef4444 81%, transparent 81%);
+    box-shadow: 0 0 20px rgba(239, 68, 68, 0.5);
+}
+
+.sweep {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    width: 50%;
+    height: 2px;
+    background: #ef4444;
+    transform-origin: 0 0;
+    animation: sweep 2s infinite linear;
+    box-shadow: 0 0 10px #ef4444;
+}
+
+@keyframes sweep {
+    from {
+        transform: rotate(0deg);
+    }
+
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+.btn {
+    border: none;
+    padding: 1rem 2rem;
+    border-radius: 4px;
+    font-weight: 700;
+    text-transform: uppercase;
+    cursor: pointer;
+    font-family: var(--font-main);
+    letter-spacing: 1px;
+}
+
+.btn.primary {
+    background-color: var(--primary-color);
+    color: white;
+    box-shadow: 0 0 20px rgba(239, 68, 68, 0.4);
+}
+
+.btn.secondary {
+    background-color: var(--secondary-color);
+    color: white;
+}

reachy_mini_sentry/tracker.py

@@ -0,0 +1,110 @@
+"""Face detection using MediaPipe for Sentry Mode.
+
+MediaPipe is much more accurate than Haar Cascades:
+- Better at detecting faces at angles and distances
+- Fewer false positives
+- Optimized for ARM/edge devices
+"""
+
+import cv2
+import mediapipe as mp
+
+
+class FaceTracker:
+    """Detects faces using MediaPipe Face Detection."""
+    
+    def __init__(self):
+        # Initialize MediaPipe Face Detection
+        self.mp_face = mp.solutions.face_detection
+        
+        # model_selection=1 is for full-range detection (better at distance)
+        # min_detection_confidence=0.75 for fewer false positives (ghosts)
+        self.detector = self.mp_face.FaceDetection(
+            model_selection=1,  # 0=within 2m, 1=full range (up to 5m)
+            min_detection_confidence=0.75
+        )
+        
+        print("✅ MediaPipe (Google) Face Detection initialized (High Confidence Mode)")
+    
+    def detect_all(self, frame):
+        """Detect ALL faces in the frame using MediaPipe.
+        
+        Returns:
+            List of face bounding boxes [(x, y, w, h), ...] sorted by size (largest first)
+            Empty list if no faces detected
+        """
+        try:
+            # Convert BGR to RGB (MediaPipe expects RGB)
+            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            
+            # Run detection
+            results = self.detector.process(rgb_frame)
+            
+            if not results.detections:
+                return []
+            
+            h, w = frame.shape[:2]
+            faces = []
+            
+            for detection in results.detections:
+                # Get bounding box (relative coordinates)
+                bbox = detection.location_data.relative_bounding_box
+                
+                # Convert to pixel coordinates
+                x = int(bbox.xmin * w)
+                y = int(bbox.ymin * h)
+                fw = int(bbox.width * w)
+                fh = int(bbox.height * h)
+                
+                # Clamp to frame bounds
+                x = max(0, x)
+                y = max(0, y)
+                fw = min(fw, w - x)
+                fh = min(fh, h - y)
+                
+                if fw > 0 and fh > 0:
+                    faces.append((x, y, fw, fh))
+            
+            # Sort by face area (largest first = closest person)
+            faces.sort(key=lambda f: f[2] * f[3], reverse=True)
+            
+            return faces
+            
+        except Exception as e:
+            print(f"Detection Error: {e}")
+            return []
+    
+    def detect(self, frame):
+        """Detect single largest face (backward compatible).
+        
+        Returns:
+            Largest face bounding box (x, y, w, h) or None
+        """
+        faces = self.detect_all(frame)
+        return faces[0] if faces else None
+    
+    def get_face_center(self, face, frame_width, frame_height):
+        """Get the normalized center position of a face.
+        
+        Returns:
+            (x_error, y_error) where:
+            - x_error: -1.0 (far left) to 1.0 (far right)
+            - y_error: -1.0 (top) to 1.0 (bottom)
+        """
+        x, y, w, h = face
+        cx = x + w / 2
+        cy = y + h / 2
+        
+        x_error = (cx - frame_width / 2) / (frame_width / 2)
+        y_error = (cy - frame_height / 2) / (frame_height / 2)
+        
+        return x_error, y_error
+    
+    def get_error(self, face, frame_width, frame_height):
+        """Get horizontal error for tracking (backward compatible)."""
+        x_err, _ = self.get_face_center(face, frame_width, frame_height)
+        return x_err
+    
+    def close(self):
+        """Clean up MediaPipe resources."""
+        self.detector.close()