"feat(entities):add-17-ESPHome-entities-for-full-robot-control"

.claude/settings.local.json

@@ -34,7 +34,8 @@
       "mcp__web-reader__webReader",
       "mcp__zread__get_repo_structure",
       "mcp__zread__read_file",
-      "Bash(dir:*)"
+      "Bash(dir:*)",
+      "Bash(C::*)"
     ],
     "deny": [],
     "ask": []

ENTITIES.md

@@ -0,0 +1,488 @@
+# Reachy Mini Home Assistant 实体使用指南
+
+本文档介绍如何在 Home Assistant 中使用 Reachy Mini 暴露的 ESPHome 实体来控制机器人。
+
+## 概述
+
+Reachy Mini HA Voice 应用通过 ESPHome 协议向 Home Assistant 暴露了多个实体，允许你完全控制机器人的运动、电机状态和系统信息。
+
+## 实体列表
+
+### 📊 Phase 1: 基础状态与音量控制
+
+#### 1. Daemon State (文本传感器)
+- **实体 ID**: `sensor.reachy_mini_daemon_state`
+- **类型**: 只读文本传感器
+- **说明**: 显示 Reachy Mini Daemon 的当前状态
+- **可能的值**:
+  - `not_initialized` - 未初始化
+  - `starting` - 启动中
+  - `running` - 运行中
+  - `stopping` - 停止中
+  - `stopped` - 已停止
+  - `error` - 错误状态
+  - `not_available` - 机器人不可用（独立模式）
+
+#### 2. Backend Ready (二进制传感器)
+- **实体 ID**: `binary_sensor.reachy_mini_backend_ready`
+- **类型**: 只读布尔传感器
+- **说明**: 指示后端服务是否就绪
+- **值**: `on` (就绪) / `off` (未就绪)
+
+#### 3. Error Message (文本传感器)
+- **实体 ID**: `sensor.reachy_mini_error_message`
+- **类型**: 只读文本传感器
+- **说明**: 显示当前的错误信息（如果有）
+
+#### 4. Speaker Volume (数字控制)
+- **实体 ID**: `number.reachy_mini_speaker_volume`
+- **类型**: 可读写数字控制
+- **范围**: 0-100%
+- **说明**: 控制扬声器音量
+- **使用示例**:
+  ```yaml
+  # 设置音量为 80%
+  service: number.set_value
+  target:
+    entity_id: number.reachy_mini_speaker_volume
+  data:
+    value: 80
+  ```
+
+---
+
+### ⚙️ Phase 2: 电机控制
+
+#### 5. Motors Enabled (开关)
+- **实体 ID**: `switch.reachy_mini_motors_enabled`
+- **类型**: 可读写开关
+- **说明**: 启用或禁用所有电机的扭矩
+- **使用示例**:
+  ```yaml
+  # 启用电机
+  service: switch.turn_on
+  target:
+    entity_id: switch.reachy_mini_motors_enabled
+
+  # 禁用电机
+  service: switch.turn_off
+  target:
+    entity_id: switch.reachy_mini_motors_enabled
+  ```
+
+#### 6. Motor Mode (选择器)
+- **实体 ID**: `select.reachy_mini_motor_mode`
+- **类型**: 可读写选择器
+- **选项**:
+  - `enabled` - 电机启用，位置控制
+  - `disabled` - 电机禁用，无扭矩
+  - `gravity_compensation` - 重力补偿模式
+- **使用示例**:
+  ```yaml
+  # 设置为重力补偿模式
+  service: select.select_option
+  target:
+    entity_id: select.reachy_mini_motor_mode
+  data:
+    option: gravity_compensation
+  ```
+
+#### 7. Wake Up (按钮)
+- **实体 ID**: `button.reachy_mini_wake_up`
+- **类型**: 按钮
+- **说明**: 执行唤醒动画
+- **使用示例**:
+  ```yaml
+  service: button.press
+  target:
+    entity_id: button.reachy_mini_wake_up
+  ```
+
+#### 8. Go to Sleep (按钮)
+- **实体 ID**: `button.reachy_mini_go_to_sleep`
+- **类型**: 按钮
+- **说明**: 执行睡眠动画
+- **使用示例**:
+  ```yaml
+  service: button.press
+  target:
+    entity_id: button.reachy_mini_go_to_sleep
+  ```
+
+---
+
+### 🎯 Phase 3: 姿态控制
+
+#### 头部位置控制 (X, Y, Z)
+
+##### 9. Head X Position (数字控制)
+- **实体 ID**: `number.reachy_mini_head_x`
+- **范围**: -50mm ~ +50mm
+- **说明**: 控制头部在 X 轴的位置
+
+##### 10. Head Y Position (数字控制)
+- **实体 ID**: `number.reachy_mini_head_y`
+- **范围**: -50mm ~ +50mm
+- **说明**: 控制头部在 Y 轴的位置
+
+##### 11. Head Z Position (数字控制)
+- **实体 ID**: `number.reachy_mini_head_z`
+- **范围**: -50mm ~ +50mm
+- **说明**: 控制头部在 Z 轴的位置
+
+**使用示例**:
+```yaml
+# 移动头部到指定位置
+service: number.set_value
+target:
+  entity_id:
+    - number.reachy_mini_head_x
+    - number.reachy_mini_head_y
+    - number.reachy_mini_head_z
+data:
+  value: 10  # 每个轴移动 10mm
+```
+
+#### 头部角度控制 (Roll, Pitch, Yaw)
+
+##### 12. Head Roll (数字控制)
+- **实体 ID**: `number.reachy_mini_head_roll`
+- **范围**: -40° ~ +40°
+- **说明**: 控制头部翻滚角（左右倾斜）
+
+##### 13. Head Pitch (数字控制)
+- **实体 ID**: `number.reachy_mini_head_pitch`
+- **范围**: -40° ~ +40°
+- **说明**: 控制头部俯仰角（上下点头）
+
+##### 14. Head Yaw (数字控制)
+- **实体 ID**: `number.reachy_mini_head_yaw`
+- **范围**: -180° ~ +180°
+- **说明**: 控制头部偏航角（左右转头）
+
+**使用示例**:
+```yaml
+# 让机器人点头（pitch = -20°）
+service: number.set_value
+target:
+  entity_id: number.reachy_mini_head_pitch
+data:
+  value: -20
+
+# 让机器人摇头（yaw 左右摆动）
+service: number.set_value
+target:
+  entity_id: number.reachy_mini_head_yaw
+data:
+  value: 30
+```
+
+#### 身体控制
+
+##### 15. Body Yaw (数字控制)
+- **实体 ID**: `number.reachy_mini_body_yaw`
+- **范围**: -160° ~ +160°
+- **说明**: 控制身体的偏航角（旋转）
+
+**使用示例**:
+```yaml
+# 旋转身体 45 度
+service: number.set_value
+target:
+  entity_id: number.reachy_mini_body_yaw
+data:
+  value: 45
+```
+
+#### 天线控制
+
+##### 16. Left Antenna (数字控制)
+- **实体 ID**: `number.reachy_mini_antenna_left`
+- **范围**: -90° ~ +90°
+- **说明**: 控制左天线角度
+
+##### 17. Right Antenna (数字控制)
+- **实体 ID**: `number.reachy_mini_antenna_right`
+- **范围**: -90° ~ +90°
+- **说明**: 控制右天线角度
+
+**使用示例**:
+```yaml
+# 让天线竖起来表示兴奋
+service: number.set_value
+target:
+  entity_id:
+    - number.reachy_mini_antenna_left
+    - number.reachy_mini_antenna_right
+data:
+  value: 45
+```
+
+---
+
+## 自动化示例
+
+### 示例 1: 早晨唤醒机器人
+
+```yaml
+automation:
+  - alias: "早晨唤醒 Reachy Mini"
+    trigger:
+      - platform: time
+        at: "08:00:00"
+    action:
+      - service: button.press
+        target:
+          entity_id: button.reachy_mini_wake_up
+      - service: number.set_value
+        target:
+          entity_id: number.reachy_mini_speaker_volume
+        data:
+          value: 70
+```
+
+### 示例 2: 晚上让机器人睡觉
+
+```yaml
+automation:
+  - alias: "晚上 Reachy Mini 睡觉"
+    trigger:
+      - platform: time
+        at: "22:00:00"
+    action:
+      - service: button.press
+        target:
+          entity_id: button.reachy_mini_go_to_sleep
+      - service: switch.turn_off
+        target:
+          entity_id: switch.reachy_mini_motors_enabled
+```
+
+### 示例 3: 有人回家时打招呼
+
+```yaml
+automation:
+  - alias: "Reachy Mini 打招呼"
+    trigger:
+      - platform: state
+        entity_id: binary_sensor.front_door
+        to: "on"
+    condition:
+      - condition: state
+        entity_id: binary_sensor.reachy_mini_backend_ready
+        state: "on"
+    action:
+      # 点头
+      - service: number.set_value
+        target:
+          entity_id: number.reachy_mini_head_pitch
+        data:
+          value: -20
+      - delay: "00:00:01"
+      - service: number.set_value
+        target:
+          entity_id: number.reachy_mini_head_pitch
+        data:
+          value: 0
+      # 天线摆动
+      - service: number.set_value
+        target:
+          entity_id:
+            - number.reachy_mini_antenna_left
+            - number.reachy_mini_antenna_right
+        data:
+          value: 45
+      - delay: "00:00:01"
+      - service: number.set_value
+        target:
+          entity_id:
+            - number.reachy_mini_antenna_left
+            - number.reachy_mini_antenna_right
+        data:
+          value: 0
+```
+
+### 示例 4: 根据后端状态显示通知
+
+```yaml
+automation:
+  - alias: "Reachy Mini 错误通知"
+    trigger:
+      - platform: state
+        entity_id: sensor.reachy_mini_daemon_state
+        to: "error"
+    action:
+      - service: notify.mobile_app
+        data:
+          title: "Reachy Mini 错误"
+          message: "{{ states('sensor.reachy_mini_error_message') }}"
+```
+
+### 示例 5: 创建自定义动作序列
+
+```yaml
+script:
+  reachy_mini_dance:
+    alias: "Reachy Mini 跳舞"
+    sequence:
+      # 启用电机
+      - service: switch.turn_on
+        target:
+          entity_id: switch.reachy_mini_motors_enabled
+      # 左右摇头
+      - repeat:
+          count: 3
+          sequence:
+            - service: number.set_value
+              target:
+                entity_id: number.reachy_mini_head_yaw
+              data:
+                value: 30
+            - delay: "00:00:00.5"
+            - service: number.set_value
+              target:
+                entity_id: number.reachy_mini_head_yaw
+              data:
+                value: -30
+            - delay: "00:00:00.5"
+      # 回到中心
+      - service: number.set_value
+        target:
+          entity_id: number.reachy_mini_head_yaw
+        data:
+          value: 0
+      # 天线摆动
+      - service: number.set_value
+        target:
+          entity_id:
+            - number.reachy_mini_antenna_left
+            - number.reachy_mini_antenna_right
+        data:
+          value: 60
+      - delay: "00:00:01"
+      - service: number.set_value
+        target:
+          entity_id:
+            - number.reachy_mini_antenna_left
+            - number.reachy_mini_antenna_right
+        data:
+          value: 0
+```
+
+---
+
+## Lovelace 仪表板示例
+
+### 基础控制卡片
+
+```yaml
+type: vertical-stack
+cards:
+  - type: entities
+    title: Reachy Mini 状态
+    entities:
+      - entity: sensor.reachy_mini_daemon_state
+        name: Daemon 状态
+      - entity: binary_sensor.reachy_mini_backend_ready
+        name: 后端就绪
+      - entity: sensor.reachy_mini_error_message
+        name: 错误信息
+
+  - type: entities
+    title: 电机控制
+    entities:
+      - entity: switch.reachy_mini_motors_enabled
+        name: 电机开关
+      - entity: select.reachy_mini_motor_mode
+        name: 电机模式
+      - entity: button.reachy_mini_wake_up
+        name: 唤醒
+      - entity: button.reachy_mini_go_to_sleep
+        name: 睡眠
+
+  - type: entities
+    title: 音量控制
+    entities:
+      - entity: number.reachy_mini_speaker_volume
+        name: 扬声器音量
+```
+
+### 头部控制卡片
+
+```yaml
+type: vertical-stack
+cards:
+  - type: entities
+    title: 头部位置 (mm)
+    entities:
+      - entity: number.reachy_mini_head_x
+        name: X 轴
+      - entity: number.reachy_mini_head_y
+        name: Y 轴
+      - entity: number.reachy_mini_head_z
+        name: Z 轴
+
+  - type: entities
+    title: 头部角度 (°)
+    entities:
+      - entity: number.reachy_mini_head_roll
+        name: 翻滚 (Roll)
+      - entity: number.reachy_mini_head_pitch
+        name: 俯仰 (Pitch)
+      - entity: number.reachy_mini_head_yaw
+        name: 偏航 (Yaw)
+
+  - type: entities
+    title: 身体与天线
+    entities:
+      - entity: number.reachy_mini_body_yaw
+        name: 身体偏航
+      - entity: number.reachy_mini_antenna_left
+        name: 左天线
+      - entity: number.reachy_mini_antenna_right
+        name: 右天线
+```
+
+---
+
+## 注意事项
+
+1. **电机安全**: 在控制姿态之前，确保电机已启用 (`switch.reachy_mini_motors_enabled` 为 `on`)
+
+2. **角度限制**: 所有角度控制都有安全限制，超出范围的值会被自动限制在有效范围内
+
+3. **独立模式**: 如果机器人不可用（独立模式），控制命令不会产生错误，但也不会执行任何动作
+
+4. **平滑运动**: 快速连续的控制命令可能导致不平滑的运动，建议在命令之间添加适当的延迟
+
+5. **状态更新**: 实体状态会实时更新，但某些传感器可能有轻微延迟
+
+---
+
+## 故障排除
+
+### 问题: 实体不显示在 Home Assistant 中
+**解决方案**:
+- 确认 Reachy Mini HA Voice 应用正在运行
+- 检查 ESPHome 集成是否正确配置
+- 重启 Home Assistant 或重新加载 ESPHome 集成
+
+### 问题: 控制命令无响应
+**解决方案**:
+- 检查 `binary_sensor.reachy_mini_backend_ready` 是否为 `on`
+- 查看 `sensor.reachy_mini_error_message` 是否有错误信息
+- 确认电机已启用（对于运动控制）
+
+### 问题: Daemon 状态显示 "error"
+**解决方案**:
+- 查看 `sensor.reachy_mini_error_message` 获取详细错误信息
+- 检查 Reachy Mini 硬件连接
+- 重启 Reachy Mini HA Voice 应用
+
+---
+
+## 更多信息
+
+- [项目 GitHub](https://github.com/yourusername/reachy_mini_ha_voice)
+- [Reachy Mini SDK 文档](https://github.com/pollen-robotics/reachy_mini)
+- [Home Assistant ESPHome 集成](https://www.home-assistant.io/integrations/esphome/)

PROJECT_PLAN.md

@@ -206,22 +206,22 @@ dependencies = [
 
 ### 实现优先级
 
-1. **Phase 1 - 基础状态与音量** (高优先级)
-   - [ ] `daemon_state` - Daemon 状态传感器
-   - [ ] `backend_ready` - 后端就绪状态
-   - [ ] `error_message` - 错误信息
-   - [ ] `speaker_volume` - 扬声器音量控制
-
-2. **Phase 2 - 电机控制** (高优先级)
-   - [ ] `motors_enabled` - 电机开关
-   - [ ] `motor_mode` - 电机模式选择 (enabled/disabled/gravity_compensation)
-   - [ ] `wake_up` / `go_to_sleep` - 唤醒/睡眠按钮
-
-3. **Phase 3 - 姿态控制** (中优先级)
-   - [ ] `head_x/y/z` - 头部位置控制
-   - [ ] `head_roll/pitch/yaw` - 头部角度控制
-   - [ ] `body_yaw` - 身体偏航角控制
-   - [ ] `antenna_left/right` - 天线角度控制
+1. **Phase 1 - 基础状态与音量** (高优先级) ✅ **已完成**
+   - [x] `daemon_state` - Daemon 状态传感器
+   - [x] `backend_ready` - 后端就绪状态
+   - [x] `error_message` - 错误信息
+   - [x] `speaker_volume` - 扬声器音量控制
+
+2. **Phase 2 - 电机控制** (高优先级) ✅ **已完成**
+   - [x] `motors_enabled` - 电机开关
+   - [x] `motor_mode` - 电机模式选择 (enabled/disabled/gravity_compensation)
+   - [x] `wake_up` / `go_to_sleep` - 唤醒/睡眠按钮
+
+3. **Phase 3 - 姿态控制** (中优先级) ✅ **已完成**
+   - [x] `head_x/y/z` - 头部位置控制
+   - [x] `head_roll/pitch/yaw` - 头部角度控制
+   - [x] `body_yaw` - 身体偏航角控制
+   - [x] `antenna_left/right` - 天线角度控制
 
 4. **Phase 4 - 注视控制** (中优先级)
    - [ ] `look_at_x/y/z` - 注视点坐标控制

README.md

@@ -21,6 +21,12 @@ A voice assistant application for **Reachy Mini robot** that integrates with Hom
 - **ESPHome Integration**: Seamlessly connects to Home Assistant
 - **Motion Control**: Head movements and antenna animations during voice interaction
 - **Zero Configuration**: Install and run - all settings are managed in Home Assistant
+- **Full Robot Control**: Expose 17+ entities to Home Assistant for complete robot control
+  - Motor control (enable/disable, mode selection)
+  - Head position and orientation control
+  - Body rotation control
+  - Antenna animation control
+  - System status monitoring
 
 ## Requirements
 
@@ -52,6 +58,30 @@ Default wake word: **"Okay Nabu"**
 
 Additional wake words can be configured through Home Assistant.
 
+## ESPHome Entities
+
+This application exposes 17+ entities to Home Assistant for complete robot control:
+
+### Status & Control
+- **Daemon State** - Monitor robot daemon status
+- **Backend Ready** - Check if backend is ready
+- **Error Message** - View current error messages
+- **Speaker Volume** - Control audio volume (0-100%)
+
+### Motor Control
+- **Motors Enabled** - Enable/disable motor torque
+- **Motor Mode** - Select motor mode (enabled/disabled/gravity_compensation)
+- **Wake Up** - Execute wake up animation
+- **Go to Sleep** - Execute sleep animation
+
+### Pose Control
+- **Head Position** - Control X/Y/Z position (±50mm)
+- **Head Orientation** - Control roll/pitch/yaw angles
+- **Body Yaw** - Rotate body (±160°)
+- **Antennas** - Control left/right antenna angles (±90°)
+
+📖 **[View Complete Entity Documentation](ENTITIES.md)** - Includes usage examples, automations, and Lovelace dashboard configurations
+
 ## How It Works
 
 ```

reachy_mini_ha_voice/entity.py

@@ -2,15 +2,34 @@
 
 from abc import abstractmethod
 from collections.abc import Iterable
-from typing import Callable, List, Optional, Union
+from typing import Callable, List, Optional, Union, TYPE_CHECKING
+import logging
 
 # pylint: disable=no-name-in-module
 from aioesphomeapi.api_pb2 import (  # type: ignore[attr-defined]
+    ListEntitiesBinarySensorResponse,
+    ListEntitiesButtonResponse,
     ListEntitiesMediaPlayerResponse,
+    ListEntitiesNumberResponse,
     ListEntitiesRequest,
+    ListEntitiesSelectResponse,
+    ListEntitiesSensorResponse,
+    ListEntitiesSwitchResponse,
+    ListEntitiesTextSensorResponse,
+    BinarySensorStateResponse,
+    ButtonCommandRequest,
     MediaPlayerCommandRequest,
     MediaPlayerStateResponse,
+    NumberCommandRequest,
+    NumberStateResponse,
+    SelectCommandRequest,
+    SelectStateResponse,
+    SensorStateResponse,
     SubscribeHomeAssistantStatesRequest,
+    SubscribeStatesRequest,
+    SwitchCommandRequest,
+    SwitchStateResponse,
+    TextSensorStateResponse,
 )
 from aioesphomeapi.model import MediaPlayerCommand, MediaPlayerState
 from google.protobuf import message
@@ -19,6 +38,11 @@ from .api_server import APIServer
 from .audio_player import AudioPlayer
 from .util import call_all
 
+if TYPE_CHECKING:
+    from reachy_mini import ReachyMini
+
+logger = logging.getLogger(__name__)
+
 
 class ESPHomeEntity:
     """Base class for ESPHome entities."""
@@ -133,3 +157,189 @@ class MediaPlayerEntity(ESPHomeEntity):
             volume=self.volume,
             muted=self.muted,
         )
+
+
+class TextSensorEntity(ESPHomeEntity):
+    """Text sensor entity for ESPHome (read-only string values)."""
+
+    def __init__(
+        self,
+        server: APIServer,
+        key: int,
+        name: str,
+        object_id: str,
+        icon: str = "",
+        value_getter: Optional[Callable[[], str]] = None,
+    ) -> None:
+        ESPHomeEntity.__init__(self, server)
+        self.key = key
+        self.name = name
+        self.object_id = object_id
+        self.icon = icon
+        self._value_getter = value_getter
+        self._value = ""
+
+    @property
+    def value(self) -> str:
+        if self._value_getter:
+            return self._value_getter()
+        return self._value
+
+    @value.setter
+    def value(self, new_value: str) -> None:
+        self._value = new_value
+
+    def handle_message(self, msg: message.Message) -> Iterable[message.Message]:
+        if isinstance(msg, ListEntitiesRequest):
+            yield ListEntitiesTextSensorResponse(
+                object_id=self.object_id,
+                key=self.key,
+                name=self.name,
+                icon=self.icon,
+            )
+        elif isinstance(msg, (SubscribeHomeAssistantStatesRequest, SubscribeStatesRequest)):
+            yield self._get_state_message()
+
+    def _get_state_message(self) -> TextSensorStateResponse:
+        return TextSensorStateResponse(
+            key=self.key,
+            state=self.value,
+            missing_state=False,
+        )
+
+    def update_state(self) -> None:
+        """Send state update to Home Assistant."""
+        self.server.send_messages([self._get_state_message()])
+
+
+class BinarySensorEntity(ESPHomeEntity):
+    """Binary sensor entity for ESPHome (read-only boolean values)."""
+
+    def __init__(
+        self,
+        server: APIServer,
+        key: int,
+        name: str,
+        object_id: str,
+        icon: str = "",
+        device_class: str = "",
+        value_getter: Optional[Callable[[], bool]] = None,
+    ) -> None:
+        ESPHomeEntity.__init__(self, server)
+        self.key = key
+        self.name = name
+        self.object_id = object_id
+        self.icon = icon
+        self.device_class = device_class
+        self._value_getter = value_getter
+        self._value = False
+
+    @property
+    def value(self) -> bool:
+        if self._value_getter:
+            return self._value_getter()
+        return self._value
+
+    @value.setter
+    def value(self, new_value: bool) -> None:
+        self._value = new_value
+
+    def handle_message(self, msg: message.Message) -> Iterable[message.Message]:
+        if isinstance(msg, ListEntitiesRequest):
+            yield ListEntitiesBinarySensorResponse(
+                object_id=self.object_id,
+                key=self.key,
+                name=self.name,
+                icon=self.icon,
+                device_class=self.device_class,
+            )
+        elif isinstance(msg, (SubscribeHomeAssistantStatesRequest, SubscribeStatesRequest)):
+            yield self._get_state_message()
+
+    def _get_state_message(self) -> BinarySensorStateResponse:
+        return BinarySensorStateResponse(
+            key=self.key,
+            state=self.value,
+            missing_state=False,
+        )
+
+    def update_state(self) -> None:
+        """Send state update to Home Assistant."""
+        self.server.send_messages([self._get_state_message()])
+
+
+class NumberEntity(ESPHomeEntity):
+    """Number entity for ESPHome (read-write numeric values)."""
+
+    def __init__(
+        self,
+        server: APIServer,
+        key: int,
+        name: str,
+        object_id: str,
+        min_value: float = 0.0,
+        max_value: float = 100.0,
+        step: float = 1.0,
+        icon: str = "",
+        unit_of_measurement: str = "",
+        mode: int = 0,  # 0 = auto, 1 = box, 2 = slider
+        value_getter: Optional[Callable[[], float]] = None,
+        value_setter: Optional[Callable[[float], None]] = None,
+    ) -> None:
+        ESPHomeEntity.__init__(self, server)
+        self.key = key
+        self.name = name
+        self.object_id = object_id
+        self.min_value = min_value
+        self.max_value = max_value
+        self.step = step
+        self.icon = icon
+        self.unit_of_measurement = unit_of_measurement
+        self.mode = mode
+        self._value_getter = value_getter
+        self._value_setter = value_setter
+        self._value = min_value
+
+    @property
+    def value(self) -> float:
+        if self._value_getter:
+            return self._value_getter()
+        return self._value
+
+    @value.setter
+    def value(self, new_value: float) -> None:
+        # Clamp value to valid range
+        new_value = max(self.min_value, min(self.max_value, new_value))
+        if self._value_setter:
+            self._value_setter(new_value)
+        self._value = new_value
+
+    def handle_message(self, msg: message.Message) -> Iterable[message.Message]:
+        if isinstance(msg, ListEntitiesRequest):
+            yield ListEntitiesNumberResponse(
+                object_id=self.object_id,
+                key=self.key,
+                name=self.name,
+                icon=self.icon,
+                min_value=self.min_value,
+                max_value=self.max_value,
+                step=self.step,
+                unit_of_measurement=self.unit_of_measurement,
+                mode=self.mode,
+            )
+        elif isinstance(msg, (SubscribeHomeAssistantStatesRequest, SubscribeStatesRequest)):
+            yield self._get_state_message()
+        elif isinstance(msg, NumberCommandRequest) and msg.key == self.key:
+            self.value = msg.state
+            yield self._get_state_message()
+
+    def _get_state_message(self) -> NumberStateResponse:
+        return NumberStateResponse(
+            key=self.key,
+            state=self.value,
+            missing_state=False,
+        )
+
+    def update_state(self) -> None:
+        """Send state update to Home Assistant."""
+        self.server.send_messages([self._get_state_message()])

reachy_mini_ha_voice/entity_extensions.py

@@ -0,0 +1,262 @@
+"""Extended ESPHome entity types for Reachy Mini control."""
+
+from collections.abc import Iterable
+from typing import Callable, List, Optional
+import logging
+
+from aioesphomeapi.api_pb2 import (  # type: ignore[attr-defined]
+    ListEntitiesButtonResponse,
+    ListEntitiesRequest,
+    ListEntitiesSelectResponse,
+    ListEntitiesSensorResponse,
+    ListEntitiesSwitchResponse,
+    ButtonCommandRequest,
+    SelectCommandRequest,
+    SelectStateResponse,
+    SensorStateResponse,
+    SubscribeHomeAssistantStatesRequest,
+    SubscribeStatesRequest,
+    SwitchCommandRequest,
+    SwitchStateResponse,
+)
+from google.protobuf import message
+
+from .api_server import APIServer
+from .entity import ESPHomeEntity
+
+logger = logging.getLogger(__name__)
+
+
+class SensorEntity(ESPHomeEntity):
+    """Sensor entity for ESPHome (read-only numeric values)."""
+
+    def __init__(
+        self,
+        server: APIServer,
+        key: int,
+        name: str,
+        object_id: str,
+        icon: str = "",
+        unit_of_measurement: str = "",
+        accuracy_decimals: int = 2,
+        device_class: str = "",
+        state_class: str = "",
+        value_getter: Optional[Callable[[], float]] = None,
+    ) -> None:
+        ESPHomeEntity.__init__(self, server)
+        self.key = key
+        self.name = name
+        self.object_id = object_id
+        self.icon = icon
+        self.unit_of_measurement = unit_of_measurement
+        self.accuracy_decimals = accuracy_decimals
+        self.device_class = device_class
+        self.state_class = state_class
+        self._value_getter = value_getter
+        self._value = 0.0
+
+    @property
+    def value(self) -> float:
+        if self._value_getter:
+            return self._value_getter()
+        return self._value
+
+    @value.setter
+    def value(self, new_value: float) -> None:
+        self._value = new_value
+
+    def handle_message(self, msg: message.Message) -> Iterable[message.Message]:
+        if isinstance(msg, ListEntitiesRequest):
+            yield ListEntitiesSensorResponse(
+                object_id=self.object_id,
+                key=self.key,
+                name=self.name,
+                icon=self.icon,
+                unit_of_measurement=self.unit_of_measurement,
+                accuracy_decimals=self.accuracy_decimals,
+                device_class=self.device_class,
+                state_class=self.state_class,
+            )
+        elif isinstance(msg, (SubscribeHomeAssistantStatesRequest, SubscribeStatesRequest)):
+            yield self._get_state_message()
+
+    def _get_state_message(self) -> SensorStateResponse:
+        return SensorStateResponse(
+            key=self.key,
+            state=self.value,
+            missing_state=False,
+        )
+
+    def update_state(self) -> None:
+        """Send state update to Home Assistant."""
+        self.server.send_messages([self._get_state_message()])
+
+
+class SwitchEntity(ESPHomeEntity):
+    """Switch entity for ESPHome (read-write boolean values)."""
+
+    def __init__(
+        self,
+        server: APIServer,
+        key: int,
+        name: str,
+        object_id: str,
+        icon: str = "",
+        device_class: str = "",
+        value_getter: Optional[Callable[[], bool]] = None,
+        value_setter: Optional[Callable[[bool], None]] = None,
+    ) -> None:
+        ESPHomeEntity.__init__(self, server)
+        self.key = key
+        self.name = name
+        self.object_id = object_id
+        self.icon = icon
+        self.device_class = device_class
+        self._value_getter = value_getter
+        self._value_setter = value_setter
+        self._value = False
+
+    @property
+    def value(self) -> bool:
+        if self._value_getter:
+            return self._value_getter()
+        return self._value
+
+    @value.setter
+    def value(self, new_value: bool) -> None:
+        if self._value_setter:
+            self._value_setter(new_value)
+        self._value = new_value
+
+    def handle_message(self, msg: message.Message) -> Iterable[message.Message]:
+        if isinstance(msg, ListEntitiesRequest):
+            yield ListEntitiesSwitchResponse(
+                object_id=self.object_id,
+                key=self.key,
+                name=self.name,
+                icon=self.icon,
+                device_class=self.device_class,
+            )
+        elif isinstance(msg, (SubscribeHomeAssistantStatesRequest, SubscribeStatesRequest)):
+            yield self._get_state_message()
+        elif isinstance(msg, SwitchCommandRequest) and msg.key == self.key:
+            self.value = msg.state
+            yield self._get_state_message()
+
+    def _get_state_message(self) -> SwitchStateResponse:
+        return SwitchStateResponse(
+            key=self.key,
+            state=self.value,
+        )
+
+    def update_state(self) -> None:
+        """Send state update to Home Assistant."""
+        self.server.send_messages([self._get_state_message()])
+
+
+class SelectEntity(ESPHomeEntity):
+    """Select entity for ESPHome (read-write string selection)."""
+
+    def __init__(
+        self,
+        server: APIServer,
+        key: int,
+        name: str,
+        object_id: str,
+        options: List[str],
+        icon: str = "",
+        value_getter: Optional[Callable[[], str]] = None,
+        value_setter: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        ESPHomeEntity.__init__(self, server)
+        self.key = key
+        self.name = name
+        self.object_id = object_id
+        self.options = options
+        self.icon = icon
+        self._value_getter = value_getter
+        self._value_setter = value_setter
+        self._value = options[0] if options else ""
+
+    @property
+    def value(self) -> str:
+        if self._value_getter:
+            return self._value_getter()
+        return self._value
+
+    @value.setter
+    def value(self, new_value: str) -> None:
+        if new_value in self.options:
+            if self._value_setter:
+                self._value_setter(new_value)
+            self._value = new_value
+        else:
+            logger.warning(f"Invalid option '{new_value}' for {self.name}")
+
+    def handle_message(self, msg: message.Message) -> Iterable[message.Message]:
+        if isinstance(msg, ListEntitiesRequest):
+            yield ListEntitiesSelectResponse(
+                object_id=self.object_id,
+                key=self.key,
+                name=self.name,
+                icon=self.icon,
+                options=self.options,
+            )
+        elif isinstance(msg, (SubscribeHomeAssistantStatesRequest, SubscribeStatesRequest)):
+            yield self._get_state_message()
+        elif isinstance(msg, SelectCommandRequest) and msg.key == self.key:
+            self.value = msg.state
+            yield self._get_state_message()
+
+    def _get_state_message(self) -> SelectStateResponse:
+        return SelectStateResponse(
+            key=self.key,
+            state=self.value,
+            missing_state=False,
+        )
+
+    def update_state(self) -> None:
+        """Send state update to Home Assistant."""
+        self.server.send_messages([self._get_state_message()])
+
+
+class ButtonEntity(ESPHomeEntity):
+    """Button entity for ESPHome (trigger actions)."""
+
+    def __init__(
+        self,
+        server: APIServer,
+        key: int,
+        name: str,
+        object_id: str,
+        icon: str = "",
+        device_class: str = "",
+        on_press: Optional[Callable[[], None]] = None,
+    ) -> None:
+        ESPHomeEntity.__init__(self, server)
+        self.key = key
+        self.name = name
+        self.object_id = object_id
+        self.icon = icon
+        self.device_class = device_class
+        self._on_press = on_press
+
+    def handle_message(self, msg: message.Message) -> Iterable[message.Message]:
+        if isinstance(msg, ListEntitiesRequest):
+            yield ListEntitiesButtonResponse(
+                object_id=self.object_id,
+                key=self.key,
+                name=self.name,
+                icon=self.icon,
+                device_class=self.device_class,
+            )
+        elif isinstance(msg, ButtonCommandRequest) and msg.key == self.key:
+            if self._on_press:
+                try:
+                    self._on_press()
+                    logger.info(f"Button '{self.name}' pressed")
+                except Exception as e:
+                    logger.error(f"Error executing button '{self.name}': {e}")
+            # Buttons don't have state responses
+            return
+            yield  # Make this a generator

reachy_mini_ha_voice/main.py

@@ -88,9 +88,13 @@ class ReachyMiniHAVoiceApp(ReachyMiniApp):
             try:
                 logger.info("Attempting to connect to Reachy Mini...")
                 super().wrapped_run(*args, **kwargs)
+            except TimeoutError as e:
+                logger.warning(f"Timeout connecting to Reachy Mini: {e}")
+                logger.info("Falling back to standalone mode")
+                self._run_standalone()
             except Exception as e:
                 error_str = str(e)
-                if "Unable to connect" in error_str or "ZError" in error_str:
+                if "Unable to connect" in error_str or "ZError" in error_str or "Timeout" in error_str:
                     logger.warning(f"Failed to connect to Reachy Mini: {e}")
                     logger.info("Falling back to standalone mode")
                     self._run_standalone()

reachy_mini_ha_voice/reachy_controller.py

@@ -0,0 +1,383 @@
+"""Reachy Mini controller wrapper for ESPHome entities."""
+
+import logging
+from typing import Optional, TYPE_CHECKING
+import math
+
+if TYPE_CHECKING:
+    from reachy_mini import ReachyMini
+
+logger = logging.getLogger(__name__)
+
+
+class ReachyController:
+    """
+    Wrapper class for Reachy Mini control operations.
+
+    Provides safe access to Reachy Mini SDK functions with error handling
+    and fallback for standalone mode (when robot is not available).
+    """
+
+    def __init__(self, reachy_mini: Optional["ReachyMini"] = None):
+        """
+        Initialize the controller.
+
+        Args:
+            reachy_mini: ReachyMini instance, or None for standalone mode
+        """
+        self.reachy = reachy_mini
+        self._speaker_volume = 100  # Default volume
+
+    @property
+    def is_available(self) -> bool:
+        """Check if robot is available."""
+        return self.reachy is not None
+
+    # ========== Phase 1: Basic Status & Volume ==========
+
+    def get_daemon_state(self) -> str:
+        """Get daemon state."""
+        if not self.is_available:
+            return "not_available"
+        try:
+            status = self.reachy.get_daemon_status()
+            return status.state.value if hasattr(status, 'state') else "unknown"
+        except Exception as e:
+            logger.error(f"Error getting daemon state: {e}")
+            return "error"
+
+    def get_backend_ready(self) -> bool:
+        """Check if backend is ready."""
+        if not self.is_available:
+            return False
+        try:
+            status = self.reachy.get_backend_status()
+            return status.ready if hasattr(status, 'ready') else False
+        except Exception as e:
+            logger.error(f"Error getting backend status: {e}")
+            return False
+
+    def get_error_message(self) -> str:
+        """Get current error message."""
+        if not self.is_available:
+            return "Robot not available"
+        try:
+            status = self.reachy.get_daemon_status()
+            return status.error if hasattr(status, 'error') else ""
+        except Exception as e:
+            logger.error(f"Error getting error message: {e}")
+            return str(e)
+
+    def get_speaker_volume(self) -> float:
+        """Get speaker volume (0-100)."""
+        return self._speaker_volume
+
+    def set_speaker_volume(self, volume: float) -> None:
+        """
+        Set speaker volume (0-100).
+
+        Args:
+            volume: Volume level 0-100
+        """
+        self._speaker_volume = max(0.0, min(100.0, volume))
+        logger.info(f"Speaker volume set to {self._speaker_volume}%")
+        # Note: Actual volume control is handled by AudioPlayer
+
+    # ========== Phase 2: Motor Control ==========
+
+    def get_motors_enabled(self) -> bool:
+        """Check if motors are enabled."""
+        if not self.is_available:
+            return False
+        try:
+            state = self.reachy.get_full_state()
+            return state.control_mode.value == "enabled"
+        except Exception as e:
+            logger.error(f"Error getting motor state: {e}")
+            return False
+
+    def set_motors_enabled(self, enabled: bool) -> None:
+        """
+        Enable or disable motors.
+
+        Args:
+            enabled: True to enable, False to disable
+        """
+        if not self.is_available:
+            logger.warning("Cannot control motors: robot not available")
+            return
+
+        try:
+            if enabled:
+                self.reachy.enable_motors()
+                logger.info("Motors enabled")
+            else:
+                self.reachy.disable_motors()
+                logger.info("Motors disabled")
+        except Exception as e:
+            logger.error(f"Error setting motor state: {e}")
+
+    def get_motor_mode(self) -> str:
+        """Get current motor control mode."""
+        if not self.is_available:
+            return "disabled"
+        try:
+            state = self.reachy.get_full_state()
+            return state.control_mode.value
+        except Exception as e:
+            logger.error(f"Error getting motor mode: {e}")
+            return "error"
+
+    def set_motor_mode(self, mode: str) -> None:
+        """
+        Set motor control mode.
+
+        Args:
+            mode: One of "enabled", "disabled", "gravity_compensation"
+        """
+        if not self.is_available:
+            logger.warning("Cannot set motor mode: robot not available")
+            return
+
+        try:
+            if mode == "enabled":
+                self.reachy.enable_motors()
+            elif mode == "disabled":
+                self.reachy.disable_motors()
+            elif mode == "gravity_compensation":
+                self.reachy.set_motor_control_mode("gravity_compensation")
+            else:
+                logger.warning(f"Invalid motor mode: {mode}")
+                return
+            logger.info(f"Motor mode set to {mode}")
+        except Exception as e:
+            logger.error(f"Error setting motor mode: {e}")
+
+    def wake_up(self) -> None:
+        """Execute wake up animation."""
+        if not self.is_available:
+            logger.warning("Cannot wake up: robot not available")
+            return
+
+        try:
+            self.reachy.wake_up()
+            logger.info("Wake up animation executed")
+        except Exception as e:
+            logger.error(f"Error executing wake up: {e}")
+
+    def go_to_sleep(self) -> None:
+        """Execute sleep animation."""
+        if not self.is_available:
+            logger.warning("Cannot sleep: robot not available")
+            return
+
+        try:
+            self.reachy.goto_sleep()
+            logger.info("Sleep animation executed")
+        except Exception as e:
+            logger.error(f"Error executing sleep: {e}")
+
+    # ========== Phase 3: Pose Control ==========
+
+    def get_head_x(self) -> float:
+        """Get head X position in mm."""
+        if not self.is_available:
+            return 0.0
+        try:
+            pose = self.reachy.get_current_head_pose()
+            return pose.x * 1000  # Convert m to mm
+        except Exception as e:
+            logger.error(f"Error getting head X: {e}")
+            return 0.0
+
+    def set_head_x(self, x_mm: float) -> None:
+        """Set head X position in mm."""
+        if not self.is_available:
+            return
+        try:
+            current = self.reachy.get_current_head_pose()
+            self.reachy.goto_target(
+                head=(x_mm / 1000, current.y, current.z, current.roll, current.pitch, current.yaw)
+            )
+        except Exception as e:
+            logger.error(f"Error setting head X: {e}")
+
+    def get_head_y(self) -> float:
+        """Get head Y position in mm."""
+        if not self.is_available:
+            return 0.0
+        try:
+            pose = self.reachy.get_current_head_pose()
+            return pose.y * 1000
+        except Exception as e:
+            logger.error(f"Error getting head Y: {e}")
+            return 0.0
+
+    def set_head_y(self, y_mm: float) -> None:
+        """Set head Y position in mm."""
+        if not self.is_available:
+            return
+        try:
+            current = self.reachy.get_current_head_pose()
+            self.reachy.goto_target(
+                head=(current.x, y_mm / 1000, current.z, current.roll, current.pitch, current.yaw)
+            )
+        except Exception as e:
+            logger.error(f"Error setting head Y: {e}")
+
+    def get_head_z(self) -> float:
+        """Get head Z position in mm."""
+        if not self.is_available:
+            return 0.0
+        try:
+            pose = self.reachy.get_current_head_pose()
+            return pose.z * 1000
+        except Exception as e:
+            logger.error(f"Error getting head Z: {e}")
+            return 0.0
+
+    def set_head_z(self, z_mm: float) -> None:
+        """Set head Z position in mm."""
+        if not self.is_available:
+            return
+        try:
+            current = self.reachy.get_current_head_pose()
+            self.reachy.goto_target(
+                head=(current.x, current.y, z_mm / 1000, current.roll, current.pitch, current.yaw)
+            )
+        except Exception as e:
+            logger.error(f"Error setting head Z: {e}")
+
+    def get_head_roll(self) -> float:
+        """Get head roll angle in degrees."""
+        if not self.is_available:
+            return 0.0
+        try:
+            pose = self.reachy.get_current_head_pose()
+            return math.degrees(pose.roll)
+        except Exception as e:
+            logger.error(f"Error getting head roll: {e}")
+            return 0.0
+
+    def set_head_roll(self, roll_deg: float) -> None:
+        """Set head roll angle in degrees."""
+        if not self.is_available:
+            return
+        try:
+            current = self.reachy.get_current_head_pose()
+            self.reachy.goto_target(
+                head=(current.x, current.y, current.z, math.radians(roll_deg), current.pitch, current.yaw)
+            )
+        except Exception as e:
+            logger.error(f"Error setting head roll: {e}")
+
+    def get_head_pitch(self) -> float:
+        """Get head pitch angle in degrees."""
+        if not self.is_available:
+            return 0.0
+        try:
+            pose = self.reachy.get_current_head_pose()
+            return math.degrees(pose.pitch)
+        except Exception as e:
+            logger.error(f"Error getting head pitch: {e}")
+            return 0.0
+
+    def set_head_pitch(self, pitch_deg: float) -> None:
+        """Set head pitch angle in degrees."""
+        if not self.is_available:
+            return
+        try:
+            current = self.reachy.get_current_head_pose()
+            self.reachy.goto_target(
+                head=(current.x, current.y, current.z, current.roll, math.radians(pitch_deg), current.yaw)
+            )
+        except Exception as e:
+            logger.error(f"Error setting head pitch: {e}")
+
+    def get_head_yaw(self) -> float:
+        """Get head yaw angle in degrees."""
+        if not self.is_available:
+            return 0.0
+        try:
+            pose = self.reachy.get_current_head_pose()
+            return math.degrees(pose.yaw)
+        except Exception as e:
+            logger.error(f"Error getting head yaw: {e}")
+            return 0.0
+
+    def set_head_yaw(self, yaw_deg: float) -> None:
+        """Set head yaw angle in degrees."""
+        if not self.is_available:
+            return
+        try:
+            current = self.reachy.get_current_head_pose()
+            self.reachy.goto_target(
+                head=(current.x, current.y, current.z, current.roll, current.pitch, math.radians(yaw_deg))
+            )
+        except Exception as e:
+            logger.error(f"Error setting head yaw: {e}")
+
+    def get_body_yaw(self) -> float:
+        """Get body yaw angle in degrees."""
+        if not self.is_available:
+            return 0.0
+        try:
+            state = self.reachy.get_full_state()
+            return math.degrees(state.body_yaw)
+        except Exception as e:
+            logger.error(f"Error getting body yaw: {e}")
+            return 0.0
+
+    def set_body_yaw(self, yaw_deg: float) -> None:
+        """Set body yaw angle in degrees."""
+        if not self.is_available:
+            return
+        try:
+            self.reachy.goto_target(body_yaw=math.radians(yaw_deg))
+        except Exception as e:
+            logger.error(f"Error setting body yaw: {e}")
+
+    def get_antenna_left(self) -> float:
+        """Get left antenna angle in degrees."""
+        if not self.is_available:
+            return 0.0
+        try:
+            state = self.reachy.get_full_state()
+            # antennas_position is [right, left]
+            return math.degrees(state.antennas_position[1])
+        except Exception as e:
+            logger.error(f"Error getting left antenna: {e}")
+            return 0.0
+
+    def set_antenna_left(self, angle_deg: float) -> None:
+        """Set left antenna angle in degrees."""
+        if not self.is_available:
+            return
+        try:
+            state = self.reachy.get_full_state()
+            right = state.antennas_position[0]
+            self.reachy.goto_target(antennas=(right, math.radians(angle_deg)))
+        except Exception as e:
+            logger.error(f"Error setting left antenna: {e}")
+
+    def get_antenna_right(self) -> float:
+        """Get right antenna angle in degrees."""
+        if not self.is_available:
+            return 0.0
+        try:
+            state = self.reachy.get_full_state()
+            return math.degrees(state.antennas_position[0])
+        except Exception as e:
+            logger.error(f"Error getting right antenna: {e}")
+            return 0.0
+
+    def set_antenna_right(self, angle_deg: float) -> None:
+        """Set right antenna angle in degrees."""
+        if not self.is_available:
+            return
+        try:
+            state = self.reachy.get_full_state()
+            left = state.antennas_position[1]
+            self.reachy.goto_target(antennas=(math.radians(angle_deg), left))
+        except Exception as e:
+            logger.error(f"Error setting right antenna: {e}")

reachy_mini_ha_voice/satellite.py

@@ -40,9 +40,11 @@ from pymicro_wakeword import MicroWakeWord
 from pyopen_wakeword import OpenWakeWord
 
 from .api_server import APIServer
-from .entity import MediaPlayerEntity
+from .entity import BinarySensorEntity, MediaPlayerEntity, NumberEntity, TextSensorEntity
+from .entity_extensions import SensorEntity, SwitchEntity, SelectEntity, ButtonEntity
 from .models import AvailableWakeWord, ServerState, WakeWordType
 from .util import call_all
+from .reachy_controller import ReachyController
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -55,6 +57,9 @@ class VoiceSatelliteProtocol(APIServer):
         self.state = state
         self.state.satellite = self
 
+        # Initialize Reachy controller
+        self.reachy_controller = ReachyController(state.reachy_mini)
+
         if self.state.media_player_entity is None:
             self.state.media_player_entity = MediaPlayerEntity(
                 server=self,
@@ -66,6 +71,11 @@ 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._is_streaming_audio = False
         self._tts_url: Optional[str] = None
         self._tts_played = False
@@ -474,3 +484,271 @@ class VoiceSatelliteProtocol(APIServer):
             _LOGGER.debug("Reachy Mini: Timer finished animation")
         except Exception as e:
             _LOGGER.error("Reachy Mini motion error: %s", 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=len(self.state.entities),
+            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=len(self.state.entities),
+            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=len(self.state.entities),
+            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=len(self.state.entities),
+            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
+            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=len(self.state.entities),
+            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)
+
+        # Motor mode select
+        motor_mode = SelectEntity(
+            server=self,
+            key=len(self.state.entities),
+            name="Motor Mode",
+            object_id="motor_mode",
+            options=["enabled", "disabled", "gravity_compensation"],
+            icon="mdi:cog",
+            value_getter=self.reachy_controller.get_motor_mode,
+            value_setter=self.reachy_controller.set_motor_mode,
+        )
+        self.state.entities.append(motor_mode)
+
+        # Wake up button
+        wake_up_button = ButtonEntity(
+            server=self,
+            key=len(self.state.entities),
+            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=len(self.state.entities),
+            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, motor_mode, 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=len(self.state.entities),
+            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=len(self.state.entities),
+            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=len(self.state.entities),
+            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=len(self.state.entities),
+            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=len(self.state.entities),
+            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=len(self.state.entities),
+            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=len(self.state.entities),
+            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=len(self.state.entities),
+            name="Left Antenna",
+            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=len(self.state.entities),
+            name="Right Antenna",
+            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")