"revert_to_version_0.2.0"

reachy_mini_ha_voice/emotion_moves.py

@@ -1,124 +0,0 @@
-"""Emotion moves for the movement queue system.
-
-This module implements emotions as Move objects that can be queued
-and executed by the MovementManager, similar to reachy_mini_conversation_app.
-"""
-
-from __future__ import annotations
-import logging
-from typing import Tuple, Optional
-
-import numpy as np
-from numpy.typing import NDArray
-
-try:
-    from reachy_mini.motion.move import Move
-    from reachy_mini.motion.recorded_move import RecordedMoves
-    REACHY_MINI_AVAILABLE = True
-except ImportError:
-    REACHY_MINI_AVAILABLE = False
-    # Create dummy base class
-    class Move:
-        pass
-
-logger = logging.getLogger(__name__)
-
-
-class EmotionQueueMove(Move):  # type: ignore
-    """Wrapper for emotion moves to work with the movement queue system."""
-
-    def __init__(self, emotion_name: str, recorded_moves: "RecordedMoves"):
-        """Initialize an EmotionQueueMove.
-
-        Args:
-            emotion_name: Name of the emotion (e.g., "happy1", "sad1")
-            recorded_moves: RecordedMoves instance containing the emotion library
-        """
-        if not REACHY_MINI_AVAILABLE:
-            raise ImportError("reachy_mini package is required for emotion moves")
-
-        self.emotion_move = recorded_moves.get(emotion_name)
-        self.emotion_name = emotion_name
-
-    @property
-    def duration(self) -> float:
-        """Duration property required by official Move interface."""
-        return float(self.emotion_move.duration)
-
-    def evaluate(self, t: float) -> Tuple[Optional[NDArray[np.float64]], Optional[NDArray[np.float64]], Optional[float]]:
-        """Evaluate emotion move at time t.
-
-        Args:
-            t: Time in seconds since move started
-
-        Returns:
-            Tuple of (head_pose, antennas, body_yaw)
-        """
-        try:
-            # Get the pose from the emotion move
-            head_pose, antennas, body_yaw = self.emotion_move.evaluate(t)
-
-            # Convert to numpy array if antennas is tuple and return in official Move format
-            if isinstance(antennas, tuple):
-                antennas = np.array([antennas[0], antennas[1]], dtype=np.float64)
-
-            return (head_pose, antennas, body_yaw)
-
-        except Exception as e:
-            logger.error(f"Error evaluating emotion '{self.emotion_name}' at t={t}: {e}")
-            # Return neutral pose on error
-            from reachy_mini.utils import create_head_pose
-
-            neutral_head_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
-            return (neutral_head_pose, np.array([0.0, 0.0], dtype=np.float64), 0.0)
-
-
-# Global emotion library instance (lazy loaded)
-_RECORDED_MOVES: Optional["RecordedMoves"] = None
-_EMOTION_LIBRARY_AVAILABLE = False
-
-
-def get_emotion_library() -> Optional["RecordedMoves"]:
-    """Get or initialize the emotion library.
-
-    Returns:
-        RecordedMoves instance or None if not available
-    """
-    global _RECORDED_MOVES, _EMOTION_LIBRARY_AVAILABLE
-
-    if not REACHY_MINI_AVAILABLE:
-        return None
-
-    if _RECORDED_MOVES is None and not _EMOTION_LIBRARY_AVAILABLE:
-        try:
-            from reachy_mini.motion.recorded_move import RecordedMoves
-            # Note: huggingface_hub automatically reads HF_TOKEN from environment variables
-            _RECORDED_MOVES = RecordedMoves("pollen-robotics/reachy-mini-emotions-library")
-            _EMOTION_LIBRARY_AVAILABLE = True
-            logger.info("Emotion library loaded successfully")
-        except Exception as e:
-            logger.warning(f"Failed to load emotion library: {e}")
-            _EMOTION_LIBRARY_AVAILABLE = True  # Mark as attempted
-
-    return _RECORDED_MOVES
-
-
-def create_emotion_move(emotion_name: str) -> Optional[EmotionQueueMove]:
-    """Create an emotion move for the given emotion name.
-
-    Args:
-        emotion_name: Name of the emotion (e.g., "happy1", "sad1")
-
-    Returns:
-        EmotionQueueMove instance or None if emotion library not available
-    """
-    recorded_moves = get_emotion_library()
-    if recorded_moves is None:
-        logger.warning(f"Cannot create emotion move '{emotion_name}': library not available")
-        return None
-
-    try:
-        return EmotionQueueMove(emotion_name, recorded_moves)
-    except Exception as e:
-        logger.error(f"Failed to create emotion move '{emotion_name}': {e}")
-        return None

reachy_mini_ha_voice/motion.py

@@ -9,7 +9,6 @@ import math
 from typing import Optional
 
 from .movement_manager import MovementManager, RobotState, PendingAction
-from .emotion_moves import create_emotion_move
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -60,7 +59,7 @@ class ReachyMiniMotion:
     # -------------------------------------------------------------------------
 
     def on_wakeup(self, doa_angle_deg: Optional[float] = None):
-        """Called when wake word is detected - turn to sound source and nod.
+        """Called when wake word is detected - turn to sound source.
 
         Non-blocking: command sent to MovementManager.
 
@@ -84,29 +83,9 @@ class ReachyMiniMotion:
             self._movement_manager.reset_to_neutral(duration=0.3)
             _LOGGER.debug("DOA angle is None, looking forward")
 
-        # Add nod confirmation gesture after turning
-        # Enhanced: More visible nod with longer duration
-        nod_action = PendingAction(
-            name="wakeup_nod",
-            target_pitch=math.radians(18),  # Nod down 18 degrees (increased from 10)
-            duration=0.5,  # Longer duration for visibility (increased from 0.3)
-        )
-        self._movement_manager.queue_action(nod_action)
-
-        # Return to neutral pitch after nod
-        return_action = PendingAction(
-            name="wakeup_return",
-            target_pitch=math.radians(0),  # Return to neutral
-            duration=0.3,  # Slightly longer return (increased from 0.2)
-        )
-        self._movement_manager.queue_action(return_action)
-
         # Set listening state
         self._movement_manager.set_state(RobotState.LISTENING)
 
-        _LOGGER.info("Reachy Mini: Wake word detected - turning to %.1f° and nodding",
-                     doa_angle_deg if doa_angle_deg is not None else 0.0)
-
     def on_listening(self):
         """Called when listening for speech - attentive pose.
 
@@ -116,18 +95,7 @@ class ReachyMiniMotion:
             return
 
         self._movement_manager.set_state(RobotState.LISTENING)
-
-        # Use a subtle attentive gesture instead of full emotion move
-        # Slight head tilt to show attention
-        attention_action = PendingAction(
-            name="listening_attention",
-            target_pitch=math.radians(-5),  # Slight look up
-            target_roll=math.radians(3),    # Slight tilt
-            duration=0.4,
-        )
-        self._movement_manager.queue_action(attention_action)
-
-        _LOGGER.debug("Reachy Mini: Listening pose - attentive gesture")
+        _LOGGER.debug("Reachy Mini: Listening pose")
 
     def on_thinking(self):
         """Called when processing speech - thinking pose.
@@ -139,17 +107,15 @@ class ReachyMiniMotion:
 
         self._movement_manager.set_state(RobotState.THINKING)
 
-        # Use a subtle thinking gesture instead of full emotion move
-        # Look up slightly as if thinking
-        thinking_action = PendingAction(
+        # Look up slightly (thinking gesture)
+        action = PendingAction(
             name="thinking",
-            target_pitch=math.radians(-8),  # Look up
-            target_yaw=math.radians(5),     # Slight turn
+            target_pitch=math.radians(-10),  # Look up
+            target_yaw=math.radians(5),      # Slight turn
             duration=0.4,
         )
-        self._movement_manager.queue_action(thinking_action)
-
-        _LOGGER.debug("Reachy Mini: Thinking pose - subtle gesture")
+        self._movement_manager.queue_action(action)
+        _LOGGER.debug("Reachy Mini: Thinking pose")
 
     def on_speaking_start(self):
         """Called when TTS starts - start speech-reactive motion.
@@ -162,9 +128,14 @@ class ReachyMiniMotion:
         self._is_speaking = True
         self._movement_manager.set_state(RobotState.SPEAKING)
 
-        # Don't queue emotion moves during conversation - let SpeechSway handle natural motion
-        # Emotion moves can still be triggered manually via ESPHome entity
-        _LOGGER.debug("Reachy Mini: Speaking started with speech sway")
+        # Gentle nod to indicate speaking
+        action = PendingAction(
+            name="speaking_start",
+            target_pitch=math.radians(5),  # Slight nod down
+            duration=0.3,
+        )
+        self._movement_manager.queue_action(action)
+        _LOGGER.debug("Reachy Mini: Speaking started")
 
     def on_speaking_end(self):
         """Called when TTS ends - stop speech-reactive motion.
@@ -188,12 +159,8 @@ class ReachyMiniMotion:
 
         self._is_speaking = False
         self._movement_manager.set_state(RobotState.IDLE)
-
-        # Return to neutral position smoothly
-        # Don't queue emotion moves - let breathing animation take over naturally
-        self._movement_manager.reset_to_neutral(duration=0.8)
-
-        _LOGGER.debug("Reachy Mini: Returning to idle - neutral pose")
+        self._movement_manager.reset_to_neutral(duration=0.5)
+        _LOGGER.debug("Reachy Mini: Idle pose")
 
     def on_timer_finished(self):
         """Called when a timer finishes - alert animation.

reachy_mini_ha_voice/movement_manager.py

@@ -17,7 +17,6 @@ import logging
 import math
 import threading
 import time
-from collections import deque
 from dataclasses import dataclass, field
 from enum import Enum
 from queue import Queue, Empty
@@ -28,7 +27,6 @@ from scipy.spatial.transform import Rotation as R
 
 if TYPE_CHECKING:
     from reachy_mini import ReachyMini
-    from reachy_mini.motion.move import Move
 
 logger = logging.getLogger(__name__)
 
@@ -339,11 +337,6 @@ class MovementManager:
         self._action_start_time: float = 0.0
         self._action_start_pose: Dict[str, float] = {}
 
-        # Move queue (for emotions and other Move objects)
-        self._move_queue: deque = deque()
-        self._current_move: Optional["Move"] = None
-        self._move_start_time: Optional[float] = None
-
         # Audio loudness (updated externally)
         self._audio_loudness_db: float = -100.0
         self._audio_lock = threading.Lock()
@@ -380,18 +373,6 @@ class MovementManager:
         """Thread-safe: Queue a motion action."""
         self._command_queue.put(("action", action))
 
-    def queue_move(self, move: "Move") -> None:
-        """Thread-safe: Queue a Move object (e.g., emotion).
-
-        Args:
-            move: A Move object (e.g., EmotionQueueMove)
-        """
-        self._command_queue.put(("queue_move", move))
-
-    def clear_move_queue(self) -> None:
-        """Thread-safe: Clear the move queue and stop current move."""
-        self._command_queue.put(("clear_queue", None))
-
     def turn_to_angle(self, yaw_deg: float, duration: float = 0.8) -> None:
         """Thread-safe: Turn head to face a direction."""
         action = PendingAction(
@@ -474,18 +455,6 @@ class MovementManager:
         elif cmd == "action":
             self._start_action(payload)
 
-        elif cmd == "queue_move":
-            if payload is not None:
-                self._move_queue.append(payload)
-                self.state.last_activity_time = self._now()
-                logger.debug("Queued move, queue size: %d", len(self._move_queue))
-
-        elif cmd == "clear_queue":
-            self._move_queue.clear()
-            self._current_move = None
-            self._move_start_time = None
-            logger.info("Cleared move queue and stopped current move")
-
         elif cmd == "nod":
             amplitude_deg, duration = payload
             self._do_nod(amplitude_deg, duration)
@@ -539,68 +508,8 @@ class MovementManager:
     # Internal: Motion updates (runs in control loop)
     # =========================================================================
 
-    def _manage_move_queue(self) -> None:
-        """Manage the move queue (emotions, etc.)."""
-        current_time = self._now()
-
-        # Check if current move is finished
-        if self._current_move is None or (
-            self._move_start_time is not None
-            and current_time - self._move_start_time >= self._current_move.duration
-        ):
-            self._current_move = None
-            self._move_start_time = None
-
-            # Start next move in queue
-            if self._move_queue:
-                self._current_move = self._move_queue.popleft()
-                self._move_start_time = current_time
-                logger.debug(f"Starting move, duration: {self._current_move.duration}s")
-
-        # Evaluate current move and update target pose
-        # NOTE: Moves set the base target pose, but SpeechSway can still add on top
-        if self._current_move is not None and self._move_start_time is not None:
-            move_time = current_time - self._move_start_time
-            try:
-                head_pose, antennas, body_yaw = self._current_move.evaluate(move_time)
-
-                if head_pose is not None:
-                    # Extract rotation from head pose matrix
-                    from scipy.spatial.transform import Rotation as R
-                    rotation = R.from_matrix(head_pose[:3, :3])
-                    euler = rotation.as_euler('xyz')
-
-                    self.state.target_pitch = float(euler[0])
-                    self.state.target_roll = float(euler[1])
-                    self.state.target_yaw = float(euler[2])
-                    self.state.target_x = float(head_pose[0, 3])
-                    self.state.target_y = float(head_pose[1, 3])
-                    self.state.target_z = float(head_pose[2, 3])
-
-                if antennas is not None:
-                    self.state.target_antenna_right = float(antennas[0])
-                    self.state.target_antenna_left = float(antennas[1])
-
-                if body_yaw is not None:
-                    self.state.target_body_yaw = float(body_yaw)
-
-                # Cancel any pending action since move takes priority
-                if self._pending_action is not None:
-                    self._pending_action = None
-                    logger.debug("Cancelled pending action due to active move")
-
-            except Exception as e:
-                logger.error(f"Error evaluating move: {e}")
-                # Clear the problematic move
-                self._current_move = None
-                self._move_start_time = None
-
     def _update_action(self, dt: float) -> None:
         """Update pending action interpolation."""
-        # Skip if a move is currently playing (moves take priority)
-        if self._current_move is not None:
-            return
-
         if self._pending_action is None:
             return
 
@@ -862,25 +771,22 @@ class MovementManager:
                 # 1. Process commands from queue
                 self._poll_commands()
 
-                # 2. Manage move queue (emotions, etc.)
-                self._manage_move_queue()
-
-                # 3. Update action interpolation
+                # 2. Update action interpolation
                 self._update_action(dt)
 
-                # 4. Update speech sway
+                # 3. Update speech sway
                 self._update_speech_sway(dt)
 
-                # 5. Update breathing animation
+                # 4. Update breathing animation
                 self._update_breathing(dt)
 
-                # 6. Update antenna blend (listening mode freeze/unfreeze)
+                # 5. Update antenna blend (listening mode freeze/unfreeze)
                 self._update_antenna_blend(dt)
 
-                # 7. Compose final pose
+                # 6. Compose final pose
                 pose = self._compose_final_pose()
 
-                # 8. Send to robot (single control point!)
+                # 7. Send to robot (single control point!)
                 self._issue_control_command(pose)
 
             except Exception as e:

reachy_mini_ha_voice/satellite.py

@@ -540,24 +540,30 @@ class VoiceSatelliteProtocol(APIServer):
     def _play_emotion(self, emotion_name: str) -> None:
         """Play an emotion/expression from the emotions library.
 
-        This method is kept for backward compatibility with entity_registry.
-        It now uses the queue-based system instead of HTTP API.
-
         Args:
             emotion_name: Name of the emotion (e.g., "happy1", "sad1", etc.)
         """
         try:
-            from .emotion_moves import create_emotion_move
-
-            if self.state.motion and self.state.motion.movement_manager:
-                emotion_move = create_emotion_move(emotion_name)
-                if emotion_move:
-                    self.state.motion.movement_manager.queue_move(emotion_move)
-                    _LOGGER.info(f"Queued emotion: {emotion_name}")
-                else:
-                    _LOGGER.warning(f"Failed to create emotion move: {emotion_name}")
+            import requests
+
+            # Get WLAN IP from daemon status
+            wlan_ip = "localhost"
+            if self.state.reachy_mini is not None:
+                try:
+                    status = self.state.reachy_mini.client.get_status(wait=False)
+                    wlan_ip = status.get('wlan_ip', 'localhost')
+                except Exception:
+                    wlan_ip = "localhost"
+
+            # Call the emotion playback API
+            # Dataset: pollen-robotics/reachy-mini-emotions-library
+            url = f"http://{wlan_ip}:8000/api/move/play/recorded-move-dataset/pollen-robotics/reachy-mini-emotions-library/{emotion_name}"
+
+            response = requests.post(url, timeout=5)
+            if response.status_code == 200:
+                _LOGGER.info(f"Playing emotion: {emotion_name}")
             else:
-                _LOGGER.warning("Motion system not available for emotion playback")
+                _LOGGER.warning(f"Failed to play emotion {emotion_name}: HTTP {response.status_code}")
 
         except Exception as e:
-            _LOGGER.error(f"Error queueing emotion {emotion_name}: {e}")
+            _LOGGER.error(f"Error playing emotion {emotion_name}: {e}")