Update README.md

resize images to 240
Update README.md
2026-02-16 08:58:08 +00:00 · 2025-01-06 04:29:59 +08:00 · 2025-01-06 04:29:22 +08:00 · 2025-01-06 04:25:36 +08:00 · 2025-01-06 01:30:55 +08:00 · 2025-01-06 01:26:39 +08:00
46 changed files with 1835 additions and 292 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,7 +4,7 @@
 # CMakeLists in this exact order for cmake to work correctly
 cmake_minimum_required(VERSION 3.16)

-set(PROJECT_VER "0.9.7")
+set(PROJECT_VER "0.9.8")

 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(xiaozhi)
--- a/README.md
+++ b/README.md
@@ -2,44 +2,71 @@

 这是虾哥的第一个硬件作品。

-[ESP32+SenseVoice+Qwen72B打造你的AI聊天伴侣！【bilibili】](https://www.bilibili.com/video/BV11msTenEH3/?share_source=copy_web&vd_source=ee1aafe19d6e60cf22e60a93881faeba)
+👉 [ESP32+SenseVoice+Qwen72B打造你的AI聊天伴侣！【bilibili】](https://www.bilibili.com/video/BV11msTenEH3/?share_source=copy_web&vd_source=ee1aafe19d6e60cf22e60a93881faeba)

-[手工打造你的 AI 女友，新手入门教程【bilibili】](https://www.bilibili.com/video/BV1XnmFYLEJN/)
+👉 [手工打造你的 AI 女友，新手入门教程【bilibili】](https://www.bilibili.com/video/BV1XnmFYLEJN/)

 ## 项目目的

 本项目基于乐鑫的 ESP-IDF 进行开发。

-本项目是一个开源项目，主要用于教学目的。我们希望通过这个项目，能够帮助更多人入门 AI 硬件开发,了解如何将当下飞速发展的大语言模型应用到实际的硬件设备中。无论你是对 AI 感兴趣的学生，还是想要探索新技术的开发者，都可以通过这个项目获得宝贵的学习经验。
+本项目是一个开源项目，主要用于教学目的。我们希望通过这个项目，能够帮助更多人入门 AI 硬件开发，了解如何将当下飞速发展的大语言模型应用到实际的硬件设备中。无论你是对 AI 感兴趣的学生，还是想要探索新技术的开发者，都可以通过这个项目获得宝贵的学习经验。

-欢迎所有人参与到项目的开发和改进中来。如果你有任何想法或建议，请随时提出 issue 或加入群聊。
+欢迎所有人参与到项目的开发和改进中来。如果你有任何想法或建议，请随时提出 Issue 或加入群聊。

 学习交流 QQ 群：946599635

 ## 已实现功能

- Wi-Fi 配网
- 支持 BOOT 键唤醒和打断
- 离线语音唤醒（乐鑫方案）
+- Wi-Fi / ML307 Cat.1 4G
+- BOOT 键唤醒和打断，支持点击和长按两种触发方式
+- 离线语音唤醒 [ESP-SR](https://github.com/espressif/esp-sr)
 - 流式语音对话（WebSocket 或 UDP 协议）
- 支持国语、粤语、英语、日语、韩语 5 种语言识别（SenseVoice 方案）
- 声纹识别（识别是谁在喊 AI 的名字，[3D Speaker 项目](https://github.com/modelscope/3D-Speaker)）
- 使用大模型 TTS（火山引擎与 CosyVoice 方案）
- 支持可配置的提示词和音色（自定义角色）
- Qwen2.5 72B 或 豆包 API
- 支持每轮对话后自我总结，生成记忆体
- 扩展液晶显示屏，显示信号强弱
- 支持 ML307 Cat.1 4G 模块
+- 支持国语、粤语、英语、日语、韩语 5 种语言识别 [SenseVoice](https://github.com/FunAudioLLM/SenseVoice)
+- 声纹识别，识别是谁在喊 AI 的名字 [3D Speaker](https://github.com/modelscope/3D-Speaker)
+- 大模型 TTS（火山引擎 或 CosyVoice）
+- 大模型 LLM（Qwen2.5 72B 或 豆包 API）
+- 可配置的提示词和音色（自定义角色）
+- 短期记忆，每轮对话后自我总结
+- OLED / LCD 显示屏，显示信号强弱或对话内容

 ## 硬件部分

-为方便协作，目前所有硬件资料都放在飞书文档中：
+### 面包板手工制作实践

-[《小智 AI 聊天机器人百科全书》](https://ccnphfhqs21z.feishu.cn/wiki/F5krwD16viZoF0kKkvDcrZNYnhb?from=from_copylink)
+详见飞书文档教程：

-面包板接线图如下：
+👉 [《小智 AI 聊天机器人百科全书》](https://ccnphfhqs21z.feishu.cn/wiki/F5krwD16viZoF0kKkvDcrZNYnhb?from=from_copylink)

-![面包板接线图](docs/wiring2.jpg)
+面包板效果图如下：
+
+![面包板效果图](docs/wiring2.jpg)
+
+### 已支持的开源硬件
+
+- <a href="https://oshwhub.com/li-chuang-kai-fa-ban/li-chuang-shi-zhan-pai-esp32-s3-kai-fa-ban" target="_blank" title="立创·实战派 ESP32-S3 开发板">立创·实战派 ESP32-S3 开发板</a>
+- <a href="https://github.com/espressif/esp-box" target="_blank" title="乐鑫 ESP32-S3-BOX3">乐鑫 ESP32-S3-BOX3</a>
+- <a href="https://docs.m5stack.com/zh_CN/core/CoreS3" target="_blank" title="M5Stack CoreS3">M5Stack CoreS3</a>
+- 神奇按钮 2.4
+- 虾哥定制版 Mini C3
+
+<div style="display: flex; justify-content: space-between;">
+  <a href="docs/lichuang-s3.jpg" target="_blank" title="立创·实战派 ESP32-S3 开发板">
+    <img src="docs/lichuang-s3.jpg" width="240" />
+  </a>
+  <a href="docs/esp32s3-box3.jpg" target="_blank" title="乐鑫 ESP32-S3-BOX3">
+    <img src="docs/esp32s3-box3.jpg" width="240" />
+  </a>
+  <a href="docs/m5stack-cores3.jpg" target="_blank" title="M5Stack CoreS3">
+    <img src="docs/m5stack-cores3.jpg" width="240" />
+  </a>
+  <a href="docs/magiclick-2p4.jpg" target="_blank" title="神奇按钮 2.4">
+    <img src="docs/magiclick-2p4.jpg" width="240" />
+  </a>
+  <a href="docs/xmini-c3.jpg" target="_blank" title="虾哥定制版 Mini C3">
+    <img src="docs/xmini-c3.jpg" width="240" />
+  </a>
+</div>

 ## 固件部分

@@ -47,19 +74,28 @@

 新手第一次操作建议先不要搭建开发环境，直接使用免开发环境烧录的固件。固件使用的是作者友情提供的测试服，目前开放免费使用，请勿用于商业用途。

-[Flash烧录固件（无IDF开发环境）](https://ccnphfhqs21z.feishu.cn/wiki/Zpz4wXBtdimBrLk25WdcXzxcnNS) 
+👉 [Flash烧录固件（无IDF开发环境）](https://ccnphfhqs21z.feishu.cn/wiki/Zpz4wXBtdimBrLk25WdcXzxcnNS) 


 ### 开发环境

 - Cursor 或 VSCode
 - 安装 ESP-IDF 插件，选择 SDK 版本 5.3 或以上
- Ubuntu 比 Windows 更好，编译速度快，也免去驱动问题的困扰
+- Linux 比 Windows 更好，编译速度快，也免去驱动问题的困扰


 ## AI 角色配置

-如果你已经拥有一个小智 AI 聊天机器人，可以参考 [后台操作视频教程](https://www.bilibili.com/video/BV1jUCUY2EKM/)
+如果你已经拥有一个小智 AI 聊天机器人，可以参考 👉 [后台操作视频教程](https://www.bilibili.com/video/BV1jUCUY2EKM/)

-详细的使用说明以及测试服的注意事项，请参考 [小智测试服的帮助说明](https://xiaozhi.me/help)。
+详细的使用说明以及测试服的注意事项，请参考 👉 [小智测试服的帮助说明](https://xiaozhi.me/help)。

+## Star History
+
+<a href="https://star-history.com/#78/xiaozhi-esp32&Date">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=78/xiaozhi-esp32&type=Date&theme=dark" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=78/xiaozhi-esp32&type=Date" />
+   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=78/xiaozhi-esp32&type=Date" />
+ </picture>
+</a>
--- a/docs/esp32s3-box3.jpg
+++ b/docs/esp32s3-box3.jpg
--- a/docs/lichuang-s3.jpg
+++ b/docs/lichuang-s3.jpg
--- a/docs/m5stack-cores3.jpg
+++ b/docs/m5stack-cores3.jpg
--- a/docs/magiclick-2p4.jpg
+++ b/docs/magiclick-2p4.jpg
--- a/docs/xmini-c3.jpg
+++ b/docs/xmini-c3.jpg
--- a/main/CMakeLists.txt
+++ b/main/CMakeLists.txt
@@ -2,9 +2,12 @@ set(SOURCES "audio_codecs/audio_codec.cc"
            "audio_codecs/no_audio_codec.cc"
            "audio_codecs/box_audio_codec.cc"
            "audio_codecs/es8311_audio_codec.cc"
+            "audio_codecs/cores3_audio_codec.cc"
+            "led/single_led.cc"
+            "led/circular_strip.cc"
            "display/display.cc"
            "display/no_display.cc"
-            "display/st7789_display.cc"
+            "display/lcd_display.cc"
            "display/ssd1306_display.cc"
            "protocols/protocol.cc"
            "protocols/mqtt_protocol.cc"
@@ -52,6 +55,10 @@ elseif(CONFIG_BOARD_TYPE_LICHUANG_DEV)
    set(BOARD_TYPE "lichuang-dev")
 elseif(CONFIG_BOARD_TYPE_TERRENCE_C3_DEV)
    set(BOARD_TYPE "terrence-c3-dev")
+elseif(CONFIG_BOARD_TYPE_MAGICLICK_2P4)
+    set(BOARD_TYPE "magiclick-2p4")
+elseif(CONFIG_BOARD_TYPE_M5STACK_CORE_S3)
+    set(BOARD_TYPE "m5stack-core-s3")
 endif()
 file(GLOB BOARD_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE}/*.cc)
 list(APPEND SOURCES ${BOARD_SOURCES})
--- a/main/Kconfig.projbuild
+++ b/main/Kconfig.projbuild
@@ -50,6 +50,10 @@ choice BOARD_TYPE
        bool "Kevin C3"
    config BOARD_TYPE_LICHUANG_DEV
        bool "立创开发板"
+    config BOARD_TYPE_MAGICLICK_2P4
+        bool "神奇按钮Magiclick_2.4"  
+    config BOARD_TYPE_M5STACK_CORE_S3
+        bool "M5Stack CoreS3"
 endchoice

 endmenu
--- a/main/application.cc
+++ b/main/application.cc
@@ -26,11 +26,14 @@ extern const char p3_err_wificonfig_end[] asm("_binary_err_wificonfig_p3_end");

 static const char* const STATE_STRINGS[] = {
    "unknown",
+    "starting",
+    "configuring",
    "idle",
    "connecting",
    "listening",
    "speaking",
    "upgrading",
+    "fatal_error",
    "invalid_state"
 };

@@ -57,9 +60,9 @@ void Application::CheckNewVersion() {
                // Wait for the chat state to be idle
                do {
                    vTaskDelay(pdMS_TO_TICKS(3000));
-                } while (GetChatState() != kChatStateIdle);
+                } while (GetDeviceState() != kDeviceStateIdle);

-                SetChatState(kChatStateUpgrading);
+                SetDeviceState(kDeviceStateUpgrading);
                
                display->SetIcon(FONT_AWESOME_DOWNLOAD);
                display->SetStatus("新版本 " + ota_.GetFirmwareVersion());
@@ -75,7 +78,7 @@ void Application::CheckNewVersion() {

                // If upgrade success, the device will reboot and never reach here
                ESP_LOGI(TAG, "Firmware upgrade failed...");
-                SetChatState(kChatStateIdle);
+                SetDeviceState(kDeviceStateIdle);
            } else {
                ota_.MarkCurrentVersionValid();
                display->ShowNotification("版本 " + ota_.GetCurrentVersion());
@@ -127,20 +130,20 @@ void Application::ToggleChatState() {
            return;
        }

-        if (chat_state_ == kChatStateIdle) {
-            SetChatState(kChatStateConnecting);
+        if (device_state_ == kDeviceStateIdle) {
+            SetDeviceState(kDeviceStateConnecting);
            if (!protocol_->OpenAudioChannel()) {
                Alert("Error", "Failed to open audio channel");
-                SetChatState(kChatStateIdle);
+                SetDeviceState(kDeviceStateIdle);
                return;
            }

            keep_listening_ = true;
            protocol_->SendStartListening(kListeningModeAutoStop);
-            SetChatState(kChatStateListening);
-        } else if (chat_state_ == kChatStateSpeaking) {
+            SetDeviceState(kDeviceStateListening);
+        } else if (device_state_ == kDeviceStateSpeaking) {
            AbortSpeaking(kAbortReasonNone);
-        } else if (chat_state_ == kChatStateListening) {
+        } else if (device_state_ == kDeviceStateListening) {
            protocol_->CloseAudioChannel();
        }
    });
@@ -154,41 +157,39 @@ void Application::StartListening() {
        }
        
        keep_listening_ = false;
-        if (chat_state_ == kChatStateIdle) {
+        if (device_state_ == kDeviceStateIdle) {
            if (!protocol_->IsAudioChannelOpened()) {
-                SetChatState(kChatStateConnecting);
+                SetDeviceState(kDeviceStateConnecting);
                if (!protocol_->OpenAudioChannel()) {
-                    SetChatState(kChatStateIdle);
+                    SetDeviceState(kDeviceStateIdle);
                    Alert("Error", "Failed to open audio channel");
                    return;
                }
            }
            protocol_->SendStartListening(kListeningModeManualStop);
-            SetChatState(kChatStateListening);
-        } else if (chat_state_ == kChatStateSpeaking) {
+            SetDeviceState(kDeviceStateListening);
+        } else if (device_state_ == kDeviceStateSpeaking) {
            AbortSpeaking(kAbortReasonNone);
            protocol_->SendStartListening(kListeningModeManualStop);
            // FIXME: Wait for the speaker to empty the buffer
            vTaskDelay(pdMS_TO_TICKS(120));
-            SetChatState(kChatStateListening);
+            SetDeviceState(kDeviceStateListening);
        }
    });
 }

 void Application::StopListening() {
    Schedule([this]() {
-        if (chat_state_ == kChatStateListening) {
+        if (device_state_ == kDeviceStateListening) {
            protocol_->SendStopListening();
-            SetChatState(kChatStateIdle);
+            SetDeviceState(kDeviceStateIdle);
        }
    });
 }

 void Application::Start() {
    auto& board = Board::GetInstance();
-    auto builtin_led = board.GetBuiltinLed();
-    builtin_led->SetBlue();
-    builtin_led->StartContinuousBlink(100);
+    SetDeviceState(kDeviceStateStarting);

    /* Setup the display */
    auto display = board.GetDisplay();
@@ -246,27 +247,27 @@ void Application::Start() {
    wake_word_detect_.Initialize(codec->input_channels(), codec->input_reference());
    wake_word_detect_.OnVadStateChange([this](bool speaking) {
        Schedule([this, speaking]() {
-            auto builtin_led = Board::GetInstance().GetBuiltinLed();
-            if (chat_state_ == kChatStateListening) {
+            if (device_state_ == kDeviceStateListening) {
                if (speaking) {
-                    builtin_led->SetRed(HIGH_BRIGHTNESS);
+                    voice_detected_ = true;
                } else {
-                    builtin_led->SetRed(LOW_BRIGHTNESS);
+                    voice_detected_ = false;
                }
-                builtin_led->TurnOn();
+                auto led = Board::GetInstance().GetLed();
+                led->OnStateChanged();
            }
        });
    });

    wake_word_detect_.OnWakeWordDetected([this](const std::string& wake_word) {
        Schedule([this, &wake_word]() {
-            if (chat_state_ == kChatStateIdle) {
-                SetChatState(kChatStateConnecting);
+            if (device_state_ == kDeviceStateIdle) {
+                SetDeviceState(kDeviceStateConnecting);
                wake_word_detect_.EncodeWakeWordData();

                if (!protocol_->OpenAudioChannel()) {
                    ESP_LOGE(TAG, "Failed to open audio channel");
-                    SetChatState(kChatStateIdle);
+                    SetDeviceState(kDeviceStateIdle);
                    wake_word_detect_.StartDetection();
                    return;
                }
@@ -280,8 +281,8 @@ void Application::Start() {
                protocol_->SendWakeWordDetected(wake_word);
                ESP_LOGI(TAG, "Wake word detected: %s", wake_word.c_str());
                keep_listening_ = true;
-                SetChatState(kChatStateListening);
-            } else if (chat_state_ == kChatStateSpeaking) {
+                SetDeviceState(kDeviceStateListening);
+            } else if (device_state_ == kDeviceStateSpeaking) {
                AbortSpeaking(kAbortReasonWakeWordDetected);
            }

@@ -304,7 +305,7 @@ void Application::Start() {
    });
    protocol_->OnIncomingAudio([this](std::vector<uint8_t>&& data) {
        std::lock_guard<std::mutex> lock(mutex_);
-        if (chat_state_ == kChatStateSpeaking) {
+        if (device_state_ == kDeviceStateSpeaking) {
            audio_decode_queue_.emplace_back(std::move(data));
        }
    });
@@ -323,7 +324,7 @@ void Application::Start() {
    protocol_->OnAudioChannelClosed([this, &board]() {
        board.SetPowerSaveMode(true);
        Schedule([this]() {
-            SetChatState(kChatStateIdle);
+            SetDeviceState(kDeviceStateIdle);
        });
    });
    protocol_->OnIncomingJson([this, display](const cJSON* root) {
@@ -334,19 +335,19 @@ void Application::Start() {
            if (strcmp(state->valuestring, "start") == 0) {
                Schedule([this]() {
                    aborted_ = false;
-                    if (chat_state_ == kChatStateIdle || chat_state_ == kChatStateListening) {
-                        SetChatState(kChatStateSpeaking);
+                    if (device_state_ == kDeviceStateIdle || device_state_ == kDeviceStateListening) {
+                        SetDeviceState(kDeviceStateSpeaking);
                    }
                });
            } else if (strcmp(state->valuestring, "stop") == 0) {
                Schedule([this]() {
-                    if (chat_state_ == kChatStateSpeaking) {
+                    if (device_state_ == kDeviceStateSpeaking) {
                        background_task_.WaitForCompletion();
                        if (keep_listening_) {
                            protocol_->SendStartListening(kListeningModeAutoStop);
-                            SetChatState(kChatStateListening);
+                            SetDeviceState(kDeviceStateListening);
                        } else {
-                            SetChatState(kChatStateIdle);
+                            SetDeviceState(kDeviceStateIdle);
                        }
                    }
                });
@@ -380,12 +381,7 @@ void Application::Start() {
        }
    });

-    // Blink the LED to indicate the device is running
-    display->SetStatus("待命");
-    builtin_led->SetGreen();
-    builtin_led->BlinkOnce();
-
-    SetChatState(kChatStateIdle);
+    SetDeviceState(kDeviceStateIdle);
 }

 void Application::Schedule(std::function<void()> callback) {
@@ -436,7 +432,7 @@ void Application::OutputAudio() {
    std::unique_lock<std::mutex> lock(mutex_);
    if (audio_decode_queue_.empty()) {
        // Disable the output if there is no audio data for a long time
-        if (chat_state_ == kChatStateIdle) {
+        if (device_state_ == kDeviceStateIdle) {
            auto duration = std::chrono::duration_cast<std::chrono::seconds>(now - last_output_time_).count();
            if (duration > max_silence_seconds) {
                codec->EnableOutput(false);
@@ -445,7 +441,7 @@ void Application::OutputAudio() {
        return;
    }

-    if (chat_state_ == kChatStateListening) {
+    if (device_state_ == kDeviceStateListening) {
        audio_decode_queue_.clear();
        return;
    }
@@ -516,7 +512,7 @@ void Application::InputAudio() {
        wake_word_detect_.Feed(data);
    }
 #else
-    if (chat_state_ == kChatStateListening) {
+    if (device_state_ == kDeviceStateListening) {
        background_task_.Schedule([this, data = std::move(data)]() mutable {
            opus_encoder_->Encode(std::move(data), [this](std::vector<uint8_t>&& opus) {
                Schedule([this, opus = std::move(opus)]() {
@@ -534,36 +530,33 @@ void Application::AbortSpeaking(AbortReason reason) {
    protocol_->SendAbortSpeaking(reason);
 }

-void Application::SetChatState(ChatState state) {
-    if (chat_state_ == state) {
+void Application::SetDeviceState(DeviceState state) {
+    if (device_state_ == state) {
        return;
    }
    
-    chat_state_ = state;
-    ESP_LOGI(TAG, "STATE: %s", STATE_STRINGS[chat_state_]);
+    device_state_ = state;
+    ESP_LOGI(TAG, "STATE: %s", STATE_STRINGS[device_state_]);
    // The state is changed, wait for all background tasks to finish
    background_task_.WaitForCompletion();

    auto display = Board::GetInstance().GetDisplay();
-    auto builtin_led = Board::GetInstance().GetBuiltinLed();
+    auto led = Board::GetInstance().GetLed();
+    led->OnStateChanged();
    switch (state) {
-        case kChatStateUnknown:
-        case kChatStateIdle:
-            builtin_led->TurnOff();
+        case kDeviceStateUnknown:
+        case kDeviceStateIdle:
            display->SetStatus("待命");
            display->SetEmotion("neutral");
+            display->SetChatMessage("", "");
 #ifdef CONFIG_IDF_TARGET_ESP32S3
            audio_processor_.Stop();
 #endif
            break;
-        case kChatStateConnecting:
-            builtin_led->SetBlue();
-            builtin_led->TurnOn();
+        case kDeviceStateConnecting:
            display->SetStatus("连接中...");
            break;
-        case kChatStateListening:
-            builtin_led->SetRed();
-            builtin_led->TurnOn();
+        case kDeviceStateListening:
            display->SetStatus("聆听中...");
            display->SetEmotion("neutral");
            ResetDecoder();
@@ -573,22 +566,16 @@ void Application::SetChatState(ChatState state) {
 #endif
            UpdateIotStates();
            break;
-        case kChatStateSpeaking:
-            builtin_led->SetGreen();
-            builtin_led->TurnOn();
+        case kDeviceStateSpeaking:
            display->SetStatus("说话中...");
            ResetDecoder();
 #if CONFIG_IDF_TARGET_ESP32S3
            audio_processor_.Stop();
 #endif
            break;
-        case kChatStateUpgrading:
-            builtin_led->SetGreen();
-            builtin_led->StartContinuousBlink(100);
-            break;
        default:
-            ESP_LOGE(TAG, "Invalid chat state: %d", chat_state_);
-            return;
+            // Do nothing
+            break;
    }
 }

--- a/main/application.h
+++ b/main/application.h
@@ -26,13 +26,16 @@
 #define AUDIO_INPUT_READY_EVENT (1 << 1)
 #define AUDIO_OUTPUT_READY_EVENT (1 << 2)

-enum ChatState {
-    kChatStateUnknown,
-    kChatStateIdle,
-    kChatStateConnecting,
-    kChatStateListening,
-    kChatStateSpeaking,
-    kChatStateUpgrading
+enum DeviceState {
+    kDeviceStateUnknown,
+    kDeviceStateStarting,
+    kDeviceStateWifiConfiguring,
+    kDeviceStateIdle,
+    kDeviceStateConnecting,
+    kDeviceStateListening,
+    kDeviceStateSpeaking,
+    kDeviceStateUpgrading,
+    kDeviceStateFatalError
 };

 #define OPUS_FRAME_DURATION_MS 60
@@ -48,9 +51,10 @@ public:
    Application& operator=(const Application&) = delete;

    void Start();
-    ChatState GetChatState() const { return chat_state_; }
+    DeviceState GetDeviceState() const { return device_state_; }
+    bool IsVoiceDetected() const { return voice_detected_; }
    void Schedule(std::function<void()> callback);
-    void SetChatState(ChatState state);
+    void SetDeviceState(DeviceState state);
    void Alert(const std::string& title, const std::string& message);
    void AbortSpeaking(AbortReason reason);
    void ToggleChatState();
@@ -71,9 +75,10 @@ private:
    std::list<std::function<void()>> main_tasks_;
    std::unique_ptr<Protocol> protocol_;
    EventGroupHandle_t event_group_;
-    volatile ChatState chat_state_ = kChatStateUnknown;
+    volatile DeviceState device_state_ = kDeviceStateUnknown;
    bool keep_listening_ = false;
    bool aborted_ = false;
+    bool voice_detected_ = false;
    std::string last_iot_states_;

    // Audio encode / decode
--- a/main/audio_codecs/cores3_audio_codec.cc
+++ b/main/audio_codecs/cores3_audio_codec.cc
@@ -0,0 +1,245 @@
+#include "cores3_audio_codec.h"
+
+#include <esp_log.h>
+#include <driver/i2c.h>
+#include <driver/i2c_master.h>
+#include <driver/i2s_tdm.h>
+
+
+static const char TAG[] = "CoreS3AudioCodec";
+
+CoreS3AudioCodec::CoreS3AudioCodec(void* i2c_master_handle, int input_sample_rate, int output_sample_rate,
+    gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din,
+    uint8_t aw88298_addr, uint8_t es7210_addr, bool input_reference) {
+    duplex_ = true; // 是否双工
+    input_reference_ = input_reference; // 是否使用参考输入，实现回声消除
+    input_channels_ = input_reference_ ? 2 : 1; // 输入通道数
+    input_sample_rate_ = input_sample_rate;
+    output_sample_rate_ = output_sample_rate;
+
+    CreateDuplexChannels(mclk, bclk, ws, dout, din);
+
+    // Do initialize of related interface: data_if, ctrl_if and gpio_if
+    audio_codec_i2s_cfg_t i2s_cfg = {
+        .port = I2S_NUM_0,
+        .rx_handle = rx_handle_,
+        .tx_handle = tx_handle_,
+    };
+    data_if_ = audio_codec_new_i2s_data(&i2s_cfg);
+    assert(data_if_ != NULL);
+
+    // Audio Output(Speaker)
+    audio_codec_i2c_cfg_t i2c_cfg = {
+        .port = (i2c_port_t)1,
+        .addr = aw88298_addr,
+        .bus_handle = i2c_master_handle,
+    };
+    out_ctrl_if_ = audio_codec_new_i2c_ctrl(&i2c_cfg);
+    assert(out_ctrl_if_ != NULL);
+
+    gpio_if_ = audio_codec_new_gpio();
+    assert(gpio_if_ != NULL);
+
+    aw88298_codec_cfg_t aw88298_cfg = {};
+    aw88298_cfg.ctrl_if = out_ctrl_if_;
+    aw88298_cfg.gpio_if = gpio_if_;
+    aw88298_cfg.reset_pin = GPIO_NUM_NC;
+    aw88298_cfg.hw_gain.pa_voltage = 5.0;
+    aw88298_cfg.hw_gain.codec_dac_voltage = 3.3;
+    aw88298_cfg.hw_gain.pa_gain = 1;
+    out_codec_if_ = aw88298_codec_new(&aw88298_cfg);
+    assert(out_codec_if_ != NULL);
+
+    esp_codec_dev_cfg_t dev_cfg = {
+        .dev_type = ESP_CODEC_DEV_TYPE_OUT,
+        .codec_if = out_codec_if_,
+        .data_if = data_if_,
+    };
+    output_dev_ = esp_codec_dev_new(&dev_cfg);
+    assert(output_dev_ != NULL);
+
+    // Audio Input(Microphone)
+    i2c_cfg.addr = es7210_addr;
+    in_ctrl_if_ = audio_codec_new_i2c_ctrl(&i2c_cfg);
+    assert(in_ctrl_if_ != NULL);
+
+    es7210_codec_cfg_t es7210_cfg = {};
+    es7210_cfg.ctrl_if = in_ctrl_if_;
+    es7210_cfg.mic_selected = ES7120_SEL_MIC1 | ES7120_SEL_MIC2 | ES7120_SEL_MIC3;
+    in_codec_if_ = es7210_codec_new(&es7210_cfg);
+    assert(in_codec_if_ != NULL);
+
+    dev_cfg.dev_type = ESP_CODEC_DEV_TYPE_IN;
+    dev_cfg.codec_if = in_codec_if_;
+    input_dev_ = esp_codec_dev_new(&dev_cfg);
+    assert(input_dev_ != NULL);
+
+    ESP_LOGI(TAG, "CoreS3AudioCodec initialized");
+}
+
+CoreS3AudioCodec::~CoreS3AudioCodec() {
+    ESP_ERROR_CHECK(esp_codec_dev_close(output_dev_));
+    esp_codec_dev_delete(output_dev_);
+    ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
+    esp_codec_dev_delete(input_dev_);
+
+    audio_codec_delete_codec_if(in_codec_if_);
+    audio_codec_delete_ctrl_if(in_ctrl_if_);
+    audio_codec_delete_codec_if(out_codec_if_);
+    audio_codec_delete_ctrl_if(out_ctrl_if_);
+    audio_codec_delete_gpio_if(gpio_if_);
+    audio_codec_delete_data_if(data_if_);
+}
+
+void CoreS3AudioCodec::CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din) {
+    assert(input_sample_rate_ == output_sample_rate_);
+
+    ESP_LOGI(TAG, "Audio IOs: mclk: %d, bclk: %d, ws: %d, dout: %d, din: %d", mclk, bclk, ws, dout, din);
+
+    i2s_chan_config_t chan_cfg = {
+        .id = I2S_NUM_0,
+        .role = I2S_ROLE_MASTER,
+        .dma_desc_num = 2,
+        .dma_frame_num = 240 * 3,
+        .auto_clear_after_cb = true,
+        .auto_clear_before_cb = false,
+        .intr_priority = 0,
+    };
+    ESP_ERROR_CHECK(i2s_new_channel(&chan_cfg, &tx_handle_, &rx_handle_));
+
+    i2s_std_config_t std_cfg = {
+        .clk_cfg = {
+            .sample_rate_hz = (uint32_t)output_sample_rate_,
+            .clk_src = I2S_CLK_SRC_DEFAULT,
+            .ext_clk_freq_hz = 0,
+            .mclk_multiple = I2S_MCLK_MULTIPLE_256
+        },
+        .slot_cfg = {
+            .data_bit_width = I2S_DATA_BIT_WIDTH_16BIT,
+            .slot_bit_width = I2S_SLOT_BIT_WIDTH_AUTO,
+            .slot_mode = I2S_SLOT_MODE_STEREO,
+            .slot_mask = I2S_STD_SLOT_BOTH,
+            .ws_width = I2S_DATA_BIT_WIDTH_16BIT,
+            .ws_pol = false,
+            .bit_shift = true,
+            .left_align = true,
+            .big_endian = false,
+            .bit_order_lsb = false
+        },
+        .gpio_cfg = {
+            .mclk = mclk,
+            .bclk = bclk,
+            .ws = ws,
+            .dout = dout,
+            .din = I2S_GPIO_UNUSED,
+            .invert_flags = {
+                .mclk_inv = false,
+                .bclk_inv = false,
+                .ws_inv = false
+            }
+        }
+    };
+
+    i2s_tdm_config_t tdm_cfg = {
+        .clk_cfg = {
+            .sample_rate_hz = (uint32_t)input_sample_rate_,
+            .clk_src = I2S_CLK_SRC_DEFAULT,
+            .ext_clk_freq_hz = 0,
+            .mclk_multiple = I2S_MCLK_MULTIPLE_256,
+            .bclk_div = 8,
+        },
+        .slot_cfg = {
+            .data_bit_width = I2S_DATA_BIT_WIDTH_16BIT,
+            .slot_bit_width = I2S_SLOT_BIT_WIDTH_AUTO,
+            .slot_mode = I2S_SLOT_MODE_STEREO,
+            .slot_mask = i2s_tdm_slot_mask_t(I2S_TDM_SLOT0 | I2S_TDM_SLOT1 | I2S_TDM_SLOT2 | I2S_TDM_SLOT3),
+            .ws_width = I2S_TDM_AUTO_WS_WIDTH,
+            .ws_pol = false,
+            .bit_shift = true,
+            .left_align = false,
+            .big_endian = false,
+            .bit_order_lsb = false,
+            .skip_mask = false,
+            .total_slot = I2S_TDM_AUTO_SLOT_NUM
+        },
+        .gpio_cfg = {
+            .mclk = mclk,
+            .bclk = bclk,
+            .ws = ws,
+            .dout = I2S_GPIO_UNUSED,
+            .din = din,
+            .invert_flags = {
+                .mclk_inv = false,
+                .bclk_inv = false,
+                .ws_inv = false
+            }
+        }
+    };
+
+    ESP_ERROR_CHECK(i2s_channel_init_std_mode(tx_handle_, &std_cfg));
+    ESP_ERROR_CHECK(i2s_channel_init_tdm_mode(rx_handle_, &tdm_cfg));
+    ESP_LOGI(TAG, "Duplex channels created");
+}
+
+void CoreS3AudioCodec::SetOutputVolume(int volume) {
+    ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, volume));
+    AudioCodec::SetOutputVolume(volume);
+}
+
+void CoreS3AudioCodec::EnableInput(bool enable) {
+    if (enable == input_enabled_) {
+        return;
+    }
+    if (enable) {
+        esp_codec_dev_sample_info_t fs = {
+            .bits_per_sample = 16,
+            .channel = 2,
+            .channel_mask = ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0),
+            .sample_rate = (uint32_t)output_sample_rate_,
+            .mclk_multiple = 0,
+        };
+        if (input_reference_) {
+            fs.channel_mask |= ESP_CODEC_DEV_MAKE_CHANNEL_MASK(1);
+        }
+        ESP_ERROR_CHECK(esp_codec_dev_open(input_dev_, &fs));
+        ESP_ERROR_CHECK(esp_codec_dev_set_in_channel_gain(input_dev_, ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0), 40.0));
+    } else {
+        ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
+    }
+    AudioCodec::EnableInput(enable);
+}
+
+void CoreS3AudioCodec::EnableOutput(bool enable) {
+    if (enable == output_enabled_) {
+        return;
+    }
+    if (enable) {
+        // Play 16bit 1 channel
+        esp_codec_dev_sample_info_t fs = {
+            .bits_per_sample = 16,
+            .channel = 1,
+            .channel_mask = 0,
+            .sample_rate = (uint32_t)output_sample_rate_,
+            .mclk_multiple = 0,
+        };
+        ESP_ERROR_CHECK(esp_codec_dev_open(output_dev_, &fs));
+        ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, output_volume_));
+    } else {
+        ESP_ERROR_CHECK(esp_codec_dev_close(output_dev_));
+    }
+    AudioCodec::EnableOutput(enable);
+}
+
+int CoreS3AudioCodec::Read(int16_t* dest, int samples) {
+    if (input_enabled_) {
+        ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void*)dest, samples * sizeof(int16_t)));
+    }
+    return samples;
+}
+
+int CoreS3AudioCodec::Write(const int16_t* data, int samples) {
+    if (output_enabled_) {
+        ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void*)data, samples * sizeof(int16_t)));
+    }
+    return samples;
+}
--- a/main/audio_codecs/cores3_audio_codec.h
+++ b/main/audio_codecs/cores3_audio_codec.h
@@ -0,0 +1,37 @@
+#ifndef _BOX_AUDIO_CODEC_H
+#define _BOX_AUDIO_CODEC_H
+
+#include "audio_codec.h"
+
+#include <esp_codec_dev.h>
+#include <esp_codec_dev_defaults.h>
+
+class CoreS3AudioCodec : public AudioCodec {
+private:
+    const audio_codec_data_if_t* data_if_ = nullptr;
+    const audio_codec_ctrl_if_t* out_ctrl_if_ = nullptr;
+    const audio_codec_if_t* out_codec_if_ = nullptr;
+    const audio_codec_ctrl_if_t* in_ctrl_if_ = nullptr;
+    const audio_codec_if_t* in_codec_if_ = nullptr;
+    const audio_codec_gpio_if_t* gpio_if_ = nullptr;
+
+    esp_codec_dev_handle_t output_dev_ = nullptr;
+    esp_codec_dev_handle_t input_dev_ = nullptr;
+
+    void CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din);
+
+    virtual int Read(int16_t* dest, int samples) override;
+    virtual int Write(const int16_t* data, int samples) override;
+
+public:
+    CoreS3AudioCodec(void* i2c_master_handle, int input_sample_rate, int output_sample_rate,
+        gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din,
+        uint8_t aw88298_addr, uint8_t es7210_addr, bool input_reference);
+    virtual ~CoreS3AudioCodec();
+
+    virtual void SetOutputVolume(int volume) override;
+    virtual void EnableInput(bool enable) override;
+    virtual void EnableOutput(bool enable) override;
+};
+
+#endif // _BOX_AUDIO_CODEC_H
--- a/main/audio_codecs/no_audio_codec.cc
+++ b/main/audio_codecs/no_audio_codec.cc
@@ -77,8 +77,8 @@ NoAudioCodec::NoAudioCodec(int input_sample_rate, int output_sample_rate, gpio_n
    i2s_chan_config_t chan_cfg = {
        .id = (i2s_port_t)0,
        .role = I2S_ROLE_MASTER,
-        .dma_desc_num = 6,
-        .dma_frame_num = 240,
+        .dma_desc_num = 2,
+        .dma_frame_num = 240 * 3,
        .auto_clear_after_cb = true,
        .auto_clear_before_cb = false,
        .intr_priority = 0,
@@ -138,8 +138,8 @@ NoAudioCodec::NoAudioCodec(int input_sample_rate, int output_sample_rate, gpio_n

    // Create a new channel for speaker
    i2s_chan_config_t tx_chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG((i2s_port_t)1, I2S_ROLE_MASTER);
-    tx_chan_cfg.dma_desc_num = 6;
-    tx_chan_cfg.dma_frame_num = 240;
+    tx_chan_cfg.dma_desc_num = 2;
+    tx_chan_cfg.dma_frame_num = 240 * 3;
    tx_chan_cfg.auto_clear_after_cb = true;
    tx_chan_cfg.auto_clear_before_cb = false;
    tx_chan_cfg.intr_priority = 0;
--- a/main/boards/bread-compact-ml307/compact_ml307_board.cc
+++ b/main/boards/bread-compact-ml307/compact_ml307_board.cc
@@ -4,9 +4,9 @@
 #include "system_reset.h"
 #include "application.h"
 #include "button.h"
-#include "led.h"
 #include "config.h"
 #include "iot/thing_manager.h"
+#include "led/single_led.h"

 #include <esp_log.h>
 #include <driver/i2c_master.h>
@@ -102,8 +102,8 @@ public:
        InitializeIot();
    }

-    virtual Led* GetBuiltinLed() override {
-        static Led led(BUILTIN_LED_GPIO);
+    virtual Led* GetLed() override {
+        static SingleLed led(BUILTIN_LED_GPIO);
        return &led;
    }

--- a/main/boards/bread-compact-wifi/compact_wifi_board.cc
+++ b/main/boards/bread-compact-wifi/compact_wifi_board.cc
@@ -4,9 +4,9 @@
 #include "system_reset.h"
 #include "application.h"
 #include "button.h"
-#include "led.h"
 #include "config.h"
 #include "iot/thing_manager.h"
+#include "led/single_led.h"

 #include <wifi_station.h>
 #include <esp_log.h>
@@ -42,7 +42,7 @@ private:
    void InitializeButtons() {
        boot_button_.OnClick([this]() {
            auto& app = Application::GetInstance();
-            if (app.GetChatState() == kChatStateUnknown && !WifiStation::GetInstance().IsConnected()) {
+            if (app.GetDeviceState() == kDeviceStateStarting && !WifiStation::GetInstance().IsConnected()) {
                ResetWifiConfiguration();
            }
            app.ToggleChatState();
@@ -107,8 +107,8 @@ public:
        InitializeIot();
    }

-    virtual Led* GetBuiltinLed() override {
-        static Led led(BUILTIN_LED_GPIO);
+    virtual Led* GetLed() override {
+        static SingleLed led(BUILTIN_LED_GPIO);
        return &led;
    }

--- a/main/boards/common/board.cc
+++ b/main/boards/common/board.cc
@@ -20,6 +20,10 @@ Display* Board::GetDisplay() {
    return &display;
 }

+Led* Board::GetLed() {
+    static NoLed led;
+    return &led;
+}

 std::string Board::GetJson() {
    /* 
--- a/main/boards/common/board.h
+++ b/main/boards/common/board.h
@@ -7,7 +7,7 @@
 #include <udp.h>
 #include <string>

-#include "led.h"
+#include "led/led.h"

 void* create_board();
 class AudioCodec;
@@ -32,7 +32,7 @@ public:

    virtual void StartNetwork() = 0;
    virtual ~Board() = default;
-    virtual Led* GetBuiltinLed() = 0;
+    virtual Led* GetLed();
    virtual AudioCodec* GetAudioCodec() = 0;
    virtual Display* GetDisplay();
    virtual Http* CreateHttp() = 0;
--- a/main/boards/common/i2c_device.cc
+++ b/main/boards/common/i2c_device.cc
@@ -29,3 +29,7 @@ uint8_t I2cDevice::ReadReg(uint8_t reg) {
    ESP_ERROR_CHECK(i2c_master_transmit_receive(i2c_device_, &reg, 1, buffer, 1, 100));
    return buffer[0];
 }
+
+void I2cDevice::ReadRegs(uint8_t reg, uint8_t* buffer, size_t length) {
+    ESP_ERROR_CHECK(i2c_master_transmit_receive(i2c_device_, &reg, 1, buffer, length, 100));
+}
--- a/main/boards/common/i2c_device.h
+++ b/main/boards/common/i2c_device.h
@@ -12,6 +12,7 @@ protected:

    void WriteReg(uint8_t reg, uint8_t value);
    uint8_t ReadReg(uint8_t reg);
+    void ReadRegs(uint8_t reg, uint8_t* buffer, size_t length);
 };

 #endif // I2C_DEVICE_H
--- a/main/boards/common/led.h
+++ b/main/boards/common/led.h
@@ -1,47 +0,0 @@
-#ifndef _LED_H_
-#define _LED_H_
-
-#include <led_strip.h>
-#include <esp_timer.h>
-#include <atomic>
-#include <mutex>
-
-#define BLINK_INFINITE -1
-#define BLINK_TASK_STOPPED_BIT BIT0
-#define BLINK_TASK_RUNNING_BIT BIT1
-
-#define DEFAULT_BRIGHTNESS 4
-#define HIGH_BRIGHTNESS 16
-#define LOW_BRIGHTNESS 2
-
-class Led {
-public:
-    Led(gpio_num_t gpio);
-    ~Led();
-
-    void BlinkOnce();
-    void Blink(int times, int interval_ms);
-    void StartContinuousBlink(int interval_ms);
-    void TurnOn();
-    void TurnOff();
-    void SetColor(uint8_t r, uint8_t g, uint8_t b);
-    void SetWhite(uint8_t brightness = DEFAULT_BRIGHTNESS) { SetColor(brightness, brightness, brightness); }
-    void SetGrey(uint8_t brightness = DEFAULT_BRIGHTNESS) { SetColor(brightness, brightness, brightness); }
-    void SetRed(uint8_t brightness = DEFAULT_BRIGHTNESS) { SetColor(brightness, 0, 0); }
-    void SetGreen(uint8_t brightness = DEFAULT_BRIGHTNESS) { SetColor(0, brightness, 0); }
-    void SetBlue(uint8_t brightness = DEFAULT_BRIGHTNESS) { SetColor(0, 0, brightness); }
-
-private:
-    std::mutex mutex_;
-    TaskHandle_t blink_task_ = nullptr;
-    led_strip_handle_t led_strip_ = nullptr;
-    uint8_t r_ = 0, g_ = 0, b_ = 0;
-    int blink_counter_ = 0;
-    int blink_interval_ms_ = 0;
-    esp_timer_handle_t blink_timer_ = nullptr;
-
-    void StartBlinkTask(int times, int interval_ms);
-    void OnBlinkTimer();
-};
-
-#endif // _LED_H_
--- a/main/boards/common/ml307_board.cc
+++ b/main/boards/common/ml307_board.cc
@@ -46,7 +46,7 @@ void Ml307Board::StartNetwork() {
    modem_.OnMaterialReady([this, &application]() {
        ESP_LOGI(TAG, "ML307 material ready");
        application.Schedule([this, &application]() {
-            application.SetChatState(kChatStateIdle);
+            application.SetDeviceState(kDeviceStateIdle);
            WaitForNetworkReady();
        });
    });
--- a/main/boards/common/wifi_board.cc
+++ b/main/boards/common/wifi_board.cc
@@ -38,15 +38,14 @@ static std::string rssi_to_string(int rssi) {
 void WifiBoard::StartNetwork() {
    auto& application = Application::GetInstance();
    auto display = Board::GetInstance().GetDisplay();
-    auto builtin_led = Board::GetInstance().GetBuiltinLed();

    // Try to connect to WiFi, if failed, launch the WiFi configuration AP
    auto& wifi_station = WifiStation::GetInstance();
    display->SetStatus(std::string("正在连接 ") + wifi_station.GetSsid());
    wifi_station.Start();
    if (!wifi_station.IsConnected()) {
-        builtin_led->SetBlue();
-        builtin_led->Blink(1000, 500);
+        application.SetDeviceState(kDeviceStateWifiConfiguring);
+
        auto& wifi_ap = WifiConfigurationAp::GetInstance();
        wifi_ap.SetSsidPrefix("Xiaozhi");
        wifi_ap.Start();
--- a/main/boards/esp-box-3/config.h
+++ b/main/boards/esp-box-3/config.h
@@ -26,12 +26,17 @@
 #define VOLUME_UP_BUTTON_GPIO   GPIO_NUM_NC
 #define VOLUME_DOWN_BUTTON_GPIO GPIO_NUM_NC

-#define DISPLAY_SDA_PIN GPIO_NUM_NC
-#define DISPLAY_SCL_PIN GPIO_NUM_NC
-#define DISPLAY_WIDTH   128
-#define DISPLAY_HEIGHT  64
+#define DISPLAY_WIDTH   320
+#define DISPLAY_HEIGHT  240
 #define DISPLAY_MIRROR_X true
 #define DISPLAY_MIRROR_Y true
+#define DISPLAY_SWAP_XY false
+
+#define DISPLAY_OFFSET_X  0
+#define DISPLAY_OFFSET_Y  0
+
+#define DISPLAY_BACKLIGHT_PIN GPIO_NUM_47
+#define DISPLAY_BACKLIGHT_OUTPUT_INVERT false


 #endif // _BOARD_CONFIG_H_
--- a/main/boards/esp-box-3/esp_box3_board.cc
+++ b/main/boards/esp-box-3/esp_box3_board.cc
@@ -1,21 +1,110 @@
 #include "wifi_board.h"
 #include "audio_codecs/box_audio_codec.h"
-#include "display/no_display.h"
+#include "display/lcd_display.h"
+#include "esp_lcd_ili9341.h"
+#include "font_awesome_symbols.h"
 #include "application.h"
 #include "button.h"
-#include "led.h"
 #include "config.h"
 #include "iot/thing_manager.h"

 #include <esp_log.h>
+#include <esp_lcd_panel_vendor.h>
 #include <driver/i2c_master.h>
+#include <driver/spi_common.h>

 #define TAG "EspBox3Board"

+// Can move to display/st7789_display.h
+LV_FONT_DECLARE(font_puhui_14_1);
+LV_FONT_DECLARE(font_awesome_30_1);
+LV_FONT_DECLARE(font_awesome_14_1);
+
+// Init ili9341 by custom cmd
+static const ili9341_lcd_init_cmd_t vendor_specific_init[] = {
+    {0xC8, (uint8_t []){0xFF, 0x93, 0x42}, 3, 0},
+    {0xC0, (uint8_t []){0x0E, 0x0E}, 2, 0},
+    {0xC5, (uint8_t []){0xD0}, 1, 0},
+    {0xC1, (uint8_t []){0x02}, 1, 0},
+    {0xB4, (uint8_t []){0x02}, 1, 0},
+    {0xE0, (uint8_t []){0x00, 0x03, 0x08, 0x06, 0x13, 0x09, 0x39, 0x39, 0x48, 0x02, 0x0a, 0x08, 0x17, 0x17, 0x0F}, 15, 0},
+    {0xE1, (uint8_t []){0x00, 0x28, 0x29, 0x01, 0x0d, 0x03, 0x3f, 0x33, 0x52, 0x04, 0x0f, 0x0e, 0x37, 0x38, 0x0F}, 15, 0},
+
+    {0xB1, (uint8_t []){00, 0x1B}, 2, 0},
+    {0x36, (uint8_t []){0x08}, 1, 0},
+    {0x3A, (uint8_t []){0x55}, 1, 0},
+    {0xB7, (uint8_t []){0x06}, 1, 0},
+
+    {0x11, (uint8_t []){0}, 0x80, 0},
+    {0x29, (uint8_t []){0}, 0x80, 0},
+
+    {0, (uint8_t []){0}, 0xff, 0},
+};
+
+// Example Display and UI overwrite in different board
+class Ili9341Display : public LcdDisplay {
+private:    
+    lv_obj_t *user_messge_label_ = nullptr;
+    lv_obj_t *ai_messge_label_ = nullptr;
+public:
+    Ili9341Display(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
+                         gpio_num_t backlight_pin, bool backlight_output_invert,
+                         int width, int height, int offset_x, int offset_y, bool mirror_x, bool mirror_y, bool swap_xy)
+        : LcdDisplay(panel_io, panel, backlight_pin, backlight_output_invert, width, height, offset_x, offset_y, mirror_x, mirror_y, swap_xy) {}
+
+    void SetChatMessage(const std::string &role, const std::string &content) override {
+        if (ai_messge_label_== nullptr || user_messge_label_== nullptr) {
+            return;
+        }
+
+        DisplayLockGuard lock(this);
+        ESP_LOGI(TAG, "role:%s", role.c_str());
+        if(role == "assistant") {
+            std::string new_content = "AI: " + content;
+            lv_label_set_text(ai_messge_label_, new_content.c_str());
+        } else if(role == "user") {
+            std::string new_content = "User: " + content;
+            lv_label_set_text(user_messge_label_, new_content.c_str());
+        } else{
+            lv_label_set_text(ai_messge_label_, "AI: ");
+            lv_label_set_text(user_messge_label_, "User: ");
+        }
+    }
+
+    void SetupUI() override {
+        DisplayLockGuard lock(this);
+
+        lv_obj_del(chat_message_label_);
+
+        lv_obj_set_flex_align(content_, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_SPACE_EVENLY); // 子对象居中对齐，等距分布
+
+        lv_obj_set_style_text_font(emotion_label_, &font_awesome_30_1, 0);
+        lv_label_set_text(emotion_label_, FONT_AWESOME_AI_CHIP);
+        lv_obj_align(emotion_label_, LV_ALIGN_TOP_MID, 0, -10); // 左侧居中，向右偏移10个单位
+
+        static lv_style_t style_msg;
+        lv_style_init(&style_msg);
+        lv_style_set_width(&style_msg, LV_HOR_RES - 25);
+
+        user_messge_label_ = lv_label_create(content_);
+        lv_obj_set_style_text_font(user_messge_label_, &font_puhui_14_1, 0);
+        lv_label_set_text(user_messge_label_, "User: ");
+        lv_obj_add_style(user_messge_label_, &style_msg, 0);
+        lv_obj_align(user_messge_label_, LV_ALIGN_TOP_LEFT, 2, 25);
+
+        ai_messge_label_ = lv_label_create(content_);
+        lv_obj_set_style_text_font(ai_messge_label_, &font_puhui_14_1, 0);
+        lv_label_set_text(ai_messge_label_, "AI: ");
+        lv_obj_add_style(ai_messge_label_, &style_msg, 0);
+        lv_obj_align(ai_messge_label_, LV_ALIGN_TOP_LEFT, 2, 77);
+    }
+};
+
 class EspBox3Board : public WifiBoard {
 private:
    i2c_master_bus_handle_t i2c_bus_;
    Button boot_button_;
+    Ili9341Display* display_;

    void InitializeI2c() {
        // Initialize I2C peripheral
@@ -34,12 +123,65 @@ private:
        ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_bus_cfg, &i2c_bus_));
    }

+    void InitializeSpi() {
+        spi_bus_config_t buscfg = {};
+        buscfg.mosi_io_num = GPIO_NUM_6;
+        buscfg.miso_io_num = GPIO_NUM_NC;
+        buscfg.sclk_io_num = GPIO_NUM_7;
+        buscfg.quadwp_io_num = GPIO_NUM_NC;
+        buscfg.quadhd_io_num = GPIO_NUM_NC;
+        buscfg.max_transfer_sz = DISPLAY_WIDTH * DISPLAY_HEIGHT * sizeof(uint16_t);
+        ESP_ERROR_CHECK(spi_bus_initialize(SPI3_HOST, &buscfg, SPI_DMA_CH_AUTO));
+    }
+
    void InitializeButtons() {
        boot_button_.OnClick([this]() {
            Application::GetInstance().ToggleChatState();
        });
    }

+    void InitializeIli9341Display() {
+        esp_lcd_panel_io_handle_t panel_io = nullptr;
+        esp_lcd_panel_handle_t panel = nullptr;
+
+        // 液晶屏控制IO初始化
+        ESP_LOGD(TAG, "Install panel IO");
+        esp_lcd_panel_io_spi_config_t io_config = {};
+        io_config.cs_gpio_num = GPIO_NUM_5;
+        io_config.dc_gpio_num = GPIO_NUM_4;
+        io_config.spi_mode = 0;
+        io_config.pclk_hz = 40 * 1000 * 1000;
+        io_config.trans_queue_depth = 10;
+        io_config.lcd_cmd_bits = 8;
+        io_config.lcd_param_bits = 8;
+        ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi(SPI3_HOST, &io_config, &panel_io));
+
+        // 初始化液晶屏驱动芯片
+        ESP_LOGD(TAG, "Install LCD driver");
+        const ili9341_vendor_config_t vendor_config = {
+            .init_cmds = &vendor_specific_init[0],
+            .init_cmds_size = sizeof(vendor_specific_init) / sizeof(ili9341_lcd_init_cmd_t),
+        };
+
+        esp_lcd_panel_dev_config_t panel_config = {};
+        panel_config.reset_gpio_num = GPIO_NUM_48;
+        panel_config.flags.reset_active_high = 1,
+        panel_config.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB;
+        panel_config.bits_per_pixel = 16;
+        panel_config.vendor_config = (void *)&vendor_config;
+        ESP_ERROR_CHECK(esp_lcd_new_panel_ili9341(panel_io, &panel_config, &panel));
+        
+        esp_lcd_panel_reset(panel);
+        esp_lcd_panel_init(panel);
+        esp_lcd_panel_invert_color(panel, true);
+        esp_lcd_panel_swap_xy(panel, DISPLAY_SWAP_XY);
+        esp_lcd_panel_mirror(panel, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+        esp_lcd_panel_disp_on_off(panel, true);
+        display_ = new Ili9341Display(panel_io, panel, DISPLAY_BACKLIGHT_PIN, DISPLAY_BACKLIGHT_OUTPUT_INVERT,
+                                    DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_OFFSET_X, DISPLAY_OFFSET_Y, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y, DISPLAY_SWAP_XY);
+        display_->SetupUI();
+    }
+
    // 物联网初始化，添加对 AI 可见设备
    void InitializeIot() {
        auto& thing_manager = iot::ThingManager::GetInstance();
@@ -49,15 +191,12 @@ private:
 public:
    EspBox3Board() : boot_button_(BOOT_BUTTON_GPIO) {
        InitializeI2c();
+        InitializeSpi();
+        InitializeIli9341Display();
        InitializeButtons();
        InitializeIot();
    }

-    virtual Led* GetBuiltinLed() override {
-        static Led led(GPIO_NUM_NC);
-        return &led;
-    }
-
    virtual AudioCodec* GetAudioCodec() override {
        static BoxAudioCodec* audio_codec = nullptr;
        if (audio_codec == nullptr) {
@@ -70,8 +209,7 @@ public:
    }

    virtual Display* GetDisplay() override {
-        static NoDisplay display;
-        return &display;
+        return display_;
    }
 };

--- a/main/boards/kevin-box-1/kevin_box_board.cc
+++ b/main/boards/kevin-box-1/kevin_box_board.cc
@@ -3,9 +3,9 @@
 #include "display/ssd1306_display.h"
 #include "application.h"
 #include "button.h"
-#include "led.h"
 #include "config.h"
 #include "iot/thing_manager.h"
+#include "led_strip/single_led.h"

 #include <esp_log.h>
 #include <esp_spiffs.h>
@@ -135,9 +135,9 @@ public:
        InitializeButtons();
        InitializeIot();
    }
-
-    virtual Led* GetBuiltinLed() override {
-        static Led led(BUILTIN_LED_GPIO);
+    
+    virtual Led* GetLed() override {
+        static SingleLed led(BUILTIN_LED_GPIO);
        return &led;
    }

--- a/main/boards/kevin-box-2/kevin_box_board.cc
+++ b/main/boards/kevin-box-2/kevin_box_board.cc
@@ -3,10 +3,10 @@
 #include "display/ssd1306_display.h"
 #include "application.h"
 #include "button.h"
-#include "led.h"
 #include "config.h"
 #include "axp2101.h"
 #include "iot/thing_manager.h"
+#include "led/single_led.h"

 #include <esp_log.h>
 #include <esp_spiffs.h>
@@ -46,7 +46,7 @@ private:
        // 电池放电模式下，如果待机超过一定时间，则自动关机
        const int seconds_to_shutdown = 600;
        static int seconds = 0;
-        if (Application::GetInstance().GetChatState() != kChatStateIdle) {
+        if (Application::GetInstance().GetDeviceState() != kDeviceStateIdle) {
            seconds = 0;
            return;
        }
@@ -179,9 +179,9 @@ public:
        InitializePowerSaveTimer();
        InitializeIot();
    }
-
-    virtual Led* GetBuiltinLed() override {
-        static Led led(BUILTIN_LED_GPIO);
+    
+    virtual Led* GetLed() override {
+        static SingleLed led(BUILTIN_LED_GPIO);
        return &led;
    }

--- a/main/boards/kevin-c3/config.h
+++ b/main/boards/kevin-c3/config.h
@@ -17,8 +17,8 @@
 #define AUDIO_CODEC_I2C_SCL_PIN  GPIO_NUM_1
 #define AUDIO_CODEC_ES8311_ADDR  ES8311_CODEC_DEFAULT_ADDR

-#define BUILTIN_LED_GPIO        GPIO_NUM_2
-#define BOOT_BUTTON_GPIO        GPIO_NUM_9
+#define BUILTIN_LED_GPIO        GPIO_NUM_5
+#define BOOT_BUTTON_GPIO        GPIO_NUM_6


 #endif // _BOARD_CONFIG_H_
--- a/main/boards/kevin-c3/kevin_box_board.cc
+++ b/main/boards/kevin-c3/kevin_box_board.cc
@@ -2,12 +2,13 @@
 #include "audio_codecs/es8311_audio_codec.h"
 #include "application.h"
 #include "button.h"
-#include "led.h"
 #include "config.h"
 #include "iot/thing_manager.h"
+#include "led/circular_strip.h"

 #include <wifi_station.h>
 #include <esp_log.h>
+#include <esp_efuse_table.h>
 #include <driver/i2c_master.h>

 #define TAG "KevinBoxBoard"
@@ -37,7 +38,7 @@ private:
    void InitializeButtons() {
        boot_button_.OnClick([this]() {
            auto& app = Application::GetInstance();
-            if (app.GetChatState() == kChatStateUnknown && !WifiStation::GetInstance().IsConnected()) {
+            if (app.GetDeviceState() == kDeviceStateUnknown && !WifiStation::GetInstance().IsConnected()) {
                ResetWifiConfiguration();
            }
        });
@@ -56,14 +57,17 @@ private:
    }

 public:
-    KevinBoxBoard() : boot_button_(BOOT_BUTTON_GPIO) {
+    KevinBoxBoard() : boot_button_(BOOT_BUTTON_GPIO) {  
+        // 把 ESP32C3 的 VDD SPI 引脚作为普通 GPIO 口使用
+        esp_efuse_write_field_bit(ESP_EFUSE_VDD_SPI_AS_GPIO);
+        
        InitializeCodecI2c();
        InitializeButtons();
        InitializeIot();
    }

-    virtual Led* GetBuiltinLed() override {
-        static Led led(BUILTIN_LED_GPIO);
+    virtual Led* GetLed() override {
+        static CircularStrip led(BUILTIN_LED_GPIO, 8);
        return &led;
    }

--- a/main/boards/lichuang-dev/lichuang_dev_board.cc
+++ b/main/boards/lichuang-dev/lichuang_dev_board.cc
@@ -1,9 +1,8 @@
 #include "wifi_board.h"
 #include "audio_codecs/box_audio_codec.h"
-#include "display/st7789_display.h"
+#include "display/lcd_display.h"
 #include "application.h"
 #include "button.h"
-#include "led.h"
 #include "config.h"
 #include "i2c_device.h"
 #include "iot/thing_manager.h"
@@ -37,7 +36,7 @@ private:
    i2c_master_bus_handle_t i2c_bus_;
    i2c_master_dev_handle_t pca9557_handle_;
    Button boot_button_;
-    St7789Display* display_;
+    LcdDisplay* display_;
    Pca9557* pca9557_;

    void InitializeI2c() {
@@ -74,7 +73,7 @@ private:
    void InitializeButtons() {
        boot_button_.OnClick([this]() {
            auto& app = Application::GetInstance();
-            if (app.GetChatState() == kChatStateUnknown && !WifiStation::GetInstance().IsConnected()) {
+            if (app.GetDeviceState() == kDeviceStateUnknown && !WifiStation::GetInstance().IsConnected()) {
                ResetWifiConfiguration();
            }
        });
@@ -116,7 +115,7 @@ private:
        esp_lcd_panel_invert_color(panel, true);
        esp_lcd_panel_swap_xy(panel, DISPLAY_SWAP_XY);
        esp_lcd_panel_mirror(panel, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
-        display_ = new St7789Display(panel_io, panel, DISPLAY_BACKLIGHT_PIN, DISPLAY_BACKLIGHT_OUTPUT_INVERT,
+        display_ = new LcdDisplay(panel_io, panel, DISPLAY_BACKLIGHT_PIN, DISPLAY_BACKLIGHT_OUTPUT_INVERT,
                                    DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_OFFSET_X, DISPLAY_OFFSET_Y, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y, DISPLAY_SWAP_XY);
    }

@@ -135,11 +134,6 @@ public:
        InitializeIot();
    }

-    virtual Led* GetBuiltinLed() override {
-        static Led led(GPIO_NUM_NC);
-        return &led;
-    }
-
    virtual AudioCodec* GetAudioCodec() override {
        static BoxAudioCodec* audio_codec = nullptr;
        if (audio_codec == nullptr) {
--- a/main/boards/m5stack-core-s3/config.h
+++ b/main/boards/m5stack-core-s3/config.h
@@ -0,0 +1,44 @@
+#ifndef _BOARD_CONFIG_H_
+#define _BOARD_CONFIG_H_
+
+// M5Stack CoreS3 Board configuration
+
+#include <driver/gpio.h>
+
+#define AUDIO_INPUT_REFERENCE    true
+#define AUDIO_INPUT_SAMPLE_RATE  24000
+#define AUDIO_OUTPUT_SAMPLE_RATE 24000
+#define AUDIO_DEFAULT_OUTPUT_VOLUME 80
+
+#define AUDIO_I2S_GPIO_MCLK GPIO_NUM_0
+#define AUDIO_I2S_GPIO_WS GPIO_NUM_33
+#define AUDIO_I2S_GPIO_BCLK GPIO_NUM_34
+#define AUDIO_I2S_GPIO_DIN  GPIO_NUM_14
+#define AUDIO_I2S_GPIO_DOUT GPIO_NUM_13
+
+#define AUDIO_CODEC_I2C_SDA_PIN  GPIO_NUM_12
+#define AUDIO_CODEC_I2C_SCL_PIN  GPIO_NUM_11
+#define AUDIO_CODEC_AW88298_ADDR AW88298_CODEC_DEFAULT_ADDR
+#define AUDIO_CODEC_ES7210_ADDR  ES7210_CODEC_DEFAULT_ADDR
+
+#define BUILTIN_LED_GPIO        GPIO_NUM_NC
+#define BOOT_BUTTON_GPIO        GPIO_NUM_0
+#define VOLUME_UP_BUTTON_GPIO   GPIO_NUM_NC
+#define VOLUME_DOWN_BUTTON_GPIO GPIO_NUM_NC
+
+#define DISPLAY_SDA_PIN GPIO_NUM_NC
+#define DISPLAY_SCL_PIN GPIO_NUM_NC
+#define DISPLAY_WIDTH   320
+#define DISPLAY_HEIGHT  240
+#define DISPLAY_MIRROR_X false
+#define DISPLAY_MIRROR_Y false
+#define DISPLAY_SWAP_XY false
+
+#define DISPLAY_OFFSET_X  0
+#define DISPLAY_OFFSET_Y  0
+
+#define DISPLAY_BACKLIGHT_PIN GPIO_NUM_NC
+#define DISPLAY_BACKLIGHT_OUTPUT_INVERT true
+
+
+#endif // _BOARD_CONFIG_H_
--- a/main/boards/m5stack-core-s3/m5stack_core_s3.cc
+++ b/main/boards/m5stack-core-s3/m5stack_core_s3.cc
@@ -0,0 +1,303 @@
+#include "wifi_board.h"
+#include "audio_codecs/cores3_audio_codec.h"
+#include "display/lcd_display.h"
+#include "application.h"
+#include "button.h"
+#include "config.h"
+#include "i2c_device.h"
+#include "iot/thing_manager.h"
+
+#include <esp_log.h>
+#include <driver/i2c_master.h>
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_panel_ops.h>
+#include "esp_lcd_ili9341.h"
+
+#define TAG "M5StackCoreS3Board"
+
+class Axp2101 : public I2cDevice {
+public:
+    // Power Init
+    Axp2101(i2c_master_bus_handle_t i2c_bus, uint8_t addr) : I2cDevice(i2c_bus, addr) {
+        uint8_t data = ReadReg(0x90);
+        data |= 0b10110100;
+        WriteReg(0x90, data);
+        WriteReg(0x99, (0b11110 - 5));
+        WriteReg(0x97, (0b11110 - 2));
+        WriteReg(0x69, 0b00110101);
+        WriteReg(0x30, 0b111111);
+        WriteReg(0x90, 0xBF);
+        WriteReg(0x94, 33 - 5);
+        WriteReg(0x95, 33 - 5);
+    }
+
+    int GetBatteryCurrentDirection() {
+        return (ReadReg(0x01) & 0b01100000) >> 5;
+    }
+
+    bool IsCharging() {
+        return GetBatteryCurrentDirection() == 1;
+    }
+
+    int GetBatteryLevel() {
+        return ReadReg(0xA4);
+    }
+};
+
+class Aw9523 : public I2cDevice {
+public:
+    // Exanpd IO Init
+    Aw9523(i2c_master_bus_handle_t i2c_bus, uint8_t addr) : I2cDevice(i2c_bus, addr) {
+        WriteReg(0x02, 0b00000111);  // P0
+        WriteReg(0x03, 0b10001111);  // P1
+        WriteReg(0x04, 0b00011000);  // CONFIG_P0
+        WriteReg(0x05, 0b00001100);  // CONFIG_P1
+        WriteReg(0x11, 0b00010000);  // GCR P0 port is Push-Pull mode.
+        WriteReg(0x12, 0b11111111);  // LEDMODE_P0
+        WriteReg(0x13, 0b11111111);  // LEDMODE_P1
+    }
+
+    void ResetAw88298() {
+        ESP_LOGI(TAG, "Reset AW88298");
+        WriteReg(0x02, 0b00000011);
+        vTaskDelay(pdMS_TO_TICKS(10));
+        WriteReg(0x02, 0b00000111);
+        vTaskDelay(pdMS_TO_TICKS(50));
+    }
+
+    void ResetIli9342() {
+        ESP_LOGI(TAG, "Reset IlI9342");
+        WriteReg(0x03, 0b10000001);
+        vTaskDelay(pdMS_TO_TICKS(20));
+        WriteReg(0x03, 0b10000011);
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+};
+
+class Ft6336 : public I2cDevice {
+public:
+    struct TouchPoint_t {
+        int num = 0;
+        int x = -1;
+        int y = -1;
+    };
+    
+    Ft6336(i2c_master_bus_handle_t i2c_bus, uint8_t addr) : I2cDevice(i2c_bus, addr) {
+        uint8_t chip_id = ReadReg(0xA3);
+        ESP_LOGI(TAG, "Get chip ID: 0x%02X", chip_id);
+        read_buffer_ = new uint8_t[6];
+    }
+
+    ~Ft6336() {
+        delete[] read_buffer_;
+    }
+
+    void UpdateTouchPoint() {
+        ReadRegs(0x02, read_buffer_, 6);
+        tp_.num = read_buffer_[0] & 0x0F;
+        tp_.x = ((read_buffer_[1] & 0x0F) << 8) | read_buffer_[2];
+        tp_.y = ((read_buffer_[3] & 0x0F) << 8) | read_buffer_[4];
+    }
+
+    const TouchPoint_t& GetTouchPoint() {
+        return tp_;
+    }
+
+private:
+    uint8_t* read_buffer_ = nullptr;
+    TouchPoint_t tp_;
+};
+
+class M5StackCoreS3Board : public WifiBoard {
+private:
+    i2c_master_bus_handle_t i2c_bus_;
+    Axp2101* axp2101_;
+    Aw9523* aw9523_;
+    Ft6336* ft6336_;
+    LcdDisplay* display_;
+    Button boot_button_;
+
+    void InitializeI2c() {
+        // Initialize I2C peripheral
+        i2c_master_bus_config_t i2c_bus_cfg = {
+            .i2c_port = (i2c_port_t)1,
+            .sda_io_num = AUDIO_CODEC_I2C_SDA_PIN,
+            .scl_io_num = AUDIO_CODEC_I2C_SCL_PIN,
+            .clk_source = I2C_CLK_SRC_DEFAULT,
+            .glitch_ignore_cnt = 7,
+            .intr_priority = 0,
+            .trans_queue_depth = 0,
+            .flags = {
+                .enable_internal_pullup = 1,
+            },
+        };
+        ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_bus_cfg, &i2c_bus_));
+    }
+
+    void I2cDetect() {
+        uint8_t address;
+        printf("     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
+        for (int i = 0; i < 128; i += 16) {
+            printf("%02x: ", i);
+            for (int j = 0; j < 16; j++) {
+                fflush(stdout);
+                address = i + j;
+                esp_err_t ret = i2c_master_probe(i2c_bus_, address, pdMS_TO_TICKS(200));
+                if (ret == ESP_OK) {
+                    printf("%02x ", address);
+                } else if (ret == ESP_ERR_TIMEOUT) {
+                    printf("UU ");
+                } else {
+                    printf("-- ");
+                }
+            }
+            printf("\r\n");
+        }
+    }
+
+    void InitializeAxp2101() {
+        ESP_LOGI(TAG, "Init AXP2101");
+        axp2101_ = new Axp2101(i2c_bus_, 0x34);
+    }
+
+    void InitializeAw9523() {
+        ESP_LOGI(TAG, "Init AW9523");
+        aw9523_ = new Aw9523(i2c_bus_, 0x58);
+        vTaskDelay(pdMS_TO_TICKS(50));
+    }
+
+    static void touchpad_daemon(void* param) {
+        vTaskDelay(pdMS_TO_TICKS(2000));
+        auto& board = (M5StackCoreS3Board&)Board::GetInstance();
+        auto touchpad = board.GetTouchpad();
+        bool was_touched = false;
+        while (1) {
+            touchpad->UpdateTouchPoint();
+            if (touchpad->GetTouchPoint().num > 0) {
+                // On press
+                if (!was_touched) {
+                    was_touched = true;
+                    Application::GetInstance().ToggleChatState();
+                }
+            }
+            // On release
+            else if (was_touched) {
+                was_touched = false;
+            }
+            vTaskDelay(pdMS_TO_TICKS(50));
+        }
+        vTaskDelete(NULL);
+    }
+
+    void InitializeFt6336TouchPad() {
+        ESP_LOGI(TAG, "Init FT6336");
+        ft6336_ = new Ft6336(i2c_bus_, 0x38);
+        xTaskCreate(touchpad_daemon, "tp", 2048, NULL, 5, NULL);
+    }
+
+    void InitializeSpi() {
+        spi_bus_config_t buscfg = {};
+        buscfg.mosi_io_num = GPIO_NUM_37;
+        buscfg.miso_io_num = GPIO_NUM_NC;
+        buscfg.sclk_io_num = GPIO_NUM_36;
+        buscfg.quadwp_io_num = GPIO_NUM_NC;
+        buscfg.quadhd_io_num = GPIO_NUM_NC;
+        buscfg.max_transfer_sz = DISPLAY_WIDTH * DISPLAY_HEIGHT * sizeof(uint16_t);
+        ESP_ERROR_CHECK(spi_bus_initialize(SPI3_HOST, &buscfg, SPI_DMA_CH_AUTO));
+    }
+
+    void InitializeIli9342Display() {
+        ESP_LOGI(TAG, "Init IlI9342");
+
+        esp_lcd_panel_io_handle_t panel_io = nullptr;
+        esp_lcd_panel_handle_t panel = nullptr;
+
+        ESP_LOGD(TAG, "Install panel IO");
+        esp_lcd_panel_io_spi_config_t io_config = {};
+        io_config.cs_gpio_num = GPIO_NUM_3;
+        io_config.dc_gpio_num = GPIO_NUM_35;
+        io_config.spi_mode = 2;
+        io_config.pclk_hz = 40 * 1000 * 1000;
+        io_config.trans_queue_depth = 10;
+        io_config.lcd_cmd_bits = 8;
+        io_config.lcd_param_bits = 8;
+        ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi(SPI3_HOST, &io_config, &panel_io));
+
+        ESP_LOGD(TAG, "Install LCD driver");
+        esp_lcd_panel_dev_config_t panel_config = {};
+        panel_config.reset_gpio_num = GPIO_NUM_NC;
+        panel_config.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB;
+        panel_config.bits_per_pixel = 16;
+        ESP_ERROR_CHECK(esp_lcd_new_panel_ili9341(panel_io, &panel_config, &panel));
+        
+        esp_lcd_panel_reset(panel);
+        aw9523_->ResetIli9342();
+
+        esp_lcd_panel_init(panel);
+        esp_lcd_panel_invert_color(panel, true);
+        esp_lcd_panel_swap_xy(panel, DISPLAY_SWAP_XY);
+        esp_lcd_panel_mirror(panel, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+
+        display_ = new LcdDisplay(panel_io, panel, DISPLAY_BACKLIGHT_PIN, DISPLAY_BACKLIGHT_OUTPUT_INVERT,
+                                    DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_OFFSET_X, DISPLAY_OFFSET_Y, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y, DISPLAY_SWAP_XY);
+    }
+
+    void InitializeButtons() {
+        boot_button_.OnClick([this]() {
+            Application::GetInstance().ToggleChatState();
+        });
+    }
+
+    // 物联网初始化，添加对 AI 可见设备
+    void InitializeIot() {
+        auto& thing_manager = iot::ThingManager::GetInstance();
+        thing_manager.AddThing(iot::CreateThing("Speaker"));
+    }
+
+public:
+    M5StackCoreS3Board() : boot_button_(GPIO_NUM_1) {
+        InitializeI2c();
+        InitializeAxp2101();
+        InitializeAw9523();
+        InitializeFt6336TouchPad();
+        I2cDetect();
+        InitializeSpi();
+        InitializeIli9342Display();
+        InitializeButtons();
+        InitializeIot();
+    }
+
+    virtual AudioCodec* GetAudioCodec() override {
+        static CoreS3AudioCodec* audio_codec = nullptr;
+        if (audio_codec == nullptr) {
+            aw9523_->ResetAw88298();
+            audio_codec = new CoreS3AudioCodec(i2c_bus_, AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
+                AUDIO_I2S_GPIO_MCLK, AUDIO_I2S_GPIO_BCLK, AUDIO_I2S_GPIO_WS, AUDIO_I2S_GPIO_DOUT, AUDIO_I2S_GPIO_DIN,
+                AUDIO_CODEC_AW88298_ADDR, AUDIO_CODEC_ES7210_ADDR, AUDIO_INPUT_REFERENCE);
+        }
+        return audio_codec;
+    }
+
+    virtual Display* GetDisplay() override {
+        return display_;
+    }
+
+    virtual bool GetBatteryLevel(int &level, bool& charging) override {
+        static int last_level = 0;
+        static bool last_charging = false;
+        level = axp2101_->GetBatteryLevel();
+        charging = axp2101_->IsCharging();
+        if (level != last_level || charging != last_charging) {
+            last_level = level;
+            last_charging = charging;
+            ESP_LOGI(TAG, "Battery level: %d, charging: %d", level, charging);
+        }
+        return true;
+    }
+
+    Ft6336* GetTouchpad() {
+        return ft6336_;
+    }
+};
+
+DECLARE_BOARD(M5StackCoreS3Board);
--- a/main/boards/magiclick-2p4/config.h
+++ b/main/boards/magiclick-2p4/config.h
@@ -0,0 +1,48 @@
+#ifndef _BOARD_CONFIG_H_
+#define _BOARD_CONFIG_H_
+
+#include <driver/gpio.h>
+
+#define AUDIO_INPUT_SAMPLE_RATE 24000
+#define AUDIO_OUTPUT_SAMPLE_RATE 24000
+
+#define AUDIO_I2S_GPIO_MCLK GPIO_NUM_8
+#define AUDIO_I2S_GPIO_WS GPIO_NUM_11
+#define AUDIO_I2S_GPIO_BCLK GPIO_NUM_9
+#define AUDIO_I2S_GPIO_DIN GPIO_NUM_10
+#define AUDIO_I2S_GPIO_DOUT GPIO_NUM_12
+
+#define AUDIO_CODEC_PA_PIN GPIO_NUM_4 // pcb v2.4不起作用，适用于2.4A
+#define AUDIO_CODEC_I2C_SDA_PIN GPIO_NUM_5
+#define AUDIO_CODEC_I2C_SCL_PIN GPIO_NUM_6
+#define AUDIO_CODEC_ES8311_ADDR ES8311_CODEC_DEFAULT_ADDR
+
+//led power
+#define BUILTIN_LED_POWER GPIO_NUM_39 // 低电平有效
+#define BUILTIN_LED_POWER_OUTPUT_INVERT true
+
+#define BUILTIN_LED_NUM 2
+#define BUILTIN_LED_GPIO GPIO_NUM_38
+
+#define BOOT_BUTTON_GPIO GPIO_NUM_21
+
+// display
+#define DISPLAY_SDA_PIN GPIO_NUM_15
+#define DISPLAY_SCL_PIN GPIO_NUM_16
+#define DISPLAY_CS_PIN GPIO_NUM_17
+#define DISPLAY_DC_PIN GPIO_NUM_18
+#define DISPLAY_RST_PIN GPIO_NUM_14
+
+#define DISPLAY_WIDTH 128
+#define DISPLAY_HEIGHT 128
+#define DISPLAY_MIRROR_X false
+#define DISPLAY_MIRROR_Y true
+#define DISPLAY_SWAP_XY false
+
+#define DISPLAY_OFFSET_X 0
+#define DISPLAY_OFFSET_Y 0
+
+#define DISPLAY_BACKLIGHT_PIN GPIO_NUM_13
+#define DISPLAY_BACKLIGHT_OUTPUT_INVERT false
+
+#endif // _BOARD_CONFIG_H_
--- a/main/boards/magiclick-2p4/magiclick_2p4_board.cc
+++ b/main/boards/magiclick-2p4/magiclick_2p4_board.cc
@@ -0,0 +1,142 @@
+#include "wifi_board.h"
+#include "display/lcd_display.h"
+#include "audio_codecs/es8311_audio_codec.h"
+#include "application.h"
+#include "button.h"
+#include "led/single_led.h"
+#include "iot/thing_manager.h"
+#include "config.h"
+#include <esp_lcd_panel_vendor.h>
+#include <wifi_station.h>
+#include <esp_log.h>
+#include <driver/i2c_master.h>
+#include <driver/spi_common.h>
+#include "esp_lcd_nv3023.h"
+#define TAG "magiclick_2p4"
+
+class magiclick_2p4 : public WifiBoard {
+private:
+    i2c_master_bus_handle_t codec_i2c_bus_;
+    Button boot_button_;
+    LcdDisplay* display_;
+
+    void InitializeCodecI2c() {
+        // Initialize I2C peripheral
+        i2c_master_bus_config_t i2c_bus_cfg = {
+            .i2c_port = I2C_NUM_0,
+            .sda_io_num = AUDIO_CODEC_I2C_SDA_PIN,
+            .scl_io_num = AUDIO_CODEC_I2C_SCL_PIN,
+            .clk_source = I2C_CLK_SRC_DEFAULT,
+            .glitch_ignore_cnt = 7,
+            .intr_priority = 0,
+            .trans_queue_depth = 0,
+            .flags = {
+                .enable_internal_pullup = 1,
+            },
+        };
+        ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_bus_cfg, &codec_i2c_bus_));
+    }
+
+    void InitializeButtons() {
+        boot_button_.OnClick([this]() {
+            auto& app = Application::GetInstance();
+            if (app.GetDeviceState() == kDeviceStateUnknown && !WifiStation::GetInstance().IsConnected()) {
+                ResetWifiConfiguration();
+            }
+        });
+        boot_button_.OnPressDown([this]() {
+            Application::GetInstance().StartListening();
+        });
+        boot_button_.OnPressUp([this]() {
+            Application::GetInstance().StopListening();
+        });
+    }
+
+    void InitializeLedPower() {
+        // 设置GPIO模式
+        gpio_reset_pin(BUILTIN_LED_POWER);
+        gpio_set_direction(BUILTIN_LED_POWER, GPIO_MODE_OUTPUT);
+        gpio_set_level(BUILTIN_LED_POWER, BUILTIN_LED_POWER_OUTPUT_INVERT ? 0 : 1);
+    }
+
+    void InitializeSpi() {
+        spi_bus_config_t buscfg = {};
+        buscfg.mosi_io_num = DISPLAY_SDA_PIN;
+        buscfg.miso_io_num = GPIO_NUM_NC;
+        buscfg.sclk_io_num = DISPLAY_SCL_PIN;
+        buscfg.quadwp_io_num = GPIO_NUM_NC;
+        buscfg.quadhd_io_num = GPIO_NUM_NC;
+        buscfg.max_transfer_sz = DISPLAY_WIDTH * DISPLAY_HEIGHT * sizeof(uint16_t);
+        ESP_ERROR_CHECK(spi_bus_initialize(SPI3_HOST, &buscfg, SPI_DMA_CH_AUTO));
+    }
+
+    void InitializeNv3023Display(){
+        esp_lcd_panel_io_handle_t panel_io = nullptr;
+        esp_lcd_panel_handle_t panel = nullptr;
+        // 液晶屏控制IO初始化
+        ESP_LOGD(TAG, "Install panel IO");
+        esp_lcd_panel_io_spi_config_t io_config = {};
+        io_config.cs_gpio_num = DISPLAY_CS_PIN;
+        io_config.dc_gpio_num = DISPLAY_DC_PIN;
+        io_config.spi_mode = 0;
+        io_config.pclk_hz = 20 * 1000 * 1000;
+        io_config.trans_queue_depth = 10;
+        io_config.lcd_cmd_bits = 8;
+        io_config.lcd_param_bits = 8;
+        ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi(SPI3_HOST, &io_config, &panel_io));
+
+        // 初始化液晶屏驱动芯片NV3023
+        ESP_LOGD(TAG, "Install LCD driver");
+        esp_lcd_panel_dev_config_t panel_config = {};
+        panel_config.reset_gpio_num = DISPLAY_RST_PIN;
+        panel_config.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB;
+        panel_config.rgb_endian = LCD_RGB_ENDIAN_RGB;
+        panel_config.bits_per_pixel = 16;
+        ESP_ERROR_CHECK(esp_lcd_new_panel_nv3023(panel_io, &panel_config, &panel));
+
+        esp_lcd_panel_reset(panel);
+
+        esp_lcd_panel_init(panel);
+        esp_lcd_panel_invert_color(panel, true);
+        esp_lcd_panel_swap_xy(panel, DISPLAY_SWAP_XY);
+        esp_lcd_panel_mirror(panel, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+        ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel, true));
+        display_ = new LcdDisplay(panel_io, panel, DISPLAY_BACKLIGHT_PIN, DISPLAY_BACKLIGHT_OUTPUT_INVERT,
+                                    DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_OFFSET_X, DISPLAY_OFFSET_Y, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y, DISPLAY_SWAP_XY);
+    }
+
+    // 物联网初始化，添加对 AI 可见设备
+    void InitializeIot() {
+        auto& thing_manager = iot::ThingManager::GetInstance();
+        thing_manager.AddThing(iot::CreateThing("Speaker"));
+    }
+
+public:
+    magiclick_2p4() :
+        boot_button_(BOOT_BUTTON_GPIO) {
+        InitializeCodecI2c();
+        InitializeButtons();
+        InitializeLedPower();
+        InitializeSpi();
+        InitializeNv3023Display();
+        InitializeIot();
+    }
+
+    virtual Led* GetLed() override {
+        static SingleLed led(BUILTIN_LED_GPIO);
+        return &led;
+    }
+
+    virtual AudioCodec* GetAudioCodec() override {
+        static Es8311AudioCodec audio_codec(codec_i2c_bus_, I2C_NUM_0, AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
+            AUDIO_I2S_GPIO_MCLK, AUDIO_I2S_GPIO_BCLK, AUDIO_I2S_GPIO_WS, AUDIO_I2S_GPIO_DOUT, AUDIO_I2S_GPIO_DIN,
+            AUDIO_CODEC_PA_PIN, AUDIO_CODEC_ES8311_ADDR);
+        return &audio_codec;
+    }
+
+    virtual Display* GetDisplay() override {
+        return display_;
+    }
+};
+
+DECLARE_BOARD(magiclick_2p4);
--- a/main/display/display.cc
+++ b/main/display/display.cc
@@ -121,8 +121,8 @@ void Display::Update() {
    }

    // 仅在聊天状态为空闲时，读取网络状态（避免升级时占用 UART 资源）
-    auto chat_state = Application::GetInstance().GetChatState();
-    if (chat_state == kChatStateIdle || chat_state == kChatStateUnknown) {
+    auto device_state = Application::GetInstance().GetDeviceState();
+    if (device_state == kDeviceStateIdle || device_state == kDeviceStateStarting) {
        icon = board.GetNetworkStateIcon();
        if (network_icon_ != icon) {
            network_icon_ = icon;
--- a/main/display/st7789_display.cc
+++ b/main/display/st7789_display.cc
@@ -1,4 +1,4 @@
-#include "st7789_display.h"
+#include "lcd_display.h"
 #include "font_awesome_symbols.h"

 #include <esp_log.h>
@@ -6,21 +6,21 @@
 #include <driver/ledc.h>
 #include <vector>

-#define TAG "St7789Display"
+#define TAG "LcdDisplay"
 #define LCD_LEDC_CH LEDC_CHANNEL_0

-#define ST7789_LVGL_TICK_PERIOD_MS 2
-#define ST7789_LVGL_TASK_MAX_DELAY_MS 20
-#define ST7789_LVGL_TASK_MIN_DELAY_MS 1
-#define ST7789_LVGL_TASK_STACK_SIZE (4 * 1024)
-#define ST7789_LVGL_TASK_PRIORITY 10
+#define LCD_LVGL_TICK_PERIOD_MS 2
+#define LCD_LVGL_TASK_MAX_DELAY_MS 20
+#define LCD_LVGL_TASK_MIN_DELAY_MS 1
+#define LCD_LVGL_TASK_STACK_SIZE (4 * 1024)
+#define LCD_LVGL_TASK_PRIORITY 10

 LV_FONT_DECLARE(font_puhui_14_1);
 LV_FONT_DECLARE(font_awesome_30_1);
 LV_FONT_DECLARE(font_awesome_14_1);

 static lv_disp_drv_t disp_drv;
-static void st7789_lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
+static void lcd_lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
 {
    esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;
    int offsetx1 = area->x1;
@@ -33,7 +33,7 @@ static void st7789_lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_c
 }

 /* Rotate display and touch, when rotated screen in LVGL. Called when driver parameters are updated. */
-static void st7789_lvgl_port_update_callback(lv_disp_drv_t *drv)
+static void lcd_lvgl_port_update_callback(lv_disp_drv_t *drv)
 {
    esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;

@@ -43,48 +43,28 @@ static void st7789_lvgl_port_update_callback(lv_disp_drv_t *drv)
        // Rotate LCD display
        esp_lcd_panel_swap_xy(panel_handle, false);
        esp_lcd_panel_mirror(panel_handle, true, false);
-#if CONFIG_ST7789_LCD_TOUCH_ENABLED
-        // Rotate LCD touch
-        esp_lcd_touch_set_mirror_y(tp, false);
-        esp_lcd_touch_set_mirror_x(tp, false);
-#endif
        break;
    case LV_DISP_ROT_90:
        // Rotate LCD display
        esp_lcd_panel_swap_xy(panel_handle, true);
        esp_lcd_panel_mirror(panel_handle, true, true);
-#if CONFIG_ST7789_LCD_TOUCH_ENABLED
-        // Rotate LCD touch
-        esp_lcd_touch_set_mirror_y(tp, false);
-        esp_lcd_touch_set_mirror_x(tp, false);
-#endif
        break;
    case LV_DISP_ROT_180:
        // Rotate LCD display
        esp_lcd_panel_swap_xy(panel_handle, false);
        esp_lcd_panel_mirror(panel_handle, false, true);
-#if CONFIG_ST7789_LCD_TOUCH_ENABLED
-        // Rotate LCD touch
-        esp_lcd_touch_set_mirror_y(tp, false);
-        esp_lcd_touch_set_mirror_x(tp, false);
-#endif
        break;
    case LV_DISP_ROT_270:
        // Rotate LCD display
        esp_lcd_panel_swap_xy(panel_handle, true);
        esp_lcd_panel_mirror(panel_handle, false, false);
-#if CONFIG_ST7789_LCD_TOUCH_ENABLED
-        // Rotate LCD touch
-        esp_lcd_touch_set_mirror_y(tp, false);
-        esp_lcd_touch_set_mirror_x(tp, false);
-#endif
        break;
    }
 }

-void St7789Display::LvglTask() {
+void LcdDisplay::LvglTask() {
    ESP_LOGI(TAG, "Starting LVGL task");
-    uint32_t task_delay_ms = ST7789_LVGL_TASK_MAX_DELAY_MS;
+    uint32_t task_delay_ms = LCD_LVGL_TASK_MAX_DELAY_MS;
    while (1)
    {
        // Lock the mutex due to the LVGL APIs are not thread-safe
@@ -93,20 +73,20 @@ void St7789Display::LvglTask() {
            task_delay_ms = lv_timer_handler();
            Unlock();
        }
-        if (task_delay_ms > ST7789_LVGL_TASK_MAX_DELAY_MS)
+        if (task_delay_ms > LCD_LVGL_TASK_MAX_DELAY_MS)
        {
-            task_delay_ms = ST7789_LVGL_TASK_MAX_DELAY_MS;
+            task_delay_ms = LCD_LVGL_TASK_MAX_DELAY_MS;
        }
-        else if (task_delay_ms < ST7789_LVGL_TASK_MIN_DELAY_MS)
+        else if (task_delay_ms < LCD_LVGL_TASK_MIN_DELAY_MS)
        {
-            task_delay_ms = ST7789_LVGL_TASK_MIN_DELAY_MS;
+            task_delay_ms = LCD_LVGL_TASK_MIN_DELAY_MS;
        }
        vTaskDelay(pdMS_TO_TICKS(task_delay_ms));
    }
 }


-St7789Display::St7789Display(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
+LcdDisplay::LcdDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
                           gpio_num_t backlight_pin, bool backlight_output_invert,
                           int width, int height, int offset_x, int offset_y, bool mirror_x, bool mirror_y, bool swap_xy)
    : panel_io_(panel_io), panel_(panel), backlight_pin_(backlight_pin), backlight_output_invert_(backlight_output_invert),
@@ -147,8 +127,8 @@ St7789Display::St7789Display(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_h
    disp_drv.ver_res = height_;
    disp_drv.offset_x = offset_x_;
    disp_drv.offset_y = offset_y_;
-    disp_drv.flush_cb = st7789_lvgl_flush_cb;
-    disp_drv.drv_update_cb = st7789_lvgl_port_update_callback;
+    disp_drv.flush_cb = lcd_lvgl_flush_cb;
+    disp_drv.drv_update_cb = lcd_lvgl_port_update_callback;
    disp_drv.draw_buf = &disp_buf;
    disp_drv.user_data = panel_;

@@ -158,7 +138,7 @@ St7789Display::St7789Display(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_h
    // Tick interface for LVGL (using esp_timer to generate 2ms periodic event)
    const esp_timer_create_args_t lvgl_tick_timer_args = {
        .callback = [](void* arg) {
-            lv_tick_inc(ST7789_LVGL_TICK_PERIOD_MS);
+            lv_tick_inc(LCD_LVGL_TICK_PERIOD_MS);
        },
        .arg = NULL,
        .dispatch_method = ESP_TIMER_TASK,
@@ -166,22 +146,22 @@ St7789Display::St7789Display(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_h
        .skip_unhandled_events = false
    };
    ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &lvgl_tick_timer_));
-    ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer_, ST7789_LVGL_TICK_PERIOD_MS * 1000));
+    ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer_, LCD_LVGL_TICK_PERIOD_MS * 1000));

    lvgl_mutex_ = xSemaphoreCreateRecursiveMutex();
    assert(lvgl_mutex_ != nullptr);
    ESP_LOGI(TAG, "Create LVGL task");
    xTaskCreate([](void *arg) {
-        static_cast<St7789Display*>(arg)->LvglTask();
+        static_cast<LcdDisplay*>(arg)->LvglTask();
        vTaskDelete(NULL);
-    }, "LVGL", ST7789_LVGL_TASK_STACK_SIZE, this, ST7789_LVGL_TASK_PRIORITY, NULL);
+    }, "LVGL", LCD_LVGL_TASK_STACK_SIZE, this, LCD_LVGL_TASK_PRIORITY, NULL);

    SetBacklight(100);

    SetupUI();
 }

-St7789Display::~St7789Display() {
+LcdDisplay::~LcdDisplay() {
    ESP_ERROR_CHECK(esp_timer_stop(lvgl_tick_timer_));
    ESP_ERROR_CHECK(esp_timer_delete(lvgl_tick_timer_));

@@ -207,7 +187,7 @@ St7789Display::~St7789Display() {
    vSemaphoreDelete(lvgl_mutex_);
 }

-void St7789Display::InitializeBacklight(gpio_num_t backlight_pin) {
+void LcdDisplay::InitializeBacklight(gpio_num_t backlight_pin) {
    if (backlight_pin == GPIO_NUM_NC) {
        return;
    }
@@ -238,7 +218,7 @@ void St7789Display::InitializeBacklight(gpio_num_t backlight_pin) {
    ESP_ERROR_CHECK(ledc_channel_config(&backlight_channel));
 }

-void St7789Display::SetBacklight(uint8_t brightness) {
+void LcdDisplay::SetBacklight(uint8_t brightness) {
    if (backlight_pin_ == GPIO_NUM_NC) {
        return;
    }
@@ -254,18 +234,18 @@ void St7789Display::SetBacklight(uint8_t brightness) {
    ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LCD_LEDC_CH));
 }

-bool St7789Display::Lock(int timeout_ms) {
+bool LcdDisplay::Lock(int timeout_ms) {
    // Convert timeout in milliseconds to FreeRTOS ticks
    // If `timeout_ms` is set to 0, the program will block until the condition is met
    const TickType_t timeout_ticks = (timeout_ms == 0) ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms);
    return xSemaphoreTakeRecursive(lvgl_mutex_, timeout_ticks) == pdTRUE;
 }

-void St7789Display::Unlock() {
+void LcdDisplay::Unlock() {
    xSemaphoreGiveRecursive(lvgl_mutex_);
 }

-void St7789Display::SetupUI() {
+void LcdDisplay::SetupUI() {
    DisplayLockGuard lock(this);

    auto screen = lv_disp_get_scr_act(lv_disp_get_default());
@@ -292,10 +272,19 @@ void St7789Display::SetupUI() {
    lv_obj_set_width(content_, LV_HOR_RES);
    lv_obj_set_flex_grow(content_, 1);

+    lv_obj_set_flex_flow(content_, LV_FLEX_FLOW_COLUMN); // 垂直布局（从上到下）
+    lv_obj_set_flex_align(content_, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_SPACE_EVENLY); // 子对象居中对齐，等距分布
+
    emotion_label_ = lv_label_create(content_);
    lv_obj_set_style_text_font(emotion_label_, &font_awesome_30_1, 0);
    lv_label_set_text(emotion_label_, FONT_AWESOME_AI_CHIP);
-    lv_obj_center(emotion_label_);
+    // lv_obj_center(emotion_label_);
+
+    chat_message_label_ = lv_label_create(content_);
+    lv_label_set_text(chat_message_label_, "");
+    lv_obj_set_width(chat_message_label_, LV_HOR_RES * 0.8); // 限制宽度为屏幕宽度的 80%
+    lv_label_set_long_mode(chat_message_label_, LV_LABEL_LONG_WRAP); // 设置为自动换行模式
+    lv_obj_set_style_text_align(chat_message_label_, LV_TEXT_ALIGN_CENTER, 0); // 设置文本居中对齐

    /* Status bar */
    lv_obj_set_flex_flow(status_bar_, LV_FLEX_FLOW_ROW);
@@ -315,6 +304,7 @@ void St7789Display::SetupUI() {

    status_label_ = lv_label_create(status_bar_);
    lv_obj_set_flex_grow(status_label_, 1);
+    lv_label_set_long_mode(status_label_, LV_LABEL_LONG_SCROLL_CIRCULAR);
    lv_label_set_text(status_label_, "正在初始化");
    lv_obj_set_style_text_align(status_label_, LV_TEXT_ALIGN_CENTER, 0);

@@ -326,3 +316,10 @@ void St7789Display::SetupUI() {
    lv_label_set_text(battery_label_, "");
    lv_obj_set_style_text_font(battery_label_, &font_awesome_14_1, 0);
 }
+
+void LcdDisplay::SetChatMessage(const std::string &role, const std::string &content) {
+    if (chat_message_label_ == nullptr) {
+        return;
+    }
+    lv_label_set_text(chat_message_label_, content.c_str());
+}
--- a/main/display/st7789_display.h
+++ b/main/display/st7789_display.h
@@ -1,5 +1,5 @@
-#ifndef ST7789_DISPLAY_H
-#define ST7789_DISPLAY_H
+#ifndef LCD_DISPLAY_H
+#define LCD_DISPLAY_H

 #include "display.h"

@@ -10,8 +10,8 @@
 #include <esp_lcd_panel_ops.h>
 #include <esp_timer.h>

-class St7789Display : public Display {
-private:
+class LcdDisplay : public Display {
+protected:
    esp_lcd_panel_io_handle_t panel_io_ = nullptr;
    esp_lcd_panel_handle_t panel_ = nullptr;
    gpio_num_t backlight_pin_ = GPIO_NUM_NC;
@@ -28,20 +28,23 @@ private:
    lv_obj_t* content_ = nullptr;
    lv_obj_t* container_ = nullptr;
    lv_obj_t* side_bar_ = nullptr;
+    lv_obj_t* chat_message_label_ = nullptr;

    void InitializeBacklight(gpio_num_t backlight_pin);
    void SetBacklight(uint8_t brightness);
-    void SetupUI();
    void LvglTask();

+    virtual void SetupUI();
    virtual bool Lock(int timeout_ms = 0) override;
    virtual void Unlock() override;

 public:
-    St7789Display(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
+    LcdDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
                  gpio_num_t backlight_pin, bool backlight_output_invert,
                  int width, int height,  int offset_x, int offset_y, bool mirror_x, bool mirror_y, bool swap_xy);
-    ~St7789Display();
+    ~LcdDisplay();
+
+    void SetChatMessage(const std::string &role, const std::string &content) override;
 };

-#endif // ST7789_DISPLAY_H
+#endif // LCD_DISPLAY_H
--- a/main/display/ssd1306_display.cc
+++ b/main/display/ssd1306_display.cc
@@ -35,7 +35,7 @@ Ssd1306Display::Ssd1306Display(void* i2c_master_handle, int width, int height, b
            .dc_low_on_data = 0,
            .disable_control_phase = 0,
        },
-        .scl_speed_hz = 400 * 1000,
+        .scl_speed_hz = 100 * 1000,
    };

    ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c_v2((i2c_master_bus_t*)i2c_master_handle, &io_config, &panel_io_));
--- a/main/idf_component.yml
+++ b/main/idf_component.yml
@@ -1,10 +1,12 @@
 ## IDF Component Manager Manifest File
 dependencies:
+  espressif/esp_lcd_ili9341: "==1.2.0"
+  78/esp_lcd_nv3023: "~1.0.0"
  78/esp-wifi-connect: "~1.4.1"
  78/esp-opus-encoder: "~2.0.0"
  78/esp-ml307: "~1.7.0"
  espressif/led_strip: "^2.4.1"
-  espressif/esp_codec_dev: "^1.3.1"
+  espressif/esp_codec_dev: "~1.3.2"
  espressif/esp-sr: "^1.9.0"
  espressif/button: "^3.3.1"
  lvgl/lvgl: "~8.4.0"
--- a/main/led/circular_strip.cc
+++ b/main/led/circular_strip.cc
@@ -0,0 +1,218 @@
+#include "circular_strip.h"
+#include "application.h"
+#include <esp_log.h>
+
+#define TAG "CircularStrip"
+
+#define DEFAULT_BRIGHTNESS 4
+#define HIGH_BRIGHTNESS 16
+#define LOW_BRIGHTNESS 1
+
+#define BLINK_INFINITE -1
+
+CircularStrip::CircularStrip(gpio_num_t gpio, uint8_t max_leds) : max_leds_(max_leds) {
+    // If the gpio is not connected, you should use NoLed class
+    assert(gpio != GPIO_NUM_NC);
+
+    colors_.resize(max_leds_);
+
+    led_strip_config_t strip_config = {};
+    strip_config.strip_gpio_num = gpio;
+    strip_config.max_leds = max_leds_;
+    strip_config.led_pixel_format = LED_PIXEL_FORMAT_GRB;
+    strip_config.led_model = LED_MODEL_WS2812;
+
+    led_strip_rmt_config_t rmt_config = {};
+    rmt_config.resolution_hz = 10 * 1000 * 1000; // 10MHz
+
+    ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &led_strip_));
+    led_strip_clear(led_strip_);
+
+    esp_timer_create_args_t strip_timer_args = {
+        .callback = [](void *arg) {
+            auto strip = static_cast<CircularStrip*>(arg);
+            std::lock_guard<std::mutex> lock(strip->mutex_);
+            if (strip->strip_callback_ != nullptr) {
+                strip->strip_callback_();
+            }
+        },
+        .arg = this,
+        .dispatch_method = ESP_TIMER_TASK,
+        .name = "Strip Timer",
+        .skip_unhandled_events = false,
+    };
+    ESP_ERROR_CHECK(esp_timer_create(&strip_timer_args, &strip_timer_));
+}
+
+CircularStrip::~CircularStrip() {
+    esp_timer_stop(strip_timer_);
+    if (led_strip_ != nullptr) {
+        led_strip_del(led_strip_);
+    }
+}
+
+
+void CircularStrip::StaticColor(StripColor color) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    esp_timer_stop(strip_timer_);
+    for (int i = 0; i < max_leds_; i++) {
+        colors_[i] = color;
+        led_strip_set_pixel(led_strip_, i, color.red, color.green, color.blue);
+    }
+    led_strip_refresh(led_strip_);
+}
+
+void CircularStrip::Blink(StripColor color, int interval_ms) {
+    for (int i = 0; i < max_leds_; i++) {
+        colors_[i] = color;
+    }
+    StartStripTask(interval_ms, [this]() {
+        static bool on = true;
+        if (on) {
+            for (int i = 0; i < max_leds_; i++) {
+                led_strip_set_pixel(led_strip_, i, colors_[i].red, colors_[i].green, colors_[i].blue);
+            }
+            led_strip_refresh(led_strip_);
+        } else {
+            led_strip_clear(led_strip_);
+        }
+        on = !on;
+    });
+}
+
+void CircularStrip::FadeOut(int interval_ms) {
+    StartStripTask(interval_ms, [this]() {
+        bool all_off = true;
+        for (int i = 0; i < max_leds_; i++) {
+            colors_[i].red /= 2;
+            colors_[i].green /= 2;
+            colors_[i].blue /= 2;
+            if (colors_[i].red != 0 || colors_[i].green != 0 || colors_[i].blue != 0) {
+                all_off = false;
+            }
+            led_strip_set_pixel(led_strip_, i, colors_[i].red, colors_[i].green, colors_[i].blue);
+        }
+        if (all_off) {
+            led_strip_clear(led_strip_);
+            esp_timer_stop(strip_timer_);
+        } else {
+            led_strip_refresh(led_strip_);
+        }
+    });
+}
+
+void CircularStrip::Breathe(StripColor low, StripColor high, int interval_ms) {
+    StartStripTask(interval_ms, [this, low, high]() {
+        static bool increase = true;
+        static StripColor color = low;
+        if (increase) {
+            if (color.red < high.red) {
+                color.red++;
+            }
+            if (color.green < high.green) {
+                color.green++;
+            }
+            if (color.blue < high.blue) {
+                color.blue++;
+            }
+            if (color.red == high.red && color.green == high.green && color.blue == high.blue) {
+                increase = false;
+            }
+        } else {
+            if (color.red > low.red) {
+                color.red--;
+            }
+            if (color.green > low.green) {
+                color.green--;
+            }
+            if (color.blue > low.blue) {
+                color.blue--;
+            }
+            if (color.red == low.red && color.green == low.green && color.blue == low.blue) {
+                increase = true;
+            }
+        }
+        for (int i = 0; i < max_leds_; i++) {
+            led_strip_set_pixel(led_strip_, i, color.red, color.green, color.blue);
+        }
+        led_strip_refresh(led_strip_);
+    });
+}
+
+void CircularStrip::Scroll(StripColor low, StripColor high, int length, int interval_ms) {
+    for (int i = 0; i < max_leds_; i++) {
+        colors_[i] = low;
+    }
+    StartStripTask(interval_ms, [this, low, high, length]() {
+        static int offset = 0;
+        for (int i = 0; i < max_leds_; i++) {
+            colors_[i] = low;
+        }
+        for (int j = 0; j < length; j++) {
+            int i = (offset + j) % max_leds_;
+            colors_[i] = high;
+        }
+        for (int i = 0; i < max_leds_; i++) {
+            led_strip_set_pixel(led_strip_, i, colors_[i].red, colors_[i].green, colors_[i].blue);
+        }
+        led_strip_refresh(led_strip_);
+        offset = (offset + 1) % max_leds_;
+    });
+}
+
+void CircularStrip::StartStripTask(int interval_ms, std::function<void()> cb) {
+    if (led_strip_ == nullptr) {
+        return;
+    }
+
+    std::lock_guard<std::mutex> lock(mutex_);
+    esp_timer_stop(strip_timer_);
+    
+    strip_callback_ = cb;
+    esp_timer_start_periodic(strip_timer_, interval_ms * 1000);
+}
+
+
+void CircularStrip::OnStateChanged() {
+    auto& app = Application::GetInstance();
+    auto device_state = app.GetDeviceState();
+    switch (device_state) {
+        case kDeviceStateStarting: {
+            StripColor low = { 0, 0, 0 };
+            StripColor high = { LOW_BRIGHTNESS, LOW_BRIGHTNESS, DEFAULT_BRIGHTNESS };
+            Scroll(low, high, 3, 100);
+            break;
+        }
+        case kDeviceStateWifiConfiguring: {
+            StripColor color = { LOW_BRIGHTNESS, LOW_BRIGHTNESS, DEFAULT_BRIGHTNESS };
+            Blink(color, 500);
+            break;
+        }
+        case kDeviceStateIdle:
+            FadeOut(50);
+            break;
+        case kDeviceStateConnecting: {
+            StripColor color = { LOW_BRIGHTNESS, LOW_BRIGHTNESS, DEFAULT_BRIGHTNESS };
+            StaticColor(color);
+            break;
+        }
+        case kDeviceStateListening: {
+            StripColor color = { DEFAULT_BRIGHTNESS, LOW_BRIGHTNESS, LOW_BRIGHTNESS };
+            StaticColor(color);
+            break;
+        }
+        case kDeviceStateSpeaking: {
+            StripColor color = { LOW_BRIGHTNESS, DEFAULT_BRIGHTNESS, LOW_BRIGHTNESS };
+            StaticColor(color);
+            break;
+        }
+        case kDeviceStateUpgrading: {
+            StripColor color = { LOW_BRIGHTNESS, DEFAULT_BRIGHTNESS, LOW_BRIGHTNESS };
+            Blink(color, 100);
+            break;
+        }
+        default:
+            ESP_LOGE(TAG, "Invalid led strip event: %d", device_state);
+            return;
+    }
+}
--- a/main/led/circular_strip.h
+++ b/main/led/circular_strip.h
@@ -0,0 +1,44 @@
+#ifndef _CIRCULAR_STRIP_H_
+#define _CIRCULAR_STRIP_H_
+
+#include "led.h"
+#include <driver/gpio.h>
+#include <led_strip.h>
+#include <esp_timer.h>
+#include <atomic>
+#include <mutex>
+#include <vector>
+
+struct StripColor {
+    uint8_t red = 0, green = 0, blue = 0;
+};
+
+class CircularStrip : public Led {
+public:
+    CircularStrip(gpio_num_t gpio, uint8_t max_leds);
+    virtual ~CircularStrip();
+
+    void OnStateChanged() override;
+
+private:
+    std::mutex mutex_;
+    TaskHandle_t blink_task_ = nullptr;
+    led_strip_handle_t led_strip_ = nullptr;
+    int max_leds_ = 0;
+    std::vector<StripColor> colors_;
+    int blink_counter_ = 0;
+    int blink_interval_ms_ = 0;
+    esp_timer_handle_t strip_timer_ = nullptr;
+    std::function<void()> strip_callback_ = nullptr;
+
+    void StartStripTask(int interval_ms, std::function<void()> cb);
+
+    void StaticColor(StripColor color);
+    void Blink(StripColor color, int interval_ms);
+    void Breathe(StripColor low, StripColor high, int interval_ms);
+    void Rainbow(StripColor low, StripColor high, int interval_ms);
+    void Scroll(StripColor low, StripColor high, int length, int interval_ms);
+    void FadeOut(int interval_ms);
+};
+
+#endif // _CIRCULAR_STRIP_H_
--- a/main/led/led.cc
+++ b/main/led/led.cc
@@ -0,0 +1,219 @@
+#include "led.h"
+#include "board.h"
+
+#include <cstring>
+#include <cmath>
+#include <esp_log.h>
+
+#define TAG "Led"
+
+Led::Led(gpio_num_t gpio, uint8_t max_leds) {
+    if (gpio == GPIO_NUM_NC) {
+        ESP_LOGI(TAG, "Builtin LED not connected");
+        return;
+    }
+
+    led_ = new Led(gpio, max_leds);
+
+    esp_timer_create_args_t led_strip_timer_args = {
+        .callback = [](void *arg) {
+            auto light = static_cast<LedStripWrapper*>(arg);
+            light->OnBlinkTimer();
+        },
+        .arg = this,
+        .dispatch_method = ESP_TIMER_TASK,
+        .name = "Led Strip Timer",
+        .skip_unhandled_events = false,
+    };
+    ESP_ERROR_CHECK(esp_timer_create(&led_strip_timer_args, &led_strip_timer_));
+}
+
+LedStripWrapper::~LedStripWrapper() {
+    if (led_strip_timer_ != nullptr) {
+        esp_timer_delete(led_strip_timer_);
+    }
+    if (led_ != nullptr) {
+        delete led_;
+    }
+}
+
+void LedStripWrapper::OnBlinkTimer() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    counter_--;
+    timer_callback_();
+}
+
+void LedStripWrapper::SetLedBasicColor(LedBasicColor color, uint8_t brightness) {
+    if (led_ == nullptr) {
+        ESP_LOGE(TAG, "Builtin LED not connected");
+        return;
+    }
+
+    switch (color) {
+        case kLedColorWhite:
+            led_->SetWhite(brightness);
+            break;
+        case kLedColorGrey:
+            led_->SetGrey(brightness);
+            break;
+        case kLedColorRed:
+            led_->SetRed(brightness);
+            break;
+        case kLedColorGreen:
+            led_->SetGreen(brightness);
+            break;
+        case kLedColorBlue:
+            led_->SetBlue(brightness);
+            break;
+    }
+}
+
+void LedStripWrapper::SetLedStripBasicColor(uint8_t index, LedBasicColor color, uint8_t brightness) {
+    if (led_ == nullptr) {
+        ESP_LOGE(TAG, "Builtin LED not connected");
+        return;
+    }
+
+    if (index >= led_->max_leds()) {
+        ESP_LOGE(TAG, "Invalid led index: %d", index);
+        return;
+    }
+
+    switch (color) {
+        case kLedColorWhite:
+            led_strip_set_pixel(led_->led_strip(), index, brightness, brightness, brightness);
+            break;
+        case kLedColorGrey:
+            led_strip_set_pixel(led_->led_strip(), index, brightness, brightness, brightness);
+            break;
+        case kLedColorRed:
+            led_strip_set_pixel(led_->led_strip(), index, brightness, 0, 0);
+            break;
+        case kLedColorGreen:
+            led_strip_set_pixel(led_->led_strip(), index, 0, brightness, 0);
+            break;
+        case kLedColorBlue:
+            led_strip_set_pixel(led_->led_strip(), index, 0, 0, brightness);
+            break;
+    }
+}
+
+void LedStripWrapper::StartBlinkTask(uint32_t times, uint32_t interval_ms) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (led_ == nullptr) {
+        ESP_LOGE(TAG, "Builtin LED not connected");
+        return;
+    }
+    
+    esp_timer_stop(led_strip_timer_);
+    counter_ = times * 2;
+    timer_callback_ = [this]() {
+        if (counter_ & 1) {
+            led_->TurnOn();
+        } else {
+            led_->TurnOff();
+            if (counter_ == 0) {
+                esp_timer_stop(led_strip_timer_);
+            }
+        }
+    };
+    esp_timer_start_periodic(led_strip_timer_, interval_ms * 1000);
+}
+
+void LedStripWrapper::BlinkOnce(LedBasicColor color, uint8_t brightness) {
+    Blink(color, brightness, 1, 100);
+}
+
+void LedStripWrapper::Blink(LedBasicColor color, uint32_t times, uint32_t interval_ms, uint8_t brightness) {
+    SetLedBasicColor(color, brightness);
+    StartBlinkTask(times, interval_ms);
+}
+
+void LedStripWrapper::ContinuousBlink(LedBasicColor color, uint32_t interval_ms, uint8_t brightness) {
+    SetLedBasicColor(color, brightness);
+    StartBlinkTask(COUNTER_INFINITE, interval_ms);
+}
+
+void LedStripWrapper::StaticLight(LedBasicColor color, uint8_t brightness) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    
+    if (led_ == nullptr) {
+        ESP_LOGE(TAG, "Builtin LED not connected");
+        return;
+    }
+
+    SetLedBasicColor(color, brightness);
+    esp_timer_stop(led_strip_timer_);
+    led_->TurnOn();
+}
+
+void LedStripWrapper::ChasingLight(LedBasicColor base_color, LedBasicColor color, uint32_t interval_ms, uint8_t brightness) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (led_ == nullptr) {
+        ESP_LOGE(TAG, "Builtin LED not connected");
+        return;
+    }
+
+    esp_timer_stop(led_strip_timer_);
+    counter_ = COUNTER_INFINITE;
+    timer_callback_ = [this, base_color, color, brightness]() {
+        auto index = counter_ % led_->max_leds();
+        for (uint8_t i = 0; i < led_->max_leds(); i++) {
+            if (i == index || i == (index + 1) % led_->max_leds()) {
+                SetLedStripBasicColor(i, color, brightness);
+            } else {
+                SetLedStripBasicColor(i, base_color, LOW_BRIGHTNESS);
+            }
+        }
+        led_strip_refresh(led_->led_strip());
+    };
+    esp_timer_start_periodic(led_strip_timer_, interval_ms * 1000);
+}
+
+void LedStripWrapper::BreathLight(LedBasicColor color, uint32_t interval_ms) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (led_ == nullptr) {
+        ESP_LOGE(TAG, "Builtin LED not connected");
+        return;
+    }
+
+    esp_timer_stop(led_strip_timer_);
+    counter_ = COUNTER_INFINITE;
+    timer_callback_ = [this, color]() {
+        static bool increase = true;
+        static uint32_t brightness = LOW_BRIGHTNESS;
+
+        for (uint8_t i = 0; i < led_->max_leds(); i++) {
+            SetLedStripBasicColor(i, color, brightness);
+        }
+        led_strip_refresh(led_->led_strip());
+        
+        if (brightness == HIGH_BRIGHTNESS) {
+            increase = false;
+        } else if (brightness == LOW_BRIGHTNESS) {
+            increase = true;
+        }
+
+        if (increase) {
+            brightness += 1;
+        } else {
+            brightness -= 1;
+        }
+    };
+    esp_timer_start_periodic(led_strip_timer_, interval_ms * 1000);
+}
+
+void LedStripWrapper::LightOff() {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (led_ == nullptr) {
+        ESP_LOGE(TAG, "Builtin LED not connected");
+        return;
+    }
+
+    esp_timer_stop(led_strip_timer_);
+    led_->TurnOff();
+}
--- a/main/led/led.h
+++ b/main/led/led.h
@@ -0,0 +1,17 @@
+#ifndef _LED_H_
+#define _LED_H_
+
+class Led {
+public:
+    virtual ~Led() = default;
+    // Set the led state based on the device state
+    virtual void OnStateChanged() = 0;
+};
+
+
+class NoLed : public Led {
+public:
+    virtual void OnStateChanged() override {}
+};
+
+#endif // _LED_H_
--- a/main/boards/common/led.cc
+++ b/main/boards/common/led.cc
@@ -1,17 +1,20 @@
-#include "led.h"
-#include "board.h"
+#include "single_led.h"
+#include "application.h"
+#include <esp_log.h> 

-#include <cstring>
-#include <esp_log.h>
+#define TAG "SingleLed"

-#define TAG "Led"
+#define DEFAULT_BRIGHTNESS 4
+#define HIGH_BRIGHTNESS 16
+#define LOW_BRIGHTNESS 2
+
+#define BLINK_INFINITE -1
+
+
+SingleLed::SingleLed(gpio_num_t gpio) {
+    // If the gpio is not connected, you should use NoLed class
+    assert(gpio != GPIO_NUM_NC);

-Led::Led(gpio_num_t gpio) {
-    if (gpio == GPIO_NUM_NC) {
-        ESP_LOGI(TAG, "Builtin LED not connected");
-        return;
-    }
-    
    led_strip_config_t strip_config = {};
    strip_config.strip_gpio_num = gpio;
    strip_config.max_leds = 1;
@@ -24,11 +27,9 @@ Led::Led(gpio_num_t gpio) {
    ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &led_strip_));
    led_strip_clear(led_strip_);

-    SetGrey();
-
    esp_timer_create_args_t blink_timer_args = {
        .callback = [](void *arg) {
-            auto led = static_cast<Led*>(arg);
+            auto led = static_cast<SingleLed*>(arg);
            led->OnBlinkTimer();
        },
        .arg = this,
@@ -39,20 +40,21 @@ Led::Led(gpio_num_t gpio) {
    ESP_ERROR_CHECK(esp_timer_create(&blink_timer_args, &blink_timer_));
 }

-Led::~Led() {
+SingleLed::~SingleLed() {
    esp_timer_stop(blink_timer_);
    if (led_strip_ != nullptr) {
        led_strip_del(led_strip_);
    }
 }

-void Led::SetColor(uint8_t r, uint8_t g, uint8_t b) {
+
+void SingleLed::SetColor(uint8_t r, uint8_t g, uint8_t b) {
    r_ = r;
    g_ = g;
    b_ = b;
 }

-void Led::TurnOn() {
+void SingleLed::TurnOn() {
    if (led_strip_ == nullptr) {
        return;
    }
@@ -63,7 +65,7 @@ void Led::TurnOn() {
    led_strip_refresh(led_strip_);
 }

-void Led::TurnOff() {
+void SingleLed::TurnOff() {
    if (led_strip_ == nullptr) {
        return;
    }
@@ -73,19 +75,19 @@ void Led::TurnOff() {
    led_strip_clear(led_strip_);
 }

-void Led::BlinkOnce() {
+void SingleLed::BlinkOnce() {
    Blink(1, 100);
 }

-void Led::Blink(int times, int interval_ms) {
+void SingleLed::Blink(int times, int interval_ms) {
    StartBlinkTask(times, interval_ms);
 }

-void Led::StartContinuousBlink(int interval_ms) {
+void SingleLed::StartContinuousBlink(int interval_ms) {
    StartBlinkTask(BLINK_INFINITE, interval_ms);
 }

-void Led::StartBlinkTask(int times, int interval_ms) {
+void SingleLed::StartBlinkTask(int times, int interval_ms) {
    if (led_strip_ == nullptr) {
        return;
    }
@@ -93,13 +95,12 @@ void Led::StartBlinkTask(int times, int interval_ms) {
    std::lock_guard<std::mutex> lock(mutex_);
    esp_timer_stop(blink_timer_);
    
-    led_strip_clear(led_strip_);
    blink_counter_ = times * 2;
    blink_interval_ms_ = interval_ms;
    esp_timer_start_periodic(blink_timer_, interval_ms * 1000);
 }

-void Led::OnBlinkTimer() {
+void SingleLed::OnBlinkTimer() {
    std::lock_guard<std::mutex> lock(mutex_);
    blink_counter_--;
    if (blink_counter_ & 1) {
@@ -113,3 +114,45 @@ void Led::OnBlinkTimer() {
        }
    }
 }
+
+
+void SingleLed::OnStateChanged() {
+    auto& app = Application::GetInstance();
+    auto device_state = app.GetDeviceState();
+    switch (device_state) {
+        case kDeviceStateStarting:
+            SetColor(0, 0, DEFAULT_BRIGHTNESS);
+            StartContinuousBlink(100);
+            break;
+        case kDeviceStateWifiConfiguring:
+            SetColor(0, 0, DEFAULT_BRIGHTNESS);
+            StartContinuousBlink(500);
+            break;
+        case kDeviceStateIdle:
+            TurnOff();
+            break;
+        case kDeviceStateConnecting:
+            SetColor(0, 0, DEFAULT_BRIGHTNESS);
+            TurnOn();
+            break;
+        case kDeviceStateListening:
+            if (app.IsVoiceDetected()) {
+                SetColor(HIGH_BRIGHTNESS, 0, 0);
+            } else {
+                SetColor(LOW_BRIGHTNESS, 0, 0);
+            }
+            TurnOn();
+            break;
+        case kDeviceStateSpeaking:
+            SetColor(0, DEFAULT_BRIGHTNESS, 0);
+            TurnOn();
+            break;
+        case kDeviceStateUpgrading:
+            SetColor(0, DEFAULT_BRIGHTNESS, 0);
+            StartContinuousBlink(100);
+            break;
+        default:
+            ESP_LOGE(TAG, "Invalid led strip event: %d", device_state);
+            return;
+    }
+}
--- a/main/led/single_led.h
+++ b/main/led/single_led.h
@@ -0,0 +1,38 @@
+#ifndef _SINGLE_LED_H_
+#define _SINGLE_LED_H_
+
+#include "led.h"
+#include <driver/gpio.h>
+#include <led_strip.h>
+#include <esp_timer.h>
+#include <atomic>
+#include <mutex>
+
+class SingleLed : public Led {
+public:
+    SingleLed(gpio_num_t gpio);
+    virtual ~SingleLed();
+
+    void OnStateChanged() override;
+
+private:
+    std::mutex mutex_;
+    TaskHandle_t blink_task_ = nullptr;
+    led_strip_handle_t led_strip_ = nullptr;
+    uint8_t r_ = 0, g_ = 0, b_ = 0;
+    int blink_counter_ = 0;
+    int blink_interval_ms_ = 0;
+    esp_timer_handle_t blink_timer_ = nullptr;
+
+    void StartBlinkTask(int times, int interval_ms);
+    void OnBlinkTimer();
+
+    void BlinkOnce();
+    void Blink(int times, int interval_ms);
+    void StartContinuousBlink(int interval_ms);
+    void TurnOn();
+    void TurnOff();
+    void SetColor(uint8_t r, uint8_t g, uint8_t b);
+};
+
+#endif // _SINGLE_LED_H_
--- a/sdkconfig.defaults
+++ b/sdkconfig.defaults
@@ -23,3 +23,5 @@ CONFIG_LV_MEM_CUSTOM=y
 CONFIG_MBEDTLS_DYNAMIC_BUFFER=y
 CONFIG_ESP_WIFI_IRAM_OPT=n
 CONFIG_ESP_WIFI_RX_IRAM_OPT=n
+
+CONFIG_CODEC_I2C_BACKWARD_COMPATIBLE=n
Author	SHA1	Message	Date
Xiaoxia	2f1c133d72	Update README.md resize images to 240	2025-01-06 04:29:59 +08:00
Xiaoxia	ece58cdf21	Update README.md resize images	2025-01-06 04:29:22 +08:00
Terrence	fd00ba9bc0	add opensource boards to README	2025-01-06 04:25:36 +08:00
Xiaoxia	0033349eba	Merge pull request #31 from 78/led_strip feat: add led strip class	2025-01-06 01:30:55 +08:00
Terrence	b3cef41d77	fix display for magicclick	2025-01-06 01:26:39 +08:00
Terrence	b94c8a6e8b	rename St7789 to LCD	2025-01-05 21:20:30 +08:00
Terrence	c7c5b74d37	reconstruct led control	2025-01-05 19:36:00 +08:00
Andy	495b949d77	fix boot button gpio	2025-01-05 19:35:38 +08:00
Andy	2e6a278b0d	feat: add led strip class	2025-01-05 19:35:38 +08:00
Terrence	1820a83256	use espressif component	2025-01-05 03:34:28 +08:00
Xiaoxia	7ed076ee83	Merge pull request #37 from MakerM0/main add 神奇按钮 MagiClick_2.4 board support	2025-01-05 01:41:37 +08:00
MakerM0	90069f0f72	add 神奇按钮Magiclick_2.4	2025-01-04 15:24:40 +08:00
MakerM0	22ad538eb7	Merge branch 'main' of https://github.com/MakerM0/xiaozhi-esp32	2025-01-03 17:03:41 +08:00
Xiaoxia	ad5f687734	Update README.md Add star history	2025-01-03 01:02:58 +08:00
Xiaoxia	7128182cf3	Merge pull request #35 from whble/main The repair screen displays ESP_BOX3	2025-01-03 00:51:22 +08:00
Xiaoxia	ded4f40e34	Update esp_box3_board.cc fix spacing	2025-01-03 00:50:58 +08:00
EMORobots	78a89be4e6	Merge pull request #1 from 78/main Update README.md	2025-01-02 19:37:41 +08:00
Xiaoxia	498fd08cc8	Update README.md 更新 QQ 群号码	2025-01-02 17:42:07 +08:00
whble	f98be27000	fix display for esp32 box3	2025-01-01 22:43:20 +08:00
whble	11a3bb3f35	The repair screen displays ESP_BOX3	2024-12-30 02:57:34 +08:00
Xiaoxia	5675d5eca9	Merge pull request #33 from m5stack/m5cores3 Add M5Stack CoreS3 board support	2024-12-28 21:55:35 +08:00
imliubo	76990c8c0e	cleanup code Signed-off-by: imliubo <imliubo@makingfun.xyz>	2024-12-26 13:38:01 +08:00
Xiaoxia	6654d6348e	Update README.md 更新群号	2024-12-26 13:28:32 +08:00
Forairaaaaa	9626b0b71b	add m5stack cores3 support	2024-12-26 12:24:53 +08:00
MakerM0	e4ebcb0b4a	add board magiclick v2.4	2024-12-21 11:13:32 +08:00
Xiaoxia	8ae4f03417	Merge pull request #28 from Kevincoooool/fix_c3_bug Add esp32c3 efuse setting & fix components version	2024-12-16 23:01:27 +08:00
Xiaoxia	9f0ee369ad	Update idf_component.yml do not use old version	2024-12-16 23:00:40 +08:00
Xiaoxia	548e1d9890	Update kevin_box_board.cc format code	2024-12-16 22:57:36 +08:00
Xiaoxia	e1e14e45c5	Update sdkconfig.defaults Fix i2c runtiime error	2024-12-16 22:54:42 +08:00
Kevincoooool	894e872cfd	Add esp32c3 efuse setting & fix components version	2024-12-13 09:35:40 +08:00