fix: enable HA control of robot pose and fix continuous conversation

1. Robot pose control from Home Assistant:
- Added set_target_pose() to MovementManager
- ReachyController now routes pose setters through MovementManager
- Head position, orientation, body yaw, antennas all controllable from HA

2. Fixed continuous conversation (tap-to-wake):
- Fixed _is_streaming_audio not being set correctly for continuation
- Fixed _reachy_on_idle() being called even when continuing
- Added _reachy_on_listening() call when continuing conversation
- Added logging for conversation continuation

3. Extended emotion list:
- Added 50+ emotions from robot's emotion library
- Includes basic emotions, extended emotions, actions, and special animations

reachy_mini_ha_voice/entity_registry.py

@@ -124,22 +124,67 @@ class EntityRegistry:
         # Emotion state
         self._current_emotion = "None"
         # Map emotion names to available robot emotions
-        # Available emotions from robot: fear1, surprised1, rage1, resigned1, go_away1, loving1,
-        # impatient1/2, enthusiastic1/2, cheerful1, laughing1/2, irritated1/2, oops1/2, curious1,
-        # electric1, contempt1, inquiring1/2/3, attentive1/2, frustrated1, dance1/2/3, no1, sad1/2,
-        # understanding1/2, come1, calming1, exhausted1, scared1, downcast1, success1/2, disgusted1,
-        # amazed1, displeased1/2, dying1, no_excited1, thoughtful1/2, lonely1, welcoming1/2,
-        # no_sad1, reprimand1/2/3, boredom1/2, grateful1, uncertain1, furious1, anxiety1, yes_sad1,
-        # proud1/2/3, shy1, indifferent1, tired1, serenity1, helpful1/2, incomprehensible2, relief1/2,
-        # confused1, sleep1, yes1, uncomfortable1, lost1
+        # Full list of available emotions from robot
         self._emotion_map = {
             "None": None,
+            # Basic emotions
             "Happy": "cheerful1",
             "Sad": "sad1",
             "Angry": "rage1",
             "Fear": "fear1",
             "Surprise": "surprised1",
             "Disgust": "disgusted1",
+            # Extended emotions
+            "Laughing": "laughing1",
+            "Loving": "loving1",
+            "Proud": "proud1",
+            "Grateful": "grateful1",
+            "Enthusiastic": "enthusiastic1",
+            "Curious": "curious1",
+            "Amazed": "amazed1",
+            "Shy": "shy1",
+            "Confused": "confused1",
+            "Thoughtful": "thoughtful1",
+            "Anxious": "anxiety1",
+            "Scared": "scared1",
+            "Frustrated": "frustrated1",
+            "Irritated": "irritated1",
+            "Furious": "furious1",
+            "Contempt": "contempt1",
+            "Bored": "boredom1",
+            "Tired": "tired1",
+            "Exhausted": "exhausted1",
+            "Lonely": "lonely1",
+            "Downcast": "downcast1",
+            "Resigned": "resigned1",
+            "Uncertain": "uncertain1",
+            "Uncomfortable": "uncomfortable1",
+            "Lost": "lost1",
+            "Indifferent": "indifferent1",
+            # Positive actions
+            "Yes": "yes1",
+            "No": "no1",
+            "Welcoming": "welcoming1",
+            "Helpful": "helpful1",
+            "Attentive": "attentive1",
+            "Understanding": "understanding1",
+            "Calming": "calming1",
+            "Relief": "relief1",
+            "Success": "success1",
+            "Serenity": "serenity1",
+            # Negative actions
+            "Oops": "oops1",
+            "Displeased": "displeased1",
+            "Impatient": "impatient1",
+            "Reprimand": "reprimand1",
+            "GoAway": "go_away1",
+            # Special
+            "Come": "come1",
+            "Inquiring": "inquiring1",
+            "Sleep": "sleep1",
+            "Dance": "dance1",
+            "Electric": "electric1",
+            "Dying": "dying1",
         }
 
     def setup_all_entities(self, entities: List) -> None:

reachy_mini_ha_voice/movement_manager.py

@@ -479,6 +479,41 @@ class MovementManager:
         with self._face_tracking_lock:
             self._face_tracking_offsets = offsets
 
+    def set_target_pose(
+        self,
+        x: Optional[float] = None,
+        y: Optional[float] = None,
+        z: Optional[float] = None,
+        roll: Optional[float] = None,
+        pitch: Optional[float] = None,
+        yaw: Optional[float] = None,
+        body_yaw: Optional[float] = None,
+        antenna_left: Optional[float] = None,
+        antenna_right: Optional[float] = None,
+    ) -> None:
+        """Thread-safe: Set target pose components.
+        
+        Only provided values will be updated. Values are in meters for position
+        and radians for angles.
+        
+        Args:
+            x, y, z: Head position in meters
+            roll, pitch, yaw: Head orientation in radians
+            body_yaw: Body yaw in radians
+            antenna_left, antenna_right: Antenna angles in radians
+        """
+        self._command_queue.put(("set_pose", {
+            "x": x,
+            "y": y,
+            "z": z,
+            "roll": roll,
+            "pitch": pitch,
+            "yaw": yaw,
+            "body_yaw": body_yaw,
+            "antenna_left": antenna_left,
+            "antenna_right": antenna_right,
+        }))
+
     # =========================================================================
     # Internal: Command processing (runs in control loop)
     # =========================================================================
@@ -534,6 +569,28 @@ class MovementManager:
             amplitude_deg, duration = payload
             self._do_shake(amplitude_deg, duration)
 
+        elif cmd == "set_pose":
+            # Update target pose from external control (e.g., Home Assistant)
+            if payload.get("x") is not None:
+                self.state.target_x = payload["x"]
+            if payload.get("y") is not None:
+                self.state.target_y = payload["y"]
+            if payload.get("z") is not None:
+                self.state.target_z = payload["z"]
+            if payload.get("roll") is not None:
+                self.state.target_roll = payload["roll"]
+            if payload.get("pitch") is not None:
+                self.state.target_pitch = payload["pitch"]
+            if payload.get("yaw") is not None:
+                self.state.target_yaw = payload["yaw"]
+            if payload.get("body_yaw") is not None:
+                self.state.target_body_yaw = payload["body_yaw"]
+            if payload.get("antenna_left") is not None:
+                self.state.target_antenna_left = payload["antenna_left"]
+            if payload.get("antenna_right") is not None:
+                self.state.target_antenna_right = payload["antenna_right"]
+            logger.debug("External pose update: %s", payload)
+
     def _start_action(self, action: PendingAction) -> None:
         """Start a new motion action."""
         self._pending_action = action

reachy_mini_ha_voice/reachy_controller.py

@@ -47,6 +47,7 @@ class ReachyController:
         """
         self.reachy = reachy_mini
         self._speaker_volume = 100  # Default volume
+        self._movement_manager = None  # Set later via set_movement_manager()
         
         # Status caching - only for get_status() which may trigger I/O
         # Note: get_current_head_pose() and get_current_joint_positions() are
@@ -58,6 +59,15 @@ class ReachyController:
         # Thread lock for ReSpeaker USB access to prevent conflicts with GStreamer audio pipeline
         self._respeaker_lock = __import__('threading').Lock()
 
+    def set_movement_manager(self, movement_manager) -> None:
+        """Set the MovementManager instance for pose control.
+        
+        Args:
+            movement_manager: MovementManager instance
+        """
+        self._movement_manager = movement_manager
+        logger.info("MovementManager set for ReachyController")
+
     @property
     def is_available(self) -> bool:
         """Check if robot is available."""
@@ -408,58 +418,74 @@ class ReachyController:
             return 0.0
 
     def _disabled_pose_setter(self, name: str) -> None:
-        """Log warning for disabled pose setters."""
-        logger.debug(f"set_{name} is disabled - MovementManager controls pose")
+        """Log warning when MovementManager is not available."""
+        logger.warning(f"set_{name} failed - MovementManager not set")
+
+    def _set_pose_via_manager(self, **kwargs) -> bool:
+        """Set pose via MovementManager if available.
+        
+        Returns True if successful, False if MovementManager not available.
+        """
+        if self._movement_manager is None:
+            return False
+        self._movement_manager.set_target_pose(**kwargs)
+        return True
 
-    # Head position getters (read-only, setters disabled for MovementManager)
+    # Head position getters and setters
     def get_head_x(self) -> float:
         """Get head X position in mm."""
         return self._get_head_pose_component('x')
 
     def set_head_x(self, x_mm: float) -> None:
-        """Disabled - MovementManager controls head pose."""
-        self._disabled_pose_setter('head_x')
+        """Set head X position in mm via MovementManager."""
+        if not self._set_pose_via_manager(x=x_mm / 1000.0):  # mm to m
+            self._disabled_pose_setter('head_x')
 
     def get_head_y(self) -> float:
         """Get head Y position in mm."""
         return self._get_head_pose_component('y')
 
     def set_head_y(self, y_mm: float) -> None:
-        """Disabled - MovementManager controls head pose."""
-        self._disabled_pose_setter('head_y')
+        """Set head Y position in mm via MovementManager."""
+        if not self._set_pose_via_manager(y=y_mm / 1000.0):  # mm to m
+            self._disabled_pose_setter('head_y')
 
     def get_head_z(self) -> float:
         """Get head Z position in mm."""
         return self._get_head_pose_component('z')
 
     def set_head_z(self, z_mm: float) -> None:
-        """Disabled - MovementManager controls head pose."""
-        self._disabled_pose_setter('head_z')
+        """Set head Z position in mm via MovementManager."""
+        if not self._set_pose_via_manager(z=z_mm / 1000.0):  # mm to m
+            self._disabled_pose_setter('head_z')
 
-    # Head orientation getters (read-only, setters disabled for MovementManager)
+    # Head orientation getters and setters
     def get_head_roll(self) -> float:
         """Get head roll angle in degrees."""
         return self._get_head_pose_component('roll')
 
     def set_head_roll(self, roll_deg: float) -> None:
-        """Disabled - MovementManager controls head pose."""
-        self._disabled_pose_setter('head_roll')
+        """Set head roll angle in degrees via MovementManager."""
+        if not self._set_pose_via_manager(roll=math.radians(roll_deg)):
+            self._disabled_pose_setter('head_roll')
 
     def get_head_pitch(self) -> float:
         """Get head pitch angle in degrees."""
         return self._get_head_pose_component('pitch')
 
     def set_head_pitch(self, pitch_deg: float) -> None:
-        """Disabled - MovementManager controls head pose."""
-        self._disabled_pose_setter('head_pitch')
+        """Set head pitch angle in degrees via MovementManager."""
+        if not self._set_pose_via_manager(pitch=math.radians(pitch_deg)):
+            self._disabled_pose_setter('head_pitch')
 
     def get_head_yaw(self) -> float:
         """Get head yaw angle in degrees."""
         return self._get_head_pose_component('yaw')
 
     def set_head_yaw(self, yaw_deg: float) -> None:
-        """Disabled - MovementManager controls head pose."""
-        self._disabled_pose_setter('head_yaw')
+        """Set head yaw angle in degrees via MovementManager."""
+        if not self._set_pose_via_manager(yaw=math.radians(yaw_deg)):
+            self._disabled_pose_setter('head_yaw')
 
     def get_body_yaw(self) -> float:
         """Get body yaw angle in degrees."""
@@ -474,8 +500,9 @@ class ReachyController:
             return 0.0
 
     def set_body_yaw(self, yaw_deg: float) -> None:
-        """Disabled - MovementManager controls body pose."""
-        self._disabled_pose_setter('body_yaw')
+        """Set body yaw angle in degrees via MovementManager."""
+        if not self._set_pose_via_manager(body_yaw=math.radians(yaw_deg)):
+            self._disabled_pose_setter('body_yaw')
 
     def get_antenna_left(self) -> float:
         """Get left antenna angle in degrees."""
@@ -490,8 +517,9 @@ class ReachyController:
             return 0.0
 
     def set_antenna_left(self, angle_deg: float) -> None:
-        """Disabled - MovementManager controls antennas."""
-        self._disabled_pose_setter('antenna_left')
+        """Set left antenna angle in degrees via MovementManager."""
+        if not self._set_pose_via_manager(antenna_left=math.radians(angle_deg)):
+            self._disabled_pose_setter('antenna_left')
 
     def get_antenna_right(self) -> float:
         """Get right antenna angle in degrees."""
@@ -506,8 +534,9 @@ class ReachyController:
             return 0.0
 
     def set_antenna_right(self, angle_deg: float) -> None:
-        """Disabled - MovementManager controls antennas."""
-        self._disabled_pose_setter('antenna_right')
+        """Set right antenna angle in degrees via MovementManager."""
+        if not self._set_pose_via_manager(antenna_right=math.radians(angle_deg)):
+            self._disabled_pose_setter('antenna_right')
 
     # ========== Phase 4: Look At Control ==========
 

reachy_mini_ha_voice/satellite.py

@@ -81,6 +81,10 @@ class VoiceSatelliteProtocol(APIServer):
 
         # Initialize Reachy controller
         self.reachy_controller = ReachyController(state.reachy_mini)
+        
+        # Connect MovementManager to ReachyController for pose control from HA
+        if state.motion is not None and state.motion.movement_manager is not None:
+            self.reachy_controller.set_movement_manager(state.motion.movement_manager)
 
         # Initialize entity registry (tap_detector from state if available)
         tap_detector = getattr(state, 'tap_detector', None)
@@ -156,12 +160,12 @@ class VoiceSatelliteProtocol(APIServer):
             self.play_tts()
 
         elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_RUN_END:
-            self._is_streaming_audio = False
+            # Note: Don't set _is_streaming_audio = False here
+            # _tts_finished() will handle it based on whether we continue conversation
             if not self._tts_played:
                 self._tts_finished()
             self._tts_played = False
-            # Reachy Mini: Return to idle
-            self._reachy_on_idle()
+            # Note: _reachy_on_idle() is called inside _tts_finished() if not continuing
 
     def handle_timer_event(
         self,
@@ -420,16 +424,19 @@ class VoiceSatelliteProtocol(APIServer):
         should_continue = self._continue_conversation or self._tap_conversation_mode
 
         if should_continue:
+            _LOGGER.info("Continuing conversation (tap_mode=%s, ha_continue=%s)", 
+                        self._tap_conversation_mode, self._continue_conversation)
             self.send_messages([VoiceAssistantRequest(start=True)])
             self._is_streaming_audio = True
             
             if self._tap_conversation_mode:
-                _LOGGER.debug("Continuing tap conversation mode")
                 # Provide feedback for continuous conversation mode
                 self._tap_continue_feedback()
-            else:
-                _LOGGER.debug("Continuing conversation (HA requested)")
+            
+            # Stay in listening mode, don't go to idle
+            self._reachy_on_listening()
         else:
+            self._is_streaming_audio = False
             self.unduck()
             _LOGGER.debug("TTS response finished")
             # Reachy Mini: Return to idle