fix: enable face tracking by default and improve tap detection logging

- Face tracking now enabled by default (was disabled)
- Face tracking stays enabled during idle (was being disabled)
- Improved tap detector logging with IMU data verification
- Improved camera server logging with FPS stats
- Better error messages for missing head tracker dependencies

reachy_mini_ha_voice/camera_server.py

@@ -76,7 +76,7 @@ class MJPEGCameraServer:
         
         # Face tracking state
         self._head_tracker = None
-        self._face_tracking_enabled = False  # Disabled by default, enabled on wake word
+        self._face_tracking_enabled = True  # Enabled by default for always-on face tracking
         self._face_tracking_offsets: List[float] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
         self._face_tracking_lock = threading.Lock()
         
@@ -103,10 +103,16 @@ class MJPEGCameraServer:
             try:
                 from .head_tracker import HeadTracker
                 self._head_tracker = HeadTracker()
-                _LOGGER.info("Face tracking enabled")
+                _LOGGER.info("Face tracking enabled with YOLO head tracker")
+            except ImportError as e:
+                _LOGGER.warning("Failed to import head tracker (missing dependencies): %s", e)
+                _LOGGER.warning("Install with: pip install ultralytics supervision huggingface_hub")
+                self._head_tracker = None
             except Exception as e:
                 _LOGGER.warning("Failed to initialize head tracker: %s", e)
                 self._head_tracker = None
+        else:
+            _LOGGER.info("Face tracking disabled by configuration")
 
         # Start frame capture thread
         self._capture_thread = threading.Thread(
@@ -144,7 +150,10 @@ class MJPEGCameraServer:
 
     def _capture_frames(self) -> None:
         """Background thread to capture frames from Reachy Mini and do face tracking."""
-        _LOGGER.info("Starting camera capture thread")
+        _LOGGER.info("Starting camera capture thread (face_tracking=%s)", self._face_tracking_enabled)
+
+        frame_count = 0
+        last_log_time = time.time()
 
         while self._running:
             try:
@@ -152,6 +161,8 @@ class MJPEGCameraServer:
                 frame = self._get_camera_frame()
 
                 if frame is not None:
+                    frame_count += 1
+                    
                     # Encode frame as JPEG for streaming
                     encode_params = [cv2.IMWRITE_JPEG_QUALITY, self.quality]
                     success, jpeg_data = cv2.imencode('.jpg', frame, encode_params)
@@ -167,6 +178,14 @@ class MJPEGCameraServer:
                     
                     # Handle smooth interpolation when face lost
                     self._process_face_lost_interpolation(current_time)
+                    
+                    # Log stats every 10 seconds
+                    if current_time - last_log_time >= 10.0:
+                        fps = frame_count / (current_time - last_log_time)
+                        _LOGGER.debug("Camera: %.1f fps, face_tracking=%s, head_tracker=%s",
+                                     fps, self._face_tracking_enabled, self._head_tracker is not None)
+                        frame_count = 0
+                        last_log_time = current_time
 
                 # Sleep to maintain target FPS
                 time.sleep(self._frame_interval)

reachy_mini_ha_voice/motion.py

@@ -85,17 +85,14 @@ class ReachyMiniMotion:
         """Called when wake word is detected.
 
         Non-blocking: command sent to MovementManager.
-        Enables face tracking to look at the user.
+        Face tracking is always enabled, so robot will look at user automatically.
         """
         _LOGGER.debug("on_wakeup called")
         if self._movement_manager is None:
             _LOGGER.warning("on_wakeup: movement_manager is None, skipping motion")
             return
 
-        # Enable face tracking when wake word detected
-        if self._camera_server is not None:
-            self._camera_server.set_face_tracking_enabled(True)
-            _LOGGER.info("Face tracking enabled on wake word")
+        # Face tracking is always enabled, no need to enable it here
 
         # Set listening state - face tracking will handle looking at user
         self._movement_manager.set_state(RobotState.LISTENING)
@@ -188,7 +185,7 @@ class ReachyMiniMotion:
         """Called when returning to idle state.
 
         Non-blocking: command sent to MovementManager.
-        Disables face tracking to save resources.
+        Face tracking remains enabled for continuous tracking.
         """
         if self._movement_manager is None:
             return
@@ -197,10 +194,8 @@ class ReachyMiniMotion:
         self._movement_manager.set_state(RobotState.IDLE)
         self._movement_manager.reset_to_neutral(duration=0.5)
 
-        # Disable face tracking when returning to idle (save resources)
-        if self._camera_server is not None:
-            self._camera_server.set_face_tracking_enabled(False)
-            _LOGGER.info("Face tracking disabled on idle")
+        # Note: Face tracking remains enabled for continuous tracking
+        # This allows the robot to always look at the user when they approach
 
         _LOGGER.debug("Reachy Mini: Idle pose")
 

reachy_mini_ha_voice/tap_detector.py

@@ -103,6 +103,16 @@ class TapDetector:
                     "(only available on Wireless version)"
                 )
                 return
+            
+            # Verify accelerometer data is present
+            if "accelerometer" not in imu_data:
+                _LOGGER.warning(
+                    "IMU accelerometer data not available - tap detection disabled"
+                )
+                return
+            
+            _LOGGER.info("IMU available, accelerometer data: %s", imu_data.get("accelerometer"))
+            
         except Exception as e:
             _LOGGER.warning("Failed to check IMU availability: %s", e)
             return
@@ -114,7 +124,8 @@ class TapDetector:
             name="tap-detector"
         )
         self._thread.start()
-        _LOGGER.info("TapDetector started (threshold=%.1fg)", self._threshold_ms2 / 9.81)
+        _LOGGER.info("TapDetector started (threshold=%.1fg, cooldown=%.1fs)", 
+                    self._threshold_g, self._cooldown_seconds)
 
     def stop(self) -> None:
         """Stop tap detection thread."""