Update app

.claude/settings.local.json

@@ -1,20 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/claude-code-settings.json",
-  "includeCoAuthoredBy": false,
-  "permissions": {
-    "allow": [
-      "SlashCommand(/zcf:git-commit)"
-    ],
-    "deny": [],
-    "ask": []
-  },
-  "hooks": {},
-  "alwaysThinkingEnabled": true,
-  "outputStyle": "default",
-  "statusLine": {
-    "type": "command",
-    "command": "%USERPROFILE%\\.claude\\ccline\\ccline.exe",
-    "padding": 0
-  },
-  "model": "opus"
-}

.gitattributes

@@ -1,4 +0,0 @@
-reachy_mini_ha_voice/wakewords/**/*.tflite filter=lfs diff=lfs merge=lfs -text
-reachy_mini_ha_voice/sounds/**/*.flac filter=lfs diff=lfs merge=lfs -text
-"reachy_mini_ha_voice/wakewords/**/*.tflite filter=lfs diff=lfs merge=lfs -text
-reachy_mini_ha_voice/sounds/**/*.flac" filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,76 +1,3 @@
-# Python
 __pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
 *.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# Virtual Environment
-.venv/
-venv/
-ENV/
-env/
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-.claude/*
-.serena/*
-.spec-workflow/
-.playwright-mcp/
-*~
-
-# Configuration
-config.json
-.env
-*.log
-
-# Cache
-.cache/
-*.cache
-.DS_Store
-
-# Testing
-.pytest_cache/
-.coverage
-htmlcov/
-.tox/
-
-# Audio (exclude package bundled files)
-*.wav
-*.mp3
-# *.flac - bundled in package
-!reachy_mini_ha_voice/sounds/*.flac
-
-# Models (exclude package bundled files)
-models/
-# *.tflite - bundled in package
-!reachy_mini_ha_voice/wakewords/*.tflite
-!reachy_mini_ha_voice/wakewords/**/*.tflite
-*.onnx
-
-# SDK Reference (local development only)
-reachy_mini/
-reachy_mini_conversation_app/
-linux-voice-assistant/
-reachy-mini-desktop-app/
+build/

.serena/.gitignore

@@ -1 +0,0 @@
-/cache

.serena/project.yml

@@ -1,84 +0,0 @@
-# list of languages for which language servers are started; choose from:
-#   al               bash             clojure          cpp              csharp           csharp_omnisharp
-#   dart             elixir           elm              erlang           fortran          go
-#   haskell          java             julia            kotlin           lua              markdown
-#   nix              perl             php              python           python_jedi      r
-#   rego             ruby             ruby_solargraph  rust             scala            swift
-#   terraform        typescript       typescript_vts   yaml             zig
-# Note:
-#   - For C, use cpp
-#   - For JavaScript, use typescript
-# Special requirements:
-#   - csharp: Requires the presence of a .sln file in the project folder.
-# When using multiple languages, the first language server that supports a given file will be used for that file.
-# The first language is the default language and the respective language server will be used as a fallback.
-# Note that when using the JetBrains backend, language servers are not used and this list is correspondingly ignored.
-languages:
-- python
-
-# the encoding used by text files in the project
-# For a list of possible encodings, see https://docs.python.org/3.11/library/codecs.html#standard-encodings
-encoding: "utf-8"
-
-# whether to use the project's gitignore file to ignore files
-# Added on 2025-04-07
-ignore_all_files_in_gitignore: true
-
-# list of additional paths to ignore
-# same syntax as gitignore, so you can use * and **
-# Was previously called `ignored_dirs`, please update your config if you are using that.
-# Added (renamed) on 2025-04-07
-ignored_paths: []
-
-# whether the project is in read-only mode
-# If set to true, all editing tools will be disabled and attempts to use them will result in an error
-# Added on 2025-04-18
-read_only: false
-
-# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
-# Below is the complete list of tools for convenience.
-# To make sure you have the latest list of tools, and to view their descriptions, 
-# execute `uv run scripts/print_tool_overview.py`.
-#
-#  * `activate_project`: Activates a project by name.
-#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
-#  * `create_text_file`: Creates/overwrites a file in the project directory.
-#  * `delete_lines`: Deletes a range of lines within a file.
-#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
-#  * `execute_shell_command`: Executes a shell command.
-#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
-#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
-#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
-#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
-#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file.
-#  * `initial_instructions`: Gets the initial instructions for the current project.
-#     Should only be used in settings where the system prompt cannot be set,
-#     e.g. in clients you have no control over, like Claude Desktop.
-#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
-#  * `insert_at_line`: Inserts content at a given line in a file.
-#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
-#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
-#  * `list_memories`: Lists memories in Serena's project-specific memory store.
-#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
-#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
-#  * `read_file`: Reads a file within the project directory.
-#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
-#  * `remove_project`: Removes a project from the Serena configuration.
-#  * `replace_lines`: Replaces a range of lines within a file with new content.
-#  * `replace_symbol_body`: Replaces the full definition of a symbol.
-#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
-#  * `search_for_pattern`: Performs a search for a pattern in the project.
-#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
-#  * `switch_modes`: Activates modes by providing a list of their names
-#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
-#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
-#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
-#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
-excluded_tools: []
-
-# initial prompt for the project. It will always be given to the LLM upon activating the project
-# (contrary to the memories, which are loaded on demand).
-initial_prompt: ""
-
-project_name: "reachy_mini_ha_voice"
-included_optional_tools: []

PROJECT_PLAN.md

@@ -1,406 +1,406 @@
-# Reachy Mini Home Assistant Voice Assistant - 项目计划
-
-## 项目概述
-
-将 Home Assistant 语音助手功能集成到 Reachy Mini 机器人，通过 ESPHome 协议与 Home Assistant 通信。
-
-## 本地项目目录参考 (禁止修改参考目录内任何文件)
-1. [linux-voice-assistant](linux-voice-assistant)
-2. [Reachy Mini SDK](reachy_mini)
-3. [reachy_mini_conversation_app](reachy_mini_conversation_app)
-4. [reachy-mini-desktop-app](reachy-mini-desktop-app)
-
-## 核心设计原则
-
-1. **零配置安装** - 用户只需安装应用，无需手动配置
-2. **使用 Reachy Mini 原生硬件** - 使用机器人自带的麦克风和扬声器
-3. **Home Assistant 集中管理** - 所有配置在 Home Assistant 端完成
-4. **运动反馈** - 语音交互时提供头部运动和天线动画反馈
-
-## 技术架构
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                      Reachy Mini                            │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
-│  │ Microphone  │→ │ Wake Word   │→ │ ESPHome Protocol    │ │
-│  │ (ReSpeaker) │  │ Detection   │  │ Server (Port 6053)  │ │
-│  └─────────────┘  └─────────────┘  └──────────┬──────────┘ │
-│                                                │            │
-│  ┌─────────────┐  ┌─────────────┐             │            │
-│  │ Speaker     │← │ Audio       │←────────────┘            │
-│  │ (ReSpeaker) │  │ Player      │                          │
-│  └─────────────┘  └─────────────┘                          │
-│                                                             │
-│  ┌─────────────────────────────────────────────────────┐   │
-│  │ Motion Controller (Head + Antennas)                 │   │
-│  │ - on_wakeup: 点头确认                                │   │
-│  │ - on_listening: 注视用户                             │   │
-│  │ - on_thinking: 抬头思考                              │   │
-│  │ - on_speaking: 说话时微动                            │   │
-│  │ - on_idle: 返回中立位置                              │   │
-│  └─────────────────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────────────────┘
-                              │
-                              │ ESPHome Protocol
-                              ▼
-┌─────────────────────────────────────────────────────────────┐
-│                    Home Assistant                           │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
-│  │ STT Engine  │  │ Intent      │  │ TTS Engine          │ │
-│  │             │  │ Processing  │  │                     │ │
-│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
-└─────────────────────────────────────────────────────────────┘
-```
-
-## 已完成功能
-
-### 核心功能
-- [x] ESPHome 协议服务器实现
-- [x] mDNS 服务发现（自动被 Home Assistant 发现）
-- [x] 本地唤醒词检测（microWakeWord）
-- [x] 音频流传输到 Home Assistant
-- [x] TTS 音频播放
-- [x] 停止词检测
-
-### Reachy Mini 集成
-- [x] 使用 Reachy Mini SDK 的麦克风输入
-- [x] 使用 Reachy Mini SDK 的扬声器输出
-- [x] 头部运动控制（点头、摇头、注视）
-- [x] 天线动画控制
-- [x] 语音状态反馈动作
-
-### 应用架构
-- [x] 符合 Reachy Mini App 架构
-- [x] 自动下载唤醒词模型
-- [x] 自动下载音效文件
-- [x] 无需 .env 配置文件
-
-## 文件清单
-
-```
-reachy_mini_ha_voice/
-├── reachy_mini_ha_voice/
-│   ├── __init__.py             # 包初始化
-│   ├── __main__.py             # 命令行入口
-│   ├── main.py                 # ReachyMiniApp 入口
-│   ├── voice_assistant.py      # 语音助手服务
-│   ├── satellite.py            # ESPHome 协议处理
-│   ├── audio_player.py         # 音频播放器
-│   ├── camera_server.py        # MJPEG 摄像头流服务器
-│   ├── motion.py               # 运动控制
-│   ├── models.py               # 数据模型
-│   ├── entity.py               # ESPHome 基础实体
-│   ├── entity_extensions.py    # 扩展实体类型
-│   ├── reachy_controller.py    # Reachy Mini 控制器包装
-│   ├── api_server.py           # API 服务器
-│   ├── zeroconf.py             # mDNS 发现
-│   └── util.py                 # 工具函数
-├── wakewords/                  # 唤醒词模型（自动下载）
-│   ├── okay_nabu.json
-│   ├── okay_nabu.tflite
-│   ├── hey_jarvis.json
-│   ├── hey_jarvis.tflite
-│   ├── stop.json
-│   └── stop.tflite
-├── sounds/                     # 音效文件（自动下载）
-│   ├── wake_word_triggered.flac
-│   └── timer_finished.flac
-├── pyproject.toml              # 项目配置
-├── README.md                   # 说明文档
-└── PROJECT_PLAN.md             # 项目计划
-```
-
-## 依赖项
-
-```toml
-dependencies = [
-    "reachy-mini",           # Reachy Mini SDK
-    "sounddevice>=0.4.6",    # 音频处理（备用）
-    "soundfile>=0.12.0",     # 音频文件读取
-    "numpy>=1.24.0",         # 数值计算
-    "pymicro-wakeword>=2.0.0,<3.0.0",  # 唤醒词检测
-    "pyopen-wakeword>=1.0.0,<2.0.0",   # 备用唤醒词
-    "aioesphomeapi>=42.0.0", # ESPHome 协议
-    "zeroconf>=0.100.0",     # mDNS 发现
-    "scipy>=1.10.0",         # 运动控制
-    "pydantic>=2.0.0",       # 数据验证
-]
-```
-
-## 使用流程
-
-1. **安装应用**
-   - 从 Reachy Mini App Store 安装
-   - 或 `pip install reachy-mini-ha-voice`
-
-2. **启动应用**
-   - 应用自动启动 ESPHome 服务器（端口 6053）
-   - 自动下载所需模型和音效
-
-3. **连接 Home Assistant**
-   - Home Assistant 自动发现设备（mDNS）
-   - 或手动添加：设置 → 设备与服务 → 添加集成 → ESPHome
-
-4. **使用语音助手**
-   - 说 "Okay Nabu" 唤醒
-   - 说出命令
-   - Reachy Mini 会做出运动反馈
-
-## ESPHome 实体规划
-
-基于 Reachy Mini SDK 深入分析，以下实体已暴露给 Home Assistant：
-
-### 已实现实体
-
-| 实体类型 | 名称 | 说明 |
-|---------|------|------|
-| Media Player | `media_player` | 音频播放控制 |
-| Voice Assistant | `voice_assistant` | 语音助手管道 |
-
-### 已实现的控制实体 (Controls) - 可读写
-
-#### Phase 1-3: 基础控制与姿态
-
-| ESPHome 实体类型 | 名称 | SDK API | 范围/选项 | 说明 |
-|-----------------|------|---------|----------|------|
-| `Number` | `speaker_volume` | `AudioPlayer.set_volume()` | 0-100 | 扬声器音量 |
-| `Select` | `motor_mode` | `set_motor_control_mode()` | enabled/disabled/gravity_compensation | 电机模式选择 |
-| `Switch` | `motors_enabled` | `enable_motors()` / `disable_motors()` | on/off | 电机扭矩开关 |
-| `Button` | `wake_up` | `mini.wake_up()` | - | 唤醒机器人动作 |
-| `Button` | `go_to_sleep` | `mini.goto_sleep()` | - | 睡眠机器人动作 |
-| `Number` | `head_x` | `goto_target(head=...)` | ±50mm | 头部 X 位置控制 |
-| `Number` | `head_y` | `goto_target(head=...)` | ±50mm | 头部 Y 位置控制 |
-| `Number` | `head_z` | `goto_target(head=...)` | ±50mm | 头部 Z 位置控制 |
-| `Number` | `head_roll` | `goto_target(head=...)` | -40° ~ +40° | 头部翻滚角控制 |
-| `Number` | `head_pitch` | `goto_target(head=...)` | -40° ~ +40° | 头部俯仰角控制 |
-| `Number` | `head_yaw` | `goto_target(head=...)` | -180° ~ +180° | 头部偏航角控制 |
-| `Number` | `body_yaw` | `goto_target(body_yaw=...)` | -160° ~ +160° | 身体偏航角控制 |
-| `Number` | `antenna_left` | `goto_target(antennas=...)` | -90° ~ +90° | 左天线角度控制 |
-| `Number` | `antenna_right` | `goto_target(antennas=...)` | -90° ~ +90° | 右天线角度控制 |
-
-#### Phase 4: 注视控制
-
-| ESPHome 实体类型 | 名称 | SDK API | 范围/选项 | 说明 |
-|-----------------|------|---------|----------|------|
-| `Number` | `look_at_x` | `look_at_world(x, y, z)` | 世界坐标 | 注视点 X 坐标 |
-| `Number` | `look_at_y` | `look_at_world(x, y, z)` | 世界坐标 | 注视点 Y 坐标 |
-| `Number` | `look_at_z` | `look_at_world(x, y, z)` | 世界坐标 | 注视点 Z 坐标 |
-
-### 已实现的传感器实体 (Sensors) - 只读
-
-#### Phase 1 & 5: 基础状态与音频传感器
-
-| ESPHome 实体类型 | 名称 | SDK API | 说明 |
-|-----------------|------|---------|------|
-| `Text Sensor` | `daemon_state` | `DaemonStatus.state` | Daemon 状态 |
-| `Binary Sensor` | `backend_ready` | `backend_status.ready` | 后端是否就绪 |
-| `Text Sensor` | `error_message` | `DaemonStatus.error` | 当前错误信息 |
-| `Sensor` | `doa_angle` | `DoAInfo.angle` | 声源方向角度 (°) |
-| `Binary Sensor` | `speech_detected` | `DoAInfo.speech_detected` | 是否检测到语音 |
-
-#### Phase 6: 诊断信息
-
-| ESPHome 实体类型 | 名称 | SDK API | 说明 |
-|-----------------|------|---------|------|
-| `Sensor` | `control_loop_frequency` | `control_loop_stats` | 控制循环频率 (Hz) |
-| `Text Sensor` | `sdk_version` | `DaemonStatus.version` | SDK 版本号 |
-| `Text Sensor` | `robot_name` | `DaemonStatus.robot_name` | 机器人名称 |
-| `Binary Sensor` | `wireless_version` | `DaemonStatus.wireless_version` | 是否为无线版本 |
-| `Binary Sensor` | `simulation_mode` | `DaemonStatus.simulation_enabled` | 是否在仿真模式 |
-| `Text Sensor` | `wlan_ip` | `DaemonStatus.wlan_ip` | 无线网络 IP |
-
-#### Phase 7: IMU 传感器 (仅无线版本)
-
-| ESPHome 实体类型 | 名称 | SDK API | 说明 |
-|-----------------|------|---------|------|
-| `Sensor` | `imu_accel_x` | `mini.imu["accelerometer"][0]` | X 轴加速度 (m/s²) |
-| `Sensor` | `imu_accel_y` | `mini.imu["accelerometer"][1]` | Y 轴加速度 (m/s²) |
-| `Sensor` | `imu_accel_z` | `mini.imu["accelerometer"][2]` | Z 轴加速度 (m/s²) |
-| `Sensor` | `imu_gyro_x` | `mini.imu["gyroscope"][0]` | X 轴角速度 (rad/s) |
-| `Sensor` | `imu_gyro_y` | `mini.imu["gyroscope"][1]` | Y 轴角速度 (rad/s) |
-| `Sensor` | `imu_gyro_z` | `mini.imu["gyroscope"][2]` | Z 轴角速度 (rad/s) |
-| `Sensor` | `imu_temperature` | `mini.imu["temperature"]` | IMU 温度 (°C) |
-
-#### Phase 8-12: 扩展功能
-
-| ESPHome 实体类型 | 名称 | 说明 |
-|-----------------|------|------|
-| `Select` | `emotion` | 表情选择器 (Happy/Sad/Angry/Fear/Surprise/Disgust) |
-| `Number` | `microphone_volume` | 麦克风音量 (0-100%) |
-| `Camera` | `camera` | ESPHome Camera 实体（实时预览） |
-| `Number` | `led_brightness` | LED 亮度 (0-100%) |
-| `Select` | `led_effect` | LED 效果 (off/solid/breathing/rainbow/doa) |
-| `Number` | `led_color_r` | LED 红色分量 (0-255) |
-| `Number` | `led_color_g` | LED 绿色分量 (0-255) |
-| `Number` | `led_color_b` | LED 蓝色分量 (0-255) |
-| `Switch` | `agc_enabled` | 自动增益控制开关 |
-| `Number` | `agc_max_gain` | AGC 最大增益 (0-30 dB) |
-| `Number` | `noise_suppression` | 噪声抑制级别 (0-100%) |
-| `Binary Sensor` | `echo_cancellation_converged` | 回声消除收敛状态 |
-
-> **注意**: 头部位置 (x/y/z) 和角度 (roll/pitch/yaw)、身体偏航角、天线角度都是**可控制**的实体，
-> 使用 `Number` 类型实现双向控制。设置新值时调用 `goto_target()`，读取当前值时调用 `get_current_head_pose()` 等。
-
-### 实现优先级
-
-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 - 注视控制** (中优先级) ✅ **已完成**
-   - [x] `look_at_x/y/z` - 注视点坐标控制
-
-5. **Phase 5 - 音频传感器** (低优先级) ✅ **已完成**
-   - [x] `doa_angle` - 声源方向
-   - [x] `speech_detected` - 语音检测
-
-6. **Phase 6 - 诊断信息** (低优先级) ✅ **已完成**
-   - [x] `control_loop_frequency` - 控制循环频率
-   - [x] `sdk_version` - SDK 版本
-   - [x] `robot_name` - 机器人名称
-   - [x] `wireless_version` - 无线版本标识
-   - [x] `simulation_mode` - 仿真模式标识
-   - [x] `wlan_ip` - 无线 IP 地址
-
-7. **Phase 7 - IMU 传感器** (可选，仅无线版本) ✅ **已完成**
-   - [x] `imu_accel_x/y/z` - 加速度计
-   - [x] `imu_gyro_x/y/z` - 陀螺仪
-   - [x] `imu_temperature` - IMU 温度
-
-8. **Phase 8 - 表情控制** ✅ **已完成**
-   - [x] `emotion` - 表情选择器 (Happy/Sad/Angry/Fear/Surprise/Disgust)
-
-9. **Phase 9 - 音频控制** ✅ **已完成**
-   - [x] `microphone_volume` - 麦克风音量控制 (0-100%)
-
-10. **Phase 10 - 摄像头集成** ✅ **已完成**
-    - [x] `camera` - ESPHome Camera 实体（实时预览）
-
-11. **Phase 11 - LED 控制** ✅ **已完成**
-    - [x] `led_brightness` - LED 亮度 (0-100%)
-    - [x] `led_effect` - LED 效果 (off/solid/breathing/rainbow/doa)
-    - [x] `led_color_r/g/b` - LED RGB 颜色 (0-255)
-
-12. **Phase 12 - 音频处理参数** ✅ **已完成**
-    - [x] `agc_enabled` - 自动增益控制开关
-    - [x] `agc_max_gain` - AGC 最大增益 (0-30 dB)
-    - [x] `noise_suppression` - 噪声抑制级别 (0-100%)
-    - [x] `echo_cancellation_converged` - 回声消除收敛状态（只读）
-
----
-
-## 🎉 所有实体已完成！
-
-**总计：45+ 个实体**
-- Phase 1: 4 个实体 (基础状态与音量)
-- Phase 2: 4 个实体 (电机控制)
-- Phase 3: 9 个实体 (姿态控制)
-- Phase 4: 3 个实体 (注视控制)
-- Phase 5: 2 个实体 (音频传感器)
-- Phase 6: 6 个实体 (诊断信息)
-- Phase 7: 7 个实体 (IMU 传感器)
-- Phase 8: 1 个实体 (表情控制)
-- Phase 9: 1 个实体 (麦克风音量)
-- Phase 10: 1 个实体 (摄像头)
-- Phase 11: 5 个实体 (LED 控制)
-- Phase 12: 4 个实体 (音频处理参数)
-
-### SDK 数据结构参考
-
-```python
-# 电机控制模式
-class MotorControlMode(str, Enum):
-    Enabled = "enabled"              # 扭矩开启，位置控制
-    Disabled = "disabled"            # 扭矩关闭
-    GravityCompensation = "gravity_compensation"  # 重力补偿模式
-
-# Daemon 状态
-class DaemonState(Enum):
-    NOT_INITIALIZED = "not_initialized"
-    STARTING = "starting"
-    RUNNING = "running"
-    STOPPING = "stopping"
-    STOPPED = "stopped"
-    ERROR = "error"
-
-# 完整状态
-class FullState:
-    control_mode: MotorControlMode
-    head_pose: XYZRPYPose  # x, y, z (m), roll, pitch, yaw (rad)
-    head_joints: list[float]  # 7 个关节角度
-    body_yaw: float
-    antennas_position: list[float]  # [right, left]
-    doa: DoAInfo  # angle (rad), speech_detected (bool)
-
-# IMU 数据 (仅无线版本)
-imu_data = {
-    "accelerometer": [x, y, z],  # m/s²
-    "gyroscope": [x, y, z],      # rad/s
-    "quaternion": [w, x, y, z],  # 姿态四元数
-    "temperature": float         # °C
-}
-
-# 安全限制
-HEAD_PITCH_ROLL_LIMIT = [-40°, +40°]
-HEAD_YAW_LIMIT = [-180°, +180°]
-BODY_YAW_LIMIT = [-160°, +160°]
-YAW_DELTA_MAX = 65°  # 头部与身体偏航角最大差值
-```
-
-### ESPHome 协议实现说明
-
-ESPHome 协议通过 protobuf 消息与 Home Assistant 通信。需要实现以下消息类型：
-
-```python
-from aioesphomeapi.api_pb2 import (
-    # Number 实体 (音量/角度控制)
-    ListEntitiesNumberResponse,
-    NumberStateResponse,
-    NumberCommandRequest,
-
-    # Select 实体 (电机模式)
-    ListEntitiesSelectResponse,
-    SelectStateResponse,
-    SelectCommandRequest,
-
-    # Button 实体 (唤醒/睡眠)
-    ListEntitiesButtonResponse,
-    ButtonCommandRequest,
-
-    # Switch 实体 (电机开关)
-    ListEntitiesSwitchResponse,
-    SwitchStateResponse,
-    SwitchCommandRequest,
-
-    # Sensor 实体 (数值传感器)
-    ListEntitiesSensorResponse,
-    SensorStateResponse,
-
-    # Binary Sensor 实体 (布尔传感器)
-    ListEntitiesBinarySensorResponse,
-    BinarySensorStateResponse,
-
-    # Text Sensor 实体 (文本传感器)
-    ListEntitiesTextSensorResponse,
-    TextSensorStateResponse,
-)
-```
-
-## 参考项目
-
-- [OHF-Voice/linux-voice-assistant](https://github.com/OHF-Voice/linux-voice-assistant)
-- [pollen-robotics/reachy_mini](https://github.com/pollen-robotics/reachy_mini)
+# Reachy Mini Home Assistant Voice Assistant - 项目计划
+
+## 项目概述
+
+将 Home Assistant 语音助手功能集成到 Reachy Mini 机器人，通过 ESPHome 协议与 Home Assistant 通信。
+
+## 本地项目目录参考 (禁止修改参考目录内任何文件)
+1. [linux-voice-assistant](linux-voice-assistant)
+2. [Reachy Mini SDK](reachy_mini)
+3. [reachy_mini_conversation_app](reachy_mini_conversation_app)
+4. [reachy-mini-desktop-app](reachy-mini-desktop-app)
+
+## 核心设计原则
+
+1. **零配置安装** - 用户只需安装应用，无需手动配置
+2. **使用 Reachy Mini 原生硬件** - 使用机器人自带的麦克风和扬声器
+3. **Home Assistant 集中管理** - 所有配置在 Home Assistant 端完成
+4. **运动反馈** - 语音交互时提供头部运动和天线动画反馈
+
+## 技术架构
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      Reachy Mini                            │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
+│  │ Microphone  │→ │ Wake Word   │→ │ ESPHome Protocol    │ │
+│  │ (ReSpeaker) │  │ Detection   │  │ Server (Port 6053)  │ │
+│  └─────────────┘  └─────────────┘  └──────────┬──────────┘ │
+│                                                │            │
+│  ┌─────────────┐  ┌─────────────┐             │            │
+│  │ Speaker     │← │ Audio       │←────────────┘            │
+│  │ (ReSpeaker) │  │ Player      │                          │
+│  └─────────────┘  └─────────────┘                          │
+│                                                             │
+│  ┌─────────────────────────────────────────────────────┐   │
+│  │ Motion Controller (Head + Antennas)                 │   │
+│  │ - on_wakeup: 点头确认                                │   │
+│  │ - on_listening: 注视用户                             │   │
+│  │ - on_thinking: 抬头思考                              │   │
+│  │ - on_speaking: 说话时微动                            │   │
+│  │ - on_idle: 返回中立位置                              │   │
+│  └─────────────────────────────────────────────────────┘   │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              │ ESPHome Protocol
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    Home Assistant                           │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
+│  │ STT Engine  │  │ Intent      │  │ TTS Engine          │ │
+│  │             │  │ Processing  │  │                     │ │
+│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## 已完成功能
+
+### 核心功能
+- [x] ESPHome 协议服务器实现
+- [x] mDNS 服务发现（自动被 Home Assistant 发现）
+- [x] 本地唤醒词检测（microWakeWord）
+- [x] 音频流传输到 Home Assistant
+- [x] TTS 音频播放
+- [x] 停止词检测
+
+### Reachy Mini 集成
+- [x] 使用 Reachy Mini SDK 的麦克风输入
+- [x] 使用 Reachy Mini SDK 的扬声器输出
+- [x] 头部运动控制（点头、摇头、注视）
+- [x] 天线动画控制
+- [x] 语音状态反馈动作
+
+### 应用架构
+- [x] 符合 Reachy Mini App 架构
+- [x] 自动下载唤醒词模型
+- [x] 自动下载音效文件
+- [x] 无需 .env 配置文件
+
+## 文件清单
+
+```
+reachy_mini_ha_voice/
+├── reachy_mini_ha_voice/
+│   ├── __init__.py             # 包初始化
+│   ├── __main__.py             # 命令行入口
+│   ├── main.py                 # ReachyMiniApp 入口
+│   ├── voice_assistant.py      # 语音助手服务
+│   ├── satellite.py            # ESPHome 协议处理
+│   ├── audio_player.py         # 音频播放器
+│   ├── camera_server.py        # MJPEG 摄像头流服务器
+│   ├── motion.py               # 运动控制
+│   ├── models.py               # 数据模型
+│   ├── entity.py               # ESPHome 基础实体
+│   ├── entity_extensions.py    # 扩展实体类型
+│   ├── reachy_controller.py    # Reachy Mini 控制器包装
+│   ├── api_server.py           # API 服务器
+│   ├── zeroconf.py             # mDNS 发现
+│   └── util.py                 # 工具函数
+├── wakewords/                  # 唤醒词模型（自动下载）
+│   ├── okay_nabu.json
+│   ├── okay_nabu.tflite
+│   ├── hey_jarvis.json
+│   ├── hey_jarvis.tflite
+│   ├── stop.json
+│   └── stop.tflite
+├── sounds/                     # 音效文件（自动下载）
+│   ├── wake_word_triggered.flac
+│   └── timer_finished.flac
+├── pyproject.toml              # 项目配置
+├── README.md                   # 说明文档
+└── PROJECT_PLAN.md             # 项目计划
+```
+
+## 依赖项
+
+```toml
+dependencies = [
+    "reachy-mini",           # Reachy Mini SDK
+    "sounddevice>=0.4.6",    # 音频处理（备用）
+    "soundfile>=0.12.0",     # 音频文件读取
+    "numpy>=1.24.0",         # 数值计算
+    "pymicro-wakeword>=2.0.0,<3.0.0",  # 唤醒词检测
+    "pyopen-wakeword>=1.0.0,<2.0.0",   # 备用唤醒词
+    "aioesphomeapi>=42.0.0", # ESPHome 协议
+    "zeroconf>=0.100.0",     # mDNS 发现
+    "scipy>=1.10.0",         # 运动控制
+    "pydantic>=2.0.0",       # 数据验证
+]
+```
+
+## 使用流程
+
+1. **安装应用**
+   - 从 Reachy Mini App Store 安装
+   - 或 `pip install reachy-mini-ha-voice`
+
+2. **启动应用**
+   - 应用自动启动 ESPHome 服务器（端口 6053）
+   - 自动下载所需模型和音效
+
+3. **连接 Home Assistant**
+   - Home Assistant 自动发现设备（mDNS）
+   - 或手动添加：设置 → 设备与服务 → 添加集成 → ESPHome
+
+4. **使用语音助手**
+   - 说 "Okay Nabu" 唤醒
+   - 说出命令
+   - Reachy Mini 会做出运动反馈
+
+## ESPHome 实体规划
+
+基于 Reachy Mini SDK 深入分析，以下实体已暴露给 Home Assistant：
+
+### 已实现实体
+
+| 实体类型 | 名称 | 说明 |
+|---------|------|------|
+| Media Player | `media_player` | 音频播放控制 |
+| Voice Assistant | `voice_assistant` | 语音助手管道 |
+
+### 已实现的控制实体 (Controls) - 可读写
+
+#### Phase 1-3: 基础控制与姿态
+
+| ESPHome 实体类型 | 名称 | SDK API | 范围/选项 | 说明 |
+|-----------------|------|---------|----------|------|
+| `Number` | `speaker_volume` | `AudioPlayer.set_volume()` | 0-100 | 扬声器音量 |
+| `Select` | `motor_mode` | `set_motor_control_mode()` | enabled/disabled/gravity_compensation | 电机模式选择 |
+| `Switch` | `motors_enabled` | `enable_motors()` / `disable_motors()` | on/off | 电机扭矩开关 |
+| `Button` | `wake_up` | `mini.wake_up()` | - | 唤醒机器人动作 |
+| `Button` | `go_to_sleep` | `mini.goto_sleep()` | - | 睡眠机器人动作 |
+| `Number` | `head_x` | `goto_target(head=...)` | ±50mm | 头部 X 位置控制 |
+| `Number` | `head_y` | `goto_target(head=...)` | ±50mm | 头部 Y 位置控制 |
+| `Number` | `head_z` | `goto_target(head=...)` | ±50mm | 头部 Z 位置控制 |
+| `Number` | `head_roll` | `goto_target(head=...)` | -40° ~ +40° | 头部翻滚角控制 |
+| `Number` | `head_pitch` | `goto_target(head=...)` | -40° ~ +40° | 头部俯仰角控制 |
+| `Number` | `head_yaw` | `goto_target(head=...)` | -180° ~ +180° | 头部偏航角控制 |
+| `Number` | `body_yaw` | `goto_target(body_yaw=...)` | -160° ~ +160° | 身体偏航角控制 |
+| `Number` | `antenna_left` | `goto_target(antennas=...)` | -90° ~ +90° | 左天线角度控制 |
+| `Number` | `antenna_right` | `goto_target(antennas=...)` | -90° ~ +90° | 右天线角度控制 |
+
+#### Phase 4: 注视控制
+
+| ESPHome 实体类型 | 名称 | SDK API | 范围/选项 | 说明 |
+|-----------------|------|---------|----------|------|
+| `Number` | `look_at_x` | `look_at_world(x, y, z)` | 世界坐标 | 注视点 X 坐标 |
+| `Number` | `look_at_y` | `look_at_world(x, y, z)` | 世界坐标 | 注视点 Y 坐标 |
+| `Number` | `look_at_z` | `look_at_world(x, y, z)` | 世界坐标 | 注视点 Z 坐标 |
+
+### 已实现的传感器实体 (Sensors) - 只读
+
+#### Phase 1 & 5: 基础状态与音频传感器
+
+| ESPHome 实体类型 | 名称 | SDK API | 说明 |
+|-----------------|------|---------|------|
+| `Text Sensor` | `daemon_state` | `DaemonStatus.state` | Daemon 状态 |
+| `Binary Sensor` | `backend_ready` | `backend_status.ready` | 后端是否就绪 |
+| `Text Sensor` | `error_message` | `DaemonStatus.error` | 当前错误信息 |
+| `Sensor` | `doa_angle` | `DoAInfo.angle` | 声源方向角度 (°) |
+| `Binary Sensor` | `speech_detected` | `DoAInfo.speech_detected` | 是否检测到语音 |
+
+#### Phase 6: 诊断信息
+
+| ESPHome 实体类型 | 名称 | SDK API | 说明 |
+|-----------------|------|---------|------|
+| `Sensor` | `control_loop_frequency` | `control_loop_stats` | 控制循环频率 (Hz) |
+| `Text Sensor` | `sdk_version` | `DaemonStatus.version` | SDK 版本号 |
+| `Text Sensor` | `robot_name` | `DaemonStatus.robot_name` | 机器人名称 |
+| `Binary Sensor` | `wireless_version` | `DaemonStatus.wireless_version` | 是否为无线版本 |
+| `Binary Sensor` | `simulation_mode` | `DaemonStatus.simulation_enabled` | 是否在仿真模式 |
+| `Text Sensor` | `wlan_ip` | `DaemonStatus.wlan_ip` | 无线网络 IP |
+
+#### Phase 7: IMU 传感器 (仅无线版本)
+
+| ESPHome 实体类型 | 名称 | SDK API | 说明 |
+|-----------------|------|---------|------|
+| `Sensor` | `imu_accel_x` | `mini.imu["accelerometer"][0]` | X 轴加速度 (m/s²) |
+| `Sensor` | `imu_accel_y` | `mini.imu["accelerometer"][1]` | Y 轴加速度 (m/s²) |
+| `Sensor` | `imu_accel_z` | `mini.imu["accelerometer"][2]` | Z 轴加速度 (m/s²) |
+| `Sensor` | `imu_gyro_x` | `mini.imu["gyroscope"][0]` | X 轴角速度 (rad/s) |
+| `Sensor` | `imu_gyro_y` | `mini.imu["gyroscope"][1]` | Y 轴角速度 (rad/s) |
+| `Sensor` | `imu_gyro_z` | `mini.imu["gyroscope"][2]` | Z 轴角速度 (rad/s) |
+| `Sensor` | `imu_temperature` | `mini.imu["temperature"]` | IMU 温度 (°C) |
+
+#### Phase 8-12: 扩展功能
+
+| ESPHome 实体类型 | 名称 | 说明 |
+|-----------------|------|------|
+| `Select` | `emotion` | 表情选择器 (Happy/Sad/Angry/Fear/Surprise/Disgust) |
+| `Number` | `microphone_volume` | 麦克风音量 (0-100%) |
+| `Camera` | `camera` | ESPHome Camera 实体（实时预览） |
+| `Number` | `led_brightness` | LED 亮度 (0-100%) |
+| `Select` | `led_effect` | LED 效果 (off/solid/breathing/rainbow/doa) |
+| `Number` | `led_color_r` | LED 红色分量 (0-255) |
+| `Number` | `led_color_g` | LED 绿色分量 (0-255) |
+| `Number` | `led_color_b` | LED 蓝色分量 (0-255) |
+| `Switch` | `agc_enabled` | 自动增益控制开关 |
+| `Number` | `agc_max_gain` | AGC 最大增益 (0-30 dB) |
+| `Number` | `noise_suppression` | 噪声抑制级别 (0-100%) |
+| `Binary Sensor` | `echo_cancellation_converged` | 回声消除收敛状态 |
+
+> **注意**: 头部位置 (x/y/z) 和角度 (roll/pitch/yaw)、身体偏航角、天线角度都是**可控制**的实体，
+> 使用 `Number` 类型实现双向控制。设置新值时调用 `goto_target()`，读取当前值时调用 `get_current_head_pose()` 等。
+
+### 实现优先级
+
+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 - 注视控制** (中优先级) ✅ **已完成**
+   - [x] `look_at_x/y/z` - 注视点坐标控制
+
+5. **Phase 5 - 音频传感器** (低优先级) ✅ **已完成**
+   - [x] `doa_angle` - 声源方向
+   - [x] `speech_detected` - 语音检测
+
+6. **Phase 6 - 诊断信息** (低优先级) ✅ **已完成**
+   - [x] `control_loop_frequency` - 控制循环频率
+   - [x] `sdk_version` - SDK 版本
+   - [x] `robot_name` - 机器人名称
+   - [x] `wireless_version` - 无线版本标识
+   - [x] `simulation_mode` - 仿真模式标识
+   - [x] `wlan_ip` - 无线 IP 地址
+
+7. **Phase 7 - IMU 传感器** (可选，仅无线版本) ✅ **已完成**
+   - [x] `imu_accel_x/y/z` - 加速度计
+   - [x] `imu_gyro_x/y/z` - 陀螺仪
+   - [x] `imu_temperature` - IMU 温度
+
+8. **Phase 8 - 表情控制** ✅ **已完成**
+   - [x] `emotion` - 表情选择器 (Happy/Sad/Angry/Fear/Surprise/Disgust)
+
+9. **Phase 9 - 音频控制** ✅ **已完成**
+   - [x] `microphone_volume` - 麦克风音量控制 (0-100%)
+
+10. **Phase 10 - 摄像头集成** ✅ **已完成**
+    - [x] `camera` - ESPHome Camera 实体（实时预览）
+
+11. **Phase 11 - LED 控制** ✅ **已完成**
+    - [x] `led_brightness` - LED 亮度 (0-100%)
+    - [x] `led_effect` - LED 效果 (off/solid/breathing/rainbow/doa)
+    - [x] `led_color_r/g/b` - LED RGB 颜色 (0-255)
+
+12. **Phase 12 - 音频处理参数** ✅ **已完成**
+    - [x] `agc_enabled` - 自动增益控制开关
+    - [x] `agc_max_gain` - AGC 最大增益 (0-30 dB)
+    - [x] `noise_suppression` - 噪声抑制级别 (0-100%)
+    - [x] `echo_cancellation_converged` - 回声消除收敛状态（只读）
+
+---
+
+## 🎉 所有实体已完成！
+
+**总计：45+ 个实体**
+- Phase 1: 4 个实体 (基础状态与音量)
+- Phase 2: 4 个实体 (电机控制)
+- Phase 3: 9 个实体 (姿态控制)
+- Phase 4: 3 个实体 (注视控制)
+- Phase 5: 2 个实体 (音频传感器)
+- Phase 6: 6 个实体 (诊断信息)
+- Phase 7: 7 个实体 (IMU 传感器)
+- Phase 8: 1 个实体 (表情控制)
+- Phase 9: 1 个实体 (麦克风音量)
+- Phase 10: 1 个实体 (摄像头)
+- Phase 11: 5 个实体 (LED 控制)
+- Phase 12: 4 个实体 (音频处理参数)
+
+### SDK 数据结构参考
+
+```python
+# 电机控制模式
+class MotorControlMode(str, Enum):
+    Enabled = "enabled"              # 扭矩开启，位置控制
+    Disabled = "disabled"            # 扭矩关闭
+    GravityCompensation = "gravity_compensation"  # 重力补偿模式
+
+# Daemon 状态
+class DaemonState(Enum):
+    NOT_INITIALIZED = "not_initialized"
+    STARTING = "starting"
+    RUNNING = "running"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+    ERROR = "error"
+
+# 完整状态
+class FullState:
+    control_mode: MotorControlMode
+    head_pose: XYZRPYPose  # x, y, z (m), roll, pitch, yaw (rad)
+    head_joints: list[float]  # 7 个关节角度
+    body_yaw: float
+    antennas_position: list[float]  # [right, left]
+    doa: DoAInfo  # angle (rad), speech_detected (bool)
+
+# IMU 数据 (仅无线版本)
+imu_data = {
+    "accelerometer": [x, y, z],  # m/s²
+    "gyroscope": [x, y, z],      # rad/s
+    "quaternion": [w, x, y, z],  # 姿态四元数
+    "temperature": float         # °C
+}
+
+# 安全限制
+HEAD_PITCH_ROLL_LIMIT = [-40°, +40°]
+HEAD_YAW_LIMIT = [-180°, +180°]
+BODY_YAW_LIMIT = [-160°, +160°]
+YAW_DELTA_MAX = 65°  # 头部与身体偏航角最大差值
+```
+
+### ESPHome 协议实现说明
+
+ESPHome 协议通过 protobuf 消息与 Home Assistant 通信。需要实现以下消息类型：
+
+```python
+from aioesphomeapi.api_pb2 import (
+    # Number 实体 (音量/角度控制)
+    ListEntitiesNumberResponse,
+    NumberStateResponse,
+    NumberCommandRequest,
+
+    # Select 实体 (电机模式)
+    ListEntitiesSelectResponse,
+    SelectStateResponse,
+    SelectCommandRequest,
+
+    # Button 实体 (唤醒/睡眠)
+    ListEntitiesButtonResponse,
+    ButtonCommandRequest,
+
+    # Switch 实体 (电机开关)
+    ListEntitiesSwitchResponse,
+    SwitchStateResponse,
+    SwitchCommandRequest,
+
+    # Sensor 实体 (数值传感器)
+    ListEntitiesSensorResponse,
+    SensorStateResponse,
+
+    # Binary Sensor 实体 (布尔传感器)
+    ListEntitiesBinarySensorResponse,
+    BinarySensorStateResponse,
+
+    # Text Sensor 实体 (文本传感器)
+    ListEntitiesTextSensorResponse,
+    TextSensorStateResponse,
+)
+```
+
+## 参考项目
+
+- [OHF-Voice/linux-voice-assistant](https://github.com/OHF-Voice/linux-voice-assistant)
+- [pollen-robotics/reachy_mini](https://github.com/pollen-robotics/reachy_mini)

README.md

@@ -1,203 +1,199 @@
----
-title: Reachy Mini HA Voice
-emoji: 🤖
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: "5.9.1"
-app_file: app.py
-pinned: false
----
-
-# Reachy Mini Home Assistant Voice Assistant
-
-A voice assistant application for **Reachy Mini robot** that integrates with Home Assistant via ESPHome protocol.
-
-> **Note**: This is a Reachy Mini App, not a Hugging Face Space. Install it on your Reachy Mini robot.
-
-## Features
-
-- **Local Wake Word Detection**: Uses microWakeWord for offline wake word detection
-- **ESPHome Integration**: Seamlessly connects to Home Assistant
-- **Camera Streaming**: MJPEG video stream for Home Assistant Generic Camera integration
-- **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 30+ 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
-  - Look-at target control
-  - Audio sensors (DOA, speech detection)
-  - System diagnostics and monitoring
-  - IMU sensors (wireless version only)
-
-## Requirements
-
-- Reachy Mini robot (with reachy-mini SDK)
-- Home Assistant with ESPHome integration
-- Python 3.10+
-
-## Installation
-
-Install from Reachy Mini App Store or manually:
-
-```bash
-pip install reachy-mini-ha-voice
-```
-
-## Usage
-
-The app runs automatically when installed on Reachy Mini. After installation:
-
-1. Open Home Assistant
-2. Go to **Settings** -> **Devices & Services** -> **Add Integration**
-3. Search for **ESPHome**
-4. Enter your Reachy Mini's IP address with port `6053`
-5. The voice assistant will be automatically discovered
-
-### Camera Setup
-
-The camera stream is available at `http://<reachy-mini-ip>:8081/stream`. To add it to Home Assistant:
-
-1. Go to **Settings** -> **Devices & Services** -> **Add Integration**
-2. Search for **Generic Camera**
-3. Enter the stream URL: `http://<reachy-mini-ip>:8081/stream`
-4. Set content type to `image/jpeg`
-
-You can also access:
-- **Live Stream**: `http://<reachy-mini-ip>:8081/stream` - MJPEG video stream
-- **Snapshot**: `http://<reachy-mini-ip>:8081/snapshot` - Single JPEG image
-- **Status Page**: `http://<reachy-mini-ip>:8081/` - Web interface with stream preview
-
-### Wake Words
-
-Default wake word: **"Okay Nabu"**
-
-Additional wake words can be configured through Home Assistant.
-
-## ESPHome Entities
-
-This application exposes 45+ entities to Home Assistant for complete robot control:
-
-### Status & Control (Phase 1)
-- **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 (Phase 2)
-- **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 (Phase 3)
-- **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°)
-
-### Look At Control (Phase 4)
-- **Look At X/Y/Z** - Point head at world coordinates
-
-### Audio Sensors (Phase 5)
-- **DOA Angle** - Direction of arrival angle
-- **Speech Detected** - Real-time speech detection
-
-### Diagnostics (Phase 6)
-- **Control Loop Frequency** - Monitor control loop performance
-- **SDK Version** - View SDK version
-- **Robot Name** - Robot identifier
-- **Wireless Version** - Check if wireless version
-- **Simulation Mode** - Check if in simulation
-- **WLAN IP** - Wireless network IP address
-
-### IMU Sensors (Phase 7 - Wireless only)
-- **Accelerometer** - X/Y/Z acceleration (m/s²)
-- **Gyroscope** - X/Y/Z angular velocity (rad/s)
-- **Temperature** - IMU temperature (°C)
-
-### Emotion Control (Phase 8)
-- **Emotion** - Select emotion (Happy/Sad/Angry/Fear/Surprise/Disgust)
-
-### Audio Control (Phase 9)
-- **Microphone Volume** - Control microphone input level (0-100%)
-
-### Camera (Phase 10)
-- **Camera** - ESPHome Camera entity with live preview in Home Assistant
-
-### LED Control (Phase 11)
-- **LED Brightness** - Control LED brightness (0-100%)
-- **LED Effect** - Select LED effect (off/solid/breathing/rainbow/doa)
-- **LED Color R/G/B** - Control LED color (0-255 per channel)
-
-### Audio Processing (Phase 12)
-- **AGC Enabled** - Toggle automatic gain control
-- **AGC Max Gain** - Set maximum AGC gain (0-30 dB)
-- **Noise Suppression** - Set noise suppression level (0-100%)
-- **Echo Cancellation Converged** - Monitor echo cancellation status
-
-## How It Works
-
-```
-[Reachy Mini Microphone] -> [Local Wake Word Detection] -> [ESPHome Protocol]
-                                                                  |
-                                                                  v
-[Reachy Mini Speaker] <- [TTS Response] <- [Home Assistant STT/TTS]
-        |
-        v
-[Head Motion & Antenna Animation]
-
-[Reachy Mini Camera] -> [MJPEG Server :8081] -> [Home Assistant Generic Camera]
-```
-
-- **Wake word detection** runs locally on Reachy Mini
-- **Speech-to-Text (STT)** and **Text-to-Speech (TTS)** are handled by Home Assistant
-- **Motion feedback** provides visual response during voice interaction
-- **Camera streaming** provides real-time video feed to Home Assistant
-
-## Project Structure
-
-```
-reachy_mini_ha_voice/
-├── reachy_mini_ha_voice/
-│   ├── __init__.py
-│   ├── __main__.py          # CLI entry point
-│   ├── main.py              # App entry point
-│   ├── voice_assistant.py   # Voice assistant service
-│   ├── camera_server.py     # MJPEG camera streaming server
-│   ├── satellite.py         # ESPHome protocol handler
-│   ├── audio_player.py      # Audio playback
-│   ├── motion.py            # Motion control
-│   ├── models.py            # Data models
-│   ├── entity.py            # ESPHome base entities
-│   ├── entity_extensions.py # Extended entity types
-│   ├── reachy_controller.py # Reachy Mini controller wrapper
-│   ├── api_server.py        # API server
-│   ├── zeroconf.py          # mDNS discovery
-│   └── util.py              # Utilities
-├── wakewords/               # Wake word models (auto-downloaded)
-├── sounds/                  # Sound effects (auto-downloaded)
-├── pyproject.toml
-├── README.md
-└── PROJECT_PLAN.md
-```
-
-## Dependencies
-
-- `reachy-mini` - Reachy Mini SDK
-- `aioesphomeapi` - ESPHome protocol
-- `pymicro-wakeword` - Wake word detection
-- `opencv-python` - Camera streaming
-- `sounddevice` / `soundfile` - Audio processing
-- `zeroconf` - mDNS discovery
-
-## License
-
-Apache 2.0 License
-
-## Acknowledgments
-
-- [OHF-Voice/linux-voice-assistant](https://github.com/OHF-Voice/linux-voice-assistant) - Original ESPHome voice assistant
-- [Pollen Robotics](https://www.pollen-robotics.com/) - Reachy Mini robot
+---
+title: Reachy Mini Home Assistant Voice Assistant
+tags:
+  - reachy_mini
+  - reachy_mini_python_app
+---
+
+# Reachy Mini Home Assistant Voice Assistant
+
+A voice assistant application for **Reachy Mini robot** that integrates with Home Assistant via ESPHome protocol.
+
+> **Note**: This is a Reachy Mini App, not a Hugging Face Space. Install it on your Reachy Mini robot.
+
+## Features
+
+- **Local Wake Word Detection**: Uses microWakeWord for offline wake word detection
+- **ESPHome Integration**: Seamlessly connects to Home Assistant
+- **Camera Streaming**: MJPEG video stream for Home Assistant Generic Camera integration
+- **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 30+ 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
+  - Look-at target control
+  - Audio sensors (DOA, speech detection)
+  - System diagnostics and monitoring
+  - IMU sensors (wireless version only)
+
+## Requirements
+
+- Reachy Mini robot (with reachy-mini SDK)
+- Home Assistant with ESPHome integration
+- Python 3.10+
+
+## Installation
+
+Install from Reachy Mini App Store or manually:
+
+```bash
+pip install reachy-mini-ha-voice
+```
+
+## Usage
+
+The app runs automatically when installed on Reachy Mini. After installation:
+
+1. Open Home Assistant
+2. Go to **Settings** -> **Devices & Services** -> **Add Integration**
+3. Search for **ESPHome**
+4. Enter your Reachy Mini's IP address with port `6053`
+5. The voice assistant will be automatically discovered
+
+### Camera Setup
+
+The camera stream is available at `http://<reachy-mini-ip>:8081/stream`. To add it to Home Assistant:
+
+1. Go to **Settings** -> **Devices & Services** -> **Add Integration**
+2. Search for **Generic Camera**
+3. Enter the stream URL: `http://<reachy-mini-ip>:8081/stream`
+4. Set content type to `image/jpeg`
+
+You can also access:
+- **Live Stream**: `http://<reachy-mini-ip>:8081/stream` - MJPEG video stream
+- **Snapshot**: `http://<reachy-mini-ip>:8081/snapshot` - Single JPEG image
+- **Status Page**: `http://<reachy-mini-ip>:8081/` - Web interface with stream preview
+
+### Wake Words
+
+Default wake word: **"Okay Nabu"**
+
+Additional wake words can be configured through Home Assistant.
+
+## ESPHome Entities
+
+This application exposes 45+ entities to Home Assistant for complete robot control:
+
+### Status & Control (Phase 1)
+- **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 (Phase 2)
+- **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 (Phase 3)
+- **Head Position** - Control X/Y/Z position (+/-50mm)
+- **Head Orientation** - Control roll/pitch/yaw angles
+- **Body Yaw** - Rotate body (+/-160 degrees)
+- **Antennas** - Control left/right antenna angles (+/-90 degrees)
+
+### Look At Control (Phase 4)
+- **Look At X/Y/Z** - Point head at world coordinates
+
+### Audio Sensors (Phase 5)
+- **DOA Angle** - Direction of arrival angle
+- **Speech Detected** - Real-time speech detection
+
+### Diagnostics (Phase 6)
+- **Control Loop Frequency** - Monitor control loop performance
+- **SDK Version** - View SDK version
+- **Robot Name** - Robot identifier
+- **Wireless Version** - Check if wireless version
+- **Simulation Mode** - Check if in simulation
+- **WLAN IP** - Wireless network IP address
+
+### IMU Sensors (Phase 7 - Wireless only)
+- **Accelerometer** - X/Y/Z acceleration (m/s^2)
+- **Gyroscope** - X/Y/Z angular velocity (rad/s)
+- **Temperature** - IMU temperature (degrees Celsius)
+
+### Emotion Control (Phase 8)
+- **Emotion** - Select emotion (Happy/Sad/Angry/Fear/Surprise/Disgust)
+
+### Audio Control (Phase 9)
+- **Microphone Volume** - Control microphone input level (0-100%)
+
+### Camera (Phase 10)
+- **Camera** - ESPHome Camera entity with live preview in Home Assistant
+
+### LED Control (Phase 11)
+- **LED Brightness** - Control LED brightness (0-100%)
+- **LED Effect** - Select LED effect (off/solid/breathing/rainbow/doa)
+- **LED Color R/G/B** - Control LED color (0-255 per channel)
+
+### Audio Processing (Phase 12)
+- **AGC Enabled** - Toggle automatic gain control
+- **AGC Max Gain** - Set maximum AGC gain (0-30 dB)
+- **Noise Suppression** - Set noise suppression level (0-100%)
+- **Echo Cancellation Converged** - Monitor echo cancellation status
+
+## How It Works
+
+```
+[Reachy Mini Microphone] -> [Local Wake Word Detection] -> [ESPHome Protocol]
+                                                                  |
+                                                                  v
+[Reachy Mini Speaker] <- [TTS Response] <- [Home Assistant STT/TTS]
+        |
+        v
+[Head Motion & Antenna Animation]
+
+[Reachy Mini Camera] -> [MJPEG Server :8081] -> [Home Assistant Generic Camera]
+```
+
+- **Wake word detection** runs locally on Reachy Mini
+- **Speech-to-Text (STT)** and **Text-to-Speech (TTS)** are handled by Home Assistant
+- **Motion feedback** provides visual response during voice interaction
+- **Camera streaming** provides real-time video feed to Home Assistant
+
+## Project Structure
+
+```
+reachy_mini_ha_voice/
+|-- reachy_mini_ha_voice/
+|   |-- __init__.py
+|   |-- __main__.py          # CLI entry point
+|   |-- main.py              # App entry point
+|   |-- voice_assistant.py   # Voice assistant service
+|   |-- camera_server.py     # MJPEG camera streaming server
+|   |-- satellite.py         # ESPHome protocol handler
+|   |-- audio_player.py      # Audio playback
+|   |-- motion.py            # Motion control
+|   |-- models.py            # Data models
+|   |-- entity.py            # ESPHome base entities
+|   |-- entity_extensions.py # Extended entity types
+|   |-- reachy_controller.py # Reachy Mini controller wrapper
+|   |-- api_server.py        # API server
+|   |-- zeroconf.py          # mDNS discovery
+|   |-- util.py              # Utilities
+|   |-- wakewords/           # Wake word models (auto-downloaded)
+|   |-- sounds/              # Sound effects (auto-downloaded)
+|   |-- pyproject.toml
+|   |-- README.md
+|   +-- PROJECT_PLAN.md
+```
+
+## Dependencies
+
+- `reachy-mini` - Reachy Mini SDK
+- `aioesphomeapi` - ESPHome protocol
+- `pymicro-wakeword` - Wake word detection
+- `opencv-python` - Camera streaming
+- `sounddevice` / `soundfile` - Audio processing
+- `zeroconf` - mDNS discovery
+
+## License
+
+Apache 2.0 License
+
+## Acknowledgments
+
+- [OHF-Voice/linux-voice-assistant](https://github.com/OHF-Voice/linux-voice-assistant) - Original ESPHome voice assistant
+- [Pollen Robotics](https://www.pollen-robotics.com/) - Reachy Mini robot

app.py

@@ -1,50 +1,50 @@
-"""
-Hugging Face Space placeholder.
-
-This is a Reachy Mini App, not a Hugging Face Space.
-Install it on your Reachy Mini robot from the App Store.
-"""
-
-import gradio as gr
-
-with gr.Blocks(title="Reachy Mini HA Voice") as demo:
-    gr.Markdown("""
-    # 🤖 Reachy Mini Home Assistant Voice Assistant
-
-    **This is a Reachy Mini App, not a Hugging Face Space.**
-
-    ## Installation
-
-    Install this app directly from your **Reachy Mini Dashboard**:
-
-    1. Open Reachy Mini Dashboard in your browser
-    2. Go to **Apps** section
-    3. Find **Reachy Mini HA Voice** and click **Install**
-
-    ## Features
-
-    - **Local Wake Word Detection**: Uses microWakeWord for offline wake word detection
-    - **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
-
-    ## Usage
-
-    After installation on Reachy Mini:
-
-    1. Open Home Assistant
-    2. Go to **Settings** → **Devices & Services** → **Add Integration**
-    3. Search for **ESPHome**
-    4. Enter your Reachy Mini's IP address with port `6053`
-
-    Default wake word: **"Okay Nabu"**
-
-    ## Links
-
-    - [Source Code](https://huggingface.co/spaces/djhui5710/reachy_mini_ha_voice/tree/main)
-    - [OHF-Voice/linux-voice-assistant](https://github.com/OHF-Voice/linux-voice-assistant)
-    - [Pollen Robotics](https://www.pollen-robotics.com/)
-    """)
-
-if __name__ == "__main__":
-    demo.launch()
+"""
+Hugging Face Space placeholder.
+
+This is a Reachy Mini App, not a Hugging Face Space.
+Install it on your Reachy Mini robot from the App Store.
+"""
+
+import gradio as gr
+
+with gr.Blocks(title="Reachy Mini HA Voice") as demo:
+    gr.Markdown("""
+    # 🤖 Reachy Mini Home Assistant Voice Assistant
+
+    **This is a Reachy Mini App, not a Hugging Face Space.**
+
+    ## Installation
+
+    Install this app directly from your **Reachy Mini Dashboard**:
+
+    1. Open Reachy Mini Dashboard in your browser
+    2. Go to **Apps** section
+    3. Find **Reachy Mini HA Voice** and click **Install**
+
+    ## Features
+
+    - **Local Wake Word Detection**: Uses microWakeWord for offline wake word detection
+    - **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
+
+    ## Usage
+
+    After installation on Reachy Mini:
+
+    1. Open Home Assistant
+    2. Go to **Settings** → **Devices & Services** → **Add Integration**
+    3. Search for **ESPHome**
+    4. Enter your Reachy Mini's IP address with port `6053`
+
+    Default wake word: **"Okay Nabu"**
+
+    ## Links
+
+    - [Source Code](https://huggingface.co/spaces/djhui5710/reachy_mini_ha_voice/tree/main)
+    - [OHF-Voice/linux-voice-assistant](https://github.com/OHF-Voice/linux-voice-assistant)
+    - [Pollen Robotics](https://www.pollen-robotics.com/)
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

index.html

@@ -0,0 +1,40 @@
+<!doctype html>
+<html>
+
+<head>
+	<meta charset="utf-8" />
+	<meta name="viewport" content="width=device-width" />
+	<title> Reachy Mini Ha Voice </title>
+	<link rel="stylesheet" href="style.css" />
+</head>
+
+<body>
+	<div class="hero">
+		<div class="hero-content">
+			<div class="app-icon">🤖⚡</div>
+			<h1> Reachy Mini Ha Voice </h1>
+			<p class="tagline">Enter your tagline here</p>
+		</div>
+	</div>
+
+	<div class="container">
+		<div class="main-card">
+			<div class="app-preview">
+				<div class="preview-image">
+					<div class="camera-feed">🛠️</div>
+				</div>
+			</div>
+		</div>
+	</div>
+
+	<div class="footer">
+		<p>
+			🤖 Reachy Mini Ha Voice •
+			<a href="https://github.com/pollen-robotics" target="_blank">Pollen Robotics</a> •
+			<a href="https://huggingface.co/spaces/pollen-robotics/reachy-mini-landing-page#apps" target="_blank">Browse More
+				Apps</a>
+		</p>
+	</div>
+</body>
+
+</html>

linux-voice-assistant

@@ -1 +0,0 @@
-Subproject commit fd4c1d972bc87e6d7a0dddc5aa52465243d63265

pyproject.toml

@@ -1,49 +1,49 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "reachy_mini_ha_voice"
-version = "0.1.0"
-description = "Home Assistant Voice Assistant for Reachy Mini"
-readme = "README.md"
-requires-python = ">=3.10"
-license = {text = "Apache-2.0"}
-dependencies = [
-    # Reachy Mini SDK (provides audio via media system)
-    "reachy-mini",
-
-    # Audio processing (fallback when not on Reachy Mini)
-    "sounddevice>=0.4.6",
-    "soundfile>=0.12.0",
-    "numpy>=1.24.0",
-
-    # Camera streaming
-    "opencv-python>=4.8.0",
-
-    # Wake word detection (local)
-    # STT/TTS is handled by Home Assistant, not locally
-    "pymicro-wakeword>=2.0.0,<3.0.0",
-    "pyopen-wakeword>=1.0.0,<2.0.0",
-
-    # ESPHome protocol (communication with Home Assistant)
-    "aioesphomeapi>=42.0.0",
-    "zeroconf>=0.100.0",
-
-    # Motion control (head movements)
-    "scipy>=1.10.0",
-]
-keywords = ["reachy-mini-app", "reachy-mini", "home-assistant", "voice-assistant"]
-
-[project.entry-points."reachy_mini_apps"]
-reachy_mini_ha_voice = "reachy_mini_ha_voice.main:ReachyMiniHAVoiceApp"
-
-[tool.setuptools]
-package-dir = { "" = "." }
-include-package-data = true
-
-[tool.setuptools.packages.find]
-where = ["."]
-
-[tool.setuptools.package-data]
-"*" = ["*.json", "*.flac", "*.md", "*.tflite"]
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reachy_mini_ha_voice"
+version = "0.1.0"
+description = "Home Assistant Voice Assistant for Reachy Mini"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+dependencies = [
+    # Reachy Mini SDK (provides audio via media system)
+    "reachy-mini",
+
+    # Audio processing (fallback when not on Reachy Mini)
+    "sounddevice>=0.4.6",
+    "soundfile>=0.12.0",
+    "numpy>=1.24.0",
+
+    # Camera streaming
+    "opencv-python>=4.8.0",
+
+    # Wake word detection (local)
+    # STT/TTS is handled by Home Assistant, not locally
+    "pymicro-wakeword>=2.0.0,<3.0.0",
+    "pyopen-wakeword>=1.0.0,<2.0.0",
+
+    # ESPHome protocol (communication with Home Assistant)
+    "aioesphomeapi>=42.0.0",
+    "zeroconf>=0.100.0",
+
+    # Motion control (head movements)
+    "scipy>=1.10.0",
+]
+keywords = ["reachy-mini-app", "reachy-mini", "home-assistant", "voice-assistant"]
+
+[project.entry-points."reachy_mini_apps"]
+reachy_mini_ha_voice = "reachy_mini_ha_voice.main:ReachyMiniHaVoice"
+
+[tool.setuptools]
+package-dir = { "" = "." }
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+
+[tool.setuptools.package-data]
+"*" = ["*.json", "*.flac", "*.md", "*.tflite"]

reachy_mini_conversation_app

@@ -1 +0,0 @@
-Subproject commit fc5123651cf50582d2b073b1779b37c26232e5cc

reachy_mini_ha_voice/__init__.py

@@ -1,22 +1,22 @@
-"""
-Reachy Mini Home Assistant Voice Assistant
-
-A voice assistant application that runs on Reachy Mini robot and integrates
-with Home Assistant via the ESPHome protocol.
-
-Key features:
-- Local wake word detection (microWakeWord/openWakeWord)
-- ESPHome protocol for Home Assistant integration
-- STT/TTS handled by Home Assistant (not locally)
-- Reachy Mini motion control integration
-"""
-
-__version__ = "0.1.0"
-__author__ = "Pollen Robotics"
-
-# Don't import main module here to avoid runpy warning
-# The app is loaded via entry point: reachy_mini_ha_voice.main:ReachyMiniHAVoiceApp
-
-__all__ = [
-    "__version__",
-]
+"""
+Reachy Mini Home Assistant Voice Assistant
+
+A voice assistant application that runs on Reachy Mini robot and integrates
+with Home Assistant via the ESPHome protocol.
+
+Key features:
+- Local wake word detection (microWakeWord/openWakeWord)
+- ESPHome protocol for Home Assistant integration
+- STT/TTS handled by Home Assistant (not locally)
+- Reachy Mini motion control integration
+"""
+
+__version__ = "0.1.0"
+__author__ = "Pollen Robotics"
+
+# Don't import main module here to avoid runpy warning
+# The app is loaded via entry point: reachy_mini_ha_voice.main:ReachyMiniHAVoiceApp
+
+__all__ = [
+    "__version__",
+]

reachy_mini_ha_voice/camera_server.py

@@ -1,365 +1,365 @@
-"""
-MJPEG Camera Server for Reachy Mini.
-
-This module provides an HTTP server that streams camera frames from Reachy Mini
-as MJPEG, which can be integrated with Home Assistant via Generic Camera.
-"""
-
-import asyncio
-import logging
-import threading
-import time
-from typing import Optional, TYPE_CHECKING
-
-import cv2
-import numpy as np
-
-if TYPE_CHECKING:
-    from reachy_mini import ReachyMini
-
-_LOGGER = logging.getLogger(__name__)
-
-# MJPEG boundary string
-MJPEG_BOUNDARY = "frame"
-
-
-class MJPEGCameraServer:
-    """
-    MJPEG streaming server for Reachy Mini camera.
-
-    Provides HTTP endpoints:
-    - /stream - MJPEG video stream
-    - /snapshot - Single JPEG image
-    - / - Simple status page
-    """
-
-    def __init__(
-        self,
-        reachy_mini: Optional["ReachyMini"] = None,
-        host: str = "0.0.0.0",
-        port: int = 8081,
-        fps: int = 15,
-        quality: int = 80,
-    ):
-        """
-        Initialize the MJPEG camera server.
-
-        Args:
-            reachy_mini: Reachy Mini robot instance (can be None for testing)
-            host: Host address to bind to
-            port: Port number for the HTTP server
-            fps: Target frames per second for the stream
-            quality: JPEG quality (1-100)
-        """
-        self.reachy_mini = reachy_mini
-        self.host = host
-        self.port = port
-        self.fps = fps
-        self.quality = quality
-
-        self._server: Optional[asyncio.Server] = None
-        self._running = False
-        self._frame_interval = 1.0 / fps
-        self._last_frame: Optional[bytes] = None
-        self._last_frame_time: float = 0
-        self._frame_lock = threading.Lock()
-
-        # Frame capture thread
-        self._capture_thread: Optional[threading.Thread] = None
-
-    async def start(self) -> None:
-        """Start the MJPEG camera server."""
-        if self._running:
-            _LOGGER.warning("Camera server already running")
-            return
-
-        self._running = True
-
-        # Start frame capture thread
-        self._capture_thread = threading.Thread(
-            target=self._capture_frames,
-            daemon=True,
-            name="camera-capture"
-        )
-        self._capture_thread.start()
-
-        # Start HTTP server
-        self._server = await asyncio.start_server(
-            self._handle_client,
-            self.host,
-            self.port,
-        )
-
-        _LOGGER.info("MJPEG Camera server started on http://%s:%d", self.host, self.port)
-        _LOGGER.info("  Stream URL: http://<ip>:%d/stream", self.port)
-        _LOGGER.info("  Snapshot URL: http://<ip>:%d/snapshot", self.port)
-
-    async def stop(self) -> None:
-        """Stop the MJPEG camera server."""
-        self._running = False
-
-        if self._capture_thread:
-            self._capture_thread.join(timeout=2.0)
-            self._capture_thread = None
-
-        if self._server:
-            self._server.close()
-            await self._server.wait_closed()
-            self._server = None
-
-        _LOGGER.info("MJPEG Camera server stopped")
-
-    def _capture_frames(self) -> None:
-        """Background thread to capture frames from Reachy Mini."""
-        _LOGGER.info("Starting camera capture thread")
-
-        while self._running:
-            try:
-                frame = self._get_camera_frame()
-
-                if frame is not None:
-                    # Encode frame as JPEG
-                    encode_params = [cv2.IMWRITE_JPEG_QUALITY, self.quality]
-                    success, jpeg_data = cv2.imencode('.jpg', frame, encode_params)
-
-                    if success:
-                        with self._frame_lock:
-                            self._last_frame = jpeg_data.tobytes()
-                            self._last_frame_time = time.time()
-
-                # Sleep to maintain target FPS
-                time.sleep(self._frame_interval)
-
-            except Exception as e:
-                _LOGGER.error("Error capturing frame: %s", e)
-                time.sleep(0.5)
-
-        _LOGGER.info("Camera capture thread stopped")
-
-    def _get_camera_frame(self) -> Optional[np.ndarray]:
-        """Get a frame from Reachy Mini's camera."""
-        if self.reachy_mini is None:
-            # Return a test pattern if no robot connected
-            return self._generate_test_frame()
-
-        try:
-            frame = self.reachy_mini.media.get_frame()
-            return frame
-        except Exception as e:
-            _LOGGER.debug("Failed to get camera frame: %s", e)
-            return None
-
-    def _generate_test_frame(self) -> np.ndarray:
-        """Generate a test pattern frame when no camera is available."""
-        # Create a simple test pattern
-        frame = np.zeros((480, 640, 3), dtype=np.uint8)
-
-        # Add some visual elements
-        cv2.putText(
-            frame,
-            "Reachy Mini Camera",
-            (150, 200),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            1.2,
-            (255, 255, 255),
-            2,
-        )
-        cv2.putText(
-            frame,
-            "No camera connected",
-            (180, 280),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            0.8,
-            (128, 128, 128),
-            1,
-        )
-
-        # Add timestamp
-        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-        cv2.putText(
-            frame,
-            timestamp,
-            (220, 350),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            0.6,
-            (0, 255, 0),
-            1,
-        )
-
-        return frame
-
-    def get_snapshot(self) -> Optional[bytes]:
-        """Get the latest frame as JPEG bytes."""
-        with self._frame_lock:
-            return self._last_frame
-
-    async def _handle_client(
-        self,
-        reader: asyncio.StreamReader,
-        writer: asyncio.StreamWriter,
-    ) -> None:
-        """Handle incoming HTTP client connections."""
-        try:
-            # Read HTTP request
-            request_line = await asyncio.wait_for(
-                reader.readline(),
-                timeout=10.0
-            )
-            request = request_line.decode('utf-8', errors='ignore').strip()
-
-            # Read headers (we don't need them but must consume them)
-            while True:
-                line = await asyncio.wait_for(reader.readline(), timeout=5.0)
-                if line == b'\r\n' or line == b'\n' or line == b'':
-                    break
-
-            # Parse request path
-            parts = request.split(' ')
-            if len(parts) >= 2:
-                path = parts[1]
-            else:
-                path = '/'
-
-            _LOGGER.debug("HTTP request: %s", request)
-
-            if path == '/stream':
-                await self._handle_stream(writer)
-            elif path == '/snapshot':
-                await self._handle_snapshot(writer)
-            else:
-                await self._handle_index(writer)
-
-        except asyncio.TimeoutError:
-            _LOGGER.debug("Client connection timeout")
-        except ConnectionResetError:
-            _LOGGER.debug("Client connection reset")
-        except Exception as e:
-            _LOGGER.error("Error handling client: %s", e)
-        finally:
-            try:
-                writer.close()
-                await writer.wait_closed()
-            except Exception:
-                pass
-
-    async def _handle_index(self, writer: asyncio.StreamWriter) -> None:
-        """Handle index page request."""
-        html = f"""<!DOCTYPE html>
-<html>
-<head>
-    <title>Reachy Mini Camera</title>
-    <style>
-        body {{ font-family: Arial, sans-serif; margin: 40px; background: #1a1a2e; color: #eee; }}
-        h1 {{ color: #00d4ff; }}
-        .container {{ max-width: 800px; margin: 0 auto; }}
-        .stream {{ width: 100%; max-width: 640px; border: 2px solid #00d4ff; border-radius: 8px; }}
-        a {{ color: #00d4ff; }}
-        .info {{ background: #16213e; padding: 20px; border-radius: 8px; margin-top: 20px; }}
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>Reachy Mini Camera</h1>
-        <img class="stream" src="/stream" alt="Camera Stream">
-        <div class="info">
-            <h3>Endpoints:</h3>
-            <ul>
-                <li><a href="/stream">/stream</a> - MJPEG video stream</li>
-                <li><a href="/snapshot">/snapshot</a> - Single JPEG snapshot</li>
-            </ul>
-            <h3>Home Assistant Integration:</h3>
-            <p>Add a Generic Camera with URL: <code>http://&lt;ip&gt;:{self.port}/stream</code></p>
-        </div>
-    </div>
-</body>
-</html>"""
-
-        response = (
-            "HTTP/1.1 200 OK\r\n"
-            "Content-Type: text/html; charset=utf-8\r\n"
-            f"Content-Length: {len(html)}\r\n"
-            "Connection: close\r\n"
-            "\r\n"
-        )
-
-        writer.write(response.encode('utf-8'))
-        writer.write(html.encode('utf-8'))
-        await writer.drain()
-
-    async def _handle_snapshot(self, writer: asyncio.StreamWriter) -> None:
-        """Handle snapshot request - return single JPEG image."""
-        jpeg_data = self.get_snapshot()
-
-        if jpeg_data is None:
-            response = (
-                "HTTP/1.1 503 Service Unavailable\r\n"
-                "Content-Type: text/plain\r\n"
-                "Connection: close\r\n"
-                "\r\n"
-                "No frame available"
-            )
-            writer.write(response.encode('utf-8'))
-        else:
-            response = (
-                "HTTP/1.1 200 OK\r\n"
-                "Content-Type: image/jpeg\r\n"
-                f"Content-Length: {len(jpeg_data)}\r\n"
-                "Cache-Control: no-cache, no-store, must-revalidate\r\n"
-                "Connection: close\r\n"
-                "\r\n"
-            )
-            writer.write(response.encode('utf-8'))
-            writer.write(jpeg_data)
-
-        await writer.drain()
-
-    async def _handle_stream(self, writer: asyncio.StreamWriter) -> None:
-        """Handle MJPEG stream request."""
-        # Send MJPEG headers
-        response = (
-            "HTTP/1.1 200 OK\r\n"
-            f"Content-Type: multipart/x-mixed-replace; boundary={MJPEG_BOUNDARY}\r\n"
-            "Cache-Control: no-cache, no-store, must-revalidate\r\n"
-            "Connection: keep-alive\r\n"
-            "\r\n"
-        )
-        writer.write(response.encode('utf-8'))
-        await writer.drain()
-
-        _LOGGER.debug("Started MJPEG stream")
-
-        last_sent_time = 0
-
-        try:
-            while self._running:
-                # Get latest frame
-                with self._frame_lock:
-                    jpeg_data = self._last_frame
-                    frame_time = self._last_frame_time
-
-                # Only send if we have a new frame
-                if jpeg_data is not None and frame_time > last_sent_time:
-                    # Send MJPEG frame
-                    frame_header = (
-                        f"--{MJPEG_BOUNDARY}\r\n"
-                        "Content-Type: image/jpeg\r\n"
-                        f"Content-Length: {len(jpeg_data)}\r\n"
-                        "\r\n"
-                    )
-
-                    writer.write(frame_header.encode('utf-8'))
-                    writer.write(jpeg_data)
-                    writer.write(b"\r\n")
-                    await writer.drain()
-
-                    last_sent_time = frame_time
-
-                # Small delay to prevent busy loop
-                await asyncio.sleep(0.01)
-
-        except (ConnectionResetError, BrokenPipeError):
-            _LOGGER.debug("Client disconnected from stream")
-        except Exception as e:
-            _LOGGER.error("Error in MJPEG stream: %s", e)
-
-        _LOGGER.debug("Ended MJPEG stream")
+"""
+MJPEG Camera Server for Reachy Mini.
+
+This module provides an HTTP server that streams camera frames from Reachy Mini
+as MJPEG, which can be integrated with Home Assistant via Generic Camera.
+"""
+
+import asyncio
+import logging
+import threading
+import time
+from typing import Optional, TYPE_CHECKING
+
+import cv2
+import numpy as np
+
+if TYPE_CHECKING:
+    from reachy_mini import ReachyMini
+
+_LOGGER = logging.getLogger(__name__)
+
+# MJPEG boundary string
+MJPEG_BOUNDARY = "frame"
+
+
+class MJPEGCameraServer:
+    """
+    MJPEG streaming server for Reachy Mini camera.
+
+    Provides HTTP endpoints:
+    - /stream - MJPEG video stream
+    - /snapshot - Single JPEG image
+    - / - Simple status page
+    """
+
+    def __init__(
+        self,
+        reachy_mini: Optional["ReachyMini"] = None,
+        host: str = "0.0.0.0",
+        port: int = 8081,
+        fps: int = 15,
+        quality: int = 80,
+    ):
+        """
+        Initialize the MJPEG camera server.
+
+        Args:
+            reachy_mini: Reachy Mini robot instance (can be None for testing)
+            host: Host address to bind to
+            port: Port number for the HTTP server
+            fps: Target frames per second for the stream
+            quality: JPEG quality (1-100)
+        """
+        self.reachy_mini = reachy_mini
+        self.host = host
+        self.port = port
+        self.fps = fps
+        self.quality = quality
+
+        self._server: Optional[asyncio.Server] = None
+        self._running = False
+        self._frame_interval = 1.0 / fps
+        self._last_frame: Optional[bytes] = None
+        self._last_frame_time: float = 0
+        self._frame_lock = threading.Lock()
+
+        # Frame capture thread
+        self._capture_thread: Optional[threading.Thread] = None
+
+    async def start(self) -> None:
+        """Start the MJPEG camera server."""
+        if self._running:
+            _LOGGER.warning("Camera server already running")
+            return
+
+        self._running = True
+
+        # Start frame capture thread
+        self._capture_thread = threading.Thread(
+            target=self._capture_frames,
+            daemon=True,
+            name="camera-capture"
+        )
+        self._capture_thread.start()
+
+        # Start HTTP server
+        self._server = await asyncio.start_server(
+            self._handle_client,
+            self.host,
+            self.port,
+        )
+
+        _LOGGER.info("MJPEG Camera server started on http://%s:%d", self.host, self.port)
+        _LOGGER.info("  Stream URL: http://<ip>:%d/stream", self.port)
+        _LOGGER.info("  Snapshot URL: http://<ip>:%d/snapshot", self.port)
+
+    async def stop(self) -> None:
+        """Stop the MJPEG camera server."""
+        self._running = False
+
+        if self._capture_thread:
+            self._capture_thread.join(timeout=2.0)
+            self._capture_thread = None
+
+        if self._server:
+            self._server.close()
+            await self._server.wait_closed()
+            self._server = None
+
+        _LOGGER.info("MJPEG Camera server stopped")
+
+    def _capture_frames(self) -> None:
+        """Background thread to capture frames from Reachy Mini."""
+        _LOGGER.info("Starting camera capture thread")
+
+        while self._running:
+            try:
+                frame = self._get_camera_frame()
+
+                if frame is not None:
+                    # Encode frame as JPEG
+                    encode_params = [cv2.IMWRITE_JPEG_QUALITY, self.quality]
+                    success, jpeg_data = cv2.imencode('.jpg', frame, encode_params)
+
+                    if success:
+                        with self._frame_lock:
+                            self._last_frame = jpeg_data.tobytes()
+                            self._last_frame_time = time.time()
+
+                # Sleep to maintain target FPS
+                time.sleep(self._frame_interval)
+
+            except Exception as e:
+                _LOGGER.error("Error capturing frame: %s", e)
+                time.sleep(0.5)
+
+        _LOGGER.info("Camera capture thread stopped")
+
+    def _get_camera_frame(self) -> Optional[np.ndarray]:
+        """Get a frame from Reachy Mini's camera."""
+        if self.reachy_mini is None:
+            # Return a test pattern if no robot connected
+            return self._generate_test_frame()
+
+        try:
+            frame = self.reachy_mini.media.get_frame()
+            return frame
+        except Exception as e:
+            _LOGGER.debug("Failed to get camera frame: %s", e)
+            return None
+
+    def _generate_test_frame(self) -> np.ndarray:
+        """Generate a test pattern frame when no camera is available."""
+        # Create a simple test pattern
+        frame = np.zeros((480, 640, 3), dtype=np.uint8)
+
+        # Add some visual elements
+        cv2.putText(
+            frame,
+            "Reachy Mini Camera",
+            (150, 200),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1.2,
+            (255, 255, 255),
+            2,
+        )
+        cv2.putText(
+            frame,
+            "No camera connected",
+            (180, 280),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.8,
+            (128, 128, 128),
+            1,
+        )
+
+        # Add timestamp
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+        cv2.putText(
+            frame,
+            timestamp,
+            (220, 350),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.6,
+            (0, 255, 0),
+            1,
+        )
+
+        return frame
+
+    def get_snapshot(self) -> Optional[bytes]:
+        """Get the latest frame as JPEG bytes."""
+        with self._frame_lock:
+            return self._last_frame
+
+    async def _handle_client(
+        self,
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter,
+    ) -> None:
+        """Handle incoming HTTP client connections."""
+        try:
+            # Read HTTP request
+            request_line = await asyncio.wait_for(
+                reader.readline(),
+                timeout=10.0
+            )
+            request = request_line.decode('utf-8', errors='ignore').strip()
+
+            # Read headers (we don't need them but must consume them)
+            while True:
+                line = await asyncio.wait_for(reader.readline(), timeout=5.0)
+                if line == b'\r\n' or line == b'\n' or line == b'':
+                    break
+
+            # Parse request path
+            parts = request.split(' ')
+            if len(parts) >= 2:
+                path = parts[1]
+            else:
+                path = '/'
+
+            _LOGGER.debug("HTTP request: %s", request)
+
+            if path == '/stream':
+                await self._handle_stream(writer)
+            elif path == '/snapshot':
+                await self._handle_snapshot(writer)
+            else:
+                await self._handle_index(writer)
+
+        except asyncio.TimeoutError:
+            _LOGGER.debug("Client connection timeout")
+        except ConnectionResetError:
+            _LOGGER.debug("Client connection reset")
+        except Exception as e:
+            _LOGGER.error("Error handling client: %s", e)
+        finally:
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except Exception:
+                pass
+
+    async def _handle_index(self, writer: asyncio.StreamWriter) -> None:
+        """Handle index page request."""
+        html = f"""<!DOCTYPE html>
+<html>
+<head>
+    <title>Reachy Mini Camera</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; margin: 40px; background: #1a1a2e; color: #eee; }}
+        h1 {{ color: #00d4ff; }}
+        .container {{ max-width: 800px; margin: 0 auto; }}
+        .stream {{ width: 100%; max-width: 640px; border: 2px solid #00d4ff; border-radius: 8px; }}
+        a {{ color: #00d4ff; }}
+        .info {{ background: #16213e; padding: 20px; border-radius: 8px; margin-top: 20px; }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Reachy Mini Camera</h1>
+        <img class="stream" src="/stream" alt="Camera Stream">
+        <div class="info">
+            <h3>Endpoints:</h3>
+            <ul>
+                <li><a href="/stream">/stream</a> - MJPEG video stream</li>
+                <li><a href="/snapshot">/snapshot</a> - Single JPEG snapshot</li>
+            </ul>
+            <h3>Home Assistant Integration:</h3>
+            <p>Add a Generic Camera with URL: <code>http://&lt;ip&gt;:{self.port}/stream</code></p>
+        </div>
+    </div>
+</body>
+</html>"""
+
+        response = (
+            "HTTP/1.1 200 OK\r\n"
+            "Content-Type: text/html; charset=utf-8\r\n"
+            f"Content-Length: {len(html)}\r\n"
+            "Connection: close\r\n"
+            "\r\n"
+        )
+
+        writer.write(response.encode('utf-8'))
+        writer.write(html.encode('utf-8'))
+        await writer.drain()
+
+    async def _handle_snapshot(self, writer: asyncio.StreamWriter) -> None:
+        """Handle snapshot request - return single JPEG image."""
+        jpeg_data = self.get_snapshot()
+
+        if jpeg_data is None:
+            response = (
+                "HTTP/1.1 503 Service Unavailable\r\n"
+                "Content-Type: text/plain\r\n"
+                "Connection: close\r\n"
+                "\r\n"
+                "No frame available"
+            )
+            writer.write(response.encode('utf-8'))
+        else:
+            response = (
+                "HTTP/1.1 200 OK\r\n"
+                "Content-Type: image/jpeg\r\n"
+                f"Content-Length: {len(jpeg_data)}\r\n"
+                "Cache-Control: no-cache, no-store, must-revalidate\r\n"
+                "Connection: close\r\n"
+                "\r\n"
+            )
+            writer.write(response.encode('utf-8'))
+            writer.write(jpeg_data)
+
+        await writer.drain()
+
+    async def _handle_stream(self, writer: asyncio.StreamWriter) -> None:
+        """Handle MJPEG stream request."""
+        # Send MJPEG headers
+        response = (
+            "HTTP/1.1 200 OK\r\n"
+            f"Content-Type: multipart/x-mixed-replace; boundary={MJPEG_BOUNDARY}\r\n"
+            "Cache-Control: no-cache, no-store, must-revalidate\r\n"
+            "Connection: keep-alive\r\n"
+            "\r\n"
+        )
+        writer.write(response.encode('utf-8'))
+        await writer.drain()
+
+        _LOGGER.debug("Started MJPEG stream")
+
+        last_sent_time = 0
+
+        try:
+            while self._running:
+                # Get latest frame
+                with self._frame_lock:
+                    jpeg_data = self._last_frame
+                    frame_time = self._last_frame_time
+
+                # Only send if we have a new frame
+                if jpeg_data is not None and frame_time > last_sent_time:
+                    # Send MJPEG frame
+                    frame_header = (
+                        f"--{MJPEG_BOUNDARY}\r\n"
+                        "Content-Type: image/jpeg\r\n"
+                        f"Content-Length: {len(jpeg_data)}\r\n"
+                        "\r\n"
+                    )
+
+                    writer.write(frame_header.encode('utf-8'))
+                    writer.write(jpeg_data)
+                    writer.write(b"\r\n")
+                    await writer.drain()
+
+                    last_sent_time = frame_time
+
+                # Small delay to prevent busy loop
+                await asyncio.sleep(0.01)
+
+        except (ConnectionResetError, BrokenPipeError):
+            _LOGGER.debug("Client disconnected from stream")
+        except Exception as e:
+            _LOGGER.error("Error in MJPEG stream: %s", e)
+
+        _LOGGER.debug("Ended MJPEG stream")

reachy_mini_ha_voice/entity_extensions.py

@@ -1,292 +1,292 @@
-"""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 SensorStateClass:
-    """ESPHome SensorStateClass enum values."""
-    NONE = 0
-    MEASUREMENT = 1
-    TOTAL_INCREASING = 2
-    TOTAL = 3
-
-
-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: int = SensorStateClass.NONE,
-        entity_category: int = 0,  # 0 = none, 1 = config, 2 = diagnostic
-        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.entity_category = entity_category
-        # Convert string state_class to int if needed (for backward compatibility)
-        if isinstance(state_class, str):
-            state_class_map = {
-                "": SensorStateClass.NONE,
-                "measurement": SensorStateClass.MEASUREMENT,
-                "total_increasing": SensorStateClass.TOTAL_INCREASING,
-                "total": SensorStateClass.TOTAL,
-            }
-            self.state_class = state_class_map.get(state_class.lower(), SensorStateClass.NONE)
-        else:
-            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,
-                entity_category=self.entity_category,
-            )
-        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 = "",
-        entity_category: int = 0,  # 0 = none, 1 = config, 2 = diagnostic
-        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.entity_category = entity_category
-        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,
-                entity_category=self.entity_category,
-            )
-        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 = "",
-        entity_category: int = 0,  # 0 = none, 1 = config, 2 = diagnostic
-        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.entity_category = entity_category
-        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,
-                entity_category=self.entity_category,
-            )
-        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 = "",
-        entity_category: int = 0,  # 0 = none, 1 = config, 2 = diagnostic
-        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.entity_category = entity_category
-        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,
-                entity_category=self.entity_category,
-            )
-        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
+"""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 SensorStateClass:
+    """ESPHome SensorStateClass enum values."""
+    NONE = 0
+    MEASUREMENT = 1
+    TOTAL_INCREASING = 2
+    TOTAL = 3
+
+
+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: int = SensorStateClass.NONE,
+        entity_category: int = 0,  # 0 = none, 1 = config, 2 = diagnostic
+        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.entity_category = entity_category
+        # Convert string state_class to int if needed (for backward compatibility)
+        if isinstance(state_class, str):
+            state_class_map = {
+                "": SensorStateClass.NONE,
+                "measurement": SensorStateClass.MEASUREMENT,
+                "total_increasing": SensorStateClass.TOTAL_INCREASING,
+                "total": SensorStateClass.TOTAL,
+            }
+            self.state_class = state_class_map.get(state_class.lower(), SensorStateClass.NONE)
+        else:
+            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,
+                entity_category=self.entity_category,
+            )
+        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 = "",
+        entity_category: int = 0,  # 0 = none, 1 = config, 2 = diagnostic
+        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.entity_category = entity_category
+        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,
+                entity_category=self.entity_category,
+            )
+        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 = "",
+        entity_category: int = 0,  # 0 = none, 1 = config, 2 = diagnostic
+        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.entity_category = entity_category
+        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,
+                entity_category=self.entity_category,
+            )
+        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 = "",
+        entity_category: int = 0,  # 0 = none, 1 = config, 2 = diagnostic
+        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.entity_category = entity_category
+        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,
+                entity_category=self.entity_category,
+            )
+        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

@@ -1,175 +1,175 @@
-"""
-Reachy Mini Home Assistant Voice Assistant Application
-
-This is the main entry point for the Reachy Mini application that integrates
-with Home Assistant via ESPHome protocol for voice control.
-"""
-
-import asyncio
-import logging
-import socket
-import threading
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-
-def _check_zenoh_available(timeout: float = 1.0) -> bool:
-    """Check if Zenoh service is available."""
-    try:
-        with socket.create_connection(("127.0.0.1", 7447), timeout=timeout):
-            return True
-    except (socket.timeout, ConnectionRefusedError, OSError):
-        return False
-
-
-# Only import ReachyMiniApp if we're running as an app
-try:
-    from reachy_mini import ReachyMini, ReachyMiniApp
-    REACHY_MINI_AVAILABLE = True
-except ImportError:
-    REACHY_MINI_AVAILABLE = False
-
-    # Create a dummy base class
-    class ReachyMiniApp:
-        custom_app_url = None
-
-        def __init__(self):
-            self.stop_event = threading.Event()
-
-        def wrapped_run(self, *args, **kwargs):
-            pass
-
-        def stop(self):
-            self.stop_event.set()
-
-    ReachyMini = None
-
-
-from .voice_assistant import VoiceAssistantService
-from .motion import ReachyMiniMotion
-
-
-class ReachyMiniHAVoiceApp(ReachyMiniApp):
-    """
-    Reachy Mini Home Assistant Voice Assistant Application.
-
-    This app runs an ESPHome-compatible voice satellite that connects
-    to Home Assistant for STT/TTS processing while providing local
-    wake word detection and robot motion feedback.
-    """
-
-    # No custom web UI needed - configuration is automatic via Home Assistant
-    custom_app_url: Optional[str] = None
-
-    def __init__(self, *args, **kwargs):
-        """Initialize the app."""
-        super().__init__(*args, **kwargs)
-        if not hasattr(self, 'stop_event'):
-            self.stop_event = threading.Event()
-
-    def wrapped_run(self, *args, **kwargs) -> None:
-        """
-        Override wrapped_run to handle Zenoh connection failures gracefully.
-
-        If Zenoh is not available, run in standalone mode without robot control.
-        """
-        logger.info("Starting Reachy Mini HA Voice App...")
-
-        # Check if Zenoh is available before trying to connect
-        if not _check_zenoh_available():
-            logger.warning("Zenoh service not available (port 7447)")
-            logger.info("Running in standalone mode without robot control")
-            self._run_standalone()
-            return
-
-        # Zenoh is available, try normal startup with ReachyMini
-        if REACHY_MINI_AVAILABLE:
-            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 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()
-                else:
-                    raise
-        else:
-            logger.info("Reachy Mini SDK not available, running standalone")
-            self._run_standalone()
-
-    def _run_standalone(self) -> None:
-        """Run in standalone mode without robot."""
-        self.run(None, self.stop_event)
-
-    def run(self, reachy_mini, stop_event: threading.Event) -> None:
-        """
-        Main application entry point.
-
-        Args:
-            reachy_mini: The Reachy Mini robot instance (can be None)
-            stop_event: Event to signal graceful shutdown
-        """
-        logger.info("Starting Home Assistant Voice Assistant...")
-
-        # Create and run the voice assistant service
-        service = VoiceAssistantService(reachy_mini)
-
-        # Run the async service in an event loop
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-
-        try:
-            loop.run_until_complete(service.start())
-
-            logger.info("=" * 50)
-            logger.info("Home Assistant Voice Assistant Started!")
-            logger.info("=" * 50)
-            logger.info("ESPHome Server: 0.0.0.0:6053")
-            logger.info("Camera Server: 0.0.0.0:8081")
-            logger.info("Wake word: Okay Nabu")
-            if reachy_mini:
-                logger.info("Motion control: enabled")
-                logger.info("Camera: enabled (Reachy Mini)")
-            else:
-                logger.info("Motion control: disabled (no robot)")
-                logger.info("Camera: test pattern (no robot)")
-            logger.info("=" * 50)
-            logger.info("To connect from Home Assistant:")
-            logger.info("  Settings -> Devices & Services -> Add Integration")
-            logger.info("  -> ESPHome -> Enter this device's IP:6053")
-            logger.info("  -> Generic Camera -> http://<ip>:8081/stream")
-            logger.info("=" * 50)
-
-            # Wait for stop signal
-            while not stop_event.is_set():
-                loop.run_until_complete(asyncio.sleep(0.5))
-
-        except Exception as e:
-            logger.error(f"Error running voice assistant: {e}")
-            raise
-        finally:
-            logger.info("Shutting down voice assistant...")
-            loop.run_until_complete(service.stop())
-            loop.close()
-            logger.info("Voice assistant stopped.")
-
-
-# This is called when running as: python -m reachy_mini_ha_voice.main
-if __name__ == "__main__":
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    )
-
-    app = ReachyMiniHAVoiceApp()
-    try:
-        app.wrapped_run()
-    except KeyboardInterrupt:
-        app.stop()
+"""
+Reachy Mini Home Assistant Voice Assistant Application
+
+This is the main entry point for the Reachy Mini application that integrates
+with Home Assistant via ESPHome protocol for voice control.
+"""
+
+import asyncio
+import logging
+import socket
+import threading
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _check_zenoh_available(timeout: float = 1.0) -> bool:
+    """Check if Zenoh service is available."""
+    try:
+        with socket.create_connection(("127.0.0.1", 7447), timeout=timeout):
+            return True
+    except (socket.timeout, ConnectionRefusedError, OSError):
+        return False
+
+
+# Only import ReachyMiniApp if we're running as an app
+try:
+    from reachy_mini import ReachyMini, ReachyMiniApp
+    REACHY_MINI_AVAILABLE = True
+except ImportError:
+    REACHY_MINI_AVAILABLE = False
+
+    # Create a dummy base class
+    class ReachyMiniApp:
+        custom_app_url = None
+
+        def __init__(self):
+            self.stop_event = threading.Event()
+
+        def wrapped_run(self, *args, **kwargs):
+            pass
+
+        def stop(self):
+            self.stop_event.set()
+
+    ReachyMini = None
+
+
+from .voice_assistant import VoiceAssistantService
+from .motion import ReachyMiniMotion
+
+
+class ReachyMiniHaVoice(ReachyMiniApp):
+    """
+    Reachy Mini Home Assistant Voice Assistant Application.
+
+    This app runs an ESPHome-compatible voice satellite that connects
+    to Home Assistant for STT/TTS processing while providing local
+    wake word detection and robot motion feedback.
+    """
+
+    # No custom web UI needed - configuration is automatic via Home Assistant
+    custom_app_url: Optional[str] = None
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the app."""
+        super().__init__(*args, **kwargs)
+        if not hasattr(self, 'stop_event'):
+            self.stop_event = threading.Event()
+
+    def wrapped_run(self, *args, **kwargs) -> None:
+        """
+        Override wrapped_run to handle Zenoh connection failures gracefully.
+
+        If Zenoh is not available, run in standalone mode without robot control.
+        """
+        logger.info("Starting Reachy Mini HA Voice App...")
+
+        # Check if Zenoh is available before trying to connect
+        if not _check_zenoh_available():
+            logger.warning("Zenoh service not available (port 7447)")
+            logger.info("Running in standalone mode without robot control")
+            self._run_standalone()
+            return
+
+        # Zenoh is available, try normal startup with ReachyMini
+        if REACHY_MINI_AVAILABLE:
+            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 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()
+                else:
+                    raise
+        else:
+            logger.info("Reachy Mini SDK not available, running standalone")
+            self._run_standalone()
+
+    def _run_standalone(self) -> None:
+        """Run in standalone mode without robot."""
+        self.run(None, self.stop_event)
+
+    def run(self, reachy_mini, stop_event: threading.Event) -> None:
+        """
+        Main application entry point.
+
+        Args:
+            reachy_mini: The Reachy Mini robot instance (can be None)
+            stop_event: Event to signal graceful shutdown
+        """
+        logger.info("Starting Home Assistant Voice Assistant...")
+
+        # Create and run the voice assistant service
+        service = VoiceAssistantService(reachy_mini)
+
+        # Run the async service in an event loop
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        try:
+            loop.run_until_complete(service.start())
+
+            logger.info("=" * 50)
+            logger.info("Home Assistant Voice Assistant Started!")
+            logger.info("=" * 50)
+            logger.info("ESPHome Server: 0.0.0.0:6053")
+            logger.info("Camera Server: 0.0.0.0:8081")
+            logger.info("Wake word: Okay Nabu")
+            if reachy_mini:
+                logger.info("Motion control: enabled")
+                logger.info("Camera: enabled (Reachy Mini)")
+            else:
+                logger.info("Motion control: disabled (no robot)")
+                logger.info("Camera: test pattern (no robot)")
+            logger.info("=" * 50)
+            logger.info("To connect from Home Assistant:")
+            logger.info("  Settings -> Devices & Services -> Add Integration")
+            logger.info("  -> ESPHome -> Enter this device's IP:6053")
+            logger.info("  -> Generic Camera -> http://<ip>:8081/stream")
+            logger.info("=" * 50)
+
+            # Wait for stop signal
+            while not stop_event.is_set():
+                loop.run_until_complete(asyncio.sleep(0.5))
+
+        except Exception as e:
+            logger.error(f"Error running voice assistant: {e}")
+            raise
+        finally:
+            logger.info("Shutting down voice assistant...")
+            loop.run_until_complete(service.stop())
+            loop.close()
+            logger.info("Voice assistant stopped.")
+
+
+# This is called when running as: python -m reachy_mini_ha_voice.main
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+
+    app = ReachyMiniHaVoice()
+    try:
+        app.wrapped_run()
+    except KeyboardInterrupt:
+        app.stop()

reachy_mini_ha_voice/reachy_controller.py

@@ -1,1008 +1,1008 @@
-"""Reachy Mini controller wrapper for ESPHome entities."""
-
-import logging
-from typing import Optional, TYPE_CHECKING
-import math
-import numpy as np
-from scipy.spatial.transform import Rotation as R
-import requests
-
-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:
-            # client.get_status() returns a dict with 'state' key
-            status = self.reachy.client.get_status(wait=False)
-            return status.get('state', '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:
-            # Check if daemon state is 'running'
-            status = self.reachy.client.get_status(wait=False)
-            return status.get('state') == 'running'
-        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.client.get_status(wait=False)
-            return status.get('error') or ""
-        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)."""
-        if not self.is_available:
-            return self._speaker_volume
-        try:
-            # Get volume from daemon API
-            status = self.reachy.client.get_status(wait=False)
-            wlan_ip = status.get('wlan_ip', 'localhost')
-            response = requests.get(f"http://{wlan_ip}:8000/api/volume/current", timeout=2)
-            if response.status_code == 200:
-                data = response.json()
-                self._speaker_volume = float(data.get('volume', self._speaker_volume))
-        except Exception as e:
-            logger.debug(f"Could not get volume from API: {e}")
-        return self._speaker_volume
-
-    def set_speaker_volume(self, volume: float) -> None:
-        """
-        Set speaker volume (0-100).
-
-        Args:
-            volume: Volume level 0-100
-        """
-        volume = max(0.0, min(100.0, volume))
-        self._speaker_volume = volume
-
-        if not self.is_available:
-            logger.warning("Cannot set volume: robot not available")
-            return
-
-        try:
-            # Set volume via daemon API
-            status = self.reachy.client.get_status(wait=False)
-            wlan_ip = status.get('wlan_ip', 'localhost')
-            response = requests.post(
-                f"http://{wlan_ip}:8000/api/volume/set",
-                json={"volume": int(volume)},
-                timeout=5
-            )
-            if response.status_code == 200:
-                logger.info(f"Speaker volume set to {volume}%")
-            else:
-                logger.error(f"Failed to set volume: {response.status_code} {response.text}")
-        except Exception as e:
-            logger.error(f"Error setting speaker volume: {e}")
-
-    def get_microphone_volume(self) -> float:
-        """Get microphone volume (0-100) using local SDK audio interface."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return getattr(self, '_microphone_volume', 50.0)
-
-        try:
-            # Try APMGR_MICGAIN first (0-31 range)
-            result = respeaker.read("APMGR_MICGAIN")
-            if result is not None:
-                # Convert 0-31 to 0-100%
-                self._microphone_volume = (result[0] / 31.0) * 100.0
-                return self._microphone_volume
-        except Exception as e:
-            logger.debug(f"Could not get microphone volume: {e}")
-
-        return getattr(self, '_microphone_volume', 50.0)
-
-    def set_microphone_volume(self, volume: float) -> None:
-        """
-        Set microphone volume (0-100) using local SDK audio interface.
-
-        Args:
-            volume: Volume level 0-100
-        """
-        volume = max(0.0, min(100.0, volume))
-        self._microphone_volume = volume
-
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            logger.warning("Cannot set microphone volume: ReSpeaker not available")
-            return
-
-        try:
-            # Convert 0-100% to 0-31 range for APMGR_MICGAIN
-            gain = int((volume / 100.0) * 31.0)
-            respeaker.write("APMGR_MICGAIN", [gain])
-            logger.info(f"Microphone volume set to {volume}% (gain: {gain})")
-        except Exception as e:
-            logger.error(f"Failed to set microphone volume: {e}")
-
-    # ========== Phase 2: Motor Control ==========
-
-    def get_motors_enabled(self) -> bool:
-        """Check if motors are enabled."""
-        if not self.is_available:
-            return False
-        try:
-            # Get motor control mode from backend status
-            status = self.reachy.client.get_status(wait=False)
-            backend_status = status.get('backend_status')
-            if backend_status and isinstance(backend_status, dict):
-                motor_mode = backend_status.get('motor_control_mode', 'disabled')
-                return motor_mode == 'enabled'
-            return status.get('state') == 'running'
-        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:
-            # Get motor control mode from backend status
-            status = self.reachy.client.get_status(wait=False)
-            backend_status = status.get('backend_status')
-            if backend_status and isinstance(backend_status, dict):
-                motor_mode = backend_status.get('motor_control_mode', 'disabled')
-                return motor_mode
-            if status.get('state') == 'running':
-                return "enabled"
-            return "disabled"
-        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.enable_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 _extract_pose_from_matrix(self, pose_matrix: np.ndarray) -> tuple:
-        """
-        Extract position (x, y, z) and rotation (roll, pitch, yaw) from 4x4 pose matrix.
-
-        Args:
-            pose_matrix: 4x4 homogeneous transformation matrix
-
-        Returns:
-            tuple: (x, y, z, roll, pitch, yaw) where position is in meters and angles in radians
-        """
-        # Extract position from the last column
-        x = pose_matrix[0, 3]
-        y = pose_matrix[1, 3]
-        z = pose_matrix[2, 3]
-
-        # Extract rotation matrix and convert to euler angles
-        rotation_matrix = pose_matrix[:3, :3]
-        rotation = R.from_matrix(rotation_matrix)
-        # Use 'xyz' convention for roll, pitch, yaw
-        roll, pitch, yaw = rotation.as_euler('xyz')
-
-        return x, y, z, roll, pitch, yaw
-
-    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()
-            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
-            return 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:
-            pose = self.reachy.get_current_head_pose()
-            # Modify the X position in the matrix
-            new_pose = pose.copy()
-            new_pose[0, 3] = x_mm / 1000  # Convert mm to m
-            self.reachy.goto_target(head=new_pose)
-        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()
-            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
-            return 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:
-            pose = self.reachy.get_current_head_pose()
-            new_pose = pose.copy()
-            new_pose[1, 3] = y_mm / 1000
-            self.reachy.goto_target(head=new_pose)
-        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()
-            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
-            return 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:
-            pose = self.reachy.get_current_head_pose()
-            new_pose = pose.copy()
-            new_pose[2, 3] = z_mm / 1000
-            self.reachy.goto_target(head=new_pose)
-        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()
-            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
-            return math.degrees(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:
-            pose = self.reachy.get_current_head_pose()
-            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
-            # Create new rotation with updated roll
-            new_rotation = R.from_euler('xyz', [math.radians(roll_deg), pitch, yaw])
-            new_pose = pose.copy()
-            new_pose[:3, :3] = new_rotation.as_matrix()
-            self.reachy.goto_target(head=new_pose)
-        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()
-            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
-            return math.degrees(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:
-            pose = self.reachy.get_current_head_pose()
-            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
-            new_rotation = R.from_euler('xyz', [roll, math.radians(pitch_deg), yaw])
-            new_pose = pose.copy()
-            new_pose[:3, :3] = new_rotation.as_matrix()
-            self.reachy.goto_target(head=new_pose)
-        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()
-            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
-            return math.degrees(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:
-            pose = self.reachy.get_current_head_pose()
-            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
-            new_rotation = R.from_euler('xyz', [roll, pitch, math.radians(yaw_deg)])
-            new_pose = pose.copy()
-            new_pose[:3, :3] = new_rotation.as_matrix()
-            self.reachy.goto_target(head=new_pose)
-        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:
-            # Body yaw is the first element of head joint positions
-            head_joints, _ = self.reachy.get_current_joint_positions()
-            return math.degrees(head_joints[0])
-        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:
-            # get_current_joint_positions() returns (head_joints, antenna_joints)
-            # antenna_joints is [right, left]
-            _, antennas = self.reachy.get_current_joint_positions()
-            return math.degrees(antennas[1])  # left is index 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:
-            _, antennas = self.reachy.get_current_joint_positions()
-            right = antennas[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:
-            _, antennas = self.reachy.get_current_joint_positions()
-            return math.degrees(antennas[0])  # right is index 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:
-            _, antennas = self.reachy.get_current_joint_positions()
-            left = antennas[1]
-            self.reachy.goto_target(antennas=[math.radians(angle_deg), left])
-        except Exception as e:
-            logger.error(f"Error setting right antenna: {e}")
-
-    # ========== Phase 4: Look At Control ==========
-
-    def get_look_at_x(self) -> float:
-        """Get look at target X coordinate in world frame (meters)."""
-        # This is a target position, not a current state
-        # We'll store it internally
-        return getattr(self, '_look_at_x', 0.0)
-
-    def set_look_at_x(self, x: float) -> None:
-        """Set look at target X coordinate."""
-        self._look_at_x = x
-        self._update_look_at()
-
-    def get_look_at_y(self) -> float:
-        """Get look at target Y coordinate in world frame (meters)."""
-        return getattr(self, '_look_at_y', 0.0)
-
-    def set_look_at_y(self, y: float) -> None:
-        """Set look at target Y coordinate."""
-        self._look_at_y = y
-        self._update_look_at()
-
-    def get_look_at_z(self) -> float:
-        """Get look at target Z coordinate in world frame (meters)."""
-        return getattr(self, '_look_at_z', 0.0)
-
-    def set_look_at_z(self, z: float) -> None:
-        """Set look at target Z coordinate."""
-        self._look_at_z = z
-        self._update_look_at()
-
-    def _update_look_at(self) -> None:
-        """Update robot to look at the target coordinates."""
-        if not self.is_available:
-            return
-        try:
-            x = getattr(self, '_look_at_x', 0.0)
-            y = getattr(self, '_look_at_y', 0.0)
-            z = getattr(self, '_look_at_z', 0.0)
-            self.reachy.look_at_world(x, y, z)
-            logger.info(f"Looking at world coordinates: ({x}, {y}, {z})")
-        except Exception as e:
-            logger.error(f"Error updating look at: {e}")
-
-    # ========== Phase 5: Audio Sensors ==========
-
-    def get_doa_angle(self) -> float:
-        """Get direction of arrival angle in degrees."""
-        if not self.is_available:
-            return 0.0
-        try:
-            # Access DOA through media_manager
-            doa_result = self.reachy.media.get_DoA()
-            if doa_result is not None:
-                # Convert radians to degrees
-                return math.degrees(doa_result[0])
-            return 0.0
-        except Exception as e:
-            logger.error(f"Error getting DOA angle: {e}")
-            return 0.0
-
-    def get_speech_detected(self) -> bool:
-        """Check if speech is detected."""
-        if not self.is_available:
-            return False
-        try:
-            # Access speech detection through media_manager
-            doa_result = self.reachy.media.get_DoA()
-            if doa_result is not None:
-                return doa_result[1]
-            return False
-        except Exception as e:
-            logger.error(f"Error getting speech detection: {e}")
-            return False
-
-    # ========== Phase 6: Diagnostic Information ==========
-
-    def get_control_loop_frequency(self) -> float:
-        """Get control loop frequency in Hz."""
-        if not self.is_available:
-            return 0.0
-        try:
-            # Get control loop stats from backend status
-            status = self.reachy.client.get_status(wait=False)
-            backend_status = status.get('backend_status')
-            if backend_status and isinstance(backend_status, dict):
-                control_loop_stats = backend_status.get('control_loop_stats', {})
-                return control_loop_stats.get('mean_control_loop_frequency', 0.0)
-            return 0.0
-        except Exception as e:
-            logger.error(f"Error getting control loop frequency: {e}")
-            return 0.0
-
-    def get_sdk_version(self) -> str:
-        """Get SDK version."""
-        if not self.is_available:
-            return "N/A"
-        try:
-            status = self.reachy.client.get_status(wait=False)
-            return status.get('version') or "unknown"
-        except Exception as e:
-            logger.error(f"Error getting SDK version: {e}")
-            return "error"
-
-    def get_robot_name(self) -> str:
-        """Get robot name."""
-        if not self.is_available:
-            return "N/A"
-        try:
-            status = self.reachy.client.get_status(wait=False)
-            return status.get('robot_name') or "unknown"
-        except Exception as e:
-            logger.error(f"Error getting robot name: {e}")
-            return "error"
-
-    def get_wireless_version(self) -> bool:
-        """Check if this is a wireless version."""
-        if not self.is_available:
-            return False
-        try:
-            status = self.reachy.client.get_status(wait=False)
-            return status.get('wireless_version', False)
-        except Exception as e:
-            logger.error(f"Error getting wireless version: {e}")
-            return False
-
-    def get_simulation_mode(self) -> bool:
-        """Check if simulation mode is enabled."""
-        if not self.is_available:
-            return False
-        try:
-            status = self.reachy.client.get_status(wait=False)
-            return status.get('simulation_enabled', False)
-        except Exception as e:
-            logger.error(f"Error getting simulation mode: {e}")
-            return False
-
-    def get_wlan_ip(self) -> str:
-        """Get WLAN IP address."""
-        if not self.is_available:
-            return "N/A"
-        try:
-            status = self.reachy.client.get_status(wait=False)
-            return status.get('wlan_ip') or "N/A"
-        except Exception as e:
-            logger.error(f"Error getting WLAN IP: {e}")
-            return "error"
-
-    # ========== Phase 7: IMU Sensors (Wireless only) ==========
-
-    def get_imu_accel_x(self) -> float:
-        """Get IMU X-axis acceleration in m/s²."""
-        if not self.is_available:
-            return 0.0
-        try:
-            imu_data = self.reachy.imu
-            if imu_data is not None and 'accelerometer' in imu_data:
-                return float(imu_data['accelerometer'][0])
-            return 0.0
-        except Exception as e:
-            logger.error(f"Error getting IMU accel X: {e}")
-            return 0.0
-
-    def get_imu_accel_y(self) -> float:
-        """Get IMU Y-axis acceleration in m/s²."""
-        if not self.is_available:
-            return 0.0
-        try:
-            imu_data = self.reachy.imu
-            if imu_data is not None and 'accelerometer' in imu_data:
-                return float(imu_data['accelerometer'][1])
-            return 0.0
-        except Exception as e:
-            logger.error(f"Error getting IMU accel Y: {e}")
-            return 0.0
-
-    def get_imu_accel_z(self) -> float:
-        """Get IMU Z-axis acceleration in m/s²."""
-        if not self.is_available:
-            return 0.0
-        try:
-            imu_data = self.reachy.imu
-            if imu_data is not None and 'accelerometer' in imu_data:
-                return float(imu_data['accelerometer'][2])
-            return 0.0
-        except Exception as e:
-            logger.error(f"Error getting IMU accel Z: {e}")
-            return 0.0
-
-    def get_imu_gyro_x(self) -> float:
-        """Get IMU X-axis angular velocity in rad/s."""
-        if not self.is_available:
-            return 0.0
-        try:
-            imu_data = self.reachy.imu
-            if imu_data is not None and 'gyroscope' in imu_data:
-                return float(imu_data['gyroscope'][0])
-            return 0.0
-        except Exception as e:
-            logger.error(f"Error getting IMU gyro X: {e}")
-            return 0.0
-
-    def get_imu_gyro_y(self) -> float:
-        """Get IMU Y-axis angular velocity in rad/s."""
-        if not self.is_available:
-            return 0.0
-        try:
-            imu_data = self.reachy.imu
-            if imu_data is not None and 'gyroscope' in imu_data:
-                return float(imu_data['gyroscope'][1])
-            return 0.0
-        except Exception as e:
-            logger.error(f"Error getting IMU gyro Y: {e}")
-            return 0.0
-
-    def get_imu_gyro_z(self) -> float:
-        """Get IMU Z-axis angular velocity in rad/s."""
-        if not self.is_available:
-            return 0.0
-        try:
-            imu_data = self.reachy.imu
-            if imu_data is not None and 'gyroscope' in imu_data:
-                return float(imu_data['gyroscope'][2])
-            return 0.0
-        except Exception as e:
-            logger.error(f"Error getting IMU gyro Z: {e}")
-            return 0.0
-
-    def get_imu_temperature(self) -> float:
-        """Get IMU temperature in °C."""
-        if not self.is_available:
-            return 0.0
-        try:
-            imu_data = self.reachy.imu
-            if imu_data is not None and 'temperature' in imu_data:
-                return float(imu_data['temperature'])
-            return 0.0
-        except Exception as e:
-            logger.error(f"Error getting IMU temperature: {e}")
-            return 0.0
-
-    # ========== Phase 11: LED Control (via local SDK) ==========
-
-    def _get_respeaker(self):
-        """Get ReSpeaker device from media manager."""
-        if not self.is_available:
-            logger.debug("ReSpeaker not available: robot not connected")
-            return None
-        try:
-            if not self.reachy.media:
-                logger.debug("ReSpeaker not available: media manager is None")
-                return None
-            if not self.reachy.media.audio:
-                logger.debug("ReSpeaker not available: audio is None")
-                return None
-            respeaker = self.reachy.media.audio._respeaker
-            if respeaker is None:
-                logger.debug("ReSpeaker not available: _respeaker is None (USB device not found)")
-            return respeaker
-        except Exception as e:
-            logger.debug(f"ReSpeaker not available: {e}")
-            return None
-
-    def get_led_brightness(self) -> float:
-        """Get LED brightness (0-100)."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return getattr(self, '_led_brightness', 50.0)
-        try:
-            result = respeaker.read("LED_BRIGHTNESS")
-            if result is not None:
-                # LED_BRIGHTNESS is 0-255, convert to 0-100
-                self._led_brightness = (result[1] / 255.0) * 100.0
-                return self._led_brightness
-        except Exception as e:
-            logger.debug(f"Error getting LED brightness: {e}")
-        return getattr(self, '_led_brightness', 50.0)
-
-    def set_led_brightness(self, brightness: float) -> None:
-        """Set LED brightness (0-100)."""
-        brightness = max(0.0, min(100.0, brightness))
-        self._led_brightness = brightness
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return
-        try:
-            # Convert 0-100 to 0-255
-            value = int((brightness / 100.0) * 255)
-            respeaker.write("LED_BRIGHTNESS", [value])
-            logger.info(f"LED brightness set to {brightness}%")
-        except Exception as e:
-            logger.error(f"Error setting LED brightness: {e}")
-
-    def get_led_effect(self) -> str:
-        """Get current LED effect."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return getattr(self, '_led_effect', 'off')
-        try:
-            result = respeaker.read("LED_EFFECT")
-            if result is not None:
-                effect_map = {0: 'off', 1: 'solid', 2: 'breathing', 3: 'rainbow', 4: 'doa'}
-                self._led_effect = effect_map.get(result[1], 'off')
-                return self._led_effect
-        except Exception as e:
-            logger.debug(f"Error getting LED effect: {e}")
-        return getattr(self, '_led_effect', 'off')
-
-    def set_led_effect(self, effect: str) -> None:
-        """Set LED effect."""
-        self._led_effect = effect
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return
-        try:
-            effect_map = {'off': 0, 'solid': 1, 'breathing': 2, 'rainbow': 3, 'doa': 4}
-            value = effect_map.get(effect, 0)
-            respeaker.write("LED_EFFECT", [value])
-            logger.info(f"LED effect set to {effect}")
-        except Exception as e:
-            logger.error(f"Error setting LED effect: {e}")
-
-    def get_led_color_r(self) -> float:
-        """Get LED red color component (0-255)."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return getattr(self, '_led_color_r', 0.0)
-        try:
-            result = respeaker.read("LED_COLOR")
-            if result is not None:
-                # LED_COLOR is a 32-bit value: 0x00RRGGBB
-                color = result[1] if len(result) > 1 else 0
-                self._led_color_r = float((color >> 16) & 0xFF)
-                return self._led_color_r
-        except Exception as e:
-            logger.debug(f"Error getting LED color R: {e}")
-        return getattr(self, '_led_color_r', 0.0)
-
-    def set_led_color_r(self, value: float) -> None:
-        """Set LED red color component (0-255)."""
-        self._led_color_r = max(0.0, min(255.0, value))
-        self._update_led_color()
-
-    def get_led_color_g(self) -> float:
-        """Get LED green color component (0-255)."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return getattr(self, '_led_color_g', 0.0)
-        try:
-            result = respeaker.read("LED_COLOR")
-            if result is not None:
-                color = result[1] if len(result) > 1 else 0
-                self._led_color_g = float((color >> 8) & 0xFF)
-                return self._led_color_g
-        except Exception as e:
-            logger.debug(f"Error getting LED color G: {e}")
-        return getattr(self, '_led_color_g', 0.0)
-
-    def set_led_color_g(self, value: float) -> None:
-        """Set LED green color component (0-255)."""
-        self._led_color_g = max(0.0, min(255.0, value))
-        self._update_led_color()
-
-    def get_led_color_b(self) -> float:
-        """Get LED blue color component (0-255)."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return getattr(self, '_led_color_b', 0.0)
-        try:
-            result = respeaker.read("LED_COLOR")
-            if result is not None:
-                color = result[1] if len(result) > 1 else 0
-                self._led_color_b = float(color & 0xFF)
-                return self._led_color_b
-        except Exception as e:
-            logger.debug(f"Error getting LED color B: {e}")
-        return getattr(self, '_led_color_b', 0.0)
-
-    def set_led_color_b(self, value: float) -> None:
-        """Set LED blue color component (0-255)."""
-        self._led_color_b = max(0.0, min(255.0, value))
-        self._update_led_color()
-
-    def _update_led_color(self) -> None:
-        """Update LED color from R, G, B components."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return
-        try:
-            r = int(getattr(self, '_led_color_r', 0))
-            g = int(getattr(self, '_led_color_g', 0))
-            b = int(getattr(self, '_led_color_b', 0))
-            color = (r << 16) | (g << 8) | b
-            respeaker.write("LED_COLOR", [color])
-            logger.info(f"LED color set to RGB({r}, {g}, {b})")
-        except Exception as e:
-            logger.error(f"Error setting LED color: {e}")
-
-    # ========== Phase 12: Audio Processing (via local SDK) ==========
-
-    def get_agc_enabled(self) -> bool:
-        """Get AGC (Automatic Gain Control) enabled status."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return getattr(self, '_agc_enabled', False)
-        try:
-            result = respeaker.read("PP_AGCONOFF")
-            if result is not None:
-                self._agc_enabled = bool(result[1])
-                return self._agc_enabled
-        except Exception as e:
-            logger.debug(f"Error getting AGC status: {e}")
-        return getattr(self, '_agc_enabled', False)
-
-    def set_agc_enabled(self, enabled: bool) -> None:
-        """Set AGC (Automatic Gain Control) enabled status."""
-        self._agc_enabled = enabled
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return
-        try:
-            respeaker.write("PP_AGCONOFF", [1 if enabled else 0])
-            logger.info(f"AGC {'enabled' if enabled else 'disabled'}")
-        except Exception as e:
-            logger.error(f"Error setting AGC status: {e}")
-
-    def get_agc_max_gain(self) -> float:
-        """Get AGC maximum gain in dB."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return getattr(self, '_agc_max_gain', 15.0)
-        try:
-            result = respeaker.read("PP_AGCMAXGAIN")
-            if result is not None:
-                self._agc_max_gain = float(result[0])
-                return self._agc_max_gain
-        except Exception as e:
-            logger.debug(f"Error getting AGC max gain: {e}")
-        return getattr(self, '_agc_max_gain', 15.0)
-
-    def set_agc_max_gain(self, gain: float) -> None:
-        """Set AGC maximum gain in dB."""
-        gain = max(0.0, min(30.0, gain))
-        self._agc_max_gain = gain
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return
-        try:
-            respeaker.write("PP_AGCMAXGAIN", [gain])
-            logger.info(f"AGC max gain set to {gain} dB")
-        except Exception as e:
-            logger.error(f"Error setting AGC max gain: {e}")
-
-    def get_noise_suppression(self) -> float:
-        """Get noise suppression level (0-100%)."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return getattr(self, '_noise_suppression', 50.0)
-        try:
-            result = respeaker.read("PP_MIN_NS")
-            if result is not None:
-                # PP_MIN_NS is typically a float value, convert to percentage
-                # Lower values = more suppression
-                self._noise_suppression = max(0.0, min(100.0, (1.0 - result[0]) * 100.0))
-                return self._noise_suppression
-        except Exception as e:
-            logger.debug(f"Error getting noise suppression: {e}")
-        return getattr(self, '_noise_suppression', 50.0)
-
-    def set_noise_suppression(self, level: float) -> None:
-        """Set noise suppression level (0-100%)."""
-        level = max(0.0, min(100.0, level))
-        self._noise_suppression = level
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return
-        try:
-            # Convert percentage to PP_MIN_NS value (inverted)
-            value = 1.0 - (level / 100.0)
-            respeaker.write("PP_MIN_NS", [value])
-            logger.info(f"Noise suppression set to {level}%")
-        except Exception as e:
-            logger.error(f"Error setting noise suppression: {e}")
-
-    def get_echo_cancellation_converged(self) -> bool:
-        """Check if echo cancellation has converged."""
-        respeaker = self._get_respeaker()
-        if respeaker is None:
-            return False
-        try:
-            result = respeaker.read("AEC_AECCONVERGED")
-            if result is not None:
-                return bool(result[1])
-        except Exception as e:
-            logger.debug(f"Error getting AEC converged status: {e}")
-        return False
+"""Reachy Mini controller wrapper for ESPHome entities."""
+
+import logging
+from typing import Optional, TYPE_CHECKING
+import math
+import numpy as np
+from scipy.spatial.transform import Rotation as R
+import requests
+
+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:
+            # client.get_status() returns a dict with 'state' key
+            status = self.reachy.client.get_status(wait=False)
+            return status.get('state', '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:
+            # Check if daemon state is 'running'
+            status = self.reachy.client.get_status(wait=False)
+            return status.get('state') == 'running'
+        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.client.get_status(wait=False)
+            return status.get('error') or ""
+        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)."""
+        if not self.is_available:
+            return self._speaker_volume
+        try:
+            # Get volume from daemon API
+            status = self.reachy.client.get_status(wait=False)
+            wlan_ip = status.get('wlan_ip', 'localhost')
+            response = requests.get(f"http://{wlan_ip}:8000/api/volume/current", timeout=2)
+            if response.status_code == 200:
+                data = response.json()
+                self._speaker_volume = float(data.get('volume', self._speaker_volume))
+        except Exception as e:
+            logger.debug(f"Could not get volume from API: {e}")
+        return self._speaker_volume
+
+    def set_speaker_volume(self, volume: float) -> None:
+        """
+        Set speaker volume (0-100).
+
+        Args:
+            volume: Volume level 0-100
+        """
+        volume = max(0.0, min(100.0, volume))
+        self._speaker_volume = volume
+
+        if not self.is_available:
+            logger.warning("Cannot set volume: robot not available")
+            return
+
+        try:
+            # Set volume via daemon API
+            status = self.reachy.client.get_status(wait=False)
+            wlan_ip = status.get('wlan_ip', 'localhost')
+            response = requests.post(
+                f"http://{wlan_ip}:8000/api/volume/set",
+                json={"volume": int(volume)},
+                timeout=5
+            )
+            if response.status_code == 200:
+                logger.info(f"Speaker volume set to {volume}%")
+            else:
+                logger.error(f"Failed to set volume: {response.status_code} {response.text}")
+        except Exception as e:
+            logger.error(f"Error setting speaker volume: {e}")
+
+    def get_microphone_volume(self) -> float:
+        """Get microphone volume (0-100) using local SDK audio interface."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return getattr(self, '_microphone_volume', 50.0)
+
+        try:
+            # Try APMGR_MICGAIN first (0-31 range)
+            result = respeaker.read("APMGR_MICGAIN")
+            if result is not None:
+                # Convert 0-31 to 0-100%
+                self._microphone_volume = (result[0] / 31.0) * 100.0
+                return self._microphone_volume
+        except Exception as e:
+            logger.debug(f"Could not get microphone volume: {e}")
+
+        return getattr(self, '_microphone_volume', 50.0)
+
+    def set_microphone_volume(self, volume: float) -> None:
+        """
+        Set microphone volume (0-100) using local SDK audio interface.
+
+        Args:
+            volume: Volume level 0-100
+        """
+        volume = max(0.0, min(100.0, volume))
+        self._microphone_volume = volume
+
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            logger.warning("Cannot set microphone volume: ReSpeaker not available")
+            return
+
+        try:
+            # Convert 0-100% to 0-31 range for APMGR_MICGAIN
+            gain = int((volume / 100.0) * 31.0)
+            respeaker.write("APMGR_MICGAIN", [gain])
+            logger.info(f"Microphone volume set to {volume}% (gain: {gain})")
+        except Exception as e:
+            logger.error(f"Failed to set microphone volume: {e}")
+
+    # ========== Phase 2: Motor Control ==========
+
+    def get_motors_enabled(self) -> bool:
+        """Check if motors are enabled."""
+        if not self.is_available:
+            return False
+        try:
+            # Get motor control mode from backend status
+            status = self.reachy.client.get_status(wait=False)
+            backend_status = status.get('backend_status')
+            if backend_status and isinstance(backend_status, dict):
+                motor_mode = backend_status.get('motor_control_mode', 'disabled')
+                return motor_mode == 'enabled'
+            return status.get('state') == 'running'
+        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:
+            # Get motor control mode from backend status
+            status = self.reachy.client.get_status(wait=False)
+            backend_status = status.get('backend_status')
+            if backend_status and isinstance(backend_status, dict):
+                motor_mode = backend_status.get('motor_control_mode', 'disabled')
+                return motor_mode
+            if status.get('state') == 'running':
+                return "enabled"
+            return "disabled"
+        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.enable_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 _extract_pose_from_matrix(self, pose_matrix: np.ndarray) -> tuple:
+        """
+        Extract position (x, y, z) and rotation (roll, pitch, yaw) from 4x4 pose matrix.
+
+        Args:
+            pose_matrix: 4x4 homogeneous transformation matrix
+
+        Returns:
+            tuple: (x, y, z, roll, pitch, yaw) where position is in meters and angles in radians
+        """
+        # Extract position from the last column
+        x = pose_matrix[0, 3]
+        y = pose_matrix[1, 3]
+        z = pose_matrix[2, 3]
+
+        # Extract rotation matrix and convert to euler angles
+        rotation_matrix = pose_matrix[:3, :3]
+        rotation = R.from_matrix(rotation_matrix)
+        # Use 'xyz' convention for roll, pitch, yaw
+        roll, pitch, yaw = rotation.as_euler('xyz')
+
+        return x, y, z, roll, pitch, yaw
+
+    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()
+            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
+            return 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:
+            pose = self.reachy.get_current_head_pose()
+            # Modify the X position in the matrix
+            new_pose = pose.copy()
+            new_pose[0, 3] = x_mm / 1000  # Convert mm to m
+            self.reachy.goto_target(head=new_pose)
+        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()
+            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
+            return 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:
+            pose = self.reachy.get_current_head_pose()
+            new_pose = pose.copy()
+            new_pose[1, 3] = y_mm / 1000
+            self.reachy.goto_target(head=new_pose)
+        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()
+            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
+            return 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:
+            pose = self.reachy.get_current_head_pose()
+            new_pose = pose.copy()
+            new_pose[2, 3] = z_mm / 1000
+            self.reachy.goto_target(head=new_pose)
+        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()
+            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
+            return math.degrees(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:
+            pose = self.reachy.get_current_head_pose()
+            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
+            # Create new rotation with updated roll
+            new_rotation = R.from_euler('xyz', [math.radians(roll_deg), pitch, yaw])
+            new_pose = pose.copy()
+            new_pose[:3, :3] = new_rotation.as_matrix()
+            self.reachy.goto_target(head=new_pose)
+        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()
+            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
+            return math.degrees(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:
+            pose = self.reachy.get_current_head_pose()
+            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
+            new_rotation = R.from_euler('xyz', [roll, math.radians(pitch_deg), yaw])
+            new_pose = pose.copy()
+            new_pose[:3, :3] = new_rotation.as_matrix()
+            self.reachy.goto_target(head=new_pose)
+        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()
+            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
+            return math.degrees(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:
+            pose = self.reachy.get_current_head_pose()
+            x, y, z, roll, pitch, yaw = self._extract_pose_from_matrix(pose)
+            new_rotation = R.from_euler('xyz', [roll, pitch, math.radians(yaw_deg)])
+            new_pose = pose.copy()
+            new_pose[:3, :3] = new_rotation.as_matrix()
+            self.reachy.goto_target(head=new_pose)
+        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:
+            # Body yaw is the first element of head joint positions
+            head_joints, _ = self.reachy.get_current_joint_positions()
+            return math.degrees(head_joints[0])
+        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:
+            # get_current_joint_positions() returns (head_joints, antenna_joints)
+            # antenna_joints is [right, left]
+            _, antennas = self.reachy.get_current_joint_positions()
+            return math.degrees(antennas[1])  # left is index 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:
+            _, antennas = self.reachy.get_current_joint_positions()
+            right = antennas[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:
+            _, antennas = self.reachy.get_current_joint_positions()
+            return math.degrees(antennas[0])  # right is index 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:
+            _, antennas = self.reachy.get_current_joint_positions()
+            left = antennas[1]
+            self.reachy.goto_target(antennas=[math.radians(angle_deg), left])
+        except Exception as e:
+            logger.error(f"Error setting right antenna: {e}")
+
+    # ========== Phase 4: Look At Control ==========
+
+    def get_look_at_x(self) -> float:
+        """Get look at target X coordinate in world frame (meters)."""
+        # This is a target position, not a current state
+        # We'll store it internally
+        return getattr(self, '_look_at_x', 0.0)
+
+    def set_look_at_x(self, x: float) -> None:
+        """Set look at target X coordinate."""
+        self._look_at_x = x
+        self._update_look_at()
+
+    def get_look_at_y(self) -> float:
+        """Get look at target Y coordinate in world frame (meters)."""
+        return getattr(self, '_look_at_y', 0.0)
+
+    def set_look_at_y(self, y: float) -> None:
+        """Set look at target Y coordinate."""
+        self._look_at_y = y
+        self._update_look_at()
+
+    def get_look_at_z(self) -> float:
+        """Get look at target Z coordinate in world frame (meters)."""
+        return getattr(self, '_look_at_z', 0.0)
+
+    def set_look_at_z(self, z: float) -> None:
+        """Set look at target Z coordinate."""
+        self._look_at_z = z
+        self._update_look_at()
+
+    def _update_look_at(self) -> None:
+        """Update robot to look at the target coordinates."""
+        if not self.is_available:
+            return
+        try:
+            x = getattr(self, '_look_at_x', 0.0)
+            y = getattr(self, '_look_at_y', 0.0)
+            z = getattr(self, '_look_at_z', 0.0)
+            self.reachy.look_at_world(x, y, z)
+            logger.info(f"Looking at world coordinates: ({x}, {y}, {z})")
+        except Exception as e:
+            logger.error(f"Error updating look at: {e}")
+
+    # ========== Phase 5: Audio Sensors ==========
+
+    def get_doa_angle(self) -> float:
+        """Get direction of arrival angle in degrees."""
+        if not self.is_available:
+            return 0.0
+        try:
+            # Access DOA through media_manager
+            doa_result = self.reachy.media.get_DoA()
+            if doa_result is not None:
+                # Convert radians to degrees
+                return math.degrees(doa_result[0])
+            return 0.0
+        except Exception as e:
+            logger.error(f"Error getting DOA angle: {e}")
+            return 0.0
+
+    def get_speech_detected(self) -> bool:
+        """Check if speech is detected."""
+        if not self.is_available:
+            return False
+        try:
+            # Access speech detection through media_manager
+            doa_result = self.reachy.media.get_DoA()
+            if doa_result is not None:
+                return doa_result[1]
+            return False
+        except Exception as e:
+            logger.error(f"Error getting speech detection: {e}")
+            return False
+
+    # ========== Phase 6: Diagnostic Information ==========
+
+    def get_control_loop_frequency(self) -> float:
+        """Get control loop frequency in Hz."""
+        if not self.is_available:
+            return 0.0
+        try:
+            # Get control loop stats from backend status
+            status = self.reachy.client.get_status(wait=False)
+            backend_status = status.get('backend_status')
+            if backend_status and isinstance(backend_status, dict):
+                control_loop_stats = backend_status.get('control_loop_stats', {})
+                return control_loop_stats.get('mean_control_loop_frequency', 0.0)
+            return 0.0
+        except Exception as e:
+            logger.error(f"Error getting control loop frequency: {e}")
+            return 0.0
+
+    def get_sdk_version(self) -> str:
+        """Get SDK version."""
+        if not self.is_available:
+            return "N/A"
+        try:
+            status = self.reachy.client.get_status(wait=False)
+            return status.get('version') or "unknown"
+        except Exception as e:
+            logger.error(f"Error getting SDK version: {e}")
+            return "error"
+
+    def get_robot_name(self) -> str:
+        """Get robot name."""
+        if not self.is_available:
+            return "N/A"
+        try:
+            status = self.reachy.client.get_status(wait=False)
+            return status.get('robot_name') or "unknown"
+        except Exception as e:
+            logger.error(f"Error getting robot name: {e}")
+            return "error"
+
+    def get_wireless_version(self) -> bool:
+        """Check if this is a wireless version."""
+        if not self.is_available:
+            return False
+        try:
+            status = self.reachy.client.get_status(wait=False)
+            return status.get('wireless_version', False)
+        except Exception as e:
+            logger.error(f"Error getting wireless version: {e}")
+            return False
+
+    def get_simulation_mode(self) -> bool:
+        """Check if simulation mode is enabled."""
+        if not self.is_available:
+            return False
+        try:
+            status = self.reachy.client.get_status(wait=False)
+            return status.get('simulation_enabled', False)
+        except Exception as e:
+            logger.error(f"Error getting simulation mode: {e}")
+            return False
+
+    def get_wlan_ip(self) -> str:
+        """Get WLAN IP address."""
+        if not self.is_available:
+            return "N/A"
+        try:
+            status = self.reachy.client.get_status(wait=False)
+            return status.get('wlan_ip') or "N/A"
+        except Exception as e:
+            logger.error(f"Error getting WLAN IP: {e}")
+            return "error"
+
+    # ========== Phase 7: IMU Sensors (Wireless only) ==========
+
+    def get_imu_accel_x(self) -> float:
+        """Get IMU X-axis acceleration in m/s²."""
+        if not self.is_available:
+            return 0.0
+        try:
+            imu_data = self.reachy.imu
+            if imu_data is not None and 'accelerometer' in imu_data:
+                return float(imu_data['accelerometer'][0])
+            return 0.0
+        except Exception as e:
+            logger.error(f"Error getting IMU accel X: {e}")
+            return 0.0
+
+    def get_imu_accel_y(self) -> float:
+        """Get IMU Y-axis acceleration in m/s²."""
+        if not self.is_available:
+            return 0.0
+        try:
+            imu_data = self.reachy.imu
+            if imu_data is not None and 'accelerometer' in imu_data:
+                return float(imu_data['accelerometer'][1])
+            return 0.0
+        except Exception as e:
+            logger.error(f"Error getting IMU accel Y: {e}")
+            return 0.0
+
+    def get_imu_accel_z(self) -> float:
+        """Get IMU Z-axis acceleration in m/s²."""
+        if not self.is_available:
+            return 0.0
+        try:
+            imu_data = self.reachy.imu
+            if imu_data is not None and 'accelerometer' in imu_data:
+                return float(imu_data['accelerometer'][2])
+            return 0.0
+        except Exception as e:
+            logger.error(f"Error getting IMU accel Z: {e}")
+            return 0.0
+
+    def get_imu_gyro_x(self) -> float:
+        """Get IMU X-axis angular velocity in rad/s."""
+        if not self.is_available:
+            return 0.0
+        try:
+            imu_data = self.reachy.imu
+            if imu_data is not None and 'gyroscope' in imu_data:
+                return float(imu_data['gyroscope'][0])
+            return 0.0
+        except Exception as e:
+            logger.error(f"Error getting IMU gyro X: {e}")
+            return 0.0
+
+    def get_imu_gyro_y(self) -> float:
+        """Get IMU Y-axis angular velocity in rad/s."""
+        if not self.is_available:
+            return 0.0
+        try:
+            imu_data = self.reachy.imu
+            if imu_data is not None and 'gyroscope' in imu_data:
+                return float(imu_data['gyroscope'][1])
+            return 0.0
+        except Exception as e:
+            logger.error(f"Error getting IMU gyro Y: {e}")
+            return 0.0
+
+    def get_imu_gyro_z(self) -> float:
+        """Get IMU Z-axis angular velocity in rad/s."""
+        if not self.is_available:
+            return 0.0
+        try:
+            imu_data = self.reachy.imu
+            if imu_data is not None and 'gyroscope' in imu_data:
+                return float(imu_data['gyroscope'][2])
+            return 0.0
+        except Exception as e:
+            logger.error(f"Error getting IMU gyro Z: {e}")
+            return 0.0
+
+    def get_imu_temperature(self) -> float:
+        """Get IMU temperature in °C."""
+        if not self.is_available:
+            return 0.0
+        try:
+            imu_data = self.reachy.imu
+            if imu_data is not None and 'temperature' in imu_data:
+                return float(imu_data['temperature'])
+            return 0.0
+        except Exception as e:
+            logger.error(f"Error getting IMU temperature: {e}")
+            return 0.0
+
+    # ========== Phase 11: LED Control (via local SDK) ==========
+
+    def _get_respeaker(self):
+        """Get ReSpeaker device from media manager."""
+        if not self.is_available:
+            logger.debug("ReSpeaker not available: robot not connected")
+            return None
+        try:
+            if not self.reachy.media:
+                logger.debug("ReSpeaker not available: media manager is None")
+                return None
+            if not self.reachy.media.audio:
+                logger.debug("ReSpeaker not available: audio is None")
+                return None
+            respeaker = self.reachy.media.audio._respeaker
+            if respeaker is None:
+                logger.debug("ReSpeaker not available: _respeaker is None (USB device not found)")
+            return respeaker
+        except Exception as e:
+            logger.debug(f"ReSpeaker not available: {e}")
+            return None
+
+    def get_led_brightness(self) -> float:
+        """Get LED brightness (0-100)."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return getattr(self, '_led_brightness', 50.0)
+        try:
+            result = respeaker.read("LED_BRIGHTNESS")
+            if result is not None:
+                # LED_BRIGHTNESS is 0-255, convert to 0-100
+                self._led_brightness = (result[1] / 255.0) * 100.0
+                return self._led_brightness
+        except Exception as e:
+            logger.debug(f"Error getting LED brightness: {e}")
+        return getattr(self, '_led_brightness', 50.0)
+
+    def set_led_brightness(self, brightness: float) -> None:
+        """Set LED brightness (0-100)."""
+        brightness = max(0.0, min(100.0, brightness))
+        self._led_brightness = brightness
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return
+        try:
+            # Convert 0-100 to 0-255
+            value = int((brightness / 100.0) * 255)
+            respeaker.write("LED_BRIGHTNESS", [value])
+            logger.info(f"LED brightness set to {brightness}%")
+        except Exception as e:
+            logger.error(f"Error setting LED brightness: {e}")
+
+    def get_led_effect(self) -> str:
+        """Get current LED effect."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return getattr(self, '_led_effect', 'off')
+        try:
+            result = respeaker.read("LED_EFFECT")
+            if result is not None:
+                effect_map = {0: 'off', 1: 'solid', 2: 'breathing', 3: 'rainbow', 4: 'doa'}
+                self._led_effect = effect_map.get(result[1], 'off')
+                return self._led_effect
+        except Exception as e:
+            logger.debug(f"Error getting LED effect: {e}")
+        return getattr(self, '_led_effect', 'off')
+
+    def set_led_effect(self, effect: str) -> None:
+        """Set LED effect."""
+        self._led_effect = effect
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return
+        try:
+            effect_map = {'off': 0, 'solid': 1, 'breathing': 2, 'rainbow': 3, 'doa': 4}
+            value = effect_map.get(effect, 0)
+            respeaker.write("LED_EFFECT", [value])
+            logger.info(f"LED effect set to {effect}")
+        except Exception as e:
+            logger.error(f"Error setting LED effect: {e}")
+
+    def get_led_color_r(self) -> float:
+        """Get LED red color component (0-255)."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return getattr(self, '_led_color_r', 0.0)
+        try:
+            result = respeaker.read("LED_COLOR")
+            if result is not None:
+                # LED_COLOR is a 32-bit value: 0x00RRGGBB
+                color = result[1] if len(result) > 1 else 0
+                self._led_color_r = float((color >> 16) & 0xFF)
+                return self._led_color_r
+        except Exception as e:
+            logger.debug(f"Error getting LED color R: {e}")
+        return getattr(self, '_led_color_r', 0.0)
+
+    def set_led_color_r(self, value: float) -> None:
+        """Set LED red color component (0-255)."""
+        self._led_color_r = max(0.0, min(255.0, value))
+        self._update_led_color()
+
+    def get_led_color_g(self) -> float:
+        """Get LED green color component (0-255)."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return getattr(self, '_led_color_g', 0.0)
+        try:
+            result = respeaker.read("LED_COLOR")
+            if result is not None:
+                color = result[1] if len(result) > 1 else 0
+                self._led_color_g = float((color >> 8) & 0xFF)
+                return self._led_color_g
+        except Exception as e:
+            logger.debug(f"Error getting LED color G: {e}")
+        return getattr(self, '_led_color_g', 0.0)
+
+    def set_led_color_g(self, value: float) -> None:
+        """Set LED green color component (0-255)."""
+        self._led_color_g = max(0.0, min(255.0, value))
+        self._update_led_color()
+
+    def get_led_color_b(self) -> float:
+        """Get LED blue color component (0-255)."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return getattr(self, '_led_color_b', 0.0)
+        try:
+            result = respeaker.read("LED_COLOR")
+            if result is not None:
+                color = result[1] if len(result) > 1 else 0
+                self._led_color_b = float(color & 0xFF)
+                return self._led_color_b
+        except Exception as e:
+            logger.debug(f"Error getting LED color B: {e}")
+        return getattr(self, '_led_color_b', 0.0)
+
+    def set_led_color_b(self, value: float) -> None:
+        """Set LED blue color component (0-255)."""
+        self._led_color_b = max(0.0, min(255.0, value))
+        self._update_led_color()
+
+    def _update_led_color(self) -> None:
+        """Update LED color from R, G, B components."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return
+        try:
+            r = int(getattr(self, '_led_color_r', 0))
+            g = int(getattr(self, '_led_color_g', 0))
+            b = int(getattr(self, '_led_color_b', 0))
+            color = (r << 16) | (g << 8) | b
+            respeaker.write("LED_COLOR", [color])
+            logger.info(f"LED color set to RGB({r}, {g}, {b})")
+        except Exception as e:
+            logger.error(f"Error setting LED color: {e}")
+
+    # ========== Phase 12: Audio Processing (via local SDK) ==========
+
+    def get_agc_enabled(self) -> bool:
+        """Get AGC (Automatic Gain Control) enabled status."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return getattr(self, '_agc_enabled', False)
+        try:
+            result = respeaker.read("PP_AGCONOFF")
+            if result is not None:
+                self._agc_enabled = bool(result[1])
+                return self._agc_enabled
+        except Exception as e:
+            logger.debug(f"Error getting AGC status: {e}")
+        return getattr(self, '_agc_enabled', False)
+
+    def set_agc_enabled(self, enabled: bool) -> None:
+        """Set AGC (Automatic Gain Control) enabled status."""
+        self._agc_enabled = enabled
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return
+        try:
+            respeaker.write("PP_AGCONOFF", [1 if enabled else 0])
+            logger.info(f"AGC {'enabled' if enabled else 'disabled'}")
+        except Exception as e:
+            logger.error(f"Error setting AGC status: {e}")
+
+    def get_agc_max_gain(self) -> float:
+        """Get AGC maximum gain in dB."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return getattr(self, '_agc_max_gain', 15.0)
+        try:
+            result = respeaker.read("PP_AGCMAXGAIN")
+            if result is not None:
+                self._agc_max_gain = float(result[0])
+                return self._agc_max_gain
+        except Exception as e:
+            logger.debug(f"Error getting AGC max gain: {e}")
+        return getattr(self, '_agc_max_gain', 15.0)
+
+    def set_agc_max_gain(self, gain: float) -> None:
+        """Set AGC maximum gain in dB."""
+        gain = max(0.0, min(30.0, gain))
+        self._agc_max_gain = gain
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return
+        try:
+            respeaker.write("PP_AGCMAXGAIN", [gain])
+            logger.info(f"AGC max gain set to {gain} dB")
+        except Exception as e:
+            logger.error(f"Error setting AGC max gain: {e}")
+
+    def get_noise_suppression(self) -> float:
+        """Get noise suppression level (0-100%)."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return getattr(self, '_noise_suppression', 50.0)
+        try:
+            result = respeaker.read("PP_MIN_NS")
+            if result is not None:
+                # PP_MIN_NS is typically a float value, convert to percentage
+                # Lower values = more suppression
+                self._noise_suppression = max(0.0, min(100.0, (1.0 - result[0]) * 100.0))
+                return self._noise_suppression
+        except Exception as e:
+            logger.debug(f"Error getting noise suppression: {e}")
+        return getattr(self, '_noise_suppression', 50.0)
+
+    def set_noise_suppression(self, level: float) -> None:
+        """Set noise suppression level (0-100%)."""
+        level = max(0.0, min(100.0, level))
+        self._noise_suppression = level
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return
+        try:
+            # Convert percentage to PP_MIN_NS value (inverted)
+            value = 1.0 - (level / 100.0)
+            respeaker.write("PP_MIN_NS", [value])
+            logger.info(f"Noise suppression set to {level}%")
+        except Exception as e:
+            logger.error(f"Error setting noise suppression: {e}")
+
+    def get_echo_cancellation_converged(self) -> bool:
+        """Check if echo cancellation has converged."""
+        respeaker = self._get_respeaker()
+        if respeaker is None:
+            return False
+        try:
+            result = respeaker.read("AEC_AECCONVERGED")
+            if result is not None:
+                return bool(result[1])
+        except Exception as e:
+            logger.debug(f"Error getting AEC converged status: {e}")
+        return False

reachy_mini_ha_voice/sounds/.gitkeep

@@ -1,2 +1,2 @@
-# This file ensures the sounds directory is tracked by git
+# This file ensures the sounds directory is tracked by git
 # Actual sound files (.flac, .mp3, .wav) should be added by users

reachy_mini_ha_voice/sounds/LICENSE.md

@@ -1 +1 @@
-[Home Assistant Voice Preview Edition Sounds](https://github.com/esphome/home-assistant-voice-pe/tree/dev/sounds) © 2024 by [Clayton Charles Tapp](https://www.cctaudio.com/) is licensed under [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0/?ref=chooser-v1) 
+[Home Assistant Voice Preview Edition Sounds](https://github.com/esphome/home-assistant-voice-pe/tree/dev/sounds) © 2024 by [Clayton Charles Tapp](https://www.cctaudio.com/) is licensed under [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0/?ref=chooser-v1) 

reachy_mini_ha_voice/sounds/README.md

@@ -1,10 +1,10 @@
-# Sound Effects
-
-Sound files are automatically downloaded on first run.
-
-## Files
-
-- `wake_word_triggered.flac` - Played when wake word is detected
-- `timer_finished.flac` - Played when a timer completes
-
+# Sound Effects
+
+Sound files are automatically downloaded on first run.
+
+## Files
+
+- `wake_word_triggered.flac` - Played when wake word is detected
+- `timer_finished.flac` - Played when a timer completes
+
 These files are downloaded from [linux-voice-assistant](https://github.com/OHF-Voice/linux-voice-assistant).

reachy_mini_ha_voice/static/index.html

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <title>Reachy Mini example app template</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="stylesheet" href="/static/style.css">
+</head>
+
+<body>
+    <h1>Reachy Mini – Control Panel</h1>
+
+    <div id="controls">
+        <label style="display:flex; align-items:center; gap:8px;">
+            <input type="checkbox" id="antenna-checkbox" checked>
+            Antennas
+        </label>
+
+        <button id="sound-btn">Play Sound</button>
+    </div>
+
+    <div id="status">Antennas status: running</div>
+    <script src="/static/main.js"></script>
+</body>
+
+</html>

reachy_mini_ha_voice/static/main.js

@@ -0,0 +1,47 @@
+let antennasEnabled = true;
+
+async function updateAntennasState(enabled) {
+    try {
+        const resp = await fetch("/antennas", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ enabled }),
+        });
+        const data = await resp.json();
+        antennasEnabled = data.antennas_enabled;
+        updateUI();
+    } catch (e) {
+        document.getElementById("status").textContent = "Backend error";
+    }
+}
+
+async function playSound() {
+    try {
+        await fetch("/play_sound", { method: "POST" });
+    } catch (e) {
+        console.error("Error triggering sound:", e);
+    }
+}
+
+function updateUI() {
+    const checkbox = document.getElementById("antenna-checkbox");
+    const status = document.getElementById("status");
+
+    checkbox.checked = antennasEnabled;
+
+    if (antennasEnabled) {
+        status.textContent = "Antennas status: running";
+    } else {
+        status.textContent = "Antennas status: stopped";
+    }
+}
+
+document.getElementById("antenna-checkbox").addEventListener("change", (e) => {
+    updateAntennasState(e.target.checked);
+});
+
+document.getElementById("sound-btn").addEventListener("click", () => {
+    playSound();
+});
+
+updateUI();

reachy_mini_ha_voice/static/style.css

@@ -0,0 +1,25 @@
+body {
+    font-family: sans-serif;
+    margin: 24px;
+}
+
+#sound-btn {
+    padding: 10px 20px;
+    border: none;
+    color: white;
+    cursor: pointer;
+    font-size: 16px;
+    border-radius: 6px;
+    background-color: #3498db;
+}
+
+#status {
+    margin-top: 16px;
+    font-weight: bold;
+}
+
+#controls {
+    display: flex;
+    align-items: center;
+    gap: 20px;
+}

reachy_mini_ha_voice/voice_assistant.py

@@ -1,671 +1,671 @@
-"""
-Voice Assistant Service for Reachy Mini.
-
-This module provides the main voice assistant service that integrates
-with Home Assistant via ESPHome protocol.
-"""
-
-import asyncio
-import json
-import logging
-import threading
-import time
-from pathlib import Path
-from queue import Queue
-from typing import Dict, List, Optional, Set, Union
-
-import numpy as np
-
-from reachy_mini import ReachyMini
-
-from .models import AvailableWakeWord, Preferences, ServerState, WakeWordType
-from .audio_player import AudioPlayer
-from .satellite import VoiceSatelliteProtocol
-from .util import get_mac
-from .zeroconf import HomeAssistantZeroconf
-from .motion import ReachyMiniMotion
-from .camera_server import MJPEGCameraServer
-
-_LOGGER = logging.getLogger(__name__)
-
-_MODULE_DIR = Path(__file__).parent
-_WAKEWORDS_DIR = _MODULE_DIR / "wakewords"
-_SOUNDS_DIR = _MODULE_DIR / "sounds"
-_LOCAL_DIR = _MODULE_DIR.parent / "local"
-
-
-class VoiceAssistantService:
-    """Voice assistant service that runs ESPHome protocol server."""
-
-    def __init__(
-        self,
-        reachy_mini: Optional[ReachyMini] = None,
-        name: str = "Reachy Mini",
-        host: str = "0.0.0.0",
-        port: int = 6053,
-        wake_model: str = "okay_nabu",
-        camera_port: int = 8081,
-        camera_enabled: bool = True,
-    ):
-        self.reachy_mini = reachy_mini
-        self.name = name
-        self.host = host
-        self.port = port
-        self.wake_model = wake_model
-        self.camera_port = camera_port
-        self.camera_enabled = camera_enabled
-
-        self._server = None
-        self._discovery = None
-        self._audio_thread = None
-        self._running = False
-        self._state: Optional[ServerState] = None
-        self._motion = ReachyMiniMotion(reachy_mini)
-        self._camera_server: Optional[MJPEGCameraServer] = None
-
-    async def start(self) -> None:
-        """Start the voice assistant service."""
-        _LOGGER.info("Initializing voice assistant service...")
-
-        # Ensure directories exist
-        _WAKEWORDS_DIR.mkdir(parents=True, exist_ok=True)
-        _SOUNDS_DIR.mkdir(parents=True, exist_ok=True)
-        _LOCAL_DIR.mkdir(parents=True, exist_ok=True)
-
-        # Verify required files (bundled with package)
-        await self._verify_required_files()
-
-        # Load wake words
-        available_wake_words = self._load_available_wake_words()
-        _LOGGER.debug("Available wake words: %s", list(available_wake_words.keys()))
-
-        # Load preferences
-        preferences_path = _LOCAL_DIR / "preferences.json"
-        preferences = self._load_preferences(preferences_path)
-
-        # Load wake word models
-        wake_models, active_wake_words = self._load_wake_models(
-            available_wake_words, preferences
-        )
-
-        # Load stop model
-        stop_model = self._load_stop_model()
-
-        # Create audio players with Reachy Mini reference
-        music_player = AudioPlayer(self.reachy_mini)
-        tts_player = AudioPlayer(self.reachy_mini)
-
-        # Create server state
-        self._state = ServerState(
-            name=self.name,
-            mac_address=get_mac(),
-            audio_queue=Queue(),
-            entities=[],
-            available_wake_words=available_wake_words,
-            wake_words=wake_models,
-            active_wake_words=active_wake_words,
-            stop_word=stop_model,
-            music_player=music_player,
-            tts_player=tts_player,
-            wakeup_sound=str(_SOUNDS_DIR / "wake_word_triggered.flac"),
-            timer_finished_sound=str(_SOUNDS_DIR / "timer_finished.flac"),
-            preferences=preferences,
-            preferences_path=preferences_path,
-            refractory_seconds=2.0,
-            download_dir=_LOCAL_DIR,
-            reachy_mini=self.reachy_mini,
-            motion_enabled=self.reachy_mini is not None,
-        )
-
-        # Set motion controller reference in state
-        self._state.motion = self._motion
-
-        # Start Reachy Mini media system if available
-        if self.reachy_mini is not None:
-            try:
-                self.reachy_mini.media.start_recording()
-                self.reachy_mini.media.start_playing()
-                _LOGGER.info("Reachy Mini media system initialized")
-            except Exception as e:
-                _LOGGER.warning("Failed to initialize Reachy Mini media: %s", e)
-
-        # Start audio processing thread
-        self._running = True
-        self._audio_thread = threading.Thread(
-            target=self._process_audio,
-            daemon=True,
-        )
-        self._audio_thread.start()
-
-        # Start camera server if enabled (must be before ESPHome server)
-        if self.camera_enabled:
-            self._camera_server = MJPEGCameraServer(
-                reachy_mini=self.reachy_mini,
-                host=self.host,
-                port=self.camera_port,
-                fps=15,
-                quality=80,
-            )
-            await self._camera_server.start()
-
-        # Create ESPHome server (pass camera_server for camera entity)
-        loop = asyncio.get_running_loop()
-        camera_server = self._camera_server  # Capture for lambda
-        self._server = await loop.create_server(
-            lambda: VoiceSatelliteProtocol(self._state, camera_server=camera_server),
-            host=self.host,
-            port=self.port,
-        )
-
-        # Start mDNS discovery
-        self._discovery = HomeAssistantZeroconf(port=self.port, name=self.name)
-        await self._discovery.register_server()
-
-        _LOGGER.info("Voice assistant service started on %s:%s", self.host, self.port)
-
-    async def stop(self) -> None:
-        """Stop the voice assistant service."""
-        _LOGGER.info("Stopping voice assistant service...")
-
-        self._running = False
-
-        if self._audio_thread:
-            self._audio_thread.join(timeout=2.0)
-
-        if self._server:
-            self._server.close()
-            await self._server.wait_closed()
-
-        if self._discovery:
-            await self._discovery.unregister_server()
-
-        # Stop camera server
-        if self._camera_server:
-            await self._camera_server.stop()
-            self._camera_server = None
-
-        # Stop Reachy Mini media system
-        if self.reachy_mini is not None:
-            try:
-                self.reachy_mini.media.stop_recording()
-                self.reachy_mini.media.stop_playing()
-            except Exception as e:
-                _LOGGER.warning("Error stopping Reachy Mini media: %s", e)
-
-        _LOGGER.info("Voice assistant service stopped.")
-
-    async def _verify_required_files(self) -> None:
-        """Verify required model and sound files exist (bundled with package)."""
-        # Required wake word files (bundled in wakewords/ directory)
-        required_wakewords = [
-            "okay_nabu.tflite",
-            "okay_nabu.json",
-            "hey_jarvis.tflite",
-            "hey_jarvis.json",
-            "stop.tflite",
-            "stop.json",
-        ]
-
-        # Required sound files (bundled in sounds/ directory)
-        required_sounds = [
-            "wake_word_triggered.flac",
-            "timer_finished.flac",
-        ]
-
-        # Verify wake word files
-        missing_wakewords = []
-        for filename in required_wakewords:
-            filepath = _WAKEWORDS_DIR / filename
-            if not filepath.exists():
-                missing_wakewords.append(filename)
-
-        if missing_wakewords:
-            _LOGGER.warning(
-                "Missing wake word files: %s. These should be bundled with the package.",
-                missing_wakewords
-            )
-
-        # Verify sound files
-        missing_sounds = []
-        for filename in required_sounds:
-            filepath = _SOUNDS_DIR / filename
-            if not filepath.exists():
-                missing_sounds.append(filename)
-
-        if missing_sounds:
-            _LOGGER.warning(
-                "Missing sound files: %s. These should be bundled with the package.",
-                missing_sounds
-            )
-
-        if not missing_wakewords and not missing_sounds:
-            _LOGGER.info("All required files verified successfully.")
-
-    def _load_available_wake_words(self) -> Dict[str, AvailableWakeWord]:
-        """Load available wake word configurations."""
-        available_wake_words: Dict[str, AvailableWakeWord] = {}
-
-        wake_word_dirs = [_WAKEWORDS_DIR, _LOCAL_DIR / "external_wake_words"]
-
-        for wake_word_dir in wake_word_dirs:
-            if not wake_word_dir.exists():
-                continue
-
-            for config_path in wake_word_dir.glob("*.json"):
-                model_id = config_path.stem
-                if model_id == "stop":
-                    continue
-
-                try:
-                    with open(config_path, "r", encoding="utf-8") as f:
-                        config = json.load(f)
-
-                    model_type = WakeWordType(config.get("type", "micro"))
-
-                    if model_type == WakeWordType.OPEN_WAKE_WORD:
-                        wake_word_path = config_path.parent / config["model"]
-                    else:
-                        wake_word_path = config_path
-
-                    available_wake_words[model_id] = AvailableWakeWord(
-                        id=model_id,
-                        type=model_type,
-                        wake_word=config.get("wake_word", model_id),
-                        trained_languages=config.get("trained_languages", []),
-                        wake_word_path=wake_word_path,
-                    )
-                except Exception as e:
-                    _LOGGER.warning("Failed to load wake word %s: %s", config_path, e)
-
-        return available_wake_words
-
-    def _load_preferences(self, preferences_path: Path) -> Preferences:
-        """Load user preferences."""
-        if preferences_path.exists():
-            try:
-                with open(preferences_path, "r", encoding="utf-8") as f:
-                    data = json.load(f)
-                return Preferences(**data)
-            except Exception as e:
-                _LOGGER.warning("Failed to load preferences: %s", e)
-
-        return Preferences()
-
-    def _load_wake_models(
-        self,
-        available_wake_words: Dict[str, AvailableWakeWord],
-        preferences: Preferences,
-    ):
-        """Load wake word models."""
-        from pymicro_wakeword import MicroWakeWord
-        from pyopen_wakeword import OpenWakeWord
-
-        wake_models: Dict[str, Union[MicroWakeWord, OpenWakeWord]] = {}
-        active_wake_words: Set[str] = set()
-
-        # Try to load preferred models
-        if preferences.active_wake_words:
-            for wake_word_id in preferences.active_wake_words:
-                wake_word = available_wake_words.get(wake_word_id)
-                if wake_word is None:
-                    _LOGGER.warning("Unknown wake word: %s", wake_word_id)
-                    continue
-
-                try:
-                    _LOGGER.debug("Loading wake model: %s", wake_word_id)
-                    wake_models[wake_word_id] = wake_word.load()
-                    active_wake_words.add(wake_word_id)
-                except Exception as e:
-                    _LOGGER.warning("Failed to load wake model %s: %s", wake_word_id, e)
-
-        # Load default model if none loaded
-        if not wake_models:
-            wake_word = available_wake_words.get(self.wake_model)
-            if wake_word:
-                try:
-                    _LOGGER.debug("Loading default wake model: %s", self.wake_model)
-                    wake_models[self.wake_model] = wake_word.load()
-                    active_wake_words.add(self.wake_model)
-                except Exception as e:
-                    _LOGGER.error("Failed to load default wake model: %s", e)
-
-        return wake_models, active_wake_words
-
-    def _load_stop_model(self):
-        """Load the stop word model."""
-        from pymicro_wakeword import MicroWakeWord
-
-        stop_config = _WAKEWORDS_DIR / "stop.json"
-        if stop_config.exists():
-            try:
-                return MicroWakeWord.from_config(stop_config)
-            except Exception as e:
-                _LOGGER.warning("Failed to load stop model: %s", e)
-
-        # Return a dummy model if stop model not available
-        _LOGGER.warning("Stop model not available, using fallback")
-        okay_nabu_config = _WAKEWORDS_DIR / "okay_nabu.json"
-        if okay_nabu_config.exists():
-            return MicroWakeWord.from_config(okay_nabu_config)
-
-        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
-
-        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
-
-        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:
-                _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
-                )
-            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
-                )
-
-        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()
-
-        while self._running:
-            try:
-                # Skip if no satellite connection
-                if self._state is None or self._state.satellite is None:
-                    time.sleep(0.1)
-                    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])
-
-                # Get audio from Reachy Mini
-                audio_data = self.reachy_mini.media.get_audio_sample()
-
-                # Skip if no data
-                if audio_data 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()
-
-            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)."""
-        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,
-            channels=1,
-            blocksize=block_size,
-            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)
-                    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()
-
-                audio_chunk_array, overflowed = stream.read(block_size)
-                if overflowed:
-                    _LOGGER.warning("Audio buffer overflow")
-
-                audio_chunk_array = audio_chunk_array.reshape(-1)
-
-                # 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()
-
-    def _get_doa_angle_deg(self) -> Optional[float]:
-        """Get DOA angle in degrees from Reachy Mini's microphone array.
-
-        The ReSpeaker DOA returns angle in radians where:
-        - 0 radians = left
-        - π/2 radians = front/back
-        - π radians = right
-
-        We convert this to head yaw degrees where:
-        - 0 = front
-        - positive = right
-        - negative = left
-
-        Returns:
-            DOA angle in degrees suitable for head yaw, or None if unavailable.
-        """
-        if self.reachy_mini is None:
-            return None
-
-        try:
-            import math
-            doa_result = self.reachy_mini.media.get_DoA()
-            if doa_result is None:
-                _LOGGER.debug("DOA not available")
-                return None
-
-            doa_radians, speech_detected = doa_result
-
-            # Note: We don't check speech_detected here because we already know
-            # speech was detected (wake word triggered this call).
-            # The DOA value should still be valid from the recent speech.
-
-            # Convert ReSpeaker DOA to head yaw angle
-            # ReSpeaker: 0=left, π/2=front, π=right
-            # Head yaw: 0=front, positive=right, negative=left
-            # Formula: yaw = (doa - π/2) converted to degrees
-            yaw_radians = doa_radians - (math.pi / 2)
-            yaw_degrees = math.degrees(yaw_radians)
-
-            _LOGGER.info("DOA detected: %.1f rad -> yaw %.1f deg (speech=%s)",
-                        doa_radians, yaw_degrees, speech_detected)
-
-            return yaw_degrees
-
-        except Exception as e:
-            _LOGGER.error("Error getting DOA angle: %s", e)
-            return None
+"""
+Voice Assistant Service for Reachy Mini.
+
+This module provides the main voice assistant service that integrates
+with Home Assistant via ESPHome protocol.
+"""
+
+import asyncio
+import json
+import logging
+import threading
+import time
+from pathlib import Path
+from queue import Queue
+from typing import Dict, List, Optional, Set, Union
+
+import numpy as np
+
+from reachy_mini import ReachyMini
+
+from .models import AvailableWakeWord, Preferences, ServerState, WakeWordType
+from .audio_player import AudioPlayer
+from .satellite import VoiceSatelliteProtocol
+from .util import get_mac
+from .zeroconf import HomeAssistantZeroconf
+from .motion import ReachyMiniMotion
+from .camera_server import MJPEGCameraServer
+
+_LOGGER = logging.getLogger(__name__)
+
+_MODULE_DIR = Path(__file__).parent
+_WAKEWORDS_DIR = _MODULE_DIR / "wakewords"
+_SOUNDS_DIR = _MODULE_DIR / "sounds"
+_LOCAL_DIR = _MODULE_DIR.parent / "local"
+
+
+class VoiceAssistantService:
+    """Voice assistant service that runs ESPHome protocol server."""
+
+    def __init__(
+        self,
+        reachy_mini: Optional[ReachyMini] = None,
+        name: str = "Reachy Mini",
+        host: str = "0.0.0.0",
+        port: int = 6053,
+        wake_model: str = "okay_nabu",
+        camera_port: int = 8081,
+        camera_enabled: bool = True,
+    ):
+        self.reachy_mini = reachy_mini
+        self.name = name
+        self.host = host
+        self.port = port
+        self.wake_model = wake_model
+        self.camera_port = camera_port
+        self.camera_enabled = camera_enabled
+
+        self._server = None
+        self._discovery = None
+        self._audio_thread = None
+        self._running = False
+        self._state: Optional[ServerState] = None
+        self._motion = ReachyMiniMotion(reachy_mini)
+        self._camera_server: Optional[MJPEGCameraServer] = None
+
+    async def start(self) -> None:
+        """Start the voice assistant service."""
+        _LOGGER.info("Initializing voice assistant service...")
+
+        # Ensure directories exist
+        _WAKEWORDS_DIR.mkdir(parents=True, exist_ok=True)
+        _SOUNDS_DIR.mkdir(parents=True, exist_ok=True)
+        _LOCAL_DIR.mkdir(parents=True, exist_ok=True)
+
+        # Verify required files (bundled with package)
+        await self._verify_required_files()
+
+        # Load wake words
+        available_wake_words = self._load_available_wake_words()
+        _LOGGER.debug("Available wake words: %s", list(available_wake_words.keys()))
+
+        # Load preferences
+        preferences_path = _LOCAL_DIR / "preferences.json"
+        preferences = self._load_preferences(preferences_path)
+
+        # Load wake word models
+        wake_models, active_wake_words = self._load_wake_models(
+            available_wake_words, preferences
+        )
+
+        # Load stop model
+        stop_model = self._load_stop_model()
+
+        # Create audio players with Reachy Mini reference
+        music_player = AudioPlayer(self.reachy_mini)
+        tts_player = AudioPlayer(self.reachy_mini)
+
+        # Create server state
+        self._state = ServerState(
+            name=self.name,
+            mac_address=get_mac(),
+            audio_queue=Queue(),
+            entities=[],
+            available_wake_words=available_wake_words,
+            wake_words=wake_models,
+            active_wake_words=active_wake_words,
+            stop_word=stop_model,
+            music_player=music_player,
+            tts_player=tts_player,
+            wakeup_sound=str(_SOUNDS_DIR / "wake_word_triggered.flac"),
+            timer_finished_sound=str(_SOUNDS_DIR / "timer_finished.flac"),
+            preferences=preferences,
+            preferences_path=preferences_path,
+            refractory_seconds=2.0,
+            download_dir=_LOCAL_DIR,
+            reachy_mini=self.reachy_mini,
+            motion_enabled=self.reachy_mini is not None,
+        )
+
+        # Set motion controller reference in state
+        self._state.motion = self._motion
+
+        # Start Reachy Mini media system if available
+        if self.reachy_mini is not None:
+            try:
+                self.reachy_mini.media.start_recording()
+                self.reachy_mini.media.start_playing()
+                _LOGGER.info("Reachy Mini media system initialized")
+            except Exception as e:
+                _LOGGER.warning("Failed to initialize Reachy Mini media: %s", e)
+
+        # Start audio processing thread
+        self._running = True
+        self._audio_thread = threading.Thread(
+            target=self._process_audio,
+            daemon=True,
+        )
+        self._audio_thread.start()
+
+        # Start camera server if enabled (must be before ESPHome server)
+        if self.camera_enabled:
+            self._camera_server = MJPEGCameraServer(
+                reachy_mini=self.reachy_mini,
+                host=self.host,
+                port=self.camera_port,
+                fps=15,
+                quality=80,
+            )
+            await self._camera_server.start()
+
+        # Create ESPHome server (pass camera_server for camera entity)
+        loop = asyncio.get_running_loop()
+        camera_server = self._camera_server  # Capture for lambda
+        self._server = await loop.create_server(
+            lambda: VoiceSatelliteProtocol(self._state, camera_server=camera_server),
+            host=self.host,
+            port=self.port,
+        )
+
+        # Start mDNS discovery
+        self._discovery = HomeAssistantZeroconf(port=self.port, name=self.name)
+        await self._discovery.register_server()
+
+        _LOGGER.info("Voice assistant service started on %s:%s", self.host, self.port)
+
+    async def stop(self) -> None:
+        """Stop the voice assistant service."""
+        _LOGGER.info("Stopping voice assistant service...")
+
+        self._running = False
+
+        if self._audio_thread:
+            self._audio_thread.join(timeout=2.0)
+
+        if self._server:
+            self._server.close()
+            await self._server.wait_closed()
+
+        if self._discovery:
+            await self._discovery.unregister_server()
+
+        # Stop camera server
+        if self._camera_server:
+            await self._camera_server.stop()
+            self._camera_server = None
+
+        # Stop Reachy Mini media system
+        if self.reachy_mini is not None:
+            try:
+                self.reachy_mini.media.stop_recording()
+                self.reachy_mini.media.stop_playing()
+            except Exception as e:
+                _LOGGER.warning("Error stopping Reachy Mini media: %s", e)
+
+        _LOGGER.info("Voice assistant service stopped.")
+
+    async def _verify_required_files(self) -> None:
+        """Verify required model and sound files exist (bundled with package)."""
+        # Required wake word files (bundled in wakewords/ directory)
+        required_wakewords = [
+            "okay_nabu.tflite",
+            "okay_nabu.json",
+            "hey_jarvis.tflite",
+            "hey_jarvis.json",
+            "stop.tflite",
+            "stop.json",
+        ]
+
+        # Required sound files (bundled in sounds/ directory)
+        required_sounds = [
+            "wake_word_triggered.flac",
+            "timer_finished.flac",
+        ]
+
+        # Verify wake word files
+        missing_wakewords = []
+        for filename in required_wakewords:
+            filepath = _WAKEWORDS_DIR / filename
+            if not filepath.exists():
+                missing_wakewords.append(filename)
+
+        if missing_wakewords:
+            _LOGGER.warning(
+                "Missing wake word files: %s. These should be bundled with the package.",
+                missing_wakewords
+            )
+
+        # Verify sound files
+        missing_sounds = []
+        for filename in required_sounds:
+            filepath = _SOUNDS_DIR / filename
+            if not filepath.exists():
+                missing_sounds.append(filename)
+
+        if missing_sounds:
+            _LOGGER.warning(
+                "Missing sound files: %s. These should be bundled with the package.",
+                missing_sounds
+            )
+
+        if not missing_wakewords and not missing_sounds:
+            _LOGGER.info("All required files verified successfully.")
+
+    def _load_available_wake_words(self) -> Dict[str, AvailableWakeWord]:
+        """Load available wake word configurations."""
+        available_wake_words: Dict[str, AvailableWakeWord] = {}
+
+        wake_word_dirs = [_WAKEWORDS_DIR, _LOCAL_DIR / "external_wake_words"]
+
+        for wake_word_dir in wake_word_dirs:
+            if not wake_word_dir.exists():
+                continue
+
+            for config_path in wake_word_dir.glob("*.json"):
+                model_id = config_path.stem
+                if model_id == "stop":
+                    continue
+
+                try:
+                    with open(config_path, "r", encoding="utf-8") as f:
+                        config = json.load(f)
+
+                    model_type = WakeWordType(config.get("type", "micro"))
+
+                    if model_type == WakeWordType.OPEN_WAKE_WORD:
+                        wake_word_path = config_path.parent / config["model"]
+                    else:
+                        wake_word_path = config_path
+
+                    available_wake_words[model_id] = AvailableWakeWord(
+                        id=model_id,
+                        type=model_type,
+                        wake_word=config.get("wake_word", model_id),
+                        trained_languages=config.get("trained_languages", []),
+                        wake_word_path=wake_word_path,
+                    )
+                except Exception as e:
+                    _LOGGER.warning("Failed to load wake word %s: %s", config_path, e)
+
+        return available_wake_words
+
+    def _load_preferences(self, preferences_path: Path) -> Preferences:
+        """Load user preferences."""
+        if preferences_path.exists():
+            try:
+                with open(preferences_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                return Preferences(**data)
+            except Exception as e:
+                _LOGGER.warning("Failed to load preferences: %s", e)
+
+        return Preferences()
+
+    def _load_wake_models(
+        self,
+        available_wake_words: Dict[str, AvailableWakeWord],
+        preferences: Preferences,
+    ):
+        """Load wake word models."""
+        from pymicro_wakeword import MicroWakeWord
+        from pyopen_wakeword import OpenWakeWord
+
+        wake_models: Dict[str, Union[MicroWakeWord, OpenWakeWord]] = {}
+        active_wake_words: Set[str] = set()
+
+        # Try to load preferred models
+        if preferences.active_wake_words:
+            for wake_word_id in preferences.active_wake_words:
+                wake_word = available_wake_words.get(wake_word_id)
+                if wake_word is None:
+                    _LOGGER.warning("Unknown wake word: %s", wake_word_id)
+                    continue
+
+                try:
+                    _LOGGER.debug("Loading wake model: %s", wake_word_id)
+                    wake_models[wake_word_id] = wake_word.load()
+                    active_wake_words.add(wake_word_id)
+                except Exception as e:
+                    _LOGGER.warning("Failed to load wake model %s: %s", wake_word_id, e)
+
+        # Load default model if none loaded
+        if not wake_models:
+            wake_word = available_wake_words.get(self.wake_model)
+            if wake_word:
+                try:
+                    _LOGGER.debug("Loading default wake model: %s", self.wake_model)
+                    wake_models[self.wake_model] = wake_word.load()
+                    active_wake_words.add(self.wake_model)
+                except Exception as e:
+                    _LOGGER.error("Failed to load default wake model: %s", e)
+
+        return wake_models, active_wake_words
+
+    def _load_stop_model(self):
+        """Load the stop word model."""
+        from pymicro_wakeword import MicroWakeWord
+
+        stop_config = _WAKEWORDS_DIR / "stop.json"
+        if stop_config.exists():
+            try:
+                return MicroWakeWord.from_config(stop_config)
+            except Exception as e:
+                _LOGGER.warning("Failed to load stop model: %s", e)
+
+        # Return a dummy model if stop model not available
+        _LOGGER.warning("Stop model not available, using fallback")
+        okay_nabu_config = _WAKEWORDS_DIR / "okay_nabu.json"
+        if okay_nabu_config.exists():
+            return MicroWakeWord.from_config(okay_nabu_config)
+
+        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
+
+        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
+
+        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:
+                _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
+                )
+            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
+                )
+
+        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()
+
+        while self._running:
+            try:
+                # Skip if no satellite connection
+                if self._state is None or self._state.satellite is None:
+                    time.sleep(0.1)
+                    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])
+
+                # Get audio from Reachy Mini
+                audio_data = self.reachy_mini.media.get_audio_sample()
+
+                # Skip if no data
+                if audio_data 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()
+
+            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)."""
+        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,
+            channels=1,
+            blocksize=block_size,
+            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)
+                    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()
+
+                audio_chunk_array, overflowed = stream.read(block_size)
+                if overflowed:
+                    _LOGGER.warning("Audio buffer overflow")
+
+                audio_chunk_array = audio_chunk_array.reshape(-1)
+
+                # 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()
+
+    def _get_doa_angle_deg(self) -> Optional[float]:
+        """Get DOA angle in degrees from Reachy Mini's microphone array.
+
+        The ReSpeaker DOA returns angle in radians where:
+        - 0 radians = left
+        - π/2 radians = front/back
+        - π radians = right
+
+        We convert this to head yaw degrees where:
+        - 0 = front
+        - positive = right
+        - negative = left
+
+        Returns:
+            DOA angle in degrees suitable for head yaw, or None if unavailable.
+        """
+        if self.reachy_mini is None:
+            return None
+
+        try:
+            import math
+            doa_result = self.reachy_mini.media.get_DoA()
+            if doa_result is None:
+                _LOGGER.debug("DOA not available")
+                return None
+
+            doa_radians, speech_detected = doa_result
+
+            # Note: We don't check speech_detected here because we already know
+            # speech was detected (wake word triggered this call).
+            # The DOA value should still be valid from the recent speech.
+
+            # Convert ReSpeaker DOA to head yaw angle
+            # ReSpeaker: 0=left, π/2=front, π=right
+            # Head yaw: 0=front, positive=right, negative=left
+            # Formula: yaw = (doa - π/2) converted to degrees
+            yaw_radians = doa_radians - (math.pi / 2)
+            yaw_degrees = math.degrees(yaw_radians)
+
+            _LOGGER.info("DOA detected: %.1f rad -> yaw %.1f deg (speech=%s)",
+                        doa_radians, yaw_degrees, speech_detected)
+
+            return yaw_degrees
+
+        except Exception as e:
+            _LOGGER.error("Error getting DOA angle: %s", e)
+            return None

reachy_mini_ha_voice/wakewords/README.md

@@ -1,11 +1,11 @@
-# Wake Word Models
-
-Wake word models are automatically downloaded on first run.
-
-## Files
-
-- `okay_nabu.json` / `okay_nabu.tflite` - Default wake word "Okay Nabu"
-- `hey_jarvis.json` / `hey_jarvis.tflite` - Alternative wake word "Hey Jarvis"
-- `stop.json` / `stop.tflite` - Stop word for canceling
-
-These models are downloaded from [esphome/micro-wake-word-models](https://github.com/esphome/micro-wake-word-models).
+# Wake Word Models
+
+Wake word models are automatically downloaded on first run.
+
+## Files
+
+- `okay_nabu.json` / `okay_nabu.tflite` - Default wake word "Okay Nabu"
+- `hey_jarvis.json` / `hey_jarvis.tflite` - Alternative wake word "Hey Jarvis"
+- `stop.json` / `stop.tflite` - Stop word for canceling
+
+These models are downloaded from [esphome/micro-wake-word-models](https://github.com/esphome/micro-wake-word-models).

reachy_mini_ha_voice/wakewords/alexa.json

@@ -1,16 +1,16 @@
-{
-  "type": "micro",
-  "wake_word": "Alexa",
-  "author": "Kevin Ahrendt",
-  "website": "https://www.kevinahrendt.com/",
-  "model": "alexa.tflite",
-  "trained_languages": ["en"],
-  "version": 2,
-  "micro": {
-    "probability_cutoff": 0.9,
-    "sliding_window_size": 5,
-    "feature_step_size": 10,
-    "tensor_arena_size": 22348,
-    "minimum_esphome_version": "2024.7.0"
-  }
-}
+{
+  "type": "micro",
+  "wake_word": "Alexa",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "alexa.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.9,
+    "sliding_window_size": 5,
+    "feature_step_size": 10,
+    "tensor_arena_size": 22348,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

reachy_mini_ha_voice/wakewords/choo_choo_homie.json

@@ -1,18 +1,18 @@
-{
-    "type": "micro",
-    "wake_word": "Choo Choo Homie",
-    "author": "Michael Hansen",
-    "website": "https://www.home-assistant.io",
-    "model": "choo_choo_homie.tflite",
-    "trained_languages": [
-        "en"
-    ],
-    "version": 2,
-    "micro": {
-        "probability_cutoff": 0.97,
-        "feature_step_size": 10,
-        "sliding_window_size": 5,
-        "tensor_arena_size": 30000,
-        "minimum_esphome_version": "2024.7.0"
-    }
+{
+    "type": "micro",
+    "wake_word": "Choo Choo Homie",
+    "author": "Michael Hansen",
+    "website": "https://www.home-assistant.io",
+    "model": "choo_choo_homie.tflite",
+    "trained_languages": [
+        "en"
+    ],
+    "version": 2,
+    "micro": {
+        "probability_cutoff": 0.97,
+        "feature_step_size": 10,
+        "sliding_window_size": 5,
+        "tensor_arena_size": 30000,
+        "minimum_esphome_version": "2024.7.0"
+    }
 }

reachy_mini_ha_voice/wakewords/hey_home_assistant.json

@@ -1,16 +1,16 @@
-{
-  "type": "micro",
-  "wake_word": "Hey Home Assistant",
-  "author": "Michael Hansen",
-  "website": "https://www.home-assistant.io",
-  "model": "hey_home_assistant.tflite",
-  "trained_languages": ["en"],
-  "version": 2,
-  "micro": {
-    "probability_cutoff": 0.97,
-    "feature_step_size": 10,
-    "sliding_window_size": 5,
-    "tensor_arena_size": 30000,
-    "minimum_esphome_version": "2024.7.0"
-  }
-}
+{
+  "type": "micro",
+  "wake_word": "Hey Home Assistant",
+  "author": "Michael Hansen",
+  "website": "https://www.home-assistant.io",
+  "model": "hey_home_assistant.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.97,
+    "feature_step_size": 10,
+    "sliding_window_size": 5,
+    "tensor_arena_size": 30000,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

reachy_mini_ha_voice/wakewords/hey_jarvis.json

@@ -1,16 +1,16 @@
-{
-  "type": "micro",
-  "wake_word": "Hey Jarvis",
-  "author": "Kevin Ahrendt",
-  "website": "https://www.kevinahrendt.com/",
-  "model": "hey_jarvis.tflite",
-  "trained_languages": ["en"],
-  "version": 2,
-  "micro": {
-    "probability_cutoff": 0.97,
-    "feature_step_size": 10,
-    "sliding_window_size": 5,
-    "tensor_arena_size": 22860,
-    "minimum_esphome_version": "2024.7.0"
-  }
-}
+{
+  "type": "micro",
+  "wake_word": "Hey Jarvis",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "hey_jarvis.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.97,
+    "feature_step_size": 10,
+    "sliding_window_size": 5,
+    "tensor_arena_size": 22860,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

reachy_mini_ha_voice/wakewords/hey_luna.json

@@ -1,16 +1,16 @@
-{
-    "type": "micro",
-    "wake_word": "hey_luna",
-    "author": "adamlonsdale",
-    "website": "https://github.com/adamlonsdale",
-    "model": "hey_luna.tflite",
-    "version": 2,
-    "trained_languages": ["en"],
-    "micro": {
-      "probability_cutoff": 0.63,
-      "sliding_window_size": 5,
-      "feature_step_size": 10,
-      "tensor_arena_size": 22860,
-      "minimum_esphome_version": "2024.7.0"
-    }
-  }
+{
+    "type": "micro",
+    "wake_word": "hey_luna",
+    "author": "adamlonsdale",
+    "website": "https://github.com/adamlonsdale",
+    "model": "hey_luna.tflite",
+    "version": 2,
+    "trained_languages": ["en"],
+    "micro": {
+      "probability_cutoff": 0.63,
+      "sliding_window_size": 5,
+      "feature_step_size": 10,
+      "tensor_arena_size": 22860,
+      "minimum_esphome_version": "2024.7.0"
+    }
+  }

reachy_mini_ha_voice/wakewords/hey_mycroft.json

@@ -1,16 +1,16 @@
-{
-  "type": "micro",
-  "wake_word": "Hey Mycroft",
-  "author": "Kevin Ahrendt",
-  "website": "https://www.kevinahrendt.com/",
-  "model": "hey_mycroft.tflite",
-  "trained_languages": ["en"],
-  "version": 2,
-  "micro": {
-    "probability_cutoff": 0.95,
-    "sliding_window_size": 5,
-    "feature_step_size": 10,
-    "tensor_arena_size": 23628,
-    "minimum_esphome_version": "2024.7.0"
-  }
-}
+{
+  "type": "micro",
+  "wake_word": "Hey Mycroft",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "hey_mycroft.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.95,
+    "sliding_window_size": 5,
+    "feature_step_size": 10,
+    "tensor_arena_size": 23628,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

reachy_mini_ha_voice/wakewords/okay_computer.json

@@ -1,18 +1,18 @@
-{
-    "type": "micro",
-    "wake_word": "Okay Computer",
-    "author": "Michael Hansen",
-    "website": "https://www.home-assistant.io",
-    "model": "okay_computer.tflite",
-    "trained_languages": [
-        "en"
-    ],
-    "version": 2,
-    "micro": {
-        "probability_cutoff": 0.97,
-        "feature_step_size": 10,
-        "sliding_window_size": 5,
-        "tensor_arena_size": 30000,
-        "minimum_esphome_version": "2024.7.0"
-    }
-}
+{
+    "type": "micro",
+    "wake_word": "Okay Computer",
+    "author": "Michael Hansen",
+    "website": "https://www.home-assistant.io",
+    "model": "okay_computer.tflite",
+    "trained_languages": [
+        "en"
+    ],
+    "version": 2,
+    "micro": {
+        "probability_cutoff": 0.97,
+        "feature_step_size": 10,
+        "sliding_window_size": 5,
+        "tensor_arena_size": 30000,
+        "minimum_esphome_version": "2024.7.0"
+    }
+}

reachy_mini_ha_voice/wakewords/okay_nabu.json

@@ -1,16 +1,16 @@
-{
-  "type": "micro",
-  "wake_word": "Okay Nabu",
-  "author": "Kevin Ahrendt",
-  "website": "https://www.kevinahrendt.com/",
-  "model": "okay_nabu.tflite",
-  "trained_languages": ["en","nl","fr","de","it","es","sv"],
-  "version": 2,
-  "micro": {
-    "probability_cutoff": 0.85,
-    "feature_step_size": 10,
-    "sliding_window_size": 5,
-    "tensor_arena_size": 37000,
-    "minimum_esphome_version": "2024.7.0"
-  }
-}
+{
+  "type": "micro",
+  "wake_word": "Okay Nabu",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "okay_nabu.tflite",
+  "trained_languages": ["en","nl","fr","de","it","es","sv"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.85,
+    "feature_step_size": 10,
+    "sliding_window_size": 5,
+    "tensor_arena_size": 37000,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

reachy_mini_ha_voice/wakewords/openWakeWord/alexa_v0.1.json

@@ -1,5 +1,5 @@
-{
-  "type": "openWakeWord",
-  "wake_word": "Alexa",
-  "model": "alexa_v0.1.tflite"
-}
+{
+  "type": "openWakeWord",
+  "wake_word": "Alexa",
+  "model": "alexa_v0.1.tflite"
+}

reachy_mini_ha_voice/wakewords/openWakeWord/hey_jarvis_v0.1.json

@@ -1,5 +1,5 @@
-{
-  "type": "openWakeWord",
-  "wake_word": "Hey Jarvis",
-  "model": "hey_jarvis_v0.1.tflite"
-}
+{
+  "type": "openWakeWord",
+  "wake_word": "Hey Jarvis",
+  "model": "hey_jarvis_v0.1.tflite"
+}

reachy_mini_ha_voice/wakewords/openWakeWord/hey_mycroft_v0.1.json

@@ -1,5 +1,5 @@
-{
-  "type": "openWakeWord",
-  "wake_word": "Hey Mycroft",
-  "model": "hey_mycroft_v0.1.tflite"
-}
+{
+  "type": "openWakeWord",
+  "wake_word": "Hey Mycroft",
+  "model": "hey_mycroft_v0.1.tflite"
+}

reachy_mini_ha_voice/wakewords/openWakeWord/hey_rhasspy_v0.1.json

@@ -1,5 +1,5 @@
-{
-  "type": "openWakeWord",
-  "wake_word": "Hey Rhasspy",
-  "model": "hey_rhasspy_v0.1.tflite"
-}
+{
+  "type": "openWakeWord",
+  "wake_word": "Hey Rhasspy",
+  "model": "hey_rhasspy_v0.1.tflite"
+}

reachy_mini_ha_voice/wakewords/openWakeWord/ok_nabu_v0.1.json

@@ -1,5 +1,5 @@
-{
-  "type": "openWakeWord",
-  "wake_word": "Okay Nabu",
-  "model": "ok_nabu_v0.1.tflite"
-}
+{
+  "type": "openWakeWord",
+  "wake_word": "Okay Nabu",
+  "model": "ok_nabu_v0.1.tflite"
+}

reachy_mini_ha_voice/wakewords/stop.json

@@ -1,16 +1,16 @@
-{
-  "type": "micro",
-  "wake_word": "Stop",
-  "author": "Kevin Ahrendt",
-  "website": "https://www.kevinahrendt.com/",
-  "model": "stop.tflite",
-  "trained_languages": ["en"],
-  "version": 2,
-  "micro": {
-    "probability_cutoff": 0.5,
-    "feature_step_size": 10,
-    "sliding_window_size": 5,
-    "tensor_arena_size": 21000,
-    "minimum_esphome_version": "2024.7.0"
-  }
-}
+{
+  "type": "micro",
+  "wake_word": "Stop",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "stop.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.5,
+    "feature_step_size": 10,
+    "sliding_window_size": 5,
+    "tensor_arena_size": 21000,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

style.css

@@ -0,0 +1,411 @@
+* {
+	margin: 0;
+	padding: 0;
+	box-sizing: border-box;
+}
+
+body {
+	font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+	line-height: 1.6;
+	color: #333;
+	background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+	min-height: 100vh;
+}
+
+.hero {
+	background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+	color: white;
+	padding: 4rem 2rem;
+	text-align: center;
+}
+
+.hero-content {
+	max-width: 800px;
+	margin: 0 auto;
+}
+
+.app-icon {
+	font-size: 4rem;
+	margin-bottom: 1rem;
+	display: inline-block;
+}
+
+.hero h1 {
+	font-size: 3rem;
+	font-weight: 700;
+	margin-bottom: 1rem;
+	background: linear-gradient(45deg, #fff, #f0f9ff);
+	background-clip: text;
+	-webkit-background-clip: text;
+	-webkit-text-fill-color: transparent;
+}
+
+.tagline {
+	font-size: 1.25rem;
+	opacity: 0.9;
+	max-width: 600px;
+	margin: 0 auto;
+}
+
+.container {
+	max-width: 1200px;
+	margin: 0 auto;
+	padding: 0 2rem;
+	position: relative;
+	z-index: 2;
+}
+
+.main-card {
+	background: white;
+	border-radius: 20px;
+	box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
+	margin-top: -2rem;
+	overflow: hidden;
+	margin-bottom: 3rem;
+}
+
+.app-preview {
+	background: linear-gradient(135deg, #1e3a8a, #3b82f6);
+	padding: 3rem;
+	color: white;
+	text-align: center;
+	position: relative;
+}
+
+.preview-image {
+	background: #000;
+	border-radius: 15px;
+	padding: 2rem;
+	max-width: 500px;
+	margin: 0 auto;
+	position: relative;
+	overflow: hidden;
+}
+
+.camera-feed {
+	font-size: 4rem;
+	margin-bottom: 1rem;
+	opacity: 0.7;
+}
+
+.detection-overlay {
+	position: absolute;
+	top: 50%;
+	left: 50%;
+	transform: translate(-50%, -50%);
+	width: 100%;
+}
+
+.bbox {
+	background: rgba(34, 197, 94, 0.9);
+	color: white;
+	padding: 0.5rem 1rem;
+	border-radius: 8px;
+	font-size: 0.9rem;
+	font-weight: 600;
+	margin: 0.5rem;
+	display: inline-block;
+	border: 2px solid #22c55e;
+}
+
+.app-details {
+	padding: 3rem;
+}
+
+.app-details h2 {
+	font-size: 2rem;
+	color: #1e293b;
+	margin-bottom: 2rem;
+	text-align: center;
+}
+
+.template-info {
+	display: grid;
+	grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+	gap: 2rem;
+	margin-bottom: 3rem;
+}
+
+.info-box {
+	background: #f0f9ff;
+	border: 2px solid #e0f2fe;
+	border-radius: 12px;
+	padding: 2rem;
+}
+
+.info-box h3 {
+	color: #0c4a6e;
+	margin-bottom: 1rem;
+	font-size: 1.2rem;
+}
+
+.info-box p {
+	color: #0369a1;
+	line-height: 1.6;
+}
+
+.how-to-use {
+	background: #fefce8;
+	border: 2px solid #fde047;
+	border-radius: 12px;
+	padding: 2rem;
+	margin-top: 3rem;
+}
+
+.how-to-use h3 {
+	color: #a16207;
+	margin-bottom: 1.5rem;
+	font-size: 1.3rem;
+	text-align: center;
+}
+
+.steps {
+	display: flex;
+	flex-direction: column;
+	gap: 1.5rem;
+}
+
+.step {
+	display: flex;
+	align-items: flex-start;
+	gap: 1rem;
+}
+
+.step-number {
+	background: #eab308;
+	color: white;
+	width: 2rem;
+	height: 2rem;
+	border-radius: 50%;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	font-weight: bold;
+	flex-shrink: 0;
+}
+
+.step h4 {
+	color: #a16207;
+	margin-bottom: 0.5rem;
+	font-size: 1.1rem;
+}
+
+.step p {
+	color: #ca8a04;
+}
+
+.download-card {
+	background: white;
+	border-radius: 20px;
+	box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
+	padding: 3rem;
+	text-align: center;
+}
+
+.download-card h2 {
+	font-size: 2rem;
+	color: #1e293b;
+	margin-bottom: 1rem;
+}
+
+.download-card>p {
+	color: #64748b;
+	font-size: 1.1rem;
+	margin-bottom: 2rem;
+}
+
+.dashboard-config {
+	margin-bottom: 2rem;
+	text-align: left;
+	max-width: 400px;
+	margin-left: auto;
+	margin-right: auto;
+}
+
+.dashboard-config label {
+	display: block;
+	color: #374151;
+	font-weight: 600;
+	margin-bottom: 0.5rem;
+}
+
+.dashboard-config input {
+	width: 100%;
+	padding: 0.75rem 1rem;
+	border: 2px solid #e5e7eb;
+	border-radius: 8px;
+	font-size: 0.95rem;
+	transition: border-color 0.2s;
+}
+
+.dashboard-config input:focus {
+	outline: none;
+	border-color: #667eea;
+}
+
+.install-btn {
+	background: linear-gradient(135deg, #667eea, #764ba2);
+	color: white;
+	border: none;
+	padding: 1.25rem 3rem;
+	border-radius: 16px;
+	font-size: 1.2rem;
+	font-weight: 700;
+	cursor: pointer;
+	transition: all 0.3s ease;
+	display: inline-flex;
+	align-items: center;
+	gap: 0.75rem;
+	margin-bottom: 2rem;
+	box-shadow: 0 8px 25px rgba(102, 126, 234, 0.3);
+}
+
+.install-btn:hover:not(:disabled) {
+	transform: translateY(-3px);
+	box-shadow: 0 15px 35px rgba(102, 126, 234, 0.4);
+}
+
+.install-btn:disabled {
+	opacity: 0.7;
+	cursor: not-allowed;
+	transform: none;
+}
+
+.manual-option {
+	background: #f8fafc;
+	border-radius: 12px;
+	padding: 2rem;
+	margin-top: 2rem;
+}
+
+.manual-option h3 {
+	color: #1e293b;
+	margin-bottom: 1rem;
+	font-size: 1.2rem;
+}
+
+.manual-option>p {
+	color: #64748b;
+	margin-bottom: 1rem;
+}
+
+.btn-icon {
+	font-size: 1.1rem;
+}
+
+.install-status {
+	padding: 1rem;
+	border-radius: 8px;
+	font-size: 0.9rem;
+	text-align: center;
+	display: none;
+	margin-top: 1rem;
+}
+
+.install-status.success {
+	background: #dcfce7;
+	color: #166534;
+	border: 1px solid #bbf7d0;
+}
+
+.install-status.error {
+	background: #fef2f2;
+	color: #dc2626;
+	border: 1px solid #fecaca;
+}
+
+.install-status.loading {
+	background: #dbeafe;
+	color: #1d4ed8;
+	border: 1px solid #bfdbfe;
+}
+
+.install-status.info {
+	background: #e0f2fe;
+	color: #0369a1;
+	border: 1px solid #7dd3fc;
+}
+
+.manual-install {
+	background: #1f2937;
+	border-radius: 8px;
+	padding: 1rem;
+	margin-bottom: 1rem;
+	display: flex;
+	align-items: center;
+	gap: 1rem;
+}
+
+.manual-install code {
+	color: #10b981;
+	font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace;
+	font-size: 0.85rem;
+	flex: 1;
+	overflow-x: auto;
+}
+
+.copy-btn {
+	background: #374151;
+	color: white;
+	border: none;
+	padding: 0.5rem 1rem;
+	border-radius: 6px;
+	font-size: 0.8rem;
+	cursor: pointer;
+	transition: background-color 0.2s;
+}
+
+.copy-btn:hover {
+	background: #4b5563;
+}
+
+.manual-steps {
+	color: #6b7280;
+	font-size: 0.9rem;
+	line-height: 1.8;
+}
+
+.footer {
+	text-align: center;
+	padding: 2rem;
+	color: white;
+	opacity: 0.8;
+}
+
+.footer a {
+	color: white;
+	text-decoration: none;
+	font-weight: 600;
+}
+
+.footer a:hover {
+	text-decoration: underline;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+	.hero {
+		padding: 2rem 1rem;
+	}
+
+	.hero h1 {
+		font-size: 2rem;
+	}
+
+	.container {
+		padding: 0 1rem;
+	}
+
+	.app-details,
+	.download-card {
+		padding: 2rem;
+	}
+
+	.features-grid {
+		grid-template-columns: 1fr;
+	}
+
+	.download-options {
+		grid-template-columns: 1fr;
+	}
+}