优化拆分代码

reachy_mini_ha_voice/__init__.py

@@ -12,7 +12,7 @@ Key features:
 """
 
 __version__ = "0.1.0"
-__author__ = "Pollen Robotics"
+__author__ = "Desmond Dong"
 
 # Don't import main module here to avoid runpy warning
 # The app is loaded via entry point: reachy_mini_ha_voice.main:ReachyMiniHAVoiceApp

reachy_mini_ha_voice/entity_registry.py

@@ -0,0 +1,800 @@
+"""Entity registry for ESPHome entities.
+
+This module handles the registration and management of all ESPHome entities
+for the Reachy Mini voice assistant.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional
+
+from .entity import BinarySensorEntity, CameraEntity, MediaPlayerEntity, NumberEntity, TextSensorEntity
+from .entity_extensions import SensorEntity, SwitchEntity, SelectEntity, ButtonEntity
+
+if TYPE_CHECKING:
+    from .reachy_controller import ReachyController
+    from .camera_server import MJPEGCameraServer
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# Fixed entity key mapping - ensures consistent keys across restarts
+# Keys are based on object_id hash to ensure uniqueness and consistency
+ENTITY_KEYS: Dict[str, int] = {
+    # Media player (key 0 reserved)
+    "reachy_mini_media_player": 0,
+    # Phase 1: Basic status and volume
+    "daemon_state": 100,
+    "backend_ready": 101,
+    "error_message": 102,
+    "speaker_volume": 103,
+    # Phase 2: Motor control
+    "motors_enabled": 200,
+    "motor_mode": 201,
+    "wake_up": 202,
+    "go_to_sleep": 203,
+    # Phase 3: Pose control
+    "head_x": 300,
+    "head_y": 301,
+    "head_z": 302,
+    "head_roll": 303,
+    "head_pitch": 304,
+    "head_yaw": 305,
+    "body_yaw": 306,
+    "antenna_left": 307,
+    "antenna_right": 308,
+    # Phase 4: Look at control
+    "look_at_x": 400,
+    "look_at_y": 401,
+    "look_at_z": 402,
+    # Phase 5: Audio sensors
+    "doa_angle": 500,
+    "speech_detected": 501,
+    # Phase 6: Diagnostic information
+    "control_loop_frequency": 600,
+    "sdk_version": 601,
+    "robot_name": 602,
+    "wireless_version": 603,
+    "simulation_mode": 604,
+    "wlan_ip": 605,
+    # Phase 7: IMU sensors
+    "imu_accel_x": 700,
+    "imu_accel_y": 701,
+    "imu_accel_z": 702,
+    "imu_gyro_x": 703,
+    "imu_gyro_y": 704,
+    "imu_gyro_z": 705,
+    "imu_temperature": 706,
+    # Phase 8: Emotion selector
+    "emotion": 800,
+    # Phase 9: Audio controls
+    "microphone_volume": 900,
+    # Phase 10: Camera
+    "camera_url": 1000,  # Keep for backward compatibility
+    "camera": 1001,      # New camera entity
+    # Phase 11: LED control (disabled - not visible)
+    # "led_brightness": 1100,
+    # "led_effect": 1101,
+    # "led_color_r": 1102,
+    # "led_color_g": 1103,
+    # "led_color_b": 1104,
+    # Phase 12: Audio processing
+    "agc_enabled": 1200,
+    "agc_max_gain": 1201,
+    "noise_suppression": 1202,
+    "echo_cancellation_converged": 1203,
+    # Phase 13: Robot joints (single JSON sensor)
+    "head_joints": 1300,
+    # Phase 14: Passive joints for 3D visualization
+    "passive_joints": 1400,
+}
+
+
+def get_entity_key(object_id: str) -> int:
+    """Get a consistent entity key for the given object_id."""
+    if object_id in ENTITY_KEYS:
+        return ENTITY_KEYS[object_id]
+    # Fallback: generate key from hash (should not happen if all entities are registered)
+    _LOGGER.warning(f"Entity key not found for {object_id}, generating from hash")
+    return abs(hash(object_id)) % 10000 + 2000
+
+
+class EntityRegistry:
+    """Registry for managing ESPHome entities."""
+
+    def __init__(
+        self,
+        server,
+        reachy_controller: "ReachyController",
+        camera_server: Optional["MJPEGCameraServer"] = None,
+        play_emotion_callback: Optional[Callable[[str], None]] = None,
+    ):
+        """Initialize the entity registry.
+
+        Args:
+            server: The VoiceSatelliteProtocol server instance
+            reachy_controller: The ReachyController instance
+            camera_server: Optional camera server for camera entity
+            play_emotion_callback: Optional callback for playing emotions
+        """
+        self.server = server
+        self.reachy_controller = reachy_controller
+        self.camera_server = camera_server
+        self._play_emotion_callback = play_emotion_callback
+
+        # Entity references that need to be accessed externally
+        self.doa_angle_entity: Optional[SensorEntity] = None
+        self.speech_detected_entity: Optional[BinarySensorEntity] = None
+
+        # Emotion state
+        self._current_emotion = "None"
+        self._emotion_map = {
+            "None": None,
+            "Happy": "happy1",
+            "Sad": "sad1",
+            "Angry": "angry1",
+            "Fear": "fear1",
+            "Surprise": "surprise1",
+            "Disgust": "disgust1",
+        }
+
+    def setup_all_entities(self, entities: List) -> None:
+        """Setup all entity phases.
+
+        Args:
+            entities: The list to append entities to
+        """
+        self._setup_phase1_entities(entities)
+        self._setup_phase2_entities(entities)
+        self._setup_phase3_entities(entities)
+        self._setup_phase4_entities(entities)
+        self._setup_phase5_entities(entities)
+        self._setup_phase6_entities(entities)
+        self._setup_phase7_entities(entities)
+        self._setup_phase8_entities(entities)
+        self._setup_phase9_entities(entities)
+        self._setup_phase10_entities(entities)
+        # Phase 11 (LED control) disabled - LEDs are inside the robot and not visible
+        self._setup_phase12_entities(entities)
+        self._setup_phase13_entities(entities)
+
+        _LOGGER.info("All entities registered: %d total", len(entities))
+
+    def _setup_phase1_entities(self, entities: List) -> None:
+        """Setup Phase 1 entities: Basic status and volume control."""
+        rc = self.reachy_controller
+
+        entities.append(TextSensorEntity(
+            server=self.server,
+            key=get_entity_key("daemon_state"),
+            name="Daemon State",
+            object_id="daemon_state",
+            icon="mdi:robot",
+            value_getter=rc.get_daemon_state,
+        ))
+
+        entities.append(BinarySensorEntity(
+            server=self.server,
+            key=get_entity_key("backend_ready"),
+            name="Backend Ready",
+            object_id="backend_ready",
+            icon="mdi:check-circle",
+            device_class="connectivity",
+            value_getter=rc.get_backend_ready,
+        ))
+
+        entities.append(TextSensorEntity(
+            server=self.server,
+            key=get_entity_key("error_message"),
+            name="Error Message",
+            object_id="error_message",
+            icon="mdi:alert-circle",
+            value_getter=rc.get_error_message,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("speaker_volume"),
+            name="Speaker Volume",
+            object_id="speaker_volume",
+            min_value=0.0,
+            max_value=100.0,
+            step=1.0,
+            icon="mdi:volume-high",
+            unit_of_measurement="%",
+            mode=2,  # Slider mode
+            entity_category=1,  # config
+            value_getter=rc.get_speaker_volume,
+            value_setter=rc.set_speaker_volume,
+        ))
+
+        _LOGGER.debug("Phase 1 entities registered: daemon_state, backend_ready, error_message, speaker_volume")
+
+    def _setup_phase2_entities(self, entities: List) -> None:
+        """Setup Phase 2 entities: Motor control."""
+        rc = self.reachy_controller
+
+        entities.append(SwitchEntity(
+            server=self.server,
+            key=get_entity_key("motors_enabled"),
+            name="Motors Enabled",
+            object_id="motors_enabled",
+            icon="mdi:engine",
+            device_class="switch",
+            value_getter=rc.get_motors_enabled,
+            value_setter=rc.set_motors_enabled,
+        ))
+
+        entities.append(ButtonEntity(
+            server=self.server,
+            key=get_entity_key("wake_up"),
+            name="Wake Up",
+            object_id="wake_up",
+            icon="mdi:alarm",
+            device_class="restart",
+            on_press=rc.wake_up,
+        ))
+
+        entities.append(ButtonEntity(
+            server=self.server,
+            key=get_entity_key("go_to_sleep"),
+            name="Go to Sleep",
+            object_id="go_to_sleep",
+            icon="mdi:sleep",
+            device_class="restart",
+            on_press=rc.go_to_sleep,
+        ))
+
+        _LOGGER.debug("Phase 2 entities registered: motors_enabled, wake_up, go_to_sleep")
+
+    def _setup_phase3_entities(self, entities: List) -> None:
+        """Setup Phase 3 entities: Pose control."""
+        rc = self.reachy_controller
+
+        # Head position controls (X, Y, Z in mm)
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("head_x"),
+            name="Head X Position",
+            object_id="head_x",
+            min_value=-50.0,
+            max_value=50.0,
+            step=1.0,
+            icon="mdi:axis-x-arrow",
+            unit_of_measurement="mm",
+            mode=2,
+            value_getter=rc.get_head_x,
+            value_setter=rc.set_head_x,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("head_y"),
+            name="Head Y Position",
+            object_id="head_y",
+            min_value=-50.0,
+            max_value=50.0,
+            step=1.0,
+            icon="mdi:axis-y-arrow",
+            unit_of_measurement="mm",
+            mode=2,
+            value_getter=rc.get_head_y,
+            value_setter=rc.set_head_y,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("head_z"),
+            name="Head Z Position",
+            object_id="head_z",
+            min_value=-50.0,
+            max_value=50.0,
+            step=1.0,
+            icon="mdi:axis-z-arrow",
+            unit_of_measurement="mm",
+            mode=2,
+            value_getter=rc.get_head_z,
+            value_setter=rc.set_head_z,
+        ))
+
+        # Head orientation controls (Roll, Pitch, Yaw in degrees)
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("head_roll"),
+            name="Head Roll",
+            object_id="head_roll",
+            min_value=-40.0,
+            max_value=40.0,
+            step=1.0,
+            icon="mdi:rotate-3d-variant",
+            unit_of_measurement="°",
+            mode=2,
+            value_getter=rc.get_head_roll,
+            value_setter=rc.set_head_roll,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("head_pitch"),
+            name="Head Pitch",
+            object_id="head_pitch",
+            min_value=-40.0,
+            max_value=40.0,
+            step=1.0,
+            icon="mdi:rotate-3d-variant",
+            unit_of_measurement="°",
+            mode=2,
+            value_getter=rc.get_head_pitch,
+            value_setter=rc.set_head_pitch,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("head_yaw"),
+            name="Head Yaw",
+            object_id="head_yaw",
+            min_value=-180.0,
+            max_value=180.0,
+            step=1.0,
+            icon="mdi:rotate-3d-variant",
+            unit_of_measurement="°",
+            mode=2,
+            value_getter=rc.get_head_yaw,
+            value_setter=rc.set_head_yaw,
+        ))
+
+        # Body yaw control
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("body_yaw"),
+            name="Body Yaw",
+            object_id="body_yaw",
+            min_value=-160.0,
+            max_value=160.0,
+            step=1.0,
+            icon="mdi:rotate-3d-variant",
+            unit_of_measurement="°",
+            mode=2,
+            value_getter=rc.get_body_yaw,
+            value_setter=rc.set_body_yaw,
+        ))
+
+        # Antenna controls
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("antenna_left"),
+            name="Antenna(L)",
+            object_id="antenna_left",
+            min_value=-90.0,
+            max_value=90.0,
+            step=1.0,
+            icon="mdi:antenna",
+            unit_of_measurement="°",
+            mode=2,
+            value_getter=rc.get_antenna_left,
+            value_setter=rc.set_antenna_left,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("antenna_right"),
+            name="Antenna(R)",
+            object_id="antenna_right",
+            min_value=-90.0,
+            max_value=90.0,
+            step=1.0,
+            icon="mdi:antenna",
+            unit_of_measurement="°",
+            mode=2,
+            value_getter=rc.get_antenna_right,
+            value_setter=rc.set_antenna_right,
+        ))
+
+        _LOGGER.debug("Phase 3 entities registered: head position/orientation, body_yaw, antennas")
+
+    def _setup_phase4_entities(self, entities: List) -> None:
+        """Setup Phase 4 entities: Look at control."""
+        rc = self.reachy_controller
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("look_at_x"),
+            name="Look At X",
+            object_id="look_at_x",
+            min_value=-2.0,
+            max_value=2.0,
+            step=0.1,
+            icon="mdi:crosshairs-gps",
+            unit_of_measurement="m",
+            mode=1,  # Box mode for precise input
+            value_getter=rc.get_look_at_x,
+            value_setter=rc.set_look_at_x,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("look_at_y"),
+            name="Look At Y",
+            object_id="look_at_y",
+            min_value=-2.0,
+            max_value=2.0,
+            step=0.1,
+            icon="mdi:crosshairs-gps",
+            unit_of_measurement="m",
+            mode=1,
+            value_getter=rc.get_look_at_y,
+            value_setter=rc.set_look_at_y,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("look_at_z"),
+            name="Look At Z",
+            object_id="look_at_z",
+            min_value=-2.0,
+            max_value=2.0,
+            step=0.1,
+            icon="mdi:crosshairs-gps",
+            unit_of_measurement="m",
+            mode=1,
+            value_getter=rc.get_look_at_z,
+            value_setter=rc.set_look_at_z,
+        ))
+
+        _LOGGER.debug("Phase 4 entities registered: look_at_x/y/z")
+
+    def _setup_phase5_entities(self, entities: List) -> None:
+        """Setup Phase 5 entities: Audio sensors."""
+        rc = self.reachy_controller
+
+        self.doa_angle_entity = SensorEntity(
+            server=self.server,
+            key=get_entity_key("doa_angle"),
+            name="DOA Angle",
+            object_id="doa_angle",
+            icon="mdi:compass",
+            unit_of_measurement="°",
+            accuracy_decimals=1,
+            state_class="measurement",
+            value_getter=rc.get_doa_angle,
+        )
+        entities.append(self.doa_angle_entity)
+
+        self.speech_detected_entity = BinarySensorEntity(
+            server=self.server,
+            key=get_entity_key("speech_detected"),
+            name="Speech Detected",
+            object_id="speech_detected",
+            icon="mdi:microphone",
+            device_class="sound",
+            value_getter=rc.get_speech_detected,
+        )
+        entities.append(self.speech_detected_entity)
+
+        _LOGGER.debug("Phase 5 entities registered: doa_angle, speech_detected")
+
+    def _setup_phase6_entities(self, entities: List) -> None:
+        """Setup Phase 6 entities: Diagnostic information."""
+        rc = self.reachy_controller
+
+        entities.append(SensorEntity(
+            server=self.server,
+            key=get_entity_key("control_loop_frequency"),
+            name="Control Loop Frequency",
+            object_id="control_loop_frequency",
+            icon="mdi:speedometer",
+            unit_of_measurement="Hz",
+            accuracy_decimals=1,
+            state_class="measurement",
+            value_getter=rc.get_control_loop_frequency,
+        ))
+
+        entities.append(TextSensorEntity(
+            server=self.server,
+            key=get_entity_key("sdk_version"),
+            name="SDK Version",
+            object_id="sdk_version",
+            icon="mdi:information",
+            value_getter=rc.get_sdk_version,
+        ))
+
+        entities.append(TextSensorEntity(
+            server=self.server,
+            key=get_entity_key("robot_name"),
+            name="Robot Name",
+            object_id="robot_name",
+            icon="mdi:robot",
+            value_getter=rc.get_robot_name,
+        ))
+
+        entities.append(BinarySensorEntity(
+            server=self.server,
+            key=get_entity_key("wireless_version"),
+            name="Wireless Version",
+            object_id="wireless_version",
+            icon="mdi:wifi",
+            device_class="connectivity",
+            value_getter=rc.get_wireless_version,
+        ))
+
+        entities.append(BinarySensorEntity(
+            server=self.server,
+            key=get_entity_key("simulation_mode"),
+            name="Simulation Mode",
+            object_id="simulation_mode",
+            icon="mdi:virtual-reality",
+            value_getter=rc.get_simulation_mode,
+        ))
+
+        entities.append(TextSensorEntity(
+            server=self.server,
+            key=get_entity_key("wlan_ip"),
+            name="WLAN IP",
+            object_id="wlan_ip",
+            icon="mdi:ip-network",
+            value_getter=rc.get_wlan_ip,
+        ))
+
+        _LOGGER.debug("Phase 6 entities registered: control_loop_frequency, sdk_version, robot_name, wireless_version, simulation_mode, wlan_ip")
+
+    def _setup_phase7_entities(self, entities: List) -> None:
+        """Setup Phase 7 entities: IMU sensors (wireless only)."""
+        rc = self.reachy_controller
+
+        # IMU Accelerometer
+        entities.append(SensorEntity(
+            server=self.server,
+            key=get_entity_key("imu_accel_x"),
+            name="IMU Accel X",
+            object_id="imu_accel_x",
+            icon="mdi:axis-x-arrow",
+            unit_of_measurement="m/s²",
+            accuracy_decimals=3,
+            state_class="measurement",
+            value_getter=rc.get_imu_accel_x,
+        ))
+
+        entities.append(SensorEntity(
+            server=self.server,
+            key=get_entity_key("imu_accel_y"),
+            name="IMU Accel Y",
+            object_id="imu_accel_y",
+            icon="mdi:axis-y-arrow",
+            unit_of_measurement="m/s²",
+            accuracy_decimals=3,
+            state_class="measurement",
+            value_getter=rc.get_imu_accel_y,
+        ))
+
+        entities.append(SensorEntity(
+            server=self.server,
+            key=get_entity_key("imu_accel_z"),
+            name="IMU Accel Z",
+            object_id="imu_accel_z",
+            icon="mdi:axis-z-arrow",
+            unit_of_measurement="m/s²",
+            accuracy_decimals=3,
+            state_class="measurement",
+            value_getter=rc.get_imu_accel_z,
+        ))
+
+        # IMU Gyroscope
+        entities.append(SensorEntity(
+            server=self.server,
+            key=get_entity_key("imu_gyro_x"),
+            name="IMU Gyro X",
+            object_id="imu_gyro_x",
+            icon="mdi:rotate-3d-variant",
+            unit_of_measurement="rad/s",
+            accuracy_decimals=3,
+            state_class="measurement",
+            value_getter=rc.get_imu_gyro_x,
+        ))
+
+        entities.append(SensorEntity(
+            server=self.server,
+            key=get_entity_key("imu_gyro_y"),
+            name="IMU Gyro Y",
+            object_id="imu_gyro_y",
+            icon="mdi:rotate-3d-variant",
+            unit_of_measurement="rad/s",
+            accuracy_decimals=3,
+            state_class="measurement",
+            value_getter=rc.get_imu_gyro_y,
+        ))
+
+        entities.append(SensorEntity(
+            server=self.server,
+            key=get_entity_key("imu_gyro_z"),
+            name="IMU Gyro Z",
+            object_id="imu_gyro_z",
+            icon="mdi:rotate-3d-variant",
+            unit_of_measurement="rad/s",
+            accuracy_decimals=3,
+            state_class="measurement",
+            value_getter=rc.get_imu_gyro_z,
+        ))
+
+        # IMU Temperature
+        entities.append(SensorEntity(
+            server=self.server,
+            key=get_entity_key("imu_temperature"),
+            name="IMU Temperature",
+            object_id="imu_temperature",
+            icon="mdi:thermometer",
+            unit_of_measurement="°C",
+            accuracy_decimals=1,
+            device_class="temperature",
+            state_class="measurement",
+            value_getter=rc.get_imu_temperature,
+        ))
+
+        _LOGGER.debug("Phase 7 entities registered: IMU accelerometer, gyroscope, temperature")
+
+    def _setup_phase8_entities(self, entities: List) -> None:
+        """Setup Phase 8 entities: Emotion selector."""
+
+        def get_emotion() -> str:
+            return self._current_emotion
+
+        def set_emotion(emotion: str) -> None:
+            self._current_emotion = emotion
+            emotion_name = self._emotion_map.get(emotion)
+            if emotion_name and self._play_emotion_callback:
+                self._play_emotion_callback(emotion_name)
+                # Reset to None after playing
+                self._current_emotion = "None"
+
+        entities.append(SelectEntity(
+            server=self.server,
+            key=get_entity_key("emotion"),
+            name="Emotion",
+            object_id="emotion",
+            options=list(self._emotion_map.keys()),
+            icon="mdi:emoticon",
+            value_getter=get_emotion,
+            value_setter=set_emotion,
+        ))
+
+        _LOGGER.debug("Phase 8 entities registered: emotion selector")
+
+    def _setup_phase9_entities(self, entities: List) -> None:
+        """Setup Phase 9 entities: Audio controls."""
+        rc = self.reachy_controller
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("microphone_volume"),
+            name="Microphone Volume",
+            object_id="microphone_volume",
+            min_value=0.0,
+            max_value=100.0,
+            step=1.0,
+            icon="mdi:microphone",
+            unit_of_measurement="%",
+            mode=2,  # Slider mode
+            entity_category=1,  # config
+            value_getter=rc.get_microphone_volume,
+            value_setter=rc.set_microphone_volume,
+        ))
+
+        _LOGGER.debug("Phase 9 entities registered: microphone_volume")
+
+    def _setup_phase10_entities(self, entities: List) -> None:
+        """Setup Phase 10 entities: Camera for Home Assistant integration."""
+
+        def get_camera_image() -> Optional[bytes]:
+            """Get camera snapshot as JPEG bytes."""
+            if self.camera_server:
+                return self.camera_server.get_snapshot()
+            return None
+
+        entities.append(CameraEntity(
+            server=self.server,
+            key=get_entity_key("camera"),
+            name="Camera",
+            object_id="camera",
+            icon="mdi:camera",
+            image_getter=get_camera_image,
+        ))
+
+        _LOGGER.debug("Phase 10 entities registered: camera (ESPHome Camera entity)")
+
+    def _setup_phase12_entities(self, entities: List) -> None:
+        """Setup Phase 12 entities: Audio processing parameters (via local SDK)."""
+        rc = self.reachy_controller
+
+        entities.append(SwitchEntity(
+            server=self.server,
+            key=get_entity_key("agc_enabled"),
+            name="AGC Enabled",
+            object_id="agc_enabled",
+            icon="mdi:tune-vertical",
+            device_class="switch",
+            entity_category=1,  # config
+            value_getter=rc.get_agc_enabled,
+            value_setter=rc.set_agc_enabled,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("agc_max_gain"),
+            name="AGC Max Gain",
+            object_id="agc_max_gain",
+            min_value=0.0,
+            max_value=30.0,
+            step=1.0,
+            icon="mdi:volume-plus",
+            unit_of_measurement="dB",
+            mode=2,
+            entity_category=1,  # config
+            value_getter=rc.get_agc_max_gain,
+            value_setter=rc.set_agc_max_gain,
+        ))
+
+        entities.append(NumberEntity(
+            server=self.server,
+            key=get_entity_key("noise_suppression"),
+            name="Noise Suppression",
+            object_id="noise_suppression",
+            min_value=0.0,
+            max_value=100.0,
+            step=1.0,
+            icon="mdi:volume-off",
+            unit_of_measurement="%",
+            mode=2,
+            entity_category=1,  # config
+            value_getter=rc.get_noise_suppression,
+            value_setter=rc.set_noise_suppression,
+        ))
+
+        entities.append(BinarySensorEntity(
+            server=self.server,
+            key=get_entity_key("echo_cancellation_converged"),
+            name="Echo Cancellation Converged",
+            object_id="echo_cancellation_converged",
+            icon="mdi:waveform",
+            device_class="running",
+            entity_category=2,  # diagnostic
+            value_getter=rc.get_echo_cancellation_converged,
+        ))
+
+        _LOGGER.debug("Phase 12 entities registered: agc_enabled, agc_max_gain, noise_suppression, echo_cancellation_converged")
+
+    def _setup_phase13_entities(self, entities: List) -> None:
+        """Setup Phase 13 entities: Robot joints as JSON sensor."""
+        rc = self.reachy_controller
+
+        entities.append(TextSensorEntity(
+            server=self.server,
+            key=get_entity_key("head_joints"),
+            name="Head Joints",
+            object_id="head_joints",
+            icon="mdi:robot",
+            value_getter=rc.get_head_joints_json,
+        ))
+
+        _LOGGER.debug("Phase 13 entities registered: head_joints")
+
+        # Phase 14: Passive joints for 3D visualization
+        entities.append(TextSensorEntity(
+            server=self.server,
+            key=get_entity_key("passive_joints"),
+            name="Passive Joints",
+            object_id="passive_joints",
+            value_getter=rc.get_passive_joints_json,
+        ))
+
+        _LOGGER.debug("Phase 14 entities registered: passive_joints")
+
+    def find_entity_references(self, entities: List) -> None:
+        """Find and store references to special entities from existing list.
+
+        Args:
+            entities: The list of existing entities to search
+        """
+        for entity in entities:
+            if hasattr(entity, 'object_id'):
+                if entity.object_id == 'doa_angle':
+                    self.doa_angle_entity = entity
+                elif entity.object_id == 'speech_detected':
+                    self.speech_detected_entity = entity

reachy_mini_ha_voice/satellite.py

@@ -49,8 +49,8 @@ from pymicro_wakeword import MicroWakeWord
 from pyopen_wakeword import OpenWakeWord
 
 from .api_server import APIServer
-from .entity import BinarySensorEntity, CameraEntity, MediaPlayerEntity, NumberEntity, TextSensorEntity
-from .entity_extensions import SensorEntity, SwitchEntity, SelectEntity, ButtonEntity
+from .entity import MediaPlayerEntity
+from .entity_registry import EntityRegistry, get_entity_key
 from .models import AvailableWakeWord, ServerState, WakeWordType
 from .util import call_all
 from .reachy_controller import ReachyController
@@ -61,85 +61,6 @@ _LOGGER = logging.getLogger(__name__)
 class VoiceSatelliteProtocol(APIServer):
     """Voice satellite protocol handler for ESPHome."""
 
-    # Fixed entity key mapping - ensures consistent keys across restarts
-    # Keys are based on object_id hash to ensure uniqueness and consistency
-    ENTITY_KEYS = {
-        # Media player (key 0 reserved)
-        "reachy_mini_media_player": 0,
-        # Phase 1: Basic status and volume
-        "daemon_state": 100,
-        "backend_ready": 101,
-        "error_message": 102,
-        "speaker_volume": 103,
-        # Phase 2: Motor control
-        "motors_enabled": 200,
-        "motor_mode": 201,
-        "wake_up": 202,
-        "go_to_sleep": 203,
-        # Phase 3: Pose control
-        "head_x": 300,
-        "head_y": 301,
-        "head_z": 302,
-        "head_roll": 303,
-        "head_pitch": 304,
-        "head_yaw": 305,
-        "body_yaw": 306,
-        "antenna_left": 307,
-        "antenna_right": 308,
-        # Phase 4: Look at control
-        "look_at_x": 400,
-        "look_at_y": 401,
-        "look_at_z": 402,
-        # Phase 5: Audio sensors
-        "doa_angle": 500,
-        "speech_detected": 501,
-        # Phase 6: Diagnostic information
-        "control_loop_frequency": 600,
-        "sdk_version": 601,
-        "robot_name": 602,
-        "wireless_version": 603,
-        "simulation_mode": 604,
-        "wlan_ip": 605,
-        # Phase 7: IMU sensors
-        "imu_accel_x": 700,
-        "imu_accel_y": 701,
-        "imu_accel_z": 702,
-        "imu_gyro_x": 703,
-        "imu_gyro_y": 704,
-        "imu_gyro_z": 705,
-        "imu_temperature": 706,
-        # Phase 8: Emotion selector
-        "emotion": 800,
-        # Phase 9: Audio controls
-        "microphone_volume": 900,
-        # Phase 10: Camera
-        "camera_url": 1000,  # Keep for backward compatibility
-        "camera": 1001,      # New camera entity
-        # Phase 11: LED control (disabled - not visible)
-        # "led_brightness": 1100,
-        # "led_effect": 1101,
-        # "led_color_r": 1102,
-        # "led_color_g": 1103,
-        # "led_color_b": 1104,
-        # Phase 12: Audio processing
-        "agc_enabled": 1200,
-        "agc_max_gain": 1201,
-        "noise_suppression": 1202,
-        "echo_cancellation_converged": 1203,
-        # Phase 13: Robot joints (single JSON sensor)
-        "head_joints": 1300,
-        # Phase 14: Passive joints for 3D visualization
-        "passive_joints": 1400,
-    }
-
-    def _get_entity_key(self, object_id: str) -> int:
-        """Get a consistent entity key for the given object_id."""
-        if object_id in self.ENTITY_KEYS:
-            return self.ENTITY_KEYS[object_id]
-        # Fallback: generate key from hash (should not happen if all entities are registered)
-        _LOGGER.warning(f"Entity key not found for {object_id}, generating from hash")
-        return abs(hash(object_id)) % 10000 + 2000
-
     def __init__(self, state: ServerState, camera_server: Optional["MJPEGCameraServer"] = None) -> None:
         super().__init__(state.name)
         self.state = state
@@ -149,9 +70,13 @@ class VoiceSatelliteProtocol(APIServer):
         # Initialize Reachy controller
         self.reachy_controller = ReachyController(state.reachy_mini)
 
-        # Initialize entity references (will be set in setup phases)
-        self._doa_angle_entity: Optional[SensorEntity] = None
-        self._speech_detected_entity: Optional[BinarySensorEntity] = None
+        # Initialize entity registry
+        self._entity_registry = EntityRegistry(
+            server=self,
+            reachy_controller=self.reachy_controller,
+            camera_server=camera_server,
+            play_emotion_callback=self._play_emotion,
+        )
 
         # Only setup entities once (check if already initialized)
         # This prevents duplicate entity registration on reconnection
@@ -159,7 +84,7 @@ class VoiceSatelliteProtocol(APIServer):
             if self.state.media_player_entity is None:
                 self.state.media_player_entity = MediaPlayerEntity(
                     server=self,
-                    key=self._get_entity_key("reachy_mini_media_player"),
+                    key=get_entity_key("reachy_mini_media_player"),
                     name="Media Player",
                     object_id="reachy_mini_media_player",
                     music_player=state.music_player,
@@ -167,20 +92,8 @@ class VoiceSatelliteProtocol(APIServer):
                 )
                 self.state.entities.append(self.state.media_player_entity)
 
-            # Setup all entity phases
-            self._setup_phase1_entities()
-            self._setup_phase2_entities()
-            self._setup_phase3_entities()
-            self._setup_phase4_entities()
-            self._setup_phase5_entities()
-            self._setup_phase6_entities()
-            self._setup_phase7_entities()
-            self._setup_phase8_entities()
-            self._setup_phase9_entities()
-            self._setup_phase10_entities()  # Camera
-            # Phase 11 (LED control) disabled - LEDs are inside the robot and not visible
-            self._setup_phase12_entities()  # Audio processing
-            self._setup_phase13_entities()  # Robot joints
+            # Setup all entities using the registry
+            self._entity_registry.setup_all_entities(self.state.entities)
 
             # Mark entities as initialized
             self.state._entities_initialized = True
@@ -191,12 +104,7 @@ class VoiceSatelliteProtocol(APIServer):
             for entity in self.state.entities:
                 entity.server = self
             # Find and store references to DOA entities
-            for entity in self.state.entities:
-                if hasattr(entity, 'object_id'):
-                    if entity.object_id == 'doa_angle':
-                        self._doa_angle_entity = entity
-                    elif entity.object_id == 'speech_detected':
-                        self._speech_detected_entity = entity
+            self._entity_registry.find_entity_references(self.state.entities)
 
         self._is_streaming_audio = False
         self._tts_url: Optional[str] = None
@@ -568,11 +476,11 @@ class VoiceSatelliteProtocol(APIServer):
     def _update_doa_entities(self) -> None:
         """Update DOA and speech detection entities in Home Assistant."""
         try:
-            if self._doa_angle_entity is not None:
-                self._doa_angle_entity.update_state()
+            if self._entity_registry.doa_angle_entity is not None:
+                self._entity_registry.doa_angle_entity.update_state()
                 _LOGGER.debug("DOA angle entity updated")
-            if self._speech_detected_entity is not None:
-                self._speech_detected_entity.update_state()
+            if self._entity_registry.speech_detected_entity is not None:
+                self._entity_registry.speech_detected_entity.update_state()
                 _LOGGER.debug("Speech detected entity updated")
         except Exception as e:
             _LOGGER.error("Error updating DOA entities: %s", e)
@@ -663,786 +571,3 @@ class VoiceSatelliteProtocol(APIServer):
 
         except Exception as e:
             _LOGGER.error(f"Error playing emotion {emotion_name}: {e}")
-
-    # -------------------------------------------------------------------------
-    # Entity Setup Methods
-    # -------------------------------------------------------------------------
-
-    def _setup_phase1_entities(self) -> None:
-        """Setup Phase 1 entities: Basic status and volume control."""
-
-        # Daemon state sensor
-        daemon_state_sensor = TextSensorEntity(
-            server=self,
-            key=self._get_entity_key("daemon_state"),
-            name="Daemon State",
-            object_id="daemon_state",
-            icon="mdi:robot",
-            value_getter=self.reachy_controller.get_daemon_state,
-        )
-        self.state.entities.append(daemon_state_sensor)
-
-        # Backend ready sensor
-        backend_ready_sensor = BinarySensorEntity(
-            server=self,
-            key=self._get_entity_key("backend_ready"),
-            name="Backend Ready",
-            object_id="backend_ready",
-            icon="mdi:check-circle",
-            device_class="connectivity",
-            value_getter=self.reachy_controller.get_backend_ready,
-        )
-        self.state.entities.append(backend_ready_sensor)
-
-        # Error message sensor
-        error_message_sensor = TextSensorEntity(
-            server=self,
-            key=self._get_entity_key("error_message"),
-            name="Error Message",
-            object_id="error_message",
-            icon="mdi:alert-circle",
-            value_getter=self.reachy_controller.get_error_message,
-        )
-        self.state.entities.append(error_message_sensor)
-
-        # Speaker volume control
-        speaker_volume = NumberEntity(
-            server=self,
-            key=self._get_entity_key("speaker_volume"),
-            name="Speaker Volume",
-            object_id="speaker_volume",
-            min_value=0.0,
-            max_value=100.0,
-            step=1.0,
-            icon="mdi:volume-high",
-            unit_of_measurement="%",
-            mode=2,  # Slider mode
-            entity_category=1,  # config
-            value_getter=self.reachy_controller.get_speaker_volume,
-            value_setter=self.reachy_controller.set_speaker_volume,
-        )
-        self.state.entities.append(speaker_volume)
-
-        _LOGGER.info("Phase 1 entities registered: daemon_state, backend_ready, error_message, speaker_volume")
-
-    def _setup_phase2_entities(self) -> None:
-        """Setup Phase 2 entities: Motor control."""
-
-        # Motors enabled switch
-        motors_enabled = SwitchEntity(
-            server=self,
-            key=self._get_entity_key("motors_enabled"),
-            name="Motors Enabled",
-            object_id="motors_enabled",
-            icon="mdi:engine",
-            device_class="switch",
-            value_getter=self.reachy_controller.get_motors_enabled,
-            value_setter=self.reachy_controller.set_motors_enabled,
-        )
-        self.state.entities.append(motors_enabled)
-
-        # Wake up button
-        wake_up_button = ButtonEntity(
-            server=self,
-            key=self._get_entity_key("wake_up"),
-            name="Wake Up",
-            object_id="wake_up",
-            icon="mdi:alarm",
-            device_class="restart",
-            on_press=self.reachy_controller.wake_up,
-        )
-        self.state.entities.append(wake_up_button)
-
-        # Go to sleep button
-        sleep_button = ButtonEntity(
-            server=self,
-            key=self._get_entity_key("go_to_sleep"),
-            name="Go to Sleep",
-            object_id="go_to_sleep",
-            icon="mdi:sleep",
-            device_class="restart",
-            on_press=self.reachy_controller.go_to_sleep,
-        )
-        self.state.entities.append(sleep_button)
-
-        _LOGGER.info("Phase 2 entities registered: motors_enabled, wake_up, go_to_sleep")
-
-    def _setup_phase3_entities(self) -> None:
-        """Setup Phase 3 entities: Pose control."""
-
-        # Head position controls (X, Y, Z in mm)
-        head_x = NumberEntity(
-            server=self,
-            key=self._get_entity_key("head_x"),
-            name="Head X Position",
-            object_id="head_x",
-            min_value=-50.0,
-            max_value=50.0,
-            step=1.0,
-            icon="mdi:axis-x-arrow",
-            unit_of_measurement="mm",
-            mode=2,  # Slider
-            value_getter=self.reachy_controller.get_head_x,
-            value_setter=self.reachy_controller.set_head_x,
-        )
-        self.state.entities.append(head_x)
-
-        head_y = NumberEntity(
-            server=self,
-            key=self._get_entity_key("head_y"),
-            name="Head Y Position",
-            object_id="head_y",
-            min_value=-50.0,
-            max_value=50.0,
-            step=1.0,
-            icon="mdi:axis-y-arrow",
-            unit_of_measurement="mm",
-            mode=2,
-            value_getter=self.reachy_controller.get_head_y,
-            value_setter=self.reachy_controller.set_head_y,
-        )
-        self.state.entities.append(head_y)
-
-        head_z = NumberEntity(
-            server=self,
-            key=self._get_entity_key("head_z"),
-            name="Head Z Position",
-            object_id="head_z",
-            min_value=-50.0,
-            max_value=50.0,
-            step=1.0,
-            icon="mdi:axis-z-arrow",
-            unit_of_measurement="mm",
-            mode=2,
-            value_getter=self.reachy_controller.get_head_z,
-            value_setter=self.reachy_controller.set_head_z,
-        )
-        self.state.entities.append(head_z)
-
-        # Head orientation controls (Roll, Pitch, Yaw in degrees)
-        head_roll = NumberEntity(
-            server=self,
-            key=self._get_entity_key("head_roll"),
-            name="Head Roll",
-            object_id="head_roll",
-            min_value=-40.0,
-            max_value=40.0,
-            step=1.0,
-            icon="mdi:rotate-3d-variant",
-            unit_of_measurement="°",
-            mode=2,
-            value_getter=self.reachy_controller.get_head_roll,
-            value_setter=self.reachy_controller.set_head_roll,
-        )
-        self.state.entities.append(head_roll)
-
-        head_pitch = NumberEntity(
-            server=self,
-            key=self._get_entity_key("head_pitch"),
-            name="Head Pitch",
-            object_id="head_pitch",
-            min_value=-40.0,
-            max_value=40.0,
-            step=1.0,
-            icon="mdi:rotate-3d-variant",
-            unit_of_measurement="°",
-            mode=2,
-            value_getter=self.reachy_controller.get_head_pitch,
-            value_setter=self.reachy_controller.set_head_pitch,
-        )
-        self.state.entities.append(head_pitch)
-
-        head_yaw = NumberEntity(
-            server=self,
-            key=self._get_entity_key("head_yaw"),
-            name="Head Yaw",
-            object_id="head_yaw",
-            min_value=-180.0,
-            max_value=180.0,
-            step=1.0,
-            icon="mdi:rotate-3d-variant",
-            unit_of_measurement="°",
-            mode=2,
-            value_getter=self.reachy_controller.get_head_yaw,
-            value_setter=self.reachy_controller.set_head_yaw,
-        )
-        self.state.entities.append(head_yaw)
-
-        # Body yaw control
-        body_yaw = NumberEntity(
-            server=self,
-            key=self._get_entity_key("body_yaw"),
-            name="Body Yaw",
-            object_id="body_yaw",
-            min_value=-160.0,
-            max_value=160.0,
-            step=1.0,
-            icon="mdi:rotate-3d-variant",
-            unit_of_measurement="°",
-            mode=2,
-            value_getter=self.reachy_controller.get_body_yaw,
-            value_setter=self.reachy_controller.set_body_yaw,
-        )
-        self.state.entities.append(body_yaw)
-
-        # Antenna controls
-        antenna_left = NumberEntity(
-            server=self,
-            key=self._get_entity_key("antenna_left"),
-            name="Antenna(L)",
-            object_id="antenna_left",
-            min_value=-90.0,
-            max_value=90.0,
-            step=1.0,
-            icon="mdi:antenna",
-            unit_of_measurement="°",
-            mode=2,
-            value_getter=self.reachy_controller.get_antenna_left,
-            value_setter=self.reachy_controller.set_antenna_left,
-        )
-        self.state.entities.append(antenna_left)
-
-        antenna_right = NumberEntity(
-            server=self,
-            key=self._get_entity_key("antenna_right"),
-            name="Antenna(R)",
-            object_id="antenna_right",
-            min_value=-90.0,
-            max_value=90.0,
-            step=1.0,
-            icon="mdi:antenna",
-            unit_of_measurement="°",
-            mode=2,
-            value_getter=self.reachy_controller.get_antenna_right,
-            value_setter=self.reachy_controller.set_antenna_right,
-        )
-        self.state.entities.append(antenna_right)
-
-        _LOGGER.info("Phase 3 entities registered: head position/orientation, body_yaw, antennas")
-
-    def _setup_phase4_entities(self) -> None:
-        """Setup Phase 4 entities: Look at control."""
-
-        # Look at X coordinate
-        look_at_x = NumberEntity(
-            server=self,
-            key=self._get_entity_key("look_at_x"),
-            name="Look At X",
-            object_id="look_at_x",
-            min_value=-2.0,
-            max_value=2.0,
-            step=0.1,
-            icon="mdi:crosshairs-gps",
-            unit_of_measurement="m",
-            mode=1,  # Box mode for precise input
-            value_getter=self.reachy_controller.get_look_at_x,
-            value_setter=self.reachy_controller.set_look_at_x,
-        )
-        self.state.entities.append(look_at_x)
-
-        # Look at Y coordinate
-        look_at_y = NumberEntity(
-            server=self,
-            key=self._get_entity_key("look_at_y"),
-            name="Look At Y",
-            object_id="look_at_y",
-            min_value=-2.0,
-            max_value=2.0,
-            step=0.1,
-            icon="mdi:crosshairs-gps",
-            unit_of_measurement="m",
-            mode=1,
-            value_getter=self.reachy_controller.get_look_at_y,
-            value_setter=self.reachy_controller.set_look_at_y,
-        )
-        self.state.entities.append(look_at_y)
-
-        # Look at Z coordinate
-        look_at_z = NumberEntity(
-            server=self,
-            key=self._get_entity_key("look_at_z"),
-            name="Look At Z",
-            object_id="look_at_z",
-            min_value=-2.0,
-            max_value=2.0,
-            step=0.1,
-            icon="mdi:crosshairs-gps",
-            unit_of_measurement="m",
-            mode=1,
-            value_getter=self.reachy_controller.get_look_at_z,
-            value_setter=self.reachy_controller.set_look_at_z,
-        )
-        self.state.entities.append(look_at_z)
-
-        _LOGGER.info("Phase 4 entities registered: look_at_x/y/z")
-
-    def _setup_phase5_entities(self) -> None:
-        """Setup Phase 5 entities: Audio sensors."""
-
-        # DOA angle sensor
-        self._doa_angle_entity = SensorEntity(
-            server=self,
-            key=self._get_entity_key("doa_angle"),
-            name="DOA Angle",
-            object_id="doa_angle",
-            icon="mdi:compass",
-            unit_of_measurement="°",
-            accuracy_decimals=1,
-            state_class="measurement",
-            value_getter=self.reachy_controller.get_doa_angle,
-        )
-        self.state.entities.append(self._doa_angle_entity)
-
-        # Speech detected sensor
-        self._speech_detected_entity = BinarySensorEntity(
-            server=self,
-            key=self._get_entity_key("speech_detected"),
-            name="Speech Detected",
-            object_id="speech_detected",
-            icon="mdi:microphone",
-            device_class="sound",
-            value_getter=self.reachy_controller.get_speech_detected,
-        )
-        self.state.entities.append(self._speech_detected_entity)
-
-        _LOGGER.info("Phase 5 entities registered: doa_angle, speech_detected")
-
-    def _setup_phase6_entities(self) -> None:
-        """Setup Phase 6 entities: Diagnostic information."""
-
-        # Control loop frequency
-        control_loop_freq = SensorEntity(
-            server=self,
-            key=self._get_entity_key("control_loop_frequency"),
-            name="Control Loop Frequency",
-            object_id="control_loop_frequency",
-            icon="mdi:speedometer",
-            unit_of_measurement="Hz",
-            accuracy_decimals=1,
-            state_class="measurement",
-            value_getter=self.reachy_controller.get_control_loop_frequency,
-        )
-        self.state.entities.append(control_loop_freq)
-
-        # SDK version
-        sdk_version = TextSensorEntity(
-            server=self,
-            key=self._get_entity_key("sdk_version"),
-            name="SDK Version",
-            object_id="sdk_version",
-            icon="mdi:information",
-            value_getter=self.reachy_controller.get_sdk_version,
-        )
-        self.state.entities.append(sdk_version)
-
-        # Robot name
-        robot_name = TextSensorEntity(
-            server=self,
-            key=self._get_entity_key("robot_name"),
-            name="Robot Name",
-            object_id="robot_name",
-            icon="mdi:robot",
-            value_getter=self.reachy_controller.get_robot_name,
-        )
-        self.state.entities.append(robot_name)
-
-        # Wireless version
-        wireless_version = BinarySensorEntity(
-            server=self,
-            key=self._get_entity_key("wireless_version"),
-            name="Wireless Version",
-            object_id="wireless_version",
-            icon="mdi:wifi",
-            device_class="connectivity",
-            value_getter=self.reachy_controller.get_wireless_version,
-        )
-        self.state.entities.append(wireless_version)
-
-        # Simulation mode
-        simulation_mode = BinarySensorEntity(
-            server=self,
-            key=self._get_entity_key("simulation_mode"),
-            name="Simulation Mode",
-            object_id="simulation_mode",
-            icon="mdi:virtual-reality",
-            value_getter=self.reachy_controller.get_simulation_mode,
-        )
-        self.state.entities.append(simulation_mode)
-
-        # WLAN IP
-        wlan_ip = TextSensorEntity(
-            server=self,
-            key=self._get_entity_key("wlan_ip"),
-            name="WLAN IP",
-            object_id="wlan_ip",
-            icon="mdi:ip-network",
-            value_getter=self.reachy_controller.get_wlan_ip,
-        )
-        self.state.entities.append(wlan_ip)
-
-        _LOGGER.info("Phase 6 entities registered: control_loop_frequency, sdk_version, robot_name, wireless_version, simulation_mode, wlan_ip")
-
-    def _setup_phase7_entities(self) -> None:
-        """Setup Phase 7 entities: IMU sensors (wireless only)."""
-
-        # IMU Accelerometer
-        imu_accel_x = SensorEntity(
-            server=self,
-            key=self._get_entity_key("imu_accel_x"),
-            name="IMU Accel X",
-            object_id="imu_accel_x",
-            icon="mdi:axis-x-arrow",
-            unit_of_measurement="m/s²",
-            accuracy_decimals=3,
-            state_class="measurement",
-            value_getter=self.reachy_controller.get_imu_accel_x,
-        )
-        self.state.entities.append(imu_accel_x)
-
-        imu_accel_y = SensorEntity(
-            server=self,
-            key=self._get_entity_key("imu_accel_y"),
-            name="IMU Accel Y",
-            object_id="imu_accel_y",
-            icon="mdi:axis-y-arrow",
-            unit_of_measurement="m/s²",
-            accuracy_decimals=3,
-            state_class="measurement",
-            value_getter=self.reachy_controller.get_imu_accel_y,
-        )
-        self.state.entities.append(imu_accel_y)
-
-        imu_accel_z = SensorEntity(
-            server=self,
-            key=self._get_entity_key("imu_accel_z"),
-            name="IMU Accel Z",
-            object_id="imu_accel_z",
-            icon="mdi:axis-z-arrow",
-            unit_of_measurement="m/s²",
-            accuracy_decimals=3,
-            state_class="measurement",
-            value_getter=self.reachy_controller.get_imu_accel_z,
-        )
-        self.state.entities.append(imu_accel_z)
-
-        # IMU Gyroscope
-        imu_gyro_x = SensorEntity(
-            server=self,
-            key=self._get_entity_key("imu_gyro_x"),
-            name="IMU Gyro X",
-            object_id="imu_gyro_x",
-            icon="mdi:rotate-3d-variant",
-            unit_of_measurement="rad/s",
-            accuracy_decimals=3,
-            state_class="measurement",
-            value_getter=self.reachy_controller.get_imu_gyro_x,
-        )
-        self.state.entities.append(imu_gyro_x)
-
-        imu_gyro_y = SensorEntity(
-            server=self,
-            key=self._get_entity_key("imu_gyro_y"),
-            name="IMU Gyro Y",
-            object_id="imu_gyro_y",
-            icon="mdi:rotate-3d-variant",
-            unit_of_measurement="rad/s",
-            accuracy_decimals=3,
-            state_class="measurement",
-            value_getter=self.reachy_controller.get_imu_gyro_y,
-        )
-        self.state.entities.append(imu_gyro_y)
-
-        imu_gyro_z = SensorEntity(
-            server=self,
-            key=self._get_entity_key("imu_gyro_z"),
-            name="IMU Gyro Z",
-            object_id="imu_gyro_z",
-            icon="mdi:rotate-3d-variant",
-            unit_of_measurement="rad/s",
-            accuracy_decimals=3,
-            state_class="measurement",
-            value_getter=self.reachy_controller.get_imu_gyro_z,
-        )
-        self.state.entities.append(imu_gyro_z)
-
-        # IMU Temperature
-        imu_temperature = SensorEntity(
-            server=self,
-            key=self._get_entity_key("imu_temperature"),
-            name="IMU Temperature",
-            object_id="imu_temperature",
-            icon="mdi:thermometer",
-            unit_of_measurement="°C",
-            accuracy_decimals=1,
-            device_class="temperature",
-            state_class="measurement",
-            value_getter=self.reachy_controller.get_imu_temperature,
-        )
-        self.state.entities.append(imu_temperature)
-
-        _LOGGER.info("Phase 7 entities registered: IMU accelerometer, gyroscope, temperature")
-
-    def _setup_phase8_entities(self) -> None:
-        """Setup Phase 8 entities: Emotion selector."""
-
-        # Emotion options mapping
-        self._emotion_map = {
-            "None": None,
-            "Happy": "happy1",
-            "Sad": "sad1",
-            "Angry": "angry1",
-            "Fear": "fear1",
-            "Surprise": "surprise1",
-            "Disgust": "disgust1",
-        }
-
-        def get_emotion() -> str:
-            return getattr(self, '_current_emotion', "None")
-
-        def set_emotion(emotion: str) -> None:
-            self._current_emotion = emotion
-            emotion_name = self._emotion_map.get(emotion)
-            if emotion_name:
-                self._play_emotion(emotion_name)
-                # Reset to None after playing
-                self._current_emotion = "None"
-
-        # Emotion selector
-        emotion_select = SelectEntity(
-            server=self,
-            key=self._get_entity_key("emotion"),
-            name="Emotion",
-            object_id="emotion",
-            options=list(self._emotion_map.keys()),
-            icon="mdi:emoticon",
-            value_getter=get_emotion,
-            value_setter=set_emotion,
-        )
-        self.state.entities.append(emotion_select)
-
-        _LOGGER.info("Phase 8 entities registered: emotion selector")
-
-    def _setup_phase9_entities(self) -> None:
-        """Setup Phase 9 entities: Audio controls."""
-
-        # Microphone volume control
-        microphone_volume = NumberEntity(
-            server=self,
-            key=self._get_entity_key("microphone_volume"),
-            name="Microphone Volume",
-            object_id="microphone_volume",
-            min_value=0.0,
-            max_value=100.0,
-            step=1.0,
-            icon="mdi:microphone",
-            unit_of_measurement="%",
-            mode=2,  # Slider mode
-            entity_category=1,  # config
-            value_getter=self.reachy_controller.get_microphone_volume,
-            value_setter=self.reachy_controller.set_microphone_volume,
-        )
-        self.state.entities.append(microphone_volume)
-
-        _LOGGER.info("Phase 9 entities registered: microphone_volume")
-
-    def _setup_phase10_entities(self) -> None:
-        """Setup Phase 10 entities: Camera for Home Assistant integration."""
-
-        # Camera image getter - returns JPEG bytes from camera server
-        def get_camera_image() -> Optional[bytes]:
-            """Get camera snapshot as JPEG bytes."""
-            if self.camera_server:
-                return self.camera_server.get_snapshot()
-            return None
-
-        # Real camera entity - shows preview in Home Assistant
-        camera_entity = CameraEntity(
-            server=self,
-            key=self._get_entity_key("camera"),  # Use new camera key
-            name="Camera",
-            object_id="camera",
-            icon="mdi:camera",
-            image_getter=get_camera_image,
-        )
-        self.state.entities.append(camera_entity)
-
-        _LOGGER.info("Phase 10 entities registered: camera (ESPHome Camera entity)")
-
-    def _setup_phase11_entities(self) -> None:
-        """Setup Phase 11 entities: LED control (via local SDK)."""
-
-        # LED Brightness
-        led_brightness = NumberEntity(
-            server=self,
-            key=self._get_entity_key("led_brightness"),
-            name="LED Brightness",
-            object_id="led_brightness",
-            min_value=0.0,
-            max_value=100.0,
-            step=1.0,
-            icon="mdi:brightness-6",
-            unit_of_measurement="%",
-            mode=2,  # Slider mode
-            value_getter=self.reachy_controller.get_led_brightness,
-            value_setter=self.reachy_controller.set_led_brightness,
-        )
-        self.state.entities.append(led_brightness)
-
-        # LED Effect
-        led_effect = SelectEntity(
-            server=self,
-            key=self._get_entity_key("led_effect"),
-            name="LED Effect",
-            object_id="led_effect",
-            options=["off", "solid", "breathing", "rainbow", "doa"],
-            icon="mdi:led-on",
-            value_getter=self.reachy_controller.get_led_effect,
-            value_setter=self.reachy_controller.set_led_effect,
-        )
-        self.state.entities.append(led_effect)
-
-        # LED Color R
-        led_color_r = NumberEntity(
-            server=self,
-            key=self._get_entity_key("led_color_r"),
-            name="LED Color Red",
-            object_id="led_color_r",
-            min_value=0.0,
-            max_value=255.0,
-            step=1.0,
-            icon="mdi:palette",
-            mode=2,
-            value_getter=self.reachy_controller.get_led_color_r,
-            value_setter=self.reachy_controller.set_led_color_r,
-        )
-        self.state.entities.append(led_color_r)
-
-        # LED Color G
-        led_color_g = NumberEntity(
-            server=self,
-            key=self._get_entity_key("led_color_g"),
-            name="LED Color Green",
-            object_id="led_color_g",
-            min_value=0.0,
-            max_value=255.0,
-            step=1.0,
-            icon="mdi:palette",
-            mode=2,
-            value_getter=self.reachy_controller.get_led_color_g,
-            value_setter=self.reachy_controller.set_led_color_g,
-        )
-        self.state.entities.append(led_color_g)
-
-        # LED Color B
-        led_color_b = NumberEntity(
-            server=self,
-            key=self._get_entity_key("led_color_b"),
-            name="LED Color Blue",
-            object_id="led_color_b",
-            min_value=0.0,
-            max_value=255.0,
-            step=1.0,
-            icon="mdi:palette",
-            mode=2,
-            value_getter=self.reachy_controller.get_led_color_b,
-            value_setter=self.reachy_controller.set_led_color_b,
-        )
-        self.state.entities.append(led_color_b)
-
-        _LOGGER.info("Phase 11 entities registered: led_brightness, led_effect, led_color_r/g/b")
-
-    def _setup_phase12_entities(self) -> None:
-        """Setup Phase 12 entities: Audio processing parameters (via local SDK)."""
-
-        # AGC Enabled
-        agc_enabled = SwitchEntity(
-            server=self,
-            key=self._get_entity_key("agc_enabled"),
-            name="AGC Enabled",
-            object_id="agc_enabled",
-            icon="mdi:tune-vertical",
-            device_class="switch",
-            entity_category=1,  # config
-            value_getter=self.reachy_controller.get_agc_enabled,
-            value_setter=self.reachy_controller.set_agc_enabled,
-        )
-        self.state.entities.append(agc_enabled)
-
-        # AGC Max Gain
-        agc_max_gain = NumberEntity(
-            server=self,
-            key=self._get_entity_key("agc_max_gain"),
-            name="AGC Max Gain",
-            object_id="agc_max_gain",
-            min_value=0.0,
-            max_value=30.0,
-            step=1.0,
-            icon="mdi:volume-plus",
-            unit_of_measurement="dB",
-            mode=2,
-            entity_category=1,  # config
-            value_getter=self.reachy_controller.get_agc_max_gain,
-            value_setter=self.reachy_controller.set_agc_max_gain,
-        )
-        self.state.entities.append(agc_max_gain)
-
-        # Noise Suppression Level
-        noise_suppression = NumberEntity(
-            server=self,
-            key=self._get_entity_key("noise_suppression"),
-            name="Noise Suppression",
-            object_id="noise_suppression",
-            min_value=0.0,
-            max_value=100.0,
-            step=1.0,
-            icon="mdi:volume-off",
-            unit_of_measurement="%",
-            mode=2,
-            entity_category=1,  # config
-            value_getter=self.reachy_controller.get_noise_suppression,
-            value_setter=self.reachy_controller.set_noise_suppression,
-        )
-        self.state.entities.append(noise_suppression)
-
-        # Echo Cancellation Converged (read-only diagnostic status)
-        echo_cancellation_converged = BinarySensorEntity(
-            server=self,
-            key=self._get_entity_key("echo_cancellation_converged"),
-            name="Echo Cancellation Converged",
-            object_id="echo_cancellation_converged",
-            icon="mdi:waveform",
-            device_class="running",
-            entity_category=2,  # diagnostic
-            value_getter=self.reachy_controller.get_echo_cancellation_converged,
-        )
-        self.state.entities.append(echo_cancellation_converged)
-
-        _LOGGER.info("Phase 12 entities registered: agc_enabled, agc_max_gain, noise_suppression, echo_cancellation_converged")
-
-    def _setup_phase13_entities(self) -> None:
-        """Setup Phase 13 entities: Robot joints as JSON sensor."""
-
-        # Head joints sensor - returns JSON array of [yaw_body, stewart_1, ..., stewart_6]
-        head_joints_sensor = TextSensorEntity(
-            server=self,
-            key=self._get_entity_key("head_joints"),
-            name="Head Joints",
-            object_id="head_joints",
-            icon="mdi:robot",
-            value_getter=self.reachy_controller.get_head_joints_json,
-        )
-        self.state.entities.append(head_joints_sensor)
-
-        _LOGGER.info("Phase 13 entities registered: head_joints")
-
-        # Phase 14: Passive joints for 3D visualization
-        passive_joints_sensor = TextSensorEntity(
-            server=self,
-            key=self._get_entity_key("passive_joints"),
-            name="Passive Joints",
-            object_id="passive_joints",
-            value_getter=self.reachy_controller.get_passive_joints_json,
-        )
-        self.state.entities.append(passive_joints_sensor)
-
-        _LOGGER.info("Phase 14 entities registered: passive_joints")

reachy_mini_ha_voice/voice_assistant.py

@@ -10,6 +10,7 @@ import json
 import logging
 import threading
 import time
+from dataclasses import dataclass, field
 from pathlib import Path
 from queue import Queue
 from typing import Dict, List, Optional, Set, Union
@@ -34,6 +35,18 @@ _SOUNDS_DIR = _MODULE_DIR / "sounds"
 _LOCAL_DIR = _MODULE_DIR.parent / "local"
 
 
+@dataclass
+class AudioProcessingContext:
+    """Context for audio processing, holding mutable state."""
+    wake_words: List = field(default_factory=list)
+    micro_features: Optional[object] = None
+    micro_inputs: List = field(default_factory=list)
+    oww_features: Optional[object] = None
+    oww_inputs: List = field(default_factory=list)
+    has_oww: bool = False
+    last_active: Optional[float] = None
+
+
 class VoiceAssistantService:
     """Voice assistant service that runs ESPHome protocol server."""
 
@@ -351,192 +364,51 @@ class VoiceAssistantService:
         return None
 
     def _process_audio(self) -> None:
-        """Process audio from Reachy Mini's microphone."""
-        from pymicro_wakeword import MicroWakeWord, MicroWakeWordFeatures
-        from pyopen_wakeword import OpenWakeWord, OpenWakeWordFeatures
+        """Process audio from microphone (Reachy Mini or system fallback)."""
+        from pymicro_wakeword import MicroWakeWordFeatures
 
-        wake_words: List[Union[MicroWakeWord, OpenWakeWord]] = []
-        micro_features: Optional[MicroWakeWordFeatures] = None
-        micro_inputs: List[np.ndarray] = []
-        oww_features: Optional[OpenWakeWordFeatures] = None
-        oww_inputs: List[np.ndarray] = []
-        has_oww = False
-        last_active: Optional[float] = None
+        ctx = AudioProcessingContext()
+        ctx.micro_features = MicroWakeWordFeatures()
 
         try:
             _LOGGER.info("Starting audio processing...")
 
-            # Use Reachy Mini's microphone if available
-            use_reachy_audio = self.reachy_mini is not None
-
-            if use_reachy_audio:
+            if self.reachy_mini is not None:
                 _LOGGER.info("Using Reachy Mini's microphone")
-                self._process_audio_reachy(
-                    wake_words, micro_features, micro_inputs,
-                    oww_features, oww_inputs, has_oww, last_active
-                )
+                self._audio_loop_reachy(ctx)
             else:
                 _LOGGER.info("Using system microphone (fallback)")
-                self._process_audio_fallback(
-                    wake_words, micro_features, micro_inputs,
-                    oww_features, oww_inputs, has_oww, last_active
-                )
+                self._audio_loop_fallback(ctx)
 
         except Exception:
             _LOGGER.exception("Error processing audio")
 
-    def _process_audio_reachy(
-        self,
-        wake_words, micro_features, micro_inputs,
-        oww_features, oww_inputs, has_oww, last_active
-    ) -> None:
-        """Process audio using Reachy Mini's microphone.
-
-        Based on official SDK examples (sound_record.py):
-        - get_audio_sample() returns np.ndarray with dtype=float32, shape=(samples, 2)
-        - Data is already normalized to [-1.0, 1.0] range
-        """
-        from pymicro_wakeword import MicroWakeWord, MicroWakeWordFeatures
-        from pyopen_wakeword import OpenWakeWord, OpenWakeWordFeatures
-
-        # Initialize features once
-        micro_features = MicroWakeWordFeatures()
-
+    def _audio_loop_reachy(self, ctx: AudioProcessingContext) -> None:
+        """Audio loop using Reachy Mini's microphone."""
         while self._running:
             try:
-                # Skip if no satellite connection
-                if self._state is None or self._state.satellite is None:
-                    time.sleep(0.1)
+                if not self._wait_for_satellite():
                     continue
 
-                # Update wake words list if changed
-                if (not wake_words) or (self._state.wake_words_changed and self._state.wake_words):
-                    self._state.wake_words_changed = False
-                    wake_words.clear()
-                    wake_words.extend([
-                        ww for ww in self._state.wake_words.values()
-                        if ww.id in self._state.active_wake_words
-                    ])
-
-                    has_oww = any(isinstance(ww, OpenWakeWord) for ww in wake_words)
-                    if has_oww and oww_features is None:
-                        oww_features = OpenWakeWordFeatures.from_builtin()
-
-                    _LOGGER.debug("Wake words updated: %s", [ww.id for ww in wake_words])
+                self._update_wake_words_list(ctx)
 
                 # Get audio from Reachy Mini
-                audio_data = self.reachy_mini.media.get_audio_sample()
-
-                # Skip if no data
-                if audio_data is None:
+                audio_chunk = self._get_reachy_audio_chunk()
+                if audio_chunk is None:
                     time.sleep(0.01)
                     continue
 
-                # Validate data type
-                if not isinstance(audio_data, np.ndarray):
-                    time.sleep(0.01)
-                    continue
-
-                # Skip empty arrays
-                if audio_data.size == 0:
-                    time.sleep(0.01)
-                    continue
-
-                # Validate and convert dtype
-                try:
-                    if audio_data.dtype.kind in ('S', 'U', 'O', 'V', 'b'):
-                        time.sleep(0.01)
-                        continue
-                    if audio_data.dtype != np.float32:
-                        audio_data = np.asarray(audio_data, dtype=np.float32)
-                except (TypeError, ValueError):
-                    time.sleep(0.01)
-                    continue
-
-                # Convert stereo to mono
-                try:
-                    if audio_data.ndim == 2 and audio_data.shape[1] == 2:
-                        audio_chunk_array = audio_data.mean(axis=1)
-                    elif audio_data.ndim == 2:
-                        audio_chunk_array = audio_data[:, 0].copy()
-                    elif audio_data.ndim == 1:
-                        audio_chunk_array = audio_data
-                    else:
-                        time.sleep(0.01)
-                        continue
-                except Exception:
-                    time.sleep(0.01)
-                    continue
-
-                # Convert to 16-bit PCM bytes
-                audio_chunk = (
-                    (np.clip(audio_chunk_array, -1.0, 1.0) * 32767.0)
-                    .astype("<i2")
-                    .tobytes()
-                )
-
-                # Stream audio to Home Assistant
-                self._state.satellite.handle_audio(audio_chunk)
-
-                # Process wake word features
-                micro_inputs.clear()
-                micro_inputs.extend(micro_features.process_streaming(audio_chunk))
-
-                if has_oww and oww_features is not None:
-                    oww_inputs.clear()
-                    oww_inputs.extend(oww_features.process_streaming(audio_chunk))
-
-                # Check each wake word
-                for wake_word in wake_words:
-                    activated = False
-
-                    if isinstance(wake_word, MicroWakeWord):
-                        for micro_input in micro_inputs:
-                            if wake_word.process_streaming(micro_input):
-                                activated = True
-                    elif isinstance(wake_word, OpenWakeWord):
-                        for oww_input in oww_inputs:
-                            for prob in wake_word.process_streaming(oww_input):
-                                if prob > 0.5:
-                                    activated = True
-
-                    if activated:
-                        now = time.monotonic()
-                        if (last_active is None) or ((now - last_active) > self._state.refractory_seconds):
-                            _LOGGER.info("Wake word detected: %s", wake_word.id)
-                            self._state.satellite.wakeup(wake_word)
-                            # Get DOA angle and turn to sound source
-                            doa_angle_deg = self._get_doa_angle_deg()
-                            self._motion.on_wakeup(doa_angle_deg)
-                            last_active = now
-
-                # Process stop word
-                if self._state.stop_word:
-                    stopped = False
-                    for micro_input in micro_inputs:
-                        if self._state.stop_word.process_streaming(micro_input):
-                            stopped = True
-
-                    if stopped and (self._state.stop_word.id in self._state.active_wake_words):
-                        _LOGGER.info("Stop word detected")
-                        self._state.satellite.stop()
+                self._process_audio_chunk(ctx, audio_chunk)
 
             except Exception as e:
                 _LOGGER.error("Error in Reachy audio processing: %s", e)
                 time.sleep(0.1)
 
-    def _process_audio_fallback(
-        self,
-        wake_words, micro_features, micro_inputs,
-        oww_features, oww_inputs, has_oww, last_active
-    ) -> None:
-        """Process audio using system microphone (fallback)."""
+    def _audio_loop_fallback(self, ctx: AudioProcessingContext) -> None:
+        """Audio loop using system microphone (fallback)."""
         import sounddevice as sd
-        from pymicro_wakeword import MicroWakeWord, MicroWakeWordFeatures
-        from pyopen_wakeword import OpenWakeWord, OpenWakeWordFeatures
 
         block_size = 1024
-        micro_features = MicroWakeWordFeatures()
 
         with sd.InputStream(
             samplerate=16000,
@@ -545,82 +417,163 @@ class VoiceAssistantService:
             dtype="float32",
         ) as stream:
             while self._running:
-                # Skip if no satellite connection
-                if self._state is None or self._state.satellite is None:
-                    time.sleep(0.1)
+                if not self._wait_for_satellite():
                     continue
 
-                # Update wake words list if changed
-                if (not wake_words) or (self._state.wake_words_changed and self._state.wake_words):
-                    self._state.wake_words_changed = False
-                    wake_words.clear()
-                    wake_words.extend([
-                        ww for ww in self._state.wake_words.values()
-                        if ww.id in self._state.active_wake_words
-                    ])
-
-                    has_oww = any(isinstance(ww, OpenWakeWord) for ww in wake_words)
-                    if has_oww and oww_features is None:
-                        oww_features = OpenWakeWordFeatures.from_builtin()
+                self._update_wake_words_list(ctx)
 
+                # Get audio from system microphone
                 audio_chunk_array, overflowed = stream.read(block_size)
                 if overflowed:
                     _LOGGER.warning("Audio buffer overflow")
 
                 audio_chunk_array = audio_chunk_array.reshape(-1)
+                audio_chunk = self._convert_to_pcm(audio_chunk_array)
+
+                self._process_audio_chunk(ctx, audio_chunk)
+
+    def _wait_for_satellite(self) -> bool:
+        """Wait for satellite connection. Returns True if connected."""
+        if self._state is None or self._state.satellite is None:
+            time.sleep(0.1)
+            return False
+        return True
+
+    def _update_wake_words_list(self, ctx: AudioProcessingContext) -> None:
+        """Update wake words list if changed."""
+        from pyopen_wakeword import OpenWakeWord, OpenWakeWordFeatures
+
+        if (not ctx.wake_words) or (self._state.wake_words_changed and self._state.wake_words):
+            self._state.wake_words_changed = False
+            ctx.wake_words.clear()
+            ctx.wake_words.extend([
+                ww for ww in self._state.wake_words.values()
+                if ww.id in self._state.active_wake_words
+            ])
+
+            ctx.has_oww = any(isinstance(ww, OpenWakeWord) for ww in ctx.wake_words)
+            if ctx.has_oww and ctx.oww_features is None:
+                ctx.oww_features = OpenWakeWordFeatures.from_builtin()
+
+            _LOGGER.debug("Wake words updated: %s", [ww.id for ww in ctx.wake_words])
+
+    def _get_reachy_audio_chunk(self) -> Optional[bytes]:
+        """Get audio chunk from Reachy Mini's microphone.
+
+        Returns:
+            PCM audio bytes, or None if no valid audio available.
+        """
+        audio_data = self.reachy_mini.media.get_audio_sample()
+
+        # Validate audio data
+        if audio_data is None:
+            return None
+        if not isinstance(audio_data, np.ndarray):
+            return None
+        if audio_data.size == 0:
+            return None
+
+        # Validate and convert dtype
+        try:
+            if audio_data.dtype.kind in ('S', 'U', 'O', 'V', 'b'):
+                return None
+            if audio_data.dtype != np.float32:
+                audio_data = np.asarray(audio_data, dtype=np.float32)
+        except (TypeError, ValueError):
+            return None
+
+        # Convert stereo to mono
+        try:
+            if audio_data.ndim == 2 and audio_data.shape[1] == 2:
+                audio_chunk_array = audio_data.mean(axis=1)
+            elif audio_data.ndim == 2:
+                audio_chunk_array = audio_data[:, 0].copy()
+            elif audio_data.ndim == 1:
+                audio_chunk_array = audio_data
+            else:
+                return None
+        except Exception:
+            return None
+
+        return self._convert_to_pcm(audio_chunk_array)
+
+    def _convert_to_pcm(self, audio_chunk_array: np.ndarray) -> bytes:
+        """Convert float32 audio array to 16-bit PCM bytes."""
+        return (
+            (np.clip(audio_chunk_array, -1.0, 1.0) * 32767.0)
+            .astype("<i2")
+            .tobytes()
+        )
+
+    def _process_audio_chunk(self, ctx: AudioProcessingContext, audio_chunk: bytes) -> None:
+        """Process an audio chunk for wake word detection.
+
+        Args:
+            ctx: Audio processing context
+            audio_chunk: PCM audio bytes
+        """
+        # Stream audio to Home Assistant
+        self._state.satellite.handle_audio(audio_chunk)
+
+        # Process wake word features
+        self._process_features(ctx, audio_chunk)
+
+        # Detect wake words
+        self._detect_wake_words(ctx)
+
+        # Detect stop word
+        self._detect_stop_word(ctx)
+
+    def _process_features(self, ctx: AudioProcessingContext, audio_chunk: bytes) -> None:
+        """Process audio features for wake word detection."""
+        ctx.micro_inputs.clear()
+        ctx.micro_inputs.extend(ctx.micro_features.process_streaming(audio_chunk))
+
+        if ctx.has_oww and ctx.oww_features is not None:
+            ctx.oww_inputs.clear()
+            ctx.oww_inputs.extend(ctx.oww_features.process_streaming(audio_chunk))
+
+    def _detect_wake_words(self, ctx: AudioProcessingContext) -> None:
+        """Detect wake words in the processed audio features."""
+        from pymicro_wakeword import MicroWakeWord
+        from pyopen_wakeword import OpenWakeWord
 
-                # Convert to 16-bit PCM bytes
-                audio_chunk = (
-                    (np.clip(audio_chunk_array, -1.0, 1.0) * 32767.0)
-                    .astype("<i2")
-                    .tobytes()
-                )
-
-                # Stream audio to Home Assistant
-                self._state.satellite.handle_audio(audio_chunk)
-
-                # Process wake word features
-                micro_inputs.clear()
-                micro_inputs.extend(micro_features.process_streaming(audio_chunk))
-
-                if has_oww and oww_features is not None:
-                    oww_inputs.clear()
-                    oww_inputs.extend(oww_features.process_streaming(audio_chunk))
-
-                # Check each wake word
-                for wake_word in wake_words:
-                    activated = False
-
-                    if isinstance(wake_word, MicroWakeWord):
-                        for micro_input in micro_inputs:
-                            if wake_word.process_streaming(micro_input):
-                                activated = True
-                    elif isinstance(wake_word, OpenWakeWord):
-                        for oww_input in oww_inputs:
-                            for prob in wake_word.process_streaming(oww_input):
-                                if prob > 0.5:
-                                    activated = True
-
-                    if activated:
-                        now = time.monotonic()
-                        if (last_active is None) or ((now - last_active) > self._state.refractory_seconds):
-                            _LOGGER.info("Wake word detected: %s", wake_word.id)
-                            self._state.satellite.wakeup(wake_word)
-                            # Get DOA angle and turn to sound source
-                            doa_angle_deg = self._get_doa_angle_deg()
-                            self._motion.on_wakeup(doa_angle_deg)
-                            last_active = now
-
-                # Process stop word
-                if self._state.stop_word:
-                    stopped = False
-                    for micro_input in micro_inputs:
-                        if self._state.stop_word.process_streaming(micro_input):
-                            stopped = True
-
-                    if stopped and (self._state.stop_word.id in self._state.active_wake_words):
-                        _LOGGER.info("Stop word detected")
-                        self._state.satellite.stop()
+        for wake_word in ctx.wake_words:
+            activated = False
+
+            if isinstance(wake_word, MicroWakeWord):
+                for micro_input in ctx.micro_inputs:
+                    if wake_word.process_streaming(micro_input):
+                        activated = True
+            elif isinstance(wake_word, OpenWakeWord):
+                for oww_input in ctx.oww_inputs:
+                    for prob in wake_word.process_streaming(oww_input):
+                        if prob > 0.5:
+                            activated = True
+
+            if activated:
+                now = time.monotonic()
+                if (ctx.last_active is None) or ((now - ctx.last_active) > self._state.refractory_seconds):
+                    _LOGGER.info("Wake word detected: %s", wake_word.id)
+                    self._state.satellite.wakeup(wake_word)
+                    # Get DOA angle and turn to sound source
+                    doa_angle_deg = self._get_doa_angle_deg()
+                    self._motion.on_wakeup(doa_angle_deg)
+                    ctx.last_active = now
+
+    def _detect_stop_word(self, ctx: AudioProcessingContext) -> None:
+        """Detect stop word in the processed audio features."""
+        if not self._state.stop_word:
+            return
+
+        stopped = False
+        for micro_input in ctx.micro_inputs:
+            if self._state.stop_word.process_streaming(micro_input):
+                stopped = True
+
+        if stopped and (self._state.stop_word.id in self._state.active_wake_words):
+            _LOGGER.info("Stop word detected")
+            self._state.satellite.stop()
 
     def _get_doa_angle_deg(self) -> Optional[float]:
         """Get DOA angle in degrees from Reachy Mini's microphone array.