fixbug: internal memory not enough

add st7789
move all hardware init to boards
2024-11-06 22:48:21 +08:00 · 2024-11-06 10:06:05 +08:00 · 2024-11-06 06:18:56 +08:00 · 2024-11-06 03:40:49 +08:00 · 2024-11-05 21:17:56 +08:00 · 2024-11-05 20:15:00 +08:00
65 changed files with 2054 additions and 1253 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.6.2")
+set(PROJECT_VER "0.7.2")

 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(xiaozhi)
--- a/flash.sh
+++ b/flash.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+esptool.py -p /dev/ttyACM0 -b 2000000 write_flash 0 releases/v0.6.2_ML307/merged-binary.bin
--- a/main/Board.cc
+++ b/main/Board.cc
@@ -1,8 +0,0 @@
-#include "Board.h"
-#include <esp_log.h>
-
-// static const char *TAG = "Board";
-
-bool Board::GetBatteryVoltage(int &voltage, bool& charging) {
-    return false;
-}
--- a/main/BoxAudioDevice.h
+++ b/main/BoxAudioDevice.h
@@ -1,38 +0,0 @@
-#ifndef _BOX_AUDIO_DEVICE_H
-#define _BOX_AUDIO_DEVICE_H
-
-#include "AudioDevice.h"
-#include <driver/i2c_master.h>
-#include <driver/i2s_tdm.h>
-#include <esp_codec_dev.h>
-#include <esp_codec_dev_defaults.h>
-
-
-class BoxAudioDevice : public AudioDevice {
-public:
-    BoxAudioDevice();
-    virtual ~BoxAudioDevice();
-    virtual void Initialize() override;
-    virtual void SetOutputVolume(int volume) override;
-    virtual void EnableInput(bool enable) override;
-    virtual void EnableOutput(bool enable) override;
-
-private:
-    i2c_master_bus_handle_t i2c_master_handle_ = nullptr;
-
-    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() override;
-    int Read(int16_t* dest, int samples) override;
-    int Write(const int16_t* data, int samples) override;
-};
-
-#endif // _BOX_AUDIO_DEVICE_H
--- a/main/CMakeLists.txt
+++ b/main/CMakeLists.txt
@@ -1,61 +1,42 @@
-set(SOURCES "AudioDevice.cc"
-            "FirmwareUpgrade.cc"
-            "SystemInfo.cc"
-            "SystemReset.cc"
-            "Application.cc"
-            "Button.cc"
-            "BuiltinLed.cc"
-            "Display.cc"
-            "Board.cc"
+set(SOURCES "audio_codec.cc"
+            "audio_codecs/no_audio_codec.cc"
+            "audio_codecs/box_audio_codec.cc"
+            "display.cc"
+            "display/no_display.cc"
+            "display/st7789_display.cc"
+            "display/ssd1306_display.cc"
+            "board.cc"
+            "boards/wifi_board.cc"
+            "boards/ml307_board.cc"
+            "system_info.cc"
+            "system_reset.cc"
+            "application.cc"
+            "button.cc"
+            "led.cc"
+            "ota.cc"
            "main.cc"
            )
 set(INCLUDE_DIRS ".")

 # 根据 BOARD_TYPE 配置添加对应的板级文件
 if(CONFIG_BOARD_TYPE_BREAD_COMPACT_WIFI)
-    # add all files from boards/bread-compact-wifi
    set(BOARD_TYPE "bread-compact-wifi")
-    file(GLOB BOARD_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE}/*.cc)
-    list(APPEND SOURCES ${BOARD_SOURCES} "WifiBoard.cc")
-    list(APPEND INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE})
 elseif(CONFIG_BOARD_TYPE_BREAD_COMPACT_ML307)
-    # add all files from boards/bread-compact-ml307
    set(BOARD_TYPE "bread-compact-ml307")
-    file(GLOB BOARD_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE}/*.cc)
-    list(APPEND SOURCES ${BOARD_SOURCES} "Ml307Board.cc")
-    list(APPEND INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE})
 elseif(CONFIG_BOARD_TYPE_ESP_BOX_3)
-    # add all files from boards/esp-box-3
    set(BOARD_TYPE "esp-box-3")
-    file(GLOB BOARD_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE}/*.cc)
-    list(APPEND SOURCES ${BOARD_SOURCES} "WifiBoard.cc")
-    list(APPEND INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE})
-    list(APPEND SOURCES "BoxAudioDevice.cc")
 elseif(CONFIG_BOARD_TYPE_KEVIN_BOX_0)
-    # add all files from boards/kevin-box-0
    set(BOARD_TYPE "kevin-box-0")
-    file(GLOB BOARD_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE}/*.cc)
-    list(APPEND SOURCES ${BOARD_SOURCES} "Ml307Board.cc")
-    list(APPEND INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE})
-    list(APPEND SOURCES "BoxAudioDevice.cc")
 elseif(CONFIG_BOARD_TYPE_KEVIN_BOX_1)
-    # add all files from boards/kevin-box-1
    set(BOARD_TYPE "kevin-box-1")
-    file(GLOB BOARD_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE}/*.cc)
-    list(APPEND SOURCES ${BOARD_SOURCES} "Ml307Board.cc")
-    list(APPEND INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE})
-    list(APPEND SOURCES "BoxAudioDevice.cc")
 elseif(CONFIG_BOARD_TYPE_LICHUANG_DEV)
-    # add all files from boards/lichuang-dev
    set(BOARD_TYPE "lichuang-dev")
-    file(GLOB BOARD_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE}/*.cc)
-    list(APPEND SOURCES ${BOARD_SOURCES} "WifiBoard.cc")
-    list(APPEND INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE})
-    list(APPEND SOURCES "BoxAudioDevice.cc")
 endif()
+file(GLOB BOARD_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/boards/${BOARD_TYPE}/*.cc)
+list(APPEND SOURCES ${BOARD_SOURCES})

 if(CONFIG_USE_AFE_SR)
-    list(APPEND SOURCES "AudioProcessor.cc" "WakeWordDetect.cc")
+    list(APPEND SOURCES "audio_processor.cc" "wake_word_detect.cc")
 endif()

 idf_component_register(SRCS ${SOURCES}
@@ -64,4 +45,6 @@ idf_component_register(SRCS ${SOURCES}
                    )

 # 使用 target_compile_definitions 来定义 BOARD_TYPE
-target_compile_definitions(${COMPONENT_LIB} PRIVATE BOARD_TYPE=\"${BOARD_TYPE}\")
+target_compile_definitions(${COMPONENT_LIB}
+                    PRIVATE BOARD_TYPE=\"${BOARD_TYPE}\"
+                    )
--- a/main/Display.cc
+++ b/main/Display.cc
@@ -1,237 +0,0 @@
-#include <esp_log.h>
-#include <esp_err.h>
-#include <esp_lcd_panel_ops.h>
-#include <esp_lcd_panel_vendor.h>
-#include <esp_lvgl_port.h>
-#include <string>
-#include <cstdlib>
-
-#include "Display.h"
-#include "Board.h"
-#include "Application.h"
-
-#define TAG "Display"
-
-Display::Display(int sda_pin, int scl_pin) : sda_pin_(sda_pin), scl_pin_(scl_pin) {
-    if (sda_pin_ == GPIO_NUM_NC || scl_pin_ == GPIO_NUM_NC) {
-        ESP_LOGI(TAG, "Display not connected");
-        return;
-    }
-
-    i2c_master_bus_config_t bus_config = {
-        .i2c_port = I2C_NUM_0,
-        .sda_io_num = (gpio_num_t)sda_pin_,
-        .scl_io_num = (gpio_num_t)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(&bus_config, &i2c_bus_));
-
-    // SSD1306 config
-    esp_lcd_panel_io_i2c_config_t io_config = {
-        .dev_addr = 0x3C,
-        .on_color_trans_done = nullptr,
-        .user_ctx = nullptr,
-        .control_phase_bytes = 1,
-        .dc_bit_offset = 6,
-        .lcd_cmd_bits = 8,
-        .lcd_param_bits = 8,
-        .flags = {
-            .dc_low_on_data = 0,
-            .disable_control_phase = 0,
-        },
-        .scl_speed_hz = 100 * 1000,
-    };
-
-    ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c_v2(i2c_bus_, &io_config, &panel_io_));
-
-    ESP_LOGI(TAG, "Install SSD1306 driver");
-    esp_lcd_panel_dev_config_t panel_config = {};
-    panel_config.reset_gpio_num = -1;
-    panel_config.bits_per_pixel = 1;
-
-    esp_lcd_panel_ssd1306_config_t ssd1306_config = {
-        .height = DISPLAY_HEIGHT
-    };
-    panel_config.vendor_config = &ssd1306_config;
-
-    ESP_ERROR_CHECK(esp_lcd_new_panel_ssd1306(panel_io_, &panel_config, &panel_));
-    ESP_LOGI(TAG, "SSD1306 driver installed");
-
-    // Reset the display
-    ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_));
-    if (esp_lcd_panel_init(panel_) != ESP_OK) {
-        ESP_LOGE(TAG, "Failed to initialize display");
-        return;
-    }
-
-    ESP_LOGI(TAG, "Initialize LVGL");
-    lvgl_port_cfg_t port_cfg = ESP_LVGL_PORT_INIT_CONFIG();
-    lvgl_port_init(&port_cfg);
-
-    // Set the display to on
-    ESP_LOGI(TAG, "Turning display on");
-    ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_, true));
-
-    ESP_LOGI(TAG, "Adding LCD screen");
-    const lvgl_port_display_cfg_t display_cfg = {
-        .io_handle = panel_io_,
-        .panel_handle = panel_,
-        .control_handle = nullptr,
-        .buffer_size = DISPLAY_WIDTH * DISPLAY_HEIGHT,
-        .double_buffer = false,
-        .trans_size = 0,
-        .hres = DISPLAY_WIDTH,
-        .vres = DISPLAY_HEIGHT,
-        .monochrome = true,
-        .rotation = {
-            .swap_xy = false,
-            .mirror_x = DISPLAY_MIRROR_X,
-            .mirror_y = DISPLAY_MIRROR_Y,
-        },
-        .flags = {
-            .buff_dma = 1,
-            .buff_spiram = 0,
-            .sw_rotate = 0,
-            .full_refresh = 0,
-            .direct_mode = 0,
-        },
-    };
-    disp_ = lvgl_port_add_disp(&display_cfg);;
-    
-    ESP_LOGI(TAG, "Display Loading...");
-    if (lvgl_port_lock(0)) {
-        label_ = lv_label_create(lv_disp_get_scr_act(disp_));
-        // lv_obj_set_style_text_font(label_, font_, 0);
-        lv_label_set_text(label_, "Initializing...");
-        lv_obj_set_width(label_, disp_->driver->hor_res);
-        lv_obj_set_height(label_, disp_->driver->ver_res);
-
-        notification_ = lv_label_create(lv_disp_get_scr_act(disp_));
-        // lv_obj_set_style_text_font(notification_, font_, 0);
-        lv_label_set_text(notification_, "Notification\nTest");
-        lv_obj_set_width(notification_, disp_->driver->hor_res);
-        lv_obj_set_height(notification_, disp_->driver->ver_res);
-        lv_obj_set_style_opa(notification_, LV_OPA_MIN, 0);
-        lvgl_port_unlock();
-    }
-
-    // Create a timer to update the display every 10 seconds
-    esp_timer_create_args_t update_display_timer_args = {
-        .callback = [](void *arg) {
-            Display* display = static_cast<Display*>(arg);
-            display->UpdateDisplay();
-        },
-        .arg = this,
-        .dispatch_method = ESP_TIMER_TASK,
-        .name = "UpdateDisplay",
-        .skip_unhandled_events = false,
-    };
-    ESP_ERROR_CHECK(esp_timer_create(&update_display_timer_args, &update_display_timer_));
-    ESP_ERROR_CHECK(esp_timer_start_periodic(update_display_timer_, 10 * 1000000));
-}
-
-Display::~Display() {
-    if (notification_timer_ != nullptr) {
-        esp_timer_stop(notification_timer_);
-        esp_timer_delete(notification_timer_);
-    }
-    if (update_display_timer_ != nullptr) {
-        esp_timer_stop(update_display_timer_);
-        esp_timer_delete(update_display_timer_);
-    }
-
-    lvgl_port_lock(0);
-    if (label_ != nullptr) {
-        lv_obj_del(label_);
-        lv_obj_del(notification_);
-    }
-    lvgl_port_unlock();
-
-    if (font_ != nullptr) {
-        lv_font_free(font_);
-    }
-
-    if (disp_ != nullptr) {
-        lvgl_port_deinit();
-        esp_lcd_panel_del(panel_);
-        esp_lcd_panel_io_del(panel_io_);
-        i2c_master_bus_reset(i2c_bus_);
-    }
-}
-
-void Display::SetText(const std::string &text) {
-    if (label_ != nullptr) {
-        text_ = text;
-        lvgl_port_lock(0);
-        // Change the text of the label
-        lv_label_set_text(label_, text_.c_str());
-        lvgl_port_unlock();
-    }
-}
-
-void Display::ShowNotification(const std::string &text) {
-    if (notification_ != nullptr) {
-        lvgl_port_lock(0);
-        lv_label_set_text(notification_, text.c_str());
-        lv_obj_set_style_opa(notification_, LV_OPA_MAX, 0);
-        lv_obj_set_style_opa(label_, LV_OPA_MIN, 0);
-        lvgl_port_unlock();
-
-        if (notification_timer_ != nullptr) {
-            esp_timer_stop(notification_timer_);
-            esp_timer_delete(notification_timer_);
-        }
-
-        esp_timer_create_args_t timer_args = {
-            .callback = [](void *arg) {
-                Display *display = static_cast<Display*>(arg);
-                lvgl_port_lock(0);
-                lv_obj_set_style_opa(display->notification_, LV_OPA_MIN, 0);
-                lv_obj_set_style_opa(display->label_, LV_OPA_MAX, 0);
-                lvgl_port_unlock();
-            },
-            .arg = this,
-            .dispatch_method = ESP_TIMER_TASK,
-            .name = "Notification Timer",
-            .skip_unhandled_events = false,
-        };
-        ESP_ERROR_CHECK(esp_timer_create(&timer_args, &notification_timer_));
-        ESP_ERROR_CHECK(esp_timer_start_once(notification_timer_, 3000000));
-    }
-}
-
-void Display::UpdateDisplay() {
-    auto chat_state = Application::GetInstance().GetChatState();
-    if (chat_state == kChatStateIdle || chat_state == kChatStateConnecting || chat_state == kChatStateListening) {
-        std::string text;
-        auto& board = Board::GetInstance();
-        std::string network_name;
-        int signal_quality;
-        std::string signal_quality_text;
-        if (!board.GetNetworkState(network_name, signal_quality, signal_quality_text)) {
-            text = "No network";
-        } else {
-            text = network_name + "\n" + signal_quality_text;
-            if (std::abs(signal_quality) != 99) {
-                text += " (" + std::to_string(signal_quality) + ")";
-            }
-        }
-
-        int battery_voltage;
-        bool charging;
-        if (board.GetBatteryVoltage(battery_voltage, charging)) {
-            text += "\n" + std::to_string(battery_voltage) + "mV";
-            if (charging) {
-                text += " (Charging)";
-            }
-        }
-        SetText(text);
-    }
-}
--- a/main/application.cc
+++ b/main/application.cc
@@ -1,8 +1,7 @@
-#include <BuiltinLed.h>
-#include <Ml307SslTransport.h>
-#include <WifiConfigurationAp.h>
-#include <WifiStation.h>
-#include <SystemInfo.h>
+#include "application.h"
+#include "system_info.h"
+#include "ml307_ssl_transport.h"
+#include "audio_codec.h"

 #include <cstring>
 #include <esp_log.h>
@@ -10,8 +9,6 @@
 #include <driver/gpio.h>
 #include <arpa/inet.h>

-#include "Application.h"
-
 #define TAG "Application"

 extern const char p3_err_reg_start[] asm("_binary_err_reg_p3_start");
@@ -22,25 +19,11 @@ extern const char p3_err_wificonfig_start[] asm("_binary_err_wificonfig_p3_start
 extern const char p3_err_wificonfig_end[] asm("_binary_err_wificonfig_p3_end");


-Application::Application()
-    : boot_button_((gpio_num_t)BOOT_BUTTON_GPIO),
-      volume_up_button_((gpio_num_t)VOLUME_UP_BUTTON_GPIO),
-      volume_down_button_((gpio_num_t)VOLUME_DOWN_BUTTON_GPIO),
-      display_(DISPLAY_SDA_PIN, DISPLAY_SCL_PIN)
-{
+Application::Application() {
    event_group_ = xEventGroupCreate();

-    opus_encoder_.Configure(16000, 1);
-    opus_decoder_ = opus_decoder_create(opus_decode_sample_rate_, 1, NULL);
-    if (opus_decode_sample_rate_ != AUDIO_OUTPUT_SAMPLE_RATE) {
-        output_resampler_.Configure(AUDIO_OUTPUT_SAMPLE_RATE, opus_decode_sample_rate_);
-    }
-    if (16000 != AUDIO_INPUT_SAMPLE_RATE) {
-        input_resampler_.Configure(AUDIO_INPUT_SAMPLE_RATE, 16000);
-    }
-
-    firmware_upgrade_.SetCheckVersionUrl(CONFIG_OTA_VERSION_URL);
-    firmware_upgrade_.SetHeader("Device-Id", SystemInfo::GetMacAddress().c_str());
+    ota_.SetCheckVersionUrl(CONFIG_OTA_VERSION_URL);
+    ota_.SetHeader("Device-Id", SystemInfo::GetMacAddress().c_str());
 }

 Application::~Application() {
@@ -60,39 +43,38 @@ Application::~Application() {
    if (main_loop_task_stack_ != nullptr) {
        heap_caps_free(main_loop_task_stack_);
    }
-    if (audio_device_ != nullptr) {
-        delete audio_device_;
-    }

    vEventGroupDelete(event_group_);
 }

 void Application::CheckNewVersion() {
    // Check if there is a new firmware version available
-    firmware_upgrade_.SetBoardJson(Board::GetInstance().GetJson());
-    firmware_upgrade_.CheckVersion();
-    if (firmware_upgrade_.HasNewVersion()) {
+    ota_.SetPostData(Board::GetInstance().GetJson());
+    ota_.CheckVersion();
+    if (ota_.HasNewVersion()) {
        // Wait for the chat state to be idle
        while (chat_state_ != kChatStateIdle) {
            vTaskDelay(100);
        }
        SetChatState(kChatStateUpgrading);
-        firmware_upgrade_.StartUpgrade([this](int progress, size_t speed) {
+        ota_.StartUpgrade([](int progress, size_t speed) {
            char buffer[64];
            snprintf(buffer, sizeof(buffer), "Upgrading...\n %d%% %zuKB/s", progress, speed / 1024);
-            display_.SetText(buffer);
+            auto display = Board::GetInstance().GetDisplay();
+            display->SetText(buffer);
        });
        // If upgrade success, the device will reboot and never reach here
        ESP_LOGI(TAG, "Firmware upgrade failed...");
        SetChatState(kChatStateIdle);
    } else {
-        firmware_upgrade_.MarkCurrentVersionValid();
+        ota_.MarkCurrentVersionValid();
    }
 }

 void Application::Alert(const std::string&& title, const std::string&& message) {
    ESP_LOGE(TAG, "Alert: %s, %s", title.c_str(), message.c_str());
-    display_.ShowNotification(std::string(title + "\n" + message));
+    auto display = Board::GetInstance().GetDisplay();
+    display->ShowNotification(std::string(title + "\n" + message));

    if (message == "PIN is not ready") {
        PlayLocalFile(p3_err_pin_start, p3_err_pin_end - p3_err_pin_start);
@@ -106,6 +88,8 @@ void Application::Alert(const std::string&& title, const std::string&& message)
 void Application::PlayLocalFile(const char* data, size_t size) {
    ESP_LOGI(TAG, "PlayLocalFile: %zu bytes", size);
    SetDecodeSampleRate(16000);
+    auto codec = Board::GetInstance().GetAudioCodec();
+    codec->EnableOutput(true);

    {
        std::lock_guard<std::mutex> lock(mutex_);
@@ -125,35 +109,72 @@ void Application::PlayLocalFile(const char* data, size_t size) {
    }
 }

-void Application::Start() {
-    auto& builtin_led = BuiltinLed::GetInstance();
-    builtin_led.SetBlue();
-    builtin_led.StartContinuousBlink(100);
+void Application::ToggleChatState() {
+    Schedule([this]() {
+        if (chat_state_ == kChatStateIdle) {
+            SetChatState(kChatStateConnecting);
+            StartWebSocketClient();

+            if (ws_client_ && ws_client_->IsConnected()) {
+                opus_encoder_.ResetState();
+#ifdef CONFIG_USE_AFE_SR
+                audio_processor_.Start();
+#endif
+                SetChatState(kChatStateListening);
+                ESP_LOGI(TAG, "Communication started");
+            } else {
+                SetChatState(kChatStateIdle);
+            }
+        } else if (chat_state_ == kChatStateSpeaking) {
+            AbortSpeaking();
+        } else if (chat_state_ == kChatStateListening) {
+            if (ws_client_ && ws_client_->IsConnected()) {
+                ws_client_->Close();
+            }
+        }
+    });
+}
+
+void Application::Start() {
    auto& board = Board::GetInstance();
    board.Initialize();

-    audio_device_ = board.CreateAudioDevice();
-    audio_device_->Initialize();
-    audio_device_->EnableOutput(true);
-    audio_device_->EnableInput(true);
-    audio_device_->OnInputData([this](std::vector<int16_t>&& data) {
-        if (16000 != AUDIO_INPUT_SAMPLE_RATE) {
-            if (audio_device_->input_channels() == 2) {
-                auto left_channel = std::vector<int16_t>(data.size() / 2);
-                auto right_channel = std::vector<int16_t>(data.size() / 2);
-                for (size_t i = 0, j = 0; i < left_channel.size(); ++i, j += 2) {
-                    left_channel[i] = data[j];
-                    right_channel[i] = data[j + 1];
+    auto builtin_led = board.GetBuiltinLed();
+    builtin_led->SetBlue();
+    builtin_led->StartContinuousBlink(100);
+
+    auto display = board.GetDisplay();
+    display->SetupUI();
+
+    auto codec = board.GetAudioCodec();
+    opus_decode_sample_rate_ = codec->output_sample_rate();
+    opus_decoder_ = opus_decoder_create(opus_decode_sample_rate_, 1, NULL);
+    opus_encoder_.Configure(16000, 1);
+    if (codec->input_sample_rate() != 16000) {
+        input_resampler_.Configure(codec->input_sample_rate(), 16000);
+        reference_resampler_.Configure(codec->input_sample_rate(), 16000);
+    }
+
+    codec->EnableInput(true);
+    codec->EnableOutput(true);
+    codec->EnableOutput(false);
+    codec->OnInputData([this, codec](std::vector<int16_t>&& data) {
+        if (codec->input_sample_rate() != 16000) {
+            if (codec->input_channels() == 2) {
+                auto mic_channel = std::vector<int16_t>(data.size() / 2);
+                auto reference_channel = std::vector<int16_t>(data.size() / 2);
+                for (size_t i = 0, j = 0; i < mic_channel.size(); ++i, j += 2) {
+                    mic_channel[i] = data[j];
+                    reference_channel[i] = data[j + 1];
                }
-                auto resampled_left = std::vector<int16_t>(input_resampler_.GetOutputSamples(left_channel.size()));
-                auto resampled_right = std::vector<int16_t>(input_resampler_.GetOutputSamples(right_channel.size()));
-                input_resampler_.Process(left_channel.data(), left_channel.size(), resampled_left.data());
-                input_resampler_.Process(right_channel.data(), right_channel.size(), resampled_right.data());
-                data.resize(resampled_left.size() + resampled_right.size());
-                for (size_t i = 0, j = 0; i < resampled_left.size(); ++i, j += 2) {
-                    data[j] = resampled_left[i];
-                    data[j + 1] = resampled_right[i];
+                auto resampled_mic = std::vector<int16_t>(input_resampler_.GetOutputSamples(mic_channel.size()));
+                auto resampled_reference = std::vector<int16_t>(reference_resampler_.GetOutputSamples(reference_channel.size()));
+                input_resampler_.Process(mic_channel.data(), mic_channel.size(), resampled_mic.data());
+                reference_resampler_.Process(reference_channel.data(), reference_channel.size(), resampled_reference.data());
+                data.resize(resampled_mic.size() + resampled_reference.size());
+                for (size_t i = 0, j = 0; i < resampled_mic.size(); ++i, j += 2) {
+                    data[j] = resampled_mic[i];
+                    data[j + 1] = resampled_reference[i];
                }
            } else {
                auto resampled = std::vector<int16_t>(input_resampler_.GetOutputSamples(data.size()));
@@ -196,70 +217,8 @@ void Application::Start() {

    board.StartNetwork();
    // Blink the LED to indicate the device is running
-    builtin_led.SetGreen();
-    builtin_led.BlinkOnce();
-
-    boot_button_.OnClick([this]() {
-        Schedule([this]() {
-            if (chat_state_ == kChatStateIdle) {
-                SetChatState(kChatStateConnecting);
-                StartWebSocketClient();
-
-                if (ws_client_ && ws_client_->IsConnected()) {
-                    opus_encoder_.ResetState();
-#ifdef CONFIG_USE_AFE_SR
-                    audio_processor_.Start();
-#endif
-                    SetChatState(kChatStateListening);
-                    ESP_LOGI(TAG, "Communication started");
-                } else {
-                    SetChatState(kChatStateIdle);
-                }
-            } else if (chat_state_ == kChatStateSpeaking) {
-                AbortSpeaking();
-            } else if (chat_state_ == kChatStateListening) {
-                if (ws_client_ && ws_client_->IsConnected()) {
-                    ws_client_->Close();
-                }
-            }
-        });
-    });
-
-    volume_up_button_.OnClick([this]() {
-        Schedule([this]() {
-            auto volume = audio_device_->output_volume() + 10;
-            if (volume > 100) {
-                volume = 100;
-            }
-            audio_device_->SetOutputVolume(volume);
-            display_.ShowNotification("Volume\n" + std::to_string(volume));
-        });
-    });
-
-    volume_up_button_.OnLongPress([this]() {
-        Schedule([this]() {
-            audio_device_->SetOutputVolume(100);
-            display_.ShowNotification("Volume\n100");
-        });
-    });
-
-    volume_down_button_.OnClick([this]() {
-        Schedule([this]() {
-            auto volume = audio_device_->output_volume() - 10;
-            if (volume < 0) {
-                volume = 0;
-            }
-            audio_device_->SetOutputVolume(volume);
-            display_.ShowNotification("Volume\n" + std::to_string(volume));
-        });
-    });
-
-    volume_down_button_.OnLongPress([this]() {
-        Schedule([this]() {
-            audio_device_->SetOutputVolume(0);
-            display_.ShowNotification("Volume\n0");
-        });
-    });
+    builtin_led->SetGreen();
+    builtin_led->BlinkOnce();

    const size_t main_loop_stack_size = 4096 * 2;
    main_loop_task_stack_ = (StackType_t*)heap_caps_malloc(main_loop_stack_size, MALLOC_CAP_SPIRAM);
@@ -277,17 +236,28 @@ void Application::Start() {
    }, "check_new_version", 4096 * 2, this, 1, NULL);

 #ifdef CONFIG_USE_AFE_SR
-    wake_word_detect_.Initialize(audio_device_->input_channels(), audio_device_->input_reference());
+    audio_processor_.Initialize(codec->input_channels(), codec->input_reference());
+    audio_processor_.OnOutput([this](std::vector<int16_t>&& data) {
+        Schedule([this, data = std::move(data)]() {
+            if (chat_state_ == kChatStateListening) {
+                std::lock_guard<std::mutex> lock(mutex_);
+                audio_encode_queue_.emplace_back(std::move(data));
+                cv_.notify_all();
+            }
+        });
+    });
+
+    wake_word_detect_.Initialize(codec->input_channels(), codec->input_reference());
    wake_word_detect_.OnVadStateChange([this](bool speaking) {
        Schedule([this, speaking]() {
-            auto& builtin_led = BuiltinLed::GetInstance();
+            auto builtin_led = Board::GetInstance().GetBuiltinLed();
            if (chat_state_ == kChatStateListening) {
                if (speaking) {
-                    builtin_led.SetRed(32);
+                    builtin_led->SetRed(32);
                } else {
-                    builtin_led.SetRed(8);
+                    builtin_led->SetRed(8);
                }
-                builtin_led.TurnOn();
+                builtin_led->TurnOn();
            }
        });
    });
@@ -325,21 +295,10 @@ void Application::Start() {
        });
    });
    wake_word_detect_.StartDetection();
-
-    audio_processor_.Initialize(audio_device_->input_channels(), audio_device_->input_reference());
-    audio_processor_.OnOutput([this](std::vector<int16_t>&& data) {
-        Schedule([this, data = std::move(data)]() {
-            if (chat_state_ == kChatStateListening) {
-                std::lock_guard<std::mutex> lock(mutex_);
-                audio_encode_queue_.emplace_back(std::move(data));
-                cv_.notify_all();
-            }
-        });
-    });
 #endif

-    SetChatState(kChatStateIdle);
-    display_.UpdateDisplay();
+    chat_state_ = kChatStateIdle;
+    display->UpdateDisplay();
 }

 void Application::Schedule(std::function<void()> callback) {
@@ -372,8 +331,6 @@ void Application::AbortSpeaking() {
        cJSON* root = cJSON_CreateObject();
        cJSON_AddStringToObject(root, "type", "abort");
        char* json = cJSON_PrintUnformatted(root);
-
-        std::lock_guard<std::mutex> lock(mutex_);
        ws_client_->Send(json);
        cJSON_Delete(root);
        free(json);
@@ -399,33 +356,36 @@ void Application::SetChatState(ChatState state) {
    chat_state_ = state;
    ESP_LOGI(TAG, "STATE: %s", state_str[chat_state_]);

-    auto& builtin_led = BuiltinLed::GetInstance();
+    auto display = Board::GetInstance().GetDisplay();
+    auto builtin_led = Board::GetInstance().GetBuiltinLed();
    switch (chat_state_) {
        case kChatStateUnknown:
        case kChatStateIdle:
-            builtin_led.TurnOff();
-            audio_device_->EnableOutput(false);
+            builtin_led->TurnOff();
+            display->SetText("I'm\nIdle.");
            break;
        case kChatStateConnecting:
-            builtin_led.SetBlue();
-            builtin_led.TurnOn();
+            builtin_led->SetBlue();
+            builtin_led->TurnOn();
+            display->SetText("I'm\nConnecting...");
            break;
        case kChatStateListening:
-            builtin_led.SetRed();
-            builtin_led.TurnOn();
+            builtin_led->SetRed();
+            builtin_led->TurnOn();
+            display->SetText("I'm\nListening...");
            break;
        case kChatStateSpeaking:
-            builtin_led.SetGreen();
-            builtin_led.TurnOn();
-            audio_device_->EnableOutput(true);
+            builtin_led->SetGreen();
+            builtin_led->TurnOn();
+            display->SetText("I'm\nSpeaking...");
            break;
        case kChatStateWakeWordDetected:
-            builtin_led.SetBlue();
-            builtin_led.TurnOn();
+            builtin_led->SetBlue();
+            builtin_led->TurnOn();
            break;
        case kChatStateUpgrading:
-            builtin_led.SetGreen();
-            builtin_led.StartContinuousBlink(100);
+            builtin_led->SetGreen();
+            builtin_led->StartContinuousBlink(100);
            break;
    }

@@ -434,8 +394,6 @@ void Application::SetChatState(ChatState state) {
        cJSON_AddStringToObject(root, "type", "state");
        cJSON_AddStringToObject(root, "state", state_str[chat_state_]);
        char* json = cJSON_PrintUnformatted(root);
-
-        std::lock_guard<std::mutex> lock(mutex_);
        ws_client_->Send(json);
        cJSON_Delete(root);
        free(json);
@@ -444,6 +402,7 @@ void Application::SetChatState(ChatState state) {

 BinaryProtocol3* Application::AllocateBinaryProtocol3(const uint8_t* payload, size_t payload_size) {
    auto protocol = (BinaryProtocol3*)heap_caps_malloc(sizeof(BinaryProtocol3) + payload_size, MALLOC_CAP_SPIRAM);
+    assert(protocol != nullptr);
    protocol->type = 0;
    protocol->reserved = 0;
    protocol->payload_size = htons(payload_size);
@@ -454,7 +413,8 @@ BinaryProtocol3* Application::AllocateBinaryProtocol3(const uint8_t* payload, si

 void Application::AudioEncodeTask() {
    ESP_LOGI(TAG, "Audio encode task started");
-    const int max_audio_play_queue_size_ = 2;
+    const int max_audio_play_queue_size_ = 2; // avoid decoding too fast
+    auto codec = Board::GetInstance().GetAudioCodec();

    while (true) {
        std::unique_lock<std::mutex> lock(mutex_);
@@ -495,7 +455,7 @@ void Application::AudioEncodeTask() {
                    continue;
                }

-                if (opus_decode_sample_rate_ != AUDIO_OUTPUT_SAMPLE_RATE) {
+                if (opus_decode_sample_rate_ != codec->output_sample_rate()) {
                    int target_size = output_resampler_.GetOutputSamples(frame_size);
                    std::vector<int16_t> resampled(target_size);
                    output_resampler_.Process(packet->pcm.data(), frame_size, resampled.data());
@@ -519,7 +479,8 @@ void Application::HandleAudioPacket(AudioPacket* packet) {
        }

        // This will block until the audio device has finished playing the audio
-        audio_device_->OutputData(packet->pcm);
+        auto codec = Board::GetInstance().GetAudioCodec();
+        codec->OutputData(packet->pcm);
        break;
    }
    case kAudioPacketTypeStart:
@@ -579,9 +540,11 @@ void Application::SetDecodeSampleRate(int sample_rate) {
    opus_decoder_destroy(opus_decoder_);
    opus_decode_sample_rate_ = sample_rate;
    opus_decoder_ = opus_decoder_create(opus_decode_sample_rate_, 1, NULL);
-    if (opus_decode_sample_rate_ != AUDIO_OUTPUT_SAMPLE_RATE) {
-        ESP_LOGI(TAG, "Resampling audio from %d to %d", opus_decode_sample_rate_, AUDIO_OUTPUT_SAMPLE_RATE);
-        output_resampler_.Configure(opus_decode_sample_rate_, AUDIO_OUTPUT_SAMPLE_RATE);
+
+    auto codec = Board::GetInstance().GetAudioCodec();
+    if (opus_decode_sample_rate_ != codec->output_sample_rate()) {
+        ESP_LOGI(TAG, "Resampling audio from %d to %d", opus_decode_sample_rate_, codec->output_sample_rate());
+        output_resampler_.Configure(opus_decode_sample_rate_, codec->output_sample_rate());
    }
 }

@@ -688,6 +651,8 @@ void Application::StartWebSocketClient() {
    ws_client_->OnDisconnected([this]() {
        ESP_LOGI(TAG, "Websocket disconnected");
        Schedule([this]() {
+            auto codec = Board::GetInstance().GetAudioCodec();
+            codec->EnableOutput(false);
 #ifdef CONFIG_USE_AFE_SR
            audio_processor_.Stop();
 #endif
@@ -701,4 +666,8 @@ void Application::StartWebSocketClient() {
        ESP_LOGE(TAG, "Failed to connect to websocket server");
        return;
    }
-}
+
+    // 建立语音通道后打开音频输出，避免待机时喇叭底噪
+    auto codec = Board::GetInstance().GetAudioCodec();
+    codec->EnableOutput(true);
+}
--- a/main/application.h
+++ b/main/application.h
@@ -1,30 +1,27 @@
 #ifndef _APPLICATION_H_
 #define _APPLICATION_H_

-#include <OpusEncoder.h>
-#include <OpusResampler.h>
-#include <WebSocket.h>
-
-#include <opus.h>
-#include <resampler_structs.h>
+#include <freertos/FreeRTOS.h>
 #include <freertos/event_groups.h>
 #include <freertos/task.h>
+#include <opus.h>
 #include <mutex>
 #include <list>
 #include <condition_variable>

-#include "AudioDevice.h"
-#include "Display.h"
-#include "Board.h"
-#include "FirmwareUpgrade.h"
+#include "opus_encoder.h"
+#include "opus_resampler.h"
+#include <web_socket.h>
+
+#include "display.h"
+#include "board.h"
+#include "ota.h"

 #ifdef CONFIG_USE_AFE_SR
-#include "WakeWordDetect.h"
-#include "AudioProcessor.h"
+#include "wake_word_detect.h"
+#include "audio_processor.h"
 #endif

-#include "Button.h"
-
 #define DETECTION_RUNNING 1
 #define COMMUNICATION_RUNNING 2

@@ -73,11 +70,11 @@ public:

    void Start();
    ChatState GetChatState() const { return chat_state_; }
-    Display& GetDisplay() { return display_; }
    void Schedule(std::function<void()> callback);
    void SetChatState(ChatState state);
    void Alert(const std::string&& title, const std::string&& message);
    void AbortSpeaking();
+    void ToggleChatState();
    // 删除拷贝构造函数和赋值运算符
    Application(const Application&) = delete;
    Application& operator=(const Application&) = delete;
@@ -86,16 +83,11 @@ private:
    Application();
    ~Application();

-    Button boot_button_;
-    Button volume_up_button_;
-    Button volume_down_button_;
-    AudioDevice* audio_device_ = nullptr;
-    Display display_;
 #ifdef CONFIG_USE_AFE_SR
    WakeWordDetect wake_word_detect_;
    AudioProcessor audio_processor_;
 #endif
-    FirmwareUpgrade firmware_upgrade_;
+    Ota ota_;
    std::mutex mutex_;
    std::condition_variable_any cv_;
    std::list<std::function<void()>> main_tasks_;
@@ -118,8 +110,9 @@ private:
    OpusDecoder* opus_decoder_ = nullptr;

    int opus_duration_ms_ = 60;
-    int opus_decode_sample_rate_ = AUDIO_OUTPUT_SAMPLE_RATE;
+    int opus_decode_sample_rate_ = -1;
    OpusResampler input_resampler_;
+    OpusResampler reference_resampler_;
    OpusResampler output_resampler_;

    TaskHandle_t main_loop_task_ = nullptr;
--- a/main/audio_codec.cc
+++ b/main/audio_codec.cc
@@ -0,0 +1,67 @@
+#include "audio_codec.h"
+#include "board.h"
+
+#include <esp_log.h>
+#include <cstring>
+
+#define TAG "AudioCodec"
+
+AudioCodec::AudioCodec() {
+}
+
+AudioCodec::~AudioCodec() {
+    if (audio_input_task_ != nullptr) {
+        vTaskDelete(audio_input_task_);
+    }
+}
+
+void AudioCodec::OnInputData(std::function<void(std::vector<int16_t>&& data)> callback) {
+    on_input_data_ = callback;
+
+    // 创建音频输入任务
+    if (audio_input_task_ == nullptr) {
+        xTaskCreate([](void* arg) {
+            auto audio_device = (AudioCodec*)arg;
+            audio_device->InputTask();
+        }, "audio_input", 4096 * 2, this, 3, &audio_input_task_);
+    }
+}
+
+void AudioCodec::OutputData(std::vector<int16_t>& data) {
+    Write(data.data(), data.size());
+}
+
+void AudioCodec::InputTask() {
+    int duration = 30;
+    int input_frame_size = input_sample_rate_ / 1000 * duration * input_channels_;
+    while (true) {
+        std::vector<int16_t> input_data(input_frame_size);
+        int samples = Read(input_data.data(), input_data.size());
+        if (samples > 0) {
+            if (on_input_data_) {
+                on_input_data_(std::move(input_data));
+            }
+        }
+    }
+}
+
+void AudioCodec::SetOutputVolume(int volume) {
+    output_volume_ = volume;
+    ESP_LOGI(TAG, "Set output volume to %d", output_volume_);
+}
+
+void AudioCodec::EnableInput(bool enable) {
+    if (enable == input_enabled_) {
+        return;
+    }
+    input_enabled_ = enable;
+    ESP_LOGI(TAG, "Set input enable to %s", enable ? "true" : "false");
+}
+
+void AudioCodec::EnableOutput(bool enable) {
+    if (enable == output_enabled_) {
+        return;
+    }
+    output_enabled_ = enable;
+    ESP_LOGI(TAG, "Set output enable to %s", enable ? "true" : "false");
+}
--- a/main/audio_codec.h
+++ b/main/audio_codec.h
@@ -1,25 +1,27 @@
-#ifndef _AUDIO_DEVICE_H
-#define _AUDIO_DEVICE_H
+#ifndef _AUDIO_CODEC_H
+#define _AUDIO_CODEC_H

 #include <freertos/FreeRTOS.h>
-#include <driver/i2s_std.h>
+#include <freertos/task.h>

 #include <vector>
 #include <string>
 #include <functional>

-class AudioDevice {
-public:
-    AudioDevice();
-    virtual ~AudioDevice();
-    virtual void Initialize();
+#include "board.h"

-    void OnInputData(std::function<void(std::vector<int16_t>&& data)> callback);
-    void OutputData(std::vector<int16_t>& data);
+class AudioCodec {
+public:
+    AudioCodec();
+    virtual ~AudioCodec();
+    
    virtual void SetOutputVolume(int volume);
    virtual void EnableInput(bool enable);
    virtual void EnableOutput(bool enable);

+    void OnInputData(std::function<void(std::vector<int16_t>&& data)> callback);
+    void OutputData(std::vector<int16_t>& data);
+
    inline bool duplex() const { return duplex_; }
    inline bool input_reference() const { return input_reference_; }
    inline int input_sample_rate() const { return input_sample_rate_; }
@@ -33,7 +35,6 @@ private:
    std::function<void(std::vector<int16_t>&& data)> on_input_data_; 

    void InputTask();
-    void CreateSimplexChannels();

 protected:
    bool duplex_ = false;
@@ -45,12 +46,9 @@ protected:
    int input_channels_ = 1;
    int output_channels_ = 1;
    int output_volume_ = 70;
-    i2s_chan_handle_t tx_handle_ = nullptr;
-    i2s_chan_handle_t rx_handle_ = nullptr;

-    virtual void CreateDuplexChannels();
-    virtual int Read(int16_t* dest, int samples);
-    virtual int Write(const int16_t* data, int samples);
+    virtual int Read(int16_t* dest, int samples) = 0;
+    virtual int Write(const int16_t* data, int samples) = 0;
 };

-#endif // _AUDIO_DEVICE_H
+#endif // _AUDIO_CODEC_H
--- a/main/audio_codecs/box_audio_codec.cc
+++ b/main/audio_codecs/box_audio_codec.cc
@@ -1,73 +1,20 @@
-#include "BoxAudioDevice.h"
-#include "Board.h"
+#include "box_audio_codec.h"

 #include <esp_log.h>
-#include <cassert>
+#include <driver/i2c.h>

-static const char* TAG = "BoxAudioDevice";
+static const char TAG[] = "BoxAudioCodec";

-BoxAudioDevice::BoxAudioDevice() {
-}
-
-BoxAudioDevice::~BoxAudioDevice() {
-    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_);
-
-    ESP_ERROR_CHECK(i2c_del_master_bus(i2c_master_handle_));
-}
-
-void BoxAudioDevice::Initialize() {
+BoxAudioCodec::BoxAudioCodec(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,
+    gpio_num_t pa_pin, uint8_t es8311_addr, uint8_t es7210_addr, bool input_reference) {
    duplex_ = true; // 是否双工
-    input_reference_ = AUDIO_INPUT_REFERENCE; // 是否使用参考输入，实现回声消除
+    input_reference_ = input_reference; // 是否使用参考输入，实现回声消除
    input_channels_ = input_reference_ ? 2 : 1; // 输入通道数
+    input_sample_rate_ = input_sample_rate;
+    output_sample_rate_ = output_sample_rate;

-    // Initialize I2C peripheral
-    i2c_master_bus_config_t i2c_bus_cfg = {
-        .i2c_port = I2C_NUM_1,
-        .sda_io_num = (gpio_num_t)AUDIO_CODEC_I2C_SDA_PIN,
-        .scl_io_num = (gpio_num_t)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_master_handle_));
-
-    CreateDuplexChannels();
-
-#ifdef AUDIO_CODEC_USE_PCA9557
-    // Initialize PCA9557
-    i2c_device_config_t pca9557_cfg = {
-        .dev_addr_length = I2C_ADDR_BIT_LEN_7,
-        .device_address = 0x19,
-        .scl_speed_hz = 400000,
-        .scl_wait_us = 0,
-        .flags = {
-            .disable_ack_check = 0,
-        },
-    };
-    i2c_master_dev_handle_t pca9557_handle;
-    ESP_ERROR_CHECK(i2c_master_bus_add_device(i2c_master_handle_, &pca9557_cfg, &pca9557_handle));
-    assert(pca9557_handle != NULL);
-    auto pca9557_set_register = [](i2c_master_dev_handle_t pca9557_handle, uint8_t data_addr, uint8_t data) {
-        uint8_t data_[2] = {data_addr, data};
-        ESP_ERROR_CHECK(i2c_master_transmit(pca9557_handle, data_, 2, 50));
-    };
-    pca9557_set_register(pca9557_handle, 0x03, 0xfd);
-    pca9557_set_register(pca9557_handle, 0x01, 0x02);
-#endif
+    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 = {
@@ -81,8 +28,8 @@ void BoxAudioDevice::Initialize() {
    // Output
    audio_codec_i2c_cfg_t i2c_cfg = {
        .port = I2C_NUM_1,
-        .addr = AUDIO_CODEC_ES8311_ADDR,
-        .bus_handle = i2c_master_handle_,
+        .addr = es8311_addr,
+        .bus_handle = i2c_master_handle,
    };
    out_ctrl_if_ = audio_codec_new_i2c_ctrl(&i2c_cfg);
    assert(out_ctrl_if_ != NULL);
@@ -94,7 +41,7 @@ void BoxAudioDevice::Initialize() {
    es8311_cfg.ctrl_if = out_ctrl_if_;
    es8311_cfg.gpio_if = gpio_if_;
    es8311_cfg.codec_mode = ESP_CODEC_DEV_WORK_MODE_DAC;
-    es8311_cfg.pa_pin = AUDIO_CODEC_PA_PIN;
+    es8311_cfg.pa_pin = pa_pin;
    es8311_cfg.use_mclk = true;
    es8311_cfg.hw_gain.pa_voltage = 5.0;
    es8311_cfg.hw_gain.codec_dac_voltage = 3.3;
@@ -110,7 +57,7 @@ void BoxAudioDevice::Initialize() {
    assert(output_dev_ != NULL);

    // Input
-    i2c_cfg.addr = AUDIO_CODEC_ES7210_ADDR;
+    i2c_cfg.addr = es7210_addr;
    in_ctrl_if_ = audio_codec_new_i2c_ctrl(&i2c_cfg);
    assert(in_ctrl_if_ != NULL);

@@ -128,7 +75,21 @@ void BoxAudioDevice::Initialize() {
    ESP_LOGI(TAG, "BoxAudioDevice initialized");
 }

-void BoxAudioDevice::CreateDuplexChannels() {
+BoxAudioCodec::~BoxAudioCodec() {
+    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 BoxAudioCodec::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_);

    i2s_chan_config_t chan_cfg = {
@@ -162,10 +123,10 @@ void BoxAudioDevice::CreateDuplexChannels() {
            .bit_order_lsb = false
        },
        .gpio_cfg = {
-            .mclk = (gpio_num_t)AUDIO_I2S_GPIO_MCLK,
-            .bclk = (gpio_num_t)AUDIO_I2S_GPIO_BCLK,
-            .ws = (gpio_num_t)AUDIO_I2S_GPIO_LRCK,
-            .dout = (gpio_num_t)AUDIO_I2S_GPIO_DOUT,
+            .mclk = mclk,
+            .bclk = bclk,
+            .ws = ws,
+            .dout = dout,
            .din = I2S_GPIO_UNUSED,
            .invert_flags = {
                .mclk_inv = false,
@@ -198,11 +159,11 @@ void BoxAudioDevice::CreateDuplexChannels() {
            .total_slot = I2S_TDM_AUTO_SLOT_NUM
        },
        .gpio_cfg = {
-            .mclk = (gpio_num_t)AUDIO_I2S_GPIO_MCLK,
-            .bclk = (gpio_num_t)AUDIO_I2S_GPIO_BCLK,
-            .ws = (gpio_num_t)AUDIO_I2S_GPIO_LRCK,
+            .mclk = mclk,
+            .bclk = bclk,
+            .ws = ws,
            .dout = I2S_GPIO_UNUSED,
-            .din = (gpio_num_t)AUDIO_I2S_GPIO_DIN,
+            .din = din,
            .invert_flags = {
                .mclk_inv = false,
                .bclk_inv = false,
@@ -218,26 +179,12 @@ void BoxAudioDevice::CreateDuplexChannels() {
    ESP_LOGI(TAG, "Duplex channels created");
 }

-int BoxAudioDevice::Read(int16_t *buffer, int samples) {
-    if (input_enabled_) {
-        ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void*)buffer, samples * sizeof(int16_t)));
-    }
-    return samples;
-}
-
-int BoxAudioDevice::Write(const int16_t *buffer, int samples) {
-    if (output_enabled_) {
-        ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void*)buffer, samples * sizeof(int16_t)));
-    }
-    return samples;
-}
-
-void BoxAudioDevice::SetOutputVolume(int volume) {
+void BoxAudioCodec::SetOutputVolume(int volume) {
    ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, volume));
-    AudioDevice::SetOutputVolume(volume);
+    AudioCodec::SetOutputVolume(volume);
 }

-void BoxAudioDevice::EnableInput(bool enable) {
+void BoxAudioCodec::EnableInput(bool enable) {
    if (enable == input_enabled_) {
        return;
    }
@@ -257,10 +204,10 @@ void BoxAudioDevice::EnableInput(bool enable) {
    } else {
        ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
    }
-    AudioDevice::EnableInput(enable);
+    AudioCodec::EnableInput(enable);
 }

-void BoxAudioDevice::EnableOutput(bool enable) {
+void BoxAudioCodec::EnableOutput(bool enable) {
    if (enable == output_enabled_) {
        return;
    }
@@ -278,5 +225,19 @@ void BoxAudioDevice::EnableOutput(bool enable) {
    } else {
        ESP_ERROR_CHECK(esp_codec_dev_close(output_dev_));
    }
-    AudioDevice::EnableOutput(enable);
+    AudioCodec::EnableOutput(enable);
 }
+
+int BoxAudioCodec::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 BoxAudioCodec::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/box_audio_codec.h
+++ b/main/audio_codecs/box_audio_codec.h
@@ -0,0 +1,42 @@
+#ifndef _BOX_AUDIO_CODEC_H
+#define _BOX_AUDIO_CODEC_H
+
+#include "audio_codec.h"
+
+#include <driver/i2s_std.h>
+#include <driver/i2s_tdm.h>
+#include <esp_codec_dev.h>
+#include <esp_codec_dev_defaults.h>
+
+class BoxAudioCodec : public AudioCodec {
+private:
+    i2s_chan_handle_t tx_handle_ = nullptr;
+    i2s_chan_handle_t rx_handle_ = nullptr;
+
+    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:
+    BoxAudioCodec(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,
+        gpio_num_t pa_pin, uint8_t es8311_addr, uint8_t es7210_addr, bool input_reference);
+    virtual ~BoxAudioCodec();
+
+    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
@@ -1,21 +1,11 @@
-#include "AudioDevice.h"
-#include "Board.h"
+#include "no_audio_codec.h"

 #include <esp_log.h>
-#include <cstring>
 #include <cmath>

-#define TAG "AudioDevice"
+#define TAG "NoAudioCodec"

-AudioDevice::AudioDevice()
-    : input_sample_rate_(AUDIO_INPUT_SAMPLE_RATE),
-      output_sample_rate_(AUDIO_OUTPUT_SAMPLE_RATE) {
-}
-
-AudioDevice::~AudioDevice() {
-    if (audio_input_task_ != nullptr) {
-        vTaskDelete(audio_input_task_);
-    }
+NoAudioCodec::~NoAudioCodec() {
    if (rx_handle_ != nullptr) {
        ESP_ERROR_CHECK(i2s_channel_disable(rx_handle_));
    }
@@ -24,17 +14,11 @@ AudioDevice::~AudioDevice() {
    }
 }

-void AudioDevice::Initialize() {
-#ifdef AUDIO_I2S_METHOD_SIMPLEX
-    CreateSimplexChannels();
-#else
-    CreateDuplexChannels();
-#endif
-}

-void AudioDevice::CreateDuplexChannels() {
-#ifndef AUDIO_I2S_METHOD_SIMPLEX
+NoAudioCodec::NoAudioCodec(int input_sample_rate, int output_sample_rate, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din) {
    duplex_ = true;
+    input_sample_rate_ = input_sample_rate;
+    output_sample_rate_ = output_sample_rate;

    i2s_chan_config_t chan_cfg = {
        .id = I2S_NUM_0,
@@ -68,10 +52,10 @@ void AudioDevice::CreateDuplexChannels() {
        },
        .gpio_cfg = {
            .mclk = I2S_GPIO_UNUSED,
-            .bclk = (gpio_num_t)AUDIO_I2S_GPIO_BCLK,
-            .ws = (gpio_num_t)AUDIO_I2S_GPIO_LRCK,
-            .dout = (gpio_num_t)AUDIO_I2S_GPIO_DOUT,
-            .din = (gpio_num_t)AUDIO_I2S_GPIO_DIN,
+            .bclk = bclk,
+            .ws = ws,
+            .dout = dout,
+            .din = din,
            .invert_flags = {
                .mclk_inv = false,
                .bclk_inv = false,
@@ -84,11 +68,13 @@ void AudioDevice::CreateDuplexChannels() {
    ESP_ERROR_CHECK(i2s_channel_enable(tx_handle_));
    ESP_ERROR_CHECK(i2s_channel_enable(rx_handle_));
    ESP_LOGI(TAG, "Duplex channels created");
-#endif
 }

-void AudioDevice::CreateSimplexChannels() {
-#ifdef AUDIO_I2S_METHOD_SIMPLEX
+NoAudioCodec::NoAudioCodec(int input_sample_rate, int output_sample_rate, gpio_num_t spk_bclk, gpio_num_t spk_ws, gpio_num_t spk_dout, gpio_num_t mic_sck, gpio_num_t mic_ws, gpio_num_t mic_din) {
+    duplex_ = false;
+    input_sample_rate_ = input_sample_rate;
+    output_sample_rate_ = output_sample_rate;
+
    // Create a new channel for speaker
    i2s_chan_config_t chan_cfg = {
        .id = I2S_NUM_0,
@@ -122,9 +108,9 @@ void AudioDevice::CreateSimplexChannels() {
        },
        .gpio_cfg = {
            .mclk = I2S_GPIO_UNUSED,
-            .bclk = (gpio_num_t)AUDIO_I2S_SPK_GPIO_BCLK,
-            .ws = (gpio_num_t)AUDIO_I2S_SPK_GPIO_LRCK,
-            .dout = (gpio_num_t)AUDIO_I2S_SPK_GPIO_DOUT,
+            .bclk = spk_bclk,
+            .ws = spk_ws,
+            .dout = spk_dout,
            .din = I2S_GPIO_UNUSED,
            .invert_flags = {
                .mclk_inv = false,
@@ -139,19 +125,18 @@ void AudioDevice::CreateSimplexChannels() {
    chan_cfg.id = I2S_NUM_1;
    ESP_ERROR_CHECK(i2s_new_channel(&chan_cfg, nullptr, &rx_handle_));
    std_cfg.clk_cfg.sample_rate_hz = (uint32_t)input_sample_rate_;
-    std_cfg.gpio_cfg.bclk = (gpio_num_t)AUDIO_I2S_MIC_GPIO_SCK;
-    std_cfg.gpio_cfg.ws = (gpio_num_t)AUDIO_I2S_MIC_GPIO_WS;
+    std_cfg.gpio_cfg.bclk = mic_sck;
+    std_cfg.gpio_cfg.ws = mic_ws;
    std_cfg.gpio_cfg.dout = I2S_GPIO_UNUSED;
-    std_cfg.gpio_cfg.din = (gpio_num_t)AUDIO_I2S_MIC_GPIO_DIN;
+    std_cfg.gpio_cfg.din = mic_din;
    ESP_ERROR_CHECK(i2s_channel_init_std_mode(rx_handle_, &std_cfg));

    ESP_ERROR_CHECK(i2s_channel_enable(tx_handle_));
    ESP_ERROR_CHECK(i2s_channel_enable(rx_handle_));
    ESP_LOGI(TAG, "Simplex channels created");
-#endif
 }

-int AudioDevice::Write(const int16_t* data, int samples) {
+int NoAudioCodec::Write(const int16_t* data, int samples) {
    int32_t buffer[samples];

    // output_volume_: 0-100
@@ -173,7 +158,7 @@ int AudioDevice::Write(const int16_t* data, int samples) {
    return bytes_written / sizeof(int32_t);
 }

-int AudioDevice::Read(int16_t* dest, int samples) {
+int NoAudioCodec::Read(int16_t* dest, int samples) {
    size_t bytes_read;

    int32_t bit32_buffer[samples];
@@ -189,54 +174,3 @@ int AudioDevice::Read(int16_t* dest, int samples) {
    }
    return samples;
 }
-
-void AudioDevice::OnInputData(std::function<void(std::vector<int16_t>&& data)> callback) {
-    on_input_data_ = callback;
-
-    // 创建音频输入任务
-    if (audio_input_task_ == nullptr) {
-        xTaskCreate([](void* arg) {
-            auto audio_device = (AudioDevice*)arg;
-            audio_device->InputTask();
-        }, "audio_input", 4096 * 2, this, 3, &audio_input_task_);
-    }
-}
-
-void AudioDevice::OutputData(std::vector<int16_t>& data) {
-    Write(data.data(), data.size());
-}
-
-void AudioDevice::InputTask() {
-    int duration = 30;
-    int input_frame_size = input_sample_rate_ / 1000 * duration * input_channels_;
-    while (true) {
-        std::vector<int16_t> input_data(input_frame_size);
-        int samples = Read(input_data.data(), input_data.size());
-        if (samples > 0) {
-            if (on_input_data_) {
-                on_input_data_(std::move(input_data));
-            }
-        }
-    }
-}
-
-void AudioDevice::SetOutputVolume(int volume) {
-    output_volume_ = volume;
-    ESP_LOGI(TAG, "Set output volume to %d", output_volume_);
-}
-
-void AudioDevice::EnableInput(bool enable) {
-    if (enable == input_enabled_) {
-        return;
-    }
-    input_enabled_ = enable;
-    ESP_LOGI(TAG, "Set input enable to %s", enable ? "true" : "false");
-}
-
-void AudioDevice::EnableOutput(bool enable) {
-    if (enable == output_enabled_) {
-        return;
-    }
-    output_enabled_ = enable;
-    ESP_LOGI(TAG, "Set output enable to %s", enable ? "true" : "false");
-}
--- a/main/audio_codecs/no_audio_codec.h
+++ b/main/audio_codecs/no_audio_codec.h
@@ -0,0 +1,25 @@
+#ifndef _NO_AUDIO_CODEC_H
+#define _NO_AUDIO_CODEC_H
+
+#include "audio_codec.h"
+
+#include <driver/i2s_std.h>
+#include <driver/gpio.h>
+
+class NoAudioCodec : public AudioCodec {
+private:
+    i2s_chan_handle_t tx_handle_ = nullptr;
+    i2s_chan_handle_t rx_handle_ = nullptr;
+
+    virtual int Write(const int16_t* data, int samples) override;
+    virtual int Read(int16_t* dest, int samples) override;
+
+public:
+    // Duplex
+    NoAudioCodec(int input_sample_rate, int output_sample_rate, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din);
+    // Simplex
+    NoAudioCodec(int input_sample_rate, int output_sample_rate, gpio_num_t spk_bclk, gpio_num_t spk_ws, gpio_num_t spk_dout, gpio_num_t mic_sck, gpio_num_t mic_ws, gpio_num_t mic_din);
+    virtual ~NoAudioCodec();
+};
+
+#endif // _NO_AUDIO_CODEC_H
--- a/main/audio_processor.cc
+++ b/main/audio_processor.cc
@@ -1,4 +1,4 @@
-#include "AudioProcessor.h"
+#include "audio_processor.h"
 #include <esp_log.h>

 #define PROCESSOR_RUNNING 0x01
--- a/main/audio_processor.h
+++ b/main/audio_processor.h
--- a/main/board.cc
+++ b/main/board.cc
@@ -0,0 +1,104 @@
+#include "board.h"
+#include "system_info.h"
+
+#include <esp_log.h>
+#include <esp_ota_ops.h>
+#include <esp_chip_info.h>
+
+// static const char *TAG = "Board";
+
+bool Board::GetBatteryVoltage(int &voltage, bool& charging) {
+    return false;
+}
+
+std::string Board::GetJson() {
+    /* 
+        {
+            "flash_size": 4194304,
+            "psram_size": 0,
+            "minimum_free_heap_size": 123456,
+            "mac_address": "00:00:00:00:00:00",
+            "chip_model_name": "esp32s3",
+            "chip_info": {
+                "model": 1,
+                "cores": 2,
+                "revision": 0,
+                "features": 0
+            },
+            "application": {
+                "name": "my-app",
+                "version": "1.0.0",
+                "compile_time": "2021-01-01T00:00:00Z"
+                "idf_version": "4.2-dev"
+                "elf_sha256": ""
+            },
+            "partition_table": [
+                "app": {
+                    "label": "app",
+                    "type": 1,
+                    "subtype": 2,
+                    "address": 0x10000,
+                    "size": 0x100000
+                }
+            ],
+            "ota": {
+                "label": "ota_0"
+            }
+        }
+    */
+    std::string json = "{";
+    json += "\"flash_size\":" + std::to_string(SystemInfo::GetFlashSize()) + ",";
+    json += "\"minimum_free_heap_size\":" + std::to_string(SystemInfo::GetMinimumFreeHeapSize()) + ",";
+    json += "\"mac_address\":\"" + SystemInfo::GetMacAddress() + "\",";
+    json += "\"chip_model_name\":\"" + SystemInfo::GetChipModelName() + "\",";
+    json += "\"chip_info\":{";
+
+    esp_chip_info_t chip_info;
+    esp_chip_info(&chip_info);
+    json += "\"model\":" + std::to_string(chip_info.model) + ",";
+    json += "\"cores\":" + std::to_string(chip_info.cores) + ",";
+    json += "\"revision\":" + std::to_string(chip_info.revision) + ",";
+    json += "\"features\":" + std::to_string(chip_info.features);
+    json += "},";
+
+    json += "\"application\":{";
+    auto app_desc = esp_app_get_description();
+    json += "\"name\":\"" + std::string(app_desc->project_name) + "\",";
+    json += "\"version\":\"" + std::string(app_desc->version) + "\",";
+    json += "\"compile_time\":\"" + std::string(app_desc->date) + "T" + std::string(app_desc->time) + "Z\",";
+    json += "\"idf_version\":\"" + std::string(app_desc->idf_ver) + "\",";
+
+    char sha256_str[65];
+    for (int i = 0; i < 32; i++) {
+        snprintf(sha256_str + i * 2, sizeof(sha256_str) - i * 2, "%02x", app_desc->app_elf_sha256[i]);
+    }
+    json += "\"elf_sha256\":\"" + std::string(sha256_str) + "\"";
+    json += "},";
+
+    json += "\"partition_table\": [";
+    esp_partition_iterator_t it = esp_partition_find(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, NULL);
+    while (it) {
+        const esp_partition_t *partition = esp_partition_get(it);
+        json += "{";
+        json += "\"label\":\"" + std::string(partition->label) + "\",";
+        json += "\"type\":" + std::to_string(partition->type) + ",";
+        json += "\"subtype\":" + std::to_string(partition->subtype) + ",";
+        json += "\"address\":" + std::to_string(partition->address) + ",";
+        json += "\"size\":" + std::to_string(partition->size);
+        json += "},";
+        it = esp_partition_next(it);
+    }
+    json.pop_back(); // Remove the last comma
+    json += "],";
+
+    json += "\"ota\":{";
+    auto ota_partition = esp_ota_get_running_partition();
+    json += "\"label\":\"" + std::string(ota_partition->label) + "\"";
+    json += "},";
+
+    json += "\"board\":" + GetBoardJson();
+
+    // Close the JSON object
+    json += "}";
+    return json;
+}
--- a/main/board.h
+++ b/main/board.h
@@ -1,15 +1,24 @@
 #ifndef BOARD_H
 #define BOARD_H

-#include "config.h"
-#include <Http.h>
-#include <WebSocket.h>
-#include <AudioDevice.h>
+#include <http.h>
+#include <web_socket.h>
 #include <string>

-void* create_board();
+#include "led.h"

+void* create_board();
+class AudioCodec;
+class Display;
 class Board {
+private:
+    Board(const Board&) = delete; // 禁用拷贝构造函数
+    Board& operator=(const Board&) = delete; // 禁用赋值操作
+    virtual std::string GetBoardJson() = 0;
+
+protected:
+    Board() = default;
+
 public:
    static Board& GetInstance() {
        static Board* instance = nullptr;
@@ -22,19 +31,14 @@ public:
    virtual void Initialize() = 0;
    virtual void StartNetwork() = 0;
    virtual ~Board() = default;
-    virtual AudioDevice* CreateAudioDevice() = 0;
+    virtual Led* GetBuiltinLed() = 0;
+    virtual AudioCodec* GetAudioCodec() = 0;
+    virtual Display* GetDisplay() = 0;
    virtual Http* CreateHttp() = 0;
    virtual WebSocket* CreateWebSocket() = 0;
    virtual bool GetNetworkState(std::string& network_name, int& signal_quality, std::string& signal_quality_text) = 0;
    virtual bool GetBatteryVoltage(int &voltage, bool& charging);
-    virtual std::string GetJson() = 0;
-
-protected:
-    Board() = default;
-
-private:
-    Board(const Board&) = delete; // 禁用拷贝构造函数
-    Board& operator=(const Board&) = delete; // 禁用赋值操作
+    virtual std::string GetJson();
 };

 #define DECLARE_BOARD(BOARD_CLASS_NAME) \
--- a/main/boards/bread-compact-ml307/CompactMl307Board.cc
+++ b/main/boards/bread-compact-ml307/CompactMl307Board.cc
@@ -1,22 +0,0 @@
-#include "Ml307Board.h"
-#include "SystemReset.h"
-#include <esp_log.h>
-
-#define TAG "CompactMl307Board"
-
-class CompactMl307Board : public Ml307Board {
-public:
-    virtual void Initialize() override {
-        ESP_LOGI(TAG, "Initializing CompactMl307Board");
-        // Check if the reset button is pressed
-        SystemReset::GetInstance().CheckButtons();
-
-        Ml307Board::Initialize();
-    }
-
-    virtual AudioDevice* CreateAudioDevice() override {
-        return new AudioDevice();
-    }
-};
-
-DECLARE_BOARD(CompactMl307Board);
--- a/main/boards/bread-compact-ml307/compact_ml307_board.cc
+++ b/main/boards/bread-compact-ml307/compact_ml307_board.cc
@@ -0,0 +1,116 @@
+#include "boards/ml307_board.h"
+#include "audio_codecs/no_audio_codec.h"
+#include "display/ssd1306_display.h"
+#include "system_reset.h"
+#include "application.h"
+#include "button.h"
+#include "led.h"
+#include "config.h"
+
+#include <esp_log.h>
+#include <driver/i2c_master.h>
+
+#define TAG "CompactMl307Board"
+
+class CompactMl307Board : public Ml307Board {
+private:
+    i2c_master_bus_handle_t display_i2c_bus_;
+    Button boot_button_;
+    Button volume_up_button_;
+    Button volume_down_button_;
+
+    void InitializeDisplayI2c() {
+        i2c_master_bus_config_t bus_config = {
+            .i2c_port = I2C_NUM_0,
+            .sda_io_num = DISPLAY_SDA_PIN,
+            .scl_io_num = DISPLAY_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(&bus_config, &display_i2c_bus_));
+    }
+
+    void InitializeButtons() {
+        boot_button_.OnClick([this]() {
+            Application::GetInstance().ToggleChatState();
+        });
+
+        volume_up_button_.OnClick([this]() {
+            auto codec = GetAudioCodec();
+            auto volume = codec->output_volume() + 10;
+            if (volume > 100) {
+                volume = 100;
+            }
+            codec->SetOutputVolume(volume);
+            GetDisplay()->ShowNotification("Volume\n" + std::to_string(volume));
+        });
+
+        volume_up_button_.OnLongPress([this]() {
+            auto codec = GetAudioCodec();
+            codec->SetOutputVolume(100);
+            GetDisplay()->ShowNotification("Volume\n100");
+        });
+
+        volume_down_button_.OnClick([this]() {
+            auto codec = GetAudioCodec();
+            auto volume = codec->output_volume() - 10;
+            if (volume < 0) {
+                volume = 0;
+            }
+            codec->SetOutputVolume(volume);
+            GetDisplay()->ShowNotification("Volume\n" + std::to_string(volume));
+        });
+
+        volume_down_button_.OnLongPress([this]() {
+            auto codec = GetAudioCodec();
+            codec->SetOutputVolume(0);
+            GetDisplay()->ShowNotification("Volume\n0");
+        });
+    }
+
+public:
+    CompactMl307Board() : Ml307Board(ML307_TX_PIN, ML307_RX_PIN, 4096),
+        boot_button_(BOOT_BUTTON_GPIO),
+        volume_up_button_(VOLUME_UP_BUTTON_GPIO),
+        volume_down_button_(VOLUME_DOWN_BUTTON_GPIO) {
+    }
+
+    virtual void Initialize() override {
+        ESP_LOGI(TAG, "Initializing CompactMl307Board");
+        // Check if the reset button is pressed
+        SystemReset::GetInstance().CheckButtons();
+
+        InitializeDisplayI2c();
+        InitializeButtons();
+
+        Ml307Board::Initialize();
+    }
+
+    virtual Led* GetBuiltinLed() override {
+        static Led led(BUILTIN_LED_GPIO);
+        return &led;
+    }
+
+    virtual AudioCodec* GetAudioCodec() override {
+#ifdef AUDIO_I2S_METHOD_SIMPLEX
+        static NoAudioCodec audio_codec(AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
+            AUDIO_I2S_SPK_GPIO_BCLK, AUDIO_I2S_SPK_GPIO_LRCK, AUDIO_I2S_SPK_GPIO_DOUT, AUDIO_I2S_MIC_GPIO_SCK, AUDIO_I2S_MIC_GPIO_WS, AUDIO_I2S_MIC_GPIO_DIN);
+#else
+        static NoAudioCodec audio_codec(AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
+            AUDIO_I2S_GPIO_BCLK, AUDIO_I2S_GPIO_WS, AUDIO_I2S_GPIO_DOUT, AUDIO_I2S_GPIO_DIN);
+#endif
+        return &audio_codec;
+    }
+
+    virtual Display* GetDisplay() override {
+        static Ssd1306Display display(display_i2c_bus_, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+        return &display;
+    }
+};
+
+DECLARE_BOARD(CompactMl307Board);
--- a/main/boards/bread-compact-ml307/config.h
+++ b/main/boards/bread-compact-ml307/config.h
@@ -6,6 +6,7 @@
 #define AUDIO_INPUT_SAMPLE_RATE  16000
 #define AUDIO_OUTPUT_SAMPLE_RATE 24000

+// 如果使用 Duplex I2S 模式，请注释下面一行
 #define AUDIO_I2S_METHOD_SIMPLEX

 #ifdef AUDIO_I2S_METHOD_SIMPLEX
@@ -19,7 +20,7 @@

 #else

-#define AUDIO_I2S_GPIO_LRCK GPIO_NUM_4
+#define AUDIO_I2S_GPIO_WS GPIO_NUM_4
 #define AUDIO_I2S_GPIO_BCLK GPIO_NUM_5
 #define AUDIO_I2S_GPIO_DIN  GPIO_NUM_6
 #define AUDIO_I2S_GPIO_DOUT GPIO_NUM_7
--- a/main/boards/bread-compact-wifi/CompactWifiBoard.cc
+++ b/main/boards/bread-compact-wifi/CompactWifiBoard.cc
@@ -1,22 +0,0 @@
-#include "WifiBoard.h"
-#include "SystemReset.h"
-#include <esp_log.h>
-
-#define TAG "CompactWifiBoard"
-
-class CompactWifiBoard : public WifiBoard {
-public:
-    virtual void Initialize() override {
-        ESP_LOGI(TAG, "Initializing CompactWifiBoard");
-        // Check if the reset button is pressed
-        SystemReset::GetInstance().CheckButtons();
-
-        WifiBoard::Initialize();
-    }
-
-    virtual AudioDevice* CreateAudioDevice() override {
-        return new AudioDevice();
-    }
-};
-
-DECLARE_BOARD(CompactWifiBoard);
--- a/main/boards/bread-compact-wifi/compact_wifi_board.cc
+++ b/main/boards/bread-compact-wifi/compact_wifi_board.cc
@@ -0,0 +1,116 @@
+#include "boards/wifi_board.h"
+#include "audio_codecs/no_audio_codec.h"
+#include "display/ssd1306_display.h"
+#include "system_reset.h"
+#include "application.h"
+#include "button.h"
+#include "led.h"
+#include "config.h"
+
+#include <esp_log.h>
+#include <driver/i2c_master.h>
+
+#define TAG "CompactWifiBoard"
+
+class CompactWifiBoard : public WifiBoard {
+private:
+    i2c_master_bus_handle_t display_i2c_bus_;
+    Button boot_button_;
+    Button volume_up_button_;
+    Button volume_down_button_;
+
+    void InitializeDisplayI2c() {
+        i2c_master_bus_config_t bus_config = {
+            .i2c_port = I2C_NUM_0,
+            .sda_io_num = DISPLAY_SDA_PIN,
+            .scl_io_num = DISPLAY_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(&bus_config, &display_i2c_bus_));
+    }
+
+    void InitializeButtons() {
+        boot_button_.OnClick([this]() {
+            Application::GetInstance().ToggleChatState();
+        });
+
+        volume_up_button_.OnClick([this]() {
+            auto codec = GetAudioCodec();
+            auto volume = codec->output_volume() + 10;
+            if (volume > 100) {
+                volume = 100;
+            }
+            codec->SetOutputVolume(volume);
+            GetDisplay()->ShowNotification("Volume\n" + std::to_string(volume));
+        });
+
+        volume_up_button_.OnLongPress([this]() {
+            auto codec = GetAudioCodec();
+            codec->SetOutputVolume(100);
+            GetDisplay()->ShowNotification("Volume\n100");
+        });
+
+        volume_down_button_.OnClick([this]() {
+            auto codec = GetAudioCodec();
+            auto volume = codec->output_volume() - 10;
+            if (volume < 0) {
+                volume = 0;
+            }
+            codec->SetOutputVolume(volume);
+            GetDisplay()->ShowNotification("Volume\n" + std::to_string(volume));
+        });
+
+        volume_down_button_.OnLongPress([this]() {
+            auto codec = GetAudioCodec();
+            codec->SetOutputVolume(0);
+            GetDisplay()->ShowNotification("Volume\n0");
+        });
+    }
+
+public:
+    CompactWifiBoard() :
+        boot_button_(BOOT_BUTTON_GPIO),
+        volume_up_button_(VOLUME_UP_BUTTON_GPIO),
+        volume_down_button_(VOLUME_DOWN_BUTTON_GPIO) {
+    }
+
+    virtual void Initialize() override {
+        ESP_LOGI(TAG, "Initializing CompactWifiBoard");
+        // Check if the reset button is pressed
+        SystemReset::GetInstance().CheckButtons();
+
+        InitializeDisplayI2c();
+        InitializeButtons();
+
+        WifiBoard::Initialize();
+    }
+
+    virtual Led* GetBuiltinLed() override {
+        static Led led(BUILTIN_LED_GPIO);
+        return &led;
+    }
+
+    virtual AudioCodec* GetAudioCodec() override {
+#ifdef AUDIO_I2S_METHOD_SIMPLEX
+        static NoAudioCodec audio_codec(AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
+            AUDIO_I2S_SPK_GPIO_BCLK, AUDIO_I2S_SPK_GPIO_LRCK, AUDIO_I2S_SPK_GPIO_DOUT, AUDIO_I2S_MIC_GPIO_SCK, AUDIO_I2S_MIC_GPIO_WS, AUDIO_I2S_MIC_GPIO_DIN);
+#else
+        static NoAudioCodec audio_codec(AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
+            AUDIO_I2S_GPIO_BCLK, AUDIO_I2S_GPIO_WS, AUDIO_I2S_GPIO_DOUT, AUDIO_I2S_GPIO_DIN);
+#endif
+        return &audio_codec;
+    }
+
+    virtual Display* GetDisplay() override {
+        static Ssd1306Display display(display_i2c_bus_, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+        return &display;
+    }
+};
+
+DECLARE_BOARD(CompactWifiBoard);
--- a/main/boards/bread-compact-wifi/config.h
+++ b/main/boards/bread-compact-wifi/config.h
@@ -6,6 +6,7 @@
 #define AUDIO_INPUT_SAMPLE_RATE  16000
 #define AUDIO_OUTPUT_SAMPLE_RATE 24000

+// 如果使用 Duplex I2S 模式，请注释下面一行
 #define AUDIO_I2S_METHOD_SIMPLEX

 #ifdef AUDIO_I2S_METHOD_SIMPLEX
@@ -19,7 +20,7 @@

 #else

-#define AUDIO_I2S_GPIO_LRCK GPIO_NUM_4
+#define AUDIO_I2S_GPIO_WS GPIO_NUM_4
 #define AUDIO_I2S_GPIO_BCLK GPIO_NUM_5
 #define AUDIO_I2S_GPIO_DIN  GPIO_NUM_6
 #define AUDIO_I2S_GPIO_DOUT GPIO_NUM_7
--- a/main/boards/esp-box-3/EspBox3Board.cc
+++ b/main/boards/esp-box-3/EspBox3Board.cc
@@ -1,20 +0,0 @@
-#include "WifiBoard.h"
-#include "BoxAudioDevice.h"
-
-#include <esp_log.h>
-
-#define TAG "EspBox3Board"
-
-class EspBox3Board : public WifiBoard {
-public:
-    virtual void Initialize() override {
-        ESP_LOGI(TAG, "Initializing EspBox3Board");
-        WifiBoard::Initialize();
-    }
-
-    virtual AudioDevice* CreateAudioDevice() override {
-        return new BoxAudioDevice();
-    }
-};
-
-DECLARE_BOARD(EspBox3Board);
--- a/main/boards/esp-box-3/config.h
+++ b/main/boards/esp-box-3/config.h
@@ -5,11 +5,12 @@

 #define AUDIO_INPUT_SAMPLE_RATE  16000
 #define AUDIO_OUTPUT_SAMPLE_RATE 16000
+#define AUDIO_DEFAULT_OUTPUT_VOLUME 80

 #define AUDIO_INPUT_REFERENCE    true

 #define AUDIO_I2S_GPIO_MCLK GPIO_NUM_2
-#define AUDIO_I2S_GPIO_LRCK GPIO_NUM_45
+#define AUDIO_I2S_GPIO_WS GPIO_NUM_45
 #define AUDIO_I2S_GPIO_BCLK GPIO_NUM_17
 #define AUDIO_I2S_GPIO_DIN  GPIO_NUM_16
 #define AUDIO_I2S_GPIO_DOUT GPIO_NUM_15
--- a/main/boards/esp-box-3/esp_box3_board.cc
+++ b/main/boards/esp-box-3/esp_box3_board.cc
@@ -0,0 +1,75 @@
+#include "boards/wifi_board.h"
+#include "audio_codecs/box_audio_codec.h"
+#include "display/no_display.h"
+#include "application.h"
+#include "button.h"
+#include "led.h"
+#include "config.h"
+
+#include <esp_log.h>
+#include <driver/i2c_master.h>
+
+#define TAG "EspBox3Board"
+
+class EspBox3Board : public WifiBoard {
+private:
+    i2c_master_bus_handle_t i2c_bus_;
+    Button boot_button_;
+
+    void InitializeI2c() {
+        // Initialize I2C peripheral
+        i2c_master_bus_config_t i2c_bus_cfg = {
+            .i2c_port = I2C_NUM_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 InitializeButtons() {
+        boot_button_.OnClick([this]() {
+            Application::GetInstance().ToggleChatState();
+        });
+    }
+
+public:
+    EspBox3Board() : boot_button_(BOOT_BUTTON_GPIO) {
+    }
+
+    virtual void Initialize() override {
+        ESP_LOGI(TAG, "Initializing EspBox3Board");
+        InitializeI2c();
+        InitializeButtons();
+        WifiBoard::Initialize();
+    }
+
+    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) {
+            audio_codec = new BoxAudioCodec(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_PA_PIN, AUDIO_CODEC_ES8311_ADDR, AUDIO_CODEC_ES7210_ADDR, AUDIO_INPUT_REFERENCE);
+            audio_codec->SetOutputVolume(AUDIO_DEFAULT_OUTPUT_VOLUME);
+        }
+        return audio_codec;
+    }
+
+    virtual Display* GetDisplay() override {
+        static NoDisplay display;
+        return &display;
+    }
+};
+
+DECLARE_BOARD(EspBox3Board);
--- a/main/boards/kevin-box-0/KevinBoxBoard.cc
+++ b/main/boards/kevin-box-0/KevinBoxBoard.cc
@@ -1,84 +0,0 @@
-#include "Ml307Board.h"
-#include "BoxAudioDevice.h"
-
-#include <esp_log.h>
-#include <esp_spiffs.h>
-#include <driver/gpio.h>
-#include <esp_adc/adc_oneshot.h>
-#include <esp_adc/adc_cali.h>
-#include <esp_adc/adc_cali_scheme.h>
-
-static const char *TAG = "KevinBoxBoard";
-
-class KevinBoxBoard : public Ml307Board {
-private:
-    adc_oneshot_unit_handle_t adc1_handle_;
-    adc_cali_handle_t adc1_cali_handle_;
-
-    void MountStorage() {
-        // Mount the storage partition
-        esp_vfs_spiffs_conf_t conf = {
-            .base_path = "/storage",
-            .partition_label = "storage",
-            .max_files = 5,
-            .format_if_mount_failed = true,
-        };
-        esp_vfs_spiffs_register(&conf);
-    }
-
-    void Enable4GModule() {
-        // Make GPIO15 HIGH to enable the 4G module
-        gpio_config_t ml307_enable_config = {
-            .pin_bit_mask = (1ULL << 15),
-            .mode = GPIO_MODE_OUTPUT,
-            .pull_up_en = GPIO_PULLUP_DISABLE,
-            .pull_down_en = GPIO_PULLDOWN_DISABLE,
-            .intr_type = GPIO_INTR_DISABLE,
-        };
-        gpio_config(&ml307_enable_config);
-        gpio_set_level(GPIO_NUM_15, 1);
-    }
-
-    virtual void InitializeADC() {
-        adc_oneshot_unit_init_cfg_t init_config1 = {};
-        init_config1.unit_id = ADC_UNIT_1;
-        ESP_ERROR_CHECK(adc_oneshot_new_unit(&init_config1, &adc1_handle_));
-
-        //-------------ADC1 Config---------------//
-        adc_oneshot_chan_cfg_t config = {
-            .atten = ADC_ATTEN_DB_12,
-            .bitwidth = ADC_BITWIDTH_DEFAULT,
-        };
-        ESP_ERROR_CHECK(adc_oneshot_config_channel(adc1_handle_, ADC_CHANNEL_0, &config));
-
-        adc_cali_curve_fitting_config_t cali_config = {
-            .unit_id = ADC_UNIT_1,
-            .chan = ADC_CHANNEL_0,
-            .atten = ADC_ATTEN_DB_12,
-            .bitwidth = ADC_BITWIDTH_DEFAULT,
-        };
-        ESP_ERROR_CHECK(adc_cali_create_scheme_curve_fitting(&cali_config, &adc1_cali_handle_));
-    }
-public:
-    virtual void Initialize() override {
-        ESP_LOGI(TAG, "Initializing KevinBoxBoard");
-        InitializeADC();
-        MountStorage();
-        Enable4GModule();
-        Ml307Board::Initialize();
-    }
-
-    virtual AudioDevice* CreateAudioDevice() override {
-        return new BoxAudioDevice();
-    }
-
-    virtual bool GetBatteryVoltage(int &voltage, bool& charging) override {
-        int adc_reading;
-        ESP_ERROR_CHECK(adc_oneshot_read(adc1_handle_, ADC_CHANNEL_0, &adc_reading));
-        ESP_ERROR_CHECK(adc_cali_raw_to_voltage(adc1_cali_handle_, adc_reading, &voltage));
-        charging = false;
-        return true;
-    }
-};
-
-DECLARE_BOARD(KevinBoxBoard);
--- a/main/boards/kevin-box-0/config.h
+++ b/main/boards/kevin-box-0/config.h
@@ -9,7 +9,7 @@
 #define AUDIO_INPUT_REFERENCE    true

 #define AUDIO_I2S_GPIO_MCLK GPIO_NUM_0
-#define AUDIO_I2S_GPIO_LRCK GPIO_NUM_47
+#define AUDIO_I2S_GPIO_WS GPIO_NUM_47
 #define AUDIO_I2S_GPIO_BCLK GPIO_NUM_48
 #define AUDIO_I2S_GPIO_DIN  GPIO_NUM_45
 #define AUDIO_I2S_GPIO_DOUT GPIO_NUM_21
--- a/main/boards/kevin-box-0/kevin_box_board.cc
+++ b/main/boards/kevin-box-0/kevin_box_board.cc
@@ -0,0 +1,191 @@
+#include "boards/ml307_board.h"
+#include "audio_codecs/box_audio_codec.h"
+#include "display/ssd1306_display.h"
+#include "application.h"
+#include "button.h"
+#include "led.h"
+#include "config.h"
+
+#include <esp_log.h>
+#include <esp_spiffs.h>
+#include <driver/gpio.h>
+#include <driver/i2c_master.h>
+#include <esp_adc/adc_oneshot.h>
+#include <esp_adc/adc_cali.h>
+#include <esp_adc/adc_cali_scheme.h>
+
+static const char *TAG = "KevinBoxBoard";
+
+class KevinBoxBoard : public Ml307Board {
+private:
+    adc_oneshot_unit_handle_t adc1_handle_;
+    adc_cali_handle_t adc1_cali_handle_;
+    i2c_master_bus_handle_t display_i2c_bus_;
+    i2c_master_bus_handle_t codec_i2c_bus_;
+    Button boot_button_;
+    Button volume_up_button_;
+    Button volume_down_button_;
+
+    void MountStorage() {
+        // Mount the storage partition
+        esp_vfs_spiffs_conf_t conf = {
+            .base_path = "/storage",
+            .partition_label = "storage",
+            .max_files = 5,
+            .format_if_mount_failed = true,
+        };
+        esp_vfs_spiffs_register(&conf);
+    }
+
+    void Enable4GModule() {
+        // Make GPIO15 HIGH to enable the 4G module
+        gpio_config_t ml307_enable_config = {
+            .pin_bit_mask = (1ULL << 15),
+            .mode = GPIO_MODE_OUTPUT,
+            .pull_up_en = GPIO_PULLUP_DISABLE,
+            .pull_down_en = GPIO_PULLDOWN_DISABLE,
+            .intr_type = GPIO_INTR_DISABLE,
+        };
+        gpio_config(&ml307_enable_config);
+        gpio_set_level(GPIO_NUM_15, 1);
+    }
+
+    void InitializeADC() {
+        adc_oneshot_unit_init_cfg_t init_config1 = {};
+        init_config1.unit_id = ADC_UNIT_1;
+        ESP_ERROR_CHECK(adc_oneshot_new_unit(&init_config1, &adc1_handle_));
+
+        //-------------ADC1 Config---------------//
+        adc_oneshot_chan_cfg_t config = {
+            .atten = ADC_ATTEN_DB_12,
+            .bitwidth = ADC_BITWIDTH_DEFAULT,
+        };
+        ESP_ERROR_CHECK(adc_oneshot_config_channel(adc1_handle_, ADC_CHANNEL_0, &config));
+
+        adc_cali_curve_fitting_config_t cali_config = {
+            .unit_id = ADC_UNIT_1,
+            .chan = ADC_CHANNEL_0,
+            .atten = ADC_ATTEN_DB_12,
+            .bitwidth = ADC_BITWIDTH_DEFAULT,
+        };
+        ESP_ERROR_CHECK(adc_cali_create_scheme_curve_fitting(&cali_config, &adc1_cali_handle_));
+    }
+
+    void InitializeDisplayI2c() {
+        i2c_master_bus_config_t bus_config = {
+            .i2c_port = I2C_NUM_0,
+            .sda_io_num = DISPLAY_SDA_PIN,
+            .scl_io_num = DISPLAY_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(&bus_config, &display_i2c_bus_));
+    }
+
+    void InitializeCodecI2c() {
+        // Initialize I2C peripheral
+        i2c_master_bus_config_t i2c_bus_cfg = {
+            .i2c_port = I2C_NUM_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, &codec_i2c_bus_));
+    }
+
+    void InitializeButtons() {
+        boot_button_.OnClick([this]() {
+            Application::GetInstance().ToggleChatState();
+        });
+
+        volume_up_button_.OnClick([this]() {
+            auto codec = GetAudioCodec();
+            auto volume = codec->output_volume() + 10;
+            if (volume > 100) {
+                volume = 100;
+            }
+            codec->SetOutputVolume(volume);
+            GetDisplay()->ShowNotification("Volume\n" + std::to_string(volume));
+        });
+
+        volume_up_button_.OnLongPress([this]() {
+            auto codec = GetAudioCodec();
+            codec->SetOutputVolume(100);
+            GetDisplay()->ShowNotification("Volume\n100");
+        });
+
+        volume_down_button_.OnClick([this]() {
+            auto codec = GetAudioCodec();
+            auto volume = codec->output_volume() - 10;
+            if (volume < 0) {
+                volume = 0;
+            }
+            codec->SetOutputVolume(volume);
+            GetDisplay()->ShowNotification("Volume\n" + std::to_string(volume));
+        });
+
+        volume_down_button_.OnLongPress([this]() {
+            auto codec = GetAudioCodec();
+            codec->SetOutputVolume(0);
+            GetDisplay()->ShowNotification("Volume\n0");
+        });
+    }
+
+public:
+    KevinBoxBoard() : Ml307Board(ML307_TX_PIN, ML307_RX_PIN, 4096),
+        boot_button_(BOOT_BUTTON_GPIO),
+        volume_up_button_(VOLUME_UP_BUTTON_GPIO),
+        volume_down_button_(VOLUME_DOWN_BUTTON_GPIO) {
+    }
+
+    virtual void Initialize() override {
+        ESP_LOGI(TAG, "Initializing KevinBoxBoard");
+        InitializeDisplayI2c();
+        InitializeCodecI2c();
+        InitializeADC();
+        MountStorage();
+        Enable4GModule();
+
+        InitializeButtons();
+
+        Ml307Board::Initialize();
+    }
+
+    virtual Led* GetBuiltinLed() override {
+        static Led led(BUILTIN_LED_GPIO);
+        return &led;
+    }
+
+    virtual AudioCodec* GetAudioCodec() override {
+        static BoxAudioCodec audio_codec(codec_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_PA_PIN, AUDIO_CODEC_ES8311_ADDR, AUDIO_CODEC_ES7210_ADDR, AUDIO_INPUT_REFERENCE);
+        return &audio_codec;
+    }
+
+    virtual Display* GetDisplay() override {
+        static Ssd1306Display display(display_i2c_bus_, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+        return &display;
+    }
+
+    virtual bool GetBatteryVoltage(int &voltage, bool& charging) override {
+        ESP_ERROR_CHECK(adc_oneshot_get_calibrated_result(adc1_handle_, adc1_cali_handle_, ADC_CHANNEL_0, &voltage));
+        voltage *= 3;
+        charging = false;
+        ESP_LOGI(TAG, "Battery voltage: %d, Charging: %d", voltage, charging);
+        return true;
+    }
+};
+
+DECLARE_BOARD(KevinBoxBoard);
--- a/main/boards/kevin-box-1/KevinBoxBoard.cc
+++ b/main/boards/kevin-box-1/KevinBoxBoard.cc
@@ -1,93 +0,0 @@
-#include "Ml307Board.h"
-#include "BoxAudioDevice.h"
-
-#include <esp_log.h>
-#include <esp_spiffs.h>
-#include <driver/gpio.h>
-#include <esp_adc/adc_oneshot.h>
-#include <esp_adc/adc_cali.h>
-#include <esp_adc/adc_cali_scheme.h>
-
-static const char *TAG = "KevinBoxBoard";
-
-class KevinBoxBoard : public Ml307Board {
-private:
-    adc_oneshot_unit_handle_t adc1_handle_;
-    adc_cali_handle_t adc1_cali_handle_;
-
-    void MountStorage() {
-        // Mount the storage partition
-        esp_vfs_spiffs_conf_t conf = {
-            .base_path = "/storage",
-            .partition_label = "storage",
-            .max_files = 5,
-            .format_if_mount_failed = true,
-        };
-        esp_vfs_spiffs_register(&conf);
-    }
-
-    void Enable4GModule() {
-        // Make GPIO15 HIGH to enable the 4G module
-        gpio_config_t ml307_enable_config = {
-            .pin_bit_mask = (1ULL << 15),
-            .mode = GPIO_MODE_OUTPUT,
-            .pull_up_en = GPIO_PULLUP_DISABLE,
-            .pull_down_en = GPIO_PULLDOWN_DISABLE,
-            .intr_type = GPIO_INTR_DISABLE,
-        };
-        gpio_config(&ml307_enable_config);
-        gpio_set_level(GPIO_NUM_15, 1);
-    }
-
-    virtual void InitializeADC() {
-        adc_oneshot_unit_init_cfg_t init_config1 = {};
-        init_config1.unit_id = ADC_UNIT_1;
-        ESP_ERROR_CHECK(adc_oneshot_new_unit(&init_config1, &adc1_handle_));
-
-        //-------------ADC1 Config---------------//
-        adc_oneshot_chan_cfg_t config = {
-            .atten = ADC_ATTEN_DB_12,
-            .bitwidth = ADC_BITWIDTH_DEFAULT,
-        };
-        ESP_ERROR_CHECK(adc_oneshot_config_channel(adc1_handle_, ADC_CHANNEL_0, &config));
-
-        adc_cali_curve_fitting_config_t cali_config = {
-            .unit_id = ADC_UNIT_1,
-            .chan = ADC_CHANNEL_0,
-            .atten = ADC_ATTEN_DB_12,
-            .bitwidth = ADC_BITWIDTH_DEFAULT,
-        };
-        ESP_ERROR_CHECK(adc_cali_create_scheme_curve_fitting(&cali_config, &adc1_cali_handle_));
-    }
-public:
-    virtual void Initialize() override {
-        ESP_LOGI(TAG, "Initializing KevinBoxBoard");
-        InitializeADC();
-        MountStorage();
-        Enable4GModule();
-
-        gpio_config_t charging_io = {
-            .pin_bit_mask = (1ULL << 2),
-            .mode = GPIO_MODE_INPUT,
-            .pull_up_en = GPIO_PULLUP_ENABLE,
-            .pull_down_en = GPIO_PULLDOWN_DISABLE,
-            .intr_type = GPIO_INTR_DISABLE,
-        };
-        gpio_config(&charging_io);
-
-        Ml307Board::Initialize();
-    }
-
-    virtual AudioDevice* CreateAudioDevice() override {
-        return new BoxAudioDevice();
-    }
-
-    virtual bool GetBatteryVoltage(int &voltage, bool& charging) override {
-        ESP_ERROR_CHECK(adc_oneshot_get_calibrated_result(adc1_handle_, adc1_cali_handle_, ADC_CHANNEL_0, &voltage));
-        charging = gpio_get_level(GPIO_NUM_2) == 0;
-        ESP_LOGI(TAG, "Battery voltage: %d, Charging: %d", voltage, charging);
-        return true;
-    }
-};
-
-DECLARE_BOARD(KevinBoxBoard);
--- a/main/boards/kevin-box-1/config.h
+++ b/main/boards/kevin-box-1/config.h
@@ -9,7 +9,7 @@
 #define AUDIO_INPUT_REFERENCE    true

 #define AUDIO_I2S_GPIO_MCLK GPIO_NUM_42
-#define AUDIO_I2S_GPIO_LRCK GPIO_NUM_47
+#define AUDIO_I2S_GPIO_WS GPIO_NUM_47
 #define AUDIO_I2S_GPIO_BCLK GPIO_NUM_48
 #define AUDIO_I2S_GPIO_DIN  GPIO_NUM_45
 #define AUDIO_I2S_GPIO_DOUT GPIO_NUM_21
--- a/main/boards/kevin-box-1/kevin_box_board.cc
+++ b/main/boards/kevin-box-1/kevin_box_board.cc
@@ -0,0 +1,201 @@
+#include "boards/ml307_board.h"
+#include "audio_codecs/box_audio_codec.h"
+#include "display/ssd1306_display.h"
+#include "application.h"
+#include "button.h"
+#include "led.h"
+#include "config.h"
+
+#include <esp_log.h>
+#include <esp_spiffs.h>
+#include <driver/gpio.h>
+#include <driver/i2c_master.h>
+#include <esp_adc/adc_oneshot.h>
+#include <esp_adc/adc_cali.h>
+#include <esp_adc/adc_cali_scheme.h>
+
+static const char *TAG = "KevinBoxBoard";
+
+class KevinBoxBoard : public Ml307Board {
+private:
+    adc_oneshot_unit_handle_t adc1_handle_;
+    adc_cali_handle_t adc1_cali_handle_;
+    i2c_master_bus_handle_t display_i2c_bus_;
+    i2c_master_bus_handle_t codec_i2c_bus_;
+    Button boot_button_;
+    Button volume_up_button_;
+    Button volume_down_button_;
+
+    void MountStorage() {
+        // Mount the storage partition
+        esp_vfs_spiffs_conf_t conf = {
+            .base_path = "/storage",
+            .partition_label = "storage",
+            .max_files = 5,
+            .format_if_mount_failed = true,
+        };
+        esp_vfs_spiffs_register(&conf);
+    }
+
+    void Enable4GModule() {
+        // Make GPIO15 HIGH to enable the 4G module
+        gpio_config_t ml307_enable_config = {
+            .pin_bit_mask = (1ULL << 15) | (1ULL << 18),
+            .mode = GPIO_MODE_OUTPUT,
+            .pull_up_en = GPIO_PULLUP_DISABLE,
+            .pull_down_en = GPIO_PULLDOWN_DISABLE,
+            .intr_type = GPIO_INTR_DISABLE,
+        };
+        gpio_config(&ml307_enable_config);
+        gpio_set_level(GPIO_NUM_15, 1);
+        gpio_set_level(GPIO_NUM_18, 1);
+    }
+
+    void InitializeADC() {
+        adc_oneshot_unit_init_cfg_t init_config1 = {};
+        init_config1.unit_id = ADC_UNIT_1;
+        ESP_ERROR_CHECK(adc_oneshot_new_unit(&init_config1, &adc1_handle_));
+
+        //-------------ADC1 Config---------------//
+        adc_oneshot_chan_cfg_t config = {
+            .atten = ADC_ATTEN_DB_12,
+            .bitwidth = ADC_BITWIDTH_DEFAULT,
+        };
+        ESP_ERROR_CHECK(adc_oneshot_config_channel(adc1_handle_, ADC_CHANNEL_0, &config));
+
+        adc_cali_curve_fitting_config_t cali_config = {
+            .unit_id = ADC_UNIT_1,
+            .chan = ADC_CHANNEL_0,
+            .atten = ADC_ATTEN_DB_12,
+            .bitwidth = ADC_BITWIDTH_DEFAULT,
+        };
+        ESP_ERROR_CHECK(adc_cali_create_scheme_curve_fitting(&cali_config, &adc1_cali_handle_));
+    }
+
+    void InitializeDisplayI2c() {
+        i2c_master_bus_config_t bus_config = {
+            .i2c_port = I2C_NUM_0,
+            .sda_io_num = DISPLAY_SDA_PIN,
+            .scl_io_num = DISPLAY_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(&bus_config, &display_i2c_bus_));
+    }
+
+    void InitializeCodecI2c() {
+        // Initialize I2C peripheral
+        i2c_master_bus_config_t i2c_bus_cfg = {
+            .i2c_port = I2C_NUM_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, &codec_i2c_bus_));
+    }
+
+    void InitializeButtons() {
+        boot_button_.OnClick([this]() {
+            Application::GetInstance().ToggleChatState();
+        });
+
+        volume_up_button_.OnClick([this]() {
+            auto codec = GetAudioCodec();
+            auto volume = codec->output_volume() + 10;
+            if (volume > 100) {
+                volume = 100;
+            }
+            codec->SetOutputVolume(volume);
+            GetDisplay()->ShowNotification("Volume\n" + std::to_string(volume));
+        });
+
+        volume_up_button_.OnLongPress([this]() {
+            auto codec = GetAudioCodec();
+            codec->SetOutputVolume(100);
+            GetDisplay()->ShowNotification("Volume\n100");
+        });
+
+        volume_down_button_.OnClick([this]() {
+            auto codec = GetAudioCodec();
+            auto volume = codec->output_volume() - 10;
+            if (volume < 0) {
+                volume = 0;
+            }
+            codec->SetOutputVolume(volume);
+            GetDisplay()->ShowNotification("Volume\n" + std::to_string(volume));
+        });
+
+        volume_down_button_.OnLongPress([this]() {
+            auto codec = GetAudioCodec();
+            codec->SetOutputVolume(0);
+            GetDisplay()->ShowNotification("Volume\n0");
+        });
+    }
+
+public:
+    KevinBoxBoard() : Ml307Board(ML307_TX_PIN, ML307_RX_PIN, 4096),
+        boot_button_(BOOT_BUTTON_GPIO),
+        volume_up_button_(VOLUME_UP_BUTTON_GPIO),
+        volume_down_button_(VOLUME_DOWN_BUTTON_GPIO) {
+    }
+
+    virtual void Initialize() override {
+        ESP_LOGI(TAG, "Initializing KevinBoxBoard");
+        InitializeDisplayI2c();
+        InitializeCodecI2c();
+        InitializeADC();
+        MountStorage();
+        Enable4GModule();
+
+        gpio_config_t charging_io = {
+            .pin_bit_mask = (1ULL << 2),
+            .mode = GPIO_MODE_INPUT,
+            .pull_up_en = GPIO_PULLUP_ENABLE,
+            .pull_down_en = GPIO_PULLDOWN_DISABLE,
+            .intr_type = GPIO_INTR_DISABLE,
+        };
+        gpio_config(&charging_io);
+
+        InitializeButtons();
+
+        Ml307Board::Initialize();
+    }
+
+    virtual Led* GetBuiltinLed() override {
+        static Led led(BUILTIN_LED_GPIO);
+        return &led;
+    }
+
+    virtual AudioCodec* GetAudioCodec() override {
+        static BoxAudioCodec audio_codec(codec_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_PA_PIN, AUDIO_CODEC_ES8311_ADDR, AUDIO_CODEC_ES7210_ADDR, AUDIO_INPUT_REFERENCE);
+        return &audio_codec;
+    }
+
+    virtual Display* GetDisplay() override {
+        static Ssd1306Display display(display_i2c_bus_, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+        return &display;
+    }
+
+    virtual bool GetBatteryVoltage(int &voltage, bool& charging) override {
+        ESP_ERROR_CHECK(adc_oneshot_get_calibrated_result(adc1_handle_, adc1_cali_handle_, ADC_CHANNEL_0, &voltage));
+        voltage *= 3;
+        charging = gpio_get_level(GPIO_NUM_2) == 0;
+        ESP_LOGI(TAG, "Battery voltage: %d, Charging: %d", voltage, charging);
+        return true;
+    }
+};
+
+DECLARE_BOARD(KevinBoxBoard);
--- a/main/boards/lichuang-dev/LiChuangDevBoard.cc
+++ b/main/boards/lichuang-dev/LiChuangDevBoard.cc
@@ -1,20 +0,0 @@
-#include "WifiBoard.h"
-#include "BoxAudioDevice.h"
-
-#include <esp_log.h>
-
-#define TAG "LiChuangDevBoard"
-
-class LiChuangDevBoard : public WifiBoard {
-public:
-    virtual void Initialize() override {
-        ESP_LOGI(TAG, "Initializing LiChuangDevBoard");
-        WifiBoard::Initialize();
-    }
-
-    virtual AudioDevice* CreateAudioDevice() override {
-        return new BoxAudioDevice();
-    }
-};
-
-DECLARE_BOARD(LiChuangDevBoard);
--- a/main/boards/lichuang-dev/config.h
+++ b/main/boards/lichuang-dev/config.h
@@ -5,17 +5,17 @@

 #define AUDIO_INPUT_SAMPLE_RATE  24000
 #define AUDIO_OUTPUT_SAMPLE_RATE 24000
+#define AUDIO_DEFAULT_OUTPUT_VOLUME 80

 #define AUDIO_INPUT_REFERENCE    true

 #define AUDIO_I2S_GPIO_MCLK GPIO_NUM_38
-#define AUDIO_I2S_GPIO_LRCK GPIO_NUM_13
+#define AUDIO_I2S_GPIO_WS GPIO_NUM_13
 #define AUDIO_I2S_GPIO_BCLK GPIO_NUM_14
 #define AUDIO_I2S_GPIO_DIN  GPIO_NUM_12
 #define AUDIO_I2S_GPIO_DOUT GPIO_NUM_45

 #define AUDIO_CODEC_USE_PCA9557
-#define AUDIO_CODEC_PA_PIN       GPIO_NUM_40
 #define AUDIO_CODEC_I2C_SDA_PIN  GPIO_NUM_1
 #define AUDIO_CODEC_I2C_SCL_PIN  GPIO_NUM_2
 #define AUDIO_CODEC_ES8311_ADDR  ES8311_CODEC_DEFAULT_ADDR
@@ -26,11 +26,9 @@
 #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_MIRROR_X false
+#define DISPLAY_WIDTH   320
+#define DISPLAY_HEIGHT  240
+#define DISPLAY_MIRROR_X true
 #define DISPLAY_MIRROR_Y false


--- a/main/boards/lichuang-dev/lichuang_dev_board.cc
+++ b/main/boards/lichuang-dev/lichuang_dev_board.cc
@@ -0,0 +1,155 @@
+#include "boards/wifi_board.h"
+#include "audio_codecs/box_audio_codec.h"
+#include "display/st7789_display.h"
+#include "application.h"
+#include "button.h"
+#include "led.h"
+#include "config.h"
+
+#include <esp_log.h>
+#include <esp_lcd_panel_vendor.h>
+#include <driver/i2c_master.h>
+#include <driver/spi_common.h>
+#define TAG "LichuangDevBoard"
+
+class LichuangDevBoard : public WifiBoard {
+private:
+    i2c_master_bus_handle_t i2c_bus_;
+    i2c_master_dev_handle_t pca9557_handle_;
+    Button boot_button_;
+
+    void InitializeI2c() {
+        // Initialize I2C peripheral
+        i2c_master_bus_config_t i2c_bus_cfg = {
+            .i2c_port = I2C_NUM_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 Pca9557ReadRegister(uint8_t addr, uint8_t* data) {
+        uint8_t tmp[1] = {addr};
+        ESP_ERROR_CHECK(i2c_master_transmit_receive(pca9557_handle_, tmp, 1, data, 1, 100));
+    }
+
+    void Pca9557WriteRegister(uint8_t addr, uint8_t data) {
+        uint8_t tmp[2] = {addr, data};
+        ESP_ERROR_CHECK(i2c_master_transmit(pca9557_handle_, tmp, 2, 100));
+    }
+
+    void Pca9557SetOutputState(uint8_t bit, uint8_t level) {
+        uint8_t data;
+        Pca9557ReadRegister(0x01, &data);
+        data = (data & ~(1 << bit)) | (level << bit);
+        Pca9557WriteRegister(0x01, data);
+    }
+
+    void InitializePca9557() {
+        i2c_device_config_t pca9557_cfg = {
+            .dev_addr_length = I2C_ADDR_BIT_LEN_7,
+            .device_address = 0x19,
+            .scl_speed_hz = 100000,
+            .scl_wait_us = 0,
+            .flags = {
+                .disable_ack_check = 0,
+            },
+        };
+        ESP_ERROR_CHECK(i2c_master_bus_add_device(i2c_bus_, &pca9557_cfg, &pca9557_handle_));
+        assert(pca9557_handle_ != NULL);
+        Pca9557WriteRegister(0x01, 0x03);
+        Pca9557WriteRegister(0x03, 0xf8);
+    }
+
+    void InitializeSpi() {
+        spi_bus_config_t buscfg = {};
+        buscfg.mosi_io_num = GPIO_NUM_40;
+        buscfg.miso_io_num = GPIO_NUM_NC;
+        buscfg.sclk_io_num = GPIO_NUM_41;
+        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();
+        });
+    }
+
+public:
+    LichuangDevBoard() : boot_button_(BOOT_BUTTON_GPIO) {
+    }
+
+    virtual void Initialize() override {
+        ESP_LOGI(TAG, "Initializing LichuangDevBoard");
+        InitializeI2c();
+        InitializePca9557();
+        InitializeSpi();
+        InitializeButtons();
+        WifiBoard::Initialize();
+    }
+
+    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) {
+            audio_codec = new BoxAudioCodec(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,
+                GPIO_NUM_NC, AUDIO_CODEC_ES8311_ADDR, AUDIO_CODEC_ES7210_ADDR, AUDIO_INPUT_REFERENCE);
+            audio_codec->SetOutputVolume(AUDIO_DEFAULT_OUTPUT_VOLUME);
+        }
+        return audio_codec;
+    }
+
+    virtual Display* GetDisplay() override {
+        static St7789Display* display = nullptr;
+        if (display == nullptr) {
+            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_NC;
+            io_config.dc_gpio_num = GPIO_NUM_39;
+            io_config.spi_mode = 2;
+            io_config.pclk_hz = 80 * 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));
+
+            // 初始化液晶屏驱动芯片ST7789
+            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_st7789(panel_io, &panel_config, &panel));
+            
+            esp_lcd_panel_reset(panel);
+            Pca9557SetOutputState(0, 0);
+
+            esp_lcd_panel_init(panel);
+            esp_lcd_panel_invert_color(panel, true);
+            esp_lcd_panel_swap_xy(panel, true);
+            esp_lcd_panel_mirror(panel, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+            display = new St7789Display(panel_io, panel, GPIO_NUM_42, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+        }
+        return display;
+    }
+};
+
+DECLARE_BOARD(LichuangDevBoard);
--- a/main/boards/ml307_board.cc
+++ b/main/boards/ml307_board.cc
@@ -1,11 +1,11 @@
-#include "Ml307Board.h"
-#include "Application.h"
+#include "ml307_board.h"
+#include "application.h"

 #include <esp_log.h>
-#include <Ml307Http.h>
-#include <Ml307SslTransport.h>
-#include <WebSocket.h>
 #include <esp_timer.h>
+#include <ml307_http.h>
+#include <ml307_ssl_transport.h>
+#include <web_socket.h>

 static const char *TAG = "Ml307Board";

@@ -27,18 +27,39 @@ static std::string csq_to_string(int csq) {
 }


-Ml307Board::Ml307Board() : modem_(ML307_TX_PIN, ML307_RX_PIN, 4096) {
+Ml307Board::Ml307Board(gpio_num_t tx_pin, gpio_num_t rx_pin, size_t rx_buffer_size) : modem_(tx_pin, rx_pin, rx_buffer_size) {
 }

 void Ml307Board::StartNetwork() {
+    auto display = Board::GetInstance().GetDisplay();
+    display->SetText(std::string("Starting modem"));
+    modem_.SetDebug(false);
+    modem_.SetBaudRate(921600);
+
    auto& application = Application::GetInstance();
-    auto& display = application.GetDisplay();
-    display.SetText(std::string("Wait for network\n"));
+    // If low power, the material ready event will be triggered by the modem because of a reset
+    modem_.OnMaterialReady([this, &application]() {
+        ESP_LOGI(TAG, "ML307 material ready");
+        application.Schedule([this, &application]() {
+            application.SetChatState(kChatStateIdle);
+            WaitForNetworkReady();
+        });
+    });
+
+    WaitForNetworkReady();
+}
+
+void Ml307Board::WaitForNetworkReady() {
+    auto& application = Application::GetInstance();
+    auto display = Board::GetInstance().GetDisplay();
+    display->SetText(std::string("Wait for network\n"));
    int result = modem_.WaitForNetworkReady();
    if (result == -1) {
        application.Alert("Error", "PIN is not ready");
+        return;
    } else if (result == -2) {
        application.Alert("Error", "Registration denied");
+        return;
    }

    // Print the ML307 modem information
@@ -50,30 +71,8 @@ void Ml307Board::StartNetwork() {
    ESP_LOGI(TAG, "ML307 ICCID: %s", iccid.c_str());
 }

-void Ml307Board::StartModem() {
-    auto& display = Application::GetInstance().GetDisplay();
-    display.SetText(std::string("Starting modem"));
-    modem_.SetDebug(false);
-    modem_.SetBaudRate(921600);
-
-    auto& application = Application::GetInstance();
-    // If low power, the material ready event will be triggered by the modem because of a reset
-    modem_.OnMaterialReady([this, &application]() {
-        ESP_LOGI(TAG, "ML307 material ready");
-        application.Schedule([this, &application]() {
-            application.SetChatState(kChatStateIdle);
-            StartNetwork();
-        });
-    });
-}
-
 void Ml307Board::Initialize() {
    ESP_LOGI(TAG, "Initializing Ml307Board");
-    StartModem();
-}
-
-AudioDevice* Ml307Board::CreateAudioDevice() {
-    return new AudioDevice();
 }

 Http* Ml307Board::CreateHttp() {
@@ -94,7 +93,7 @@ bool Ml307Board::GetNetworkState(std::string& network_name, int& signal_quality,
    return signal_quality != -1;
 }

-std::string Ml307Board::GetJson() {
+std::string Ml307Board::GetBoardJson() {
    // Set the board type for OTA
    std::string board_type = BOARD_TYPE;
    std::string module_name = modem_.GetModuleName();
--- a/main/boards/ml307_board.h
+++ b/main/boards/ml307_board.h
@@ -1,24 +1,23 @@
 #ifndef ML307_BOARD_H
 #define ML307_BOARD_H

-#include "Board.h"
-#include <Ml307AtModem.h>
+#include "board.h"
+#include <ml307_at_modem.h>

 class Ml307Board : public Board {
 protected:
    Ml307AtModem modem_;

-    void StartModem();
+    virtual std::string GetBoardJson() override;
+    void WaitForNetworkReady();

 public:
-    Ml307Board();
+    Ml307Board(gpio_num_t tx_pin, gpio_num_t rx_pin, size_t rx_buffer_size = 4096);
    virtual void Initialize() override;
    virtual void StartNetwork() override;
-    virtual AudioDevice* CreateAudioDevice() override;
    virtual Http* CreateHttp() override;
    virtual WebSocket* CreateWebSocket() override;
    virtual bool GetNetworkState(std::string& network_name, int& signal_quality, std::string& signal_quality_text) override;
-    virtual std::string GetJson() override;
 };

 #endif // ML307_BOARD_H
--- a/main/boards/wifi_board.cc
+++ b/main/boards/wifi_board.cc
@@ -1,18 +1,18 @@
-#include "WifiBoard.h"
-#include "Application.h"
-#include "WifiStation.h"
-#include "WifiConfigurationAp.h"
-#include "SystemInfo.h"
-#include "BuiltinLed.h"
+#include "wifi_board.h"
+#include "application.h"
+#include "system_info.h"

 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-#include <EspHttp.h>
-#include <TcpTransport.h>
-#include <TlsTransport.h>
-#include <WebSocket.h>
+#include <esp_http.h>
+#include <tcp_transport.h>
+#include <tls_transport.h>
+#include <web_socket.h>
 #include <esp_log.h>

+#include <wifi_station.h>
+#include <wifi_configuration_ap.h>
+
 static const char *TAG = "WifiBoard";

 static std::string rssi_to_string(int rssi) {
@@ -31,17 +31,17 @@ static std::string rssi_to_string(int rssi) {

 void WifiBoard::StartNetwork() {
    auto& application = Application::GetInstance();
-    auto& display = application.GetDisplay();
-    auto& builtin_led = BuiltinLed::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.SetText(std::string("Connect to WiFi\n") + wifi_station.GetSsid());
+    display->SetText(std::string("Connect to WiFi\n") + wifi_station.GetSsid());
    wifi_station.Start();
    if (!wifi_station.IsConnected()) {
        application.Alert("Info", "Configuring WiFi");
-        builtin_led.SetBlue();
-        builtin_led.Blink(1000, 500);
+        builtin_led->SetBlue();
+        builtin_led->Blink(1000, 500);
        auto& wifi_ap = WifiConfigurationAp::GetInstance();
        wifi_ap.SetSsidPrefix("Xiaozhi");
        wifi_ap.Start();
@@ -87,7 +87,7 @@ bool WifiBoard::GetNetworkState(std::string& network_name, int& signal_quality,
    return signal_quality != -1;
 }

-std::string WifiBoard::GetJson() {
+std::string WifiBoard::GetBoardJson() {
    // Set the board type for OTA
    auto& wifi_station = WifiStation::GetInstance();
    std::string board_type = BOARD_TYPE;
--- a/main/boards/wifi_board.h
+++ b/main/boards/wifi_board.h
@@ -1,19 +1,20 @@
 #ifndef WIFI_BOARD_H
 #define WIFI_BOARD_H

-#include "Board.h"
+#include "board.h"

 class WifiBoard : public Board {
 protected:
    bool wifi_config_mode_ = false;

+    virtual std::string GetBoardJson() override;
+
 public:
    virtual void Initialize() override;
    virtual void StartNetwork() override;
    virtual Http* CreateHttp() override;
    virtual WebSocket* CreateWebSocket() override;
    virtual bool GetNetworkState(std::string& network_name, int& signal_quality, std::string& signal_quality_text) override;
-    virtual std::string GetJson() override;
 };

 #endif // WIFI_BOARD_H
--- a/main/button.cc
+++ b/main/button.cc
@@ -1,4 +1,5 @@
-#include "Button.h"
+#include "button.h"
+
 #include <esp_log.h>

 static const char* TAG = "Button";
--- a/main/button.h
+++ b/main/button.h
--- a/main/display.cc
+++ b/main/display.cc
@@ -0,0 +1,136 @@
+#include <esp_log.h>
+#include <esp_err.h>
+#include <string>
+#include <cstdlib>
+
+#include "display.h"
+#include "board.h"
+#include "application.h"
+
+#define TAG "Display"
+
+void Display::SetupUI() {
+    if (disp_ == nullptr) {
+        return;
+    }
+
+    ESP_LOGI(TAG, "Setting up UI");
+    Lock();
+    label_ = lv_label_create(lv_disp_get_scr_act(disp_));
+    // lv_obj_set_style_text_font(label_, font_, 0);
+    lv_obj_set_style_text_color(label_, lv_color_black(), 0);
+    lv_label_set_text(label_, "Initializing...");
+    lv_obj_set_width(label_, disp_->driver->hor_res);
+    lv_obj_set_height(label_, disp_->driver->ver_res);
+
+    notification_ = lv_label_create(lv_disp_get_scr_act(disp_));
+    // lv_obj_set_style_text_font(notification_, font_, 0);
+    lv_obj_set_style_text_color(notification_, lv_color_black(), 0);
+    lv_label_set_text(notification_, "Notification\nTest");
+    lv_obj_set_width(notification_, disp_->driver->hor_res);
+    lv_obj_set_height(notification_, disp_->driver->ver_res);
+    lv_obj_set_style_opa(notification_, LV_OPA_MIN, 0);
+    Unlock();
+
+    // Create a timer to update the display every 10 seconds
+    esp_timer_create_args_t update_display_timer_args = {
+        .callback = [](void *arg) {
+            Display* display = static_cast<Display*>(arg);
+            display->UpdateDisplay();
+        },
+        .arg = this,
+        .dispatch_method = ESP_TIMER_TASK,
+        .name = "UpdateDisplay",
+        .skip_unhandled_events = false,
+    };
+    ESP_ERROR_CHECK(esp_timer_create(&update_display_timer_args, &update_display_timer_));
+    ESP_ERROR_CHECK(esp_timer_start_periodic(update_display_timer_, 10 * 1000000));
+}
+
+Display::~Display() {
+    if (notification_timer_ != nullptr) {
+        esp_timer_stop(notification_timer_);
+        esp_timer_delete(notification_timer_);
+    }
+    if (update_display_timer_ != nullptr) {
+        esp_timer_stop(update_display_timer_);
+        esp_timer_delete(update_display_timer_);
+    }
+    if (label_ != nullptr) {
+        lv_obj_del(label_);
+        lv_obj_del(notification_);
+    }
+    if (font_ != nullptr) {
+        lv_font_free(font_);
+    }
+}
+
+void Display::SetText(const std::string &text) {
+    if (label_ != nullptr) {
+        text_ = text;
+        Lock();
+        // Change the text of the label
+        lv_label_set_text(label_, text_.c_str());
+        Unlock();
+    }
+}
+
+void Display::ShowNotification(const std::string &text) {
+    if (notification_ != nullptr) {
+        Lock();
+        lv_label_set_text(notification_, text.c_str());
+        lv_obj_set_style_opa(notification_, LV_OPA_MAX, 0);
+        lv_obj_set_style_opa(label_, LV_OPA_MIN, 0);
+        Unlock();
+
+        if (notification_timer_ != nullptr) {
+            esp_timer_stop(notification_timer_);
+            esp_timer_delete(notification_timer_);
+        }
+
+        esp_timer_create_args_t timer_args = {
+            .callback = [](void *arg) {
+                Display *display = static_cast<Display*>(arg);
+                display->Lock();
+                lv_obj_set_style_opa(display->notification_, LV_OPA_MIN, 0);
+                lv_obj_set_style_opa(display->label_, LV_OPA_MAX, 0);
+                display->Unlock();
+            },
+            .arg = this,
+            .dispatch_method = ESP_TIMER_TASK,
+            .name = "Notification Timer",
+            .skip_unhandled_events = false,
+        };
+        ESP_ERROR_CHECK(esp_timer_create(&timer_args, &notification_timer_));
+        ESP_ERROR_CHECK(esp_timer_start_once(notification_timer_, 3000000));
+    }
+}
+
+void Display::UpdateDisplay() {
+    auto chat_state = Application::GetInstance().GetChatState();
+    if (chat_state == kChatStateIdle) {
+        std::string text;
+        auto& board = Board::GetInstance();
+        std::string network_name;
+        int signal_quality;
+        std::string signal_quality_text;
+        if (!board.GetNetworkState(network_name, signal_quality, signal_quality_text)) {
+            text = "No network";
+        } else {
+            text = network_name + "\n" + signal_quality_text;
+            if (std::abs(signal_quality) != 99) {
+                text += " (" + std::to_string(signal_quality) + ")";
+            }
+        }
+
+        int battery_voltage;
+        bool charging;
+        if (board.GetBatteryVoltage(battery_voltage, charging)) {
+            text += "\n" + std::to_string(battery_voltage) + "mV";
+            if (charging) {
+                text += " (Charging)";
+            }
+        }
+        SetText(text);
+    }
+}
--- a/main/display.h
+++ b/main/display.h
@@ -1,9 +1,6 @@
 #ifndef DISPLAY_H
 #define DISPLAY_H

-#include <driver/i2c_master.h>
-#include <esp_lcd_panel_io.h>
-#include <esp_lcd_panel_ops.h>
 #include <lvgl.h>
 #include <esp_timer.h>

@@ -11,22 +8,18 @@

 class Display {
 public:
-    Display(int sda_pin, int scl_pin);
-    ~Display();
+    virtual ~Display();

+    void SetupUI();
    void SetText(const std::string &text);
    void ShowNotification(const std::string &text);

    void UpdateDisplay();

-private:
-    int sda_pin_;
-    int scl_pin_;
+    int width() const { return width_; }
+    int height() const { return height_; }

-    i2c_master_bus_handle_t i2c_bus_ = nullptr;
-
-    esp_lcd_panel_io_handle_t panel_io_ = nullptr;
-    esp_lcd_panel_handle_t panel_ = nullptr;
+protected:
    lv_disp_t *disp_ = nullptr;
    lv_font_t *font_ = nullptr;
    lv_obj_t *label_ = nullptr;
@@ -34,7 +27,13 @@ private:
    esp_timer_handle_t notification_timer_ = nullptr;
    esp_timer_handle_t update_display_timer_ = nullptr;

+    int width_ = 0;
+    int height_ = 0;
+
    std::string text_;
+
+    virtual void Lock() = 0;
+    virtual void Unlock() = 0;
 };

 #endif
--- a/main/display/no_display.cc
+++ b/main/display/no_display.cc
@@ -0,0 +1,9 @@
+#include "no_display.h"
+
+NoDisplay::NoDisplay() {}
+
+NoDisplay::~NoDisplay() {}
+
+void NoDisplay::Lock() {}
+
+void NoDisplay::Unlock() {}
--- a/main/display/no_display.h
+++ b/main/display/no_display.h
@@ -0,0 +1,16 @@
+#ifndef _NO_DISPLAY_H_
+#define _NO_DISPLAY_H_
+
+#include "display.h"
+
+class NoDisplay : public Display {
+private:
+    virtual void Lock() override;
+    virtual void Unlock() override;
+
+public:
+    NoDisplay();
+    ~NoDisplay();
+};
+
+#endif
--- a/main/display/ssd1306_display.cc
+++ b/main/display/ssd1306_display.cc
@@ -0,0 +1,106 @@
+#include "ssd1306_display.h"
+
+#include <esp_log.h>
+#include <esp_err.h>
+#include <esp_lcd_panel_ops.h>
+#include <esp_lcd_panel_vendor.h>
+#include <esp_lvgl_port.h>
+
+#define TAG "Ssd1306Display"
+
+Ssd1306Display::Ssd1306Display(void* i2c_master_handle, int width, int height, bool mirror_x, bool mirror_y)
+    : mirror_x_(mirror_x), mirror_y_(mirror_y) {
+    width_ = width;
+    height_ = height;
+
+    ESP_LOGI(TAG, "Initialize LVGL");
+    lvgl_port_cfg_t port_cfg = ESP_LVGL_PORT_INIT_CONFIG();
+    lvgl_port_init(&port_cfg);
+
+    // SSD1306 config
+    esp_lcd_panel_io_i2c_config_t io_config = {
+        .dev_addr = 0x3C,
+        .on_color_trans_done = nullptr,
+        .user_ctx = nullptr,
+        .control_phase_bytes = 1,
+        .dc_bit_offset = 6,
+        .lcd_cmd_bits = 8,
+        .lcd_param_bits = 8,
+        .flags = {
+            .dc_low_on_data = 0,
+            .disable_control_phase = 0,
+        },
+        .scl_speed_hz = 400 * 1000,
+    };
+
+    ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c_v2((i2c_master_bus_t*)i2c_master_handle, &io_config, &panel_io_));
+
+    ESP_LOGI(TAG, "Install SSD1306 driver");
+    esp_lcd_panel_dev_config_t panel_config = {};
+    panel_config.reset_gpio_num = -1;
+    panel_config.bits_per_pixel = 1;
+
+    esp_lcd_panel_ssd1306_config_t ssd1306_config = {
+        .height = static_cast<uint8_t>(height_),
+    };
+    panel_config.vendor_config = &ssd1306_config;
+
+    ESP_ERROR_CHECK(esp_lcd_new_panel_ssd1306(panel_io_, &panel_config, &panel_));
+    ESP_LOGI(TAG, "SSD1306 driver installed");
+
+    // Reset the display
+    ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_));
+    if (esp_lcd_panel_init(panel_) != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to initialize display");
+        return;
+    }
+
+    // Set the display to on
+    ESP_LOGI(TAG, "Turning display on");
+    ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_, true));
+
+    ESP_LOGI(TAG, "Adding LCD screen");
+    const lvgl_port_display_cfg_t display_cfg = {
+        .io_handle = panel_io_,
+        .panel_handle = panel_,
+        .control_handle = nullptr,
+        .buffer_size = static_cast<uint32_t>(width_ * height_),
+        .double_buffer = false,
+        .trans_size = 0,
+        .hres = static_cast<uint32_t>(width_),
+        .vres = static_cast<uint32_t>(height_),
+        .monochrome = true,
+        .rotation = {
+            .swap_xy = false,
+            .mirror_x = mirror_x_,
+            .mirror_y = mirror_y_,
+        },
+        .flags = {
+            .buff_dma = 1,
+            .buff_spiram = 0,
+            .sw_rotate = 0,
+            .full_refresh = 0,
+            .direct_mode = 0,
+        },
+    };
+
+    disp_ = lvgl_port_add_disp(&display_cfg);
+}
+
+Ssd1306Display::~Ssd1306Display() {
+    if (panel_ != nullptr) {
+        esp_lcd_panel_del(panel_);
+    }
+    if (panel_io_ != nullptr) {
+        esp_lcd_panel_io_del(panel_io_);
+    }
+    lvgl_port_deinit();
+}
+
+void Ssd1306Display::Lock() {
+    lvgl_port_lock(0);
+}
+
+void Ssd1306Display::Unlock() {
+    lvgl_port_unlock();
+}
--- a/main/display/ssd1306_display.h
+++ b/main/display/ssd1306_display.h
@@ -0,0 +1,24 @@
+#ifndef SSD1306_DISPLAY_H
+#define SSD1306_DISPLAY_H
+
+#include "display.h"
+
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_panel_ops.h>
+
+class Ssd1306Display : public Display {
+private:
+    esp_lcd_panel_io_handle_t panel_io_ = nullptr;
+    esp_lcd_panel_handle_t panel_ = nullptr;
+    bool mirror_x_ = false;
+    bool mirror_y_ = false;
+
+    virtual void Lock() override;
+    virtual void Unlock() override;
+
+public:
+    Ssd1306Display(void* i2c_master_handle, int width, int height, bool mirror_x = false, bool mirror_y = false);
+    ~Ssd1306Display();
+};
+
+#endif // SSD1306_DISPLAY_H
--- a/main/display/st7789_display.cc
+++ b/main/display/st7789_display.cc
@@ -0,0 +1,123 @@
+#include "st7789_display.h"
+
+#include <esp_log.h>
+#include <esp_err.h>
+#include <esp_lvgl_port.h>
+#include <driver/ledc.h>
+#include <vector>
+
+#define TAG "St7789Display"
+#define LCD_LEDC_CH LEDC_CHANNEL_0
+
+St7789Display::St7789Display(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel, gpio_num_t backlight_pin,
+                           int width, int height, bool mirror_x, bool mirror_y)
+    : panel_io_(panel_io), panel_(panel), mirror_x_(mirror_x), mirror_y_(mirror_y) {
+    width_ = width;
+    height_ = height;
+
+    ESP_LOGI(TAG, "Initialize LVGL");
+    lvgl_port_cfg_t port_cfg = ESP_LVGL_PORT_INIT_CONFIG();
+    lvgl_port_init(&port_cfg);
+
+    InitializeBacklight(backlight_pin);
+
+    // draw white
+    std::vector<uint16_t> buffer(width_, 0xFFFF);
+    for (int y = 0; y < height_; y++) {
+        esp_lcd_panel_draw_bitmap(panel_, 0, y, width_, y + 1, buffer.data());
+    }
+
+    // Set the display to on
+    ESP_LOGI(TAG, "Turning display on");
+    ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_, true));
+
+    ESP_LOGI(TAG, "Adding LCD screen");
+    const lvgl_port_display_cfg_t display_cfg = {
+        .io_handle = panel_io_,
+        .panel_handle = panel_,
+        .control_handle = nullptr,
+        .buffer_size = static_cast<uint32_t>(width_ * 20),
+        .double_buffer = false,
+        .trans_size = 0,
+        .hres = static_cast<uint32_t>(width_),
+        .vres = static_cast<uint32_t>(height_),
+        .monochrome = false,
+        .rotation = {
+            .swap_xy = true,
+            .mirror_x = mirror_x_,
+            .mirror_y = mirror_y_,
+        },
+        .flags = {
+            .buff_dma = 1,
+            .buff_spiram = 0,
+            .sw_rotate = 0,
+            .full_refresh = 0,
+            .direct_mode = 0,
+        },
+    };
+
+    disp_ = lvgl_port_add_disp(&display_cfg);
+
+    SetBacklight(100);
+}
+
+St7789Display::~St7789Display() {
+    if (panel_ != nullptr) {
+        esp_lcd_panel_del(panel_);
+    }
+    if (panel_io_ != nullptr) {
+        esp_lcd_panel_io_del(panel_io_);
+    }
+    lvgl_port_deinit();
+}
+
+void St7789Display::InitializeBacklight(gpio_num_t backlight_pin) {
+    if (backlight_pin == GPIO_NUM_NC) {
+        return;
+    }
+
+    // Setup LEDC peripheral for PWM backlight control
+    const ledc_channel_config_t backlight_channel = {
+        .gpio_num = backlight_pin,
+        .speed_mode = LEDC_LOW_SPEED_MODE,
+        .channel = LCD_LEDC_CH,
+        .intr_type = LEDC_INTR_DISABLE,
+        .timer_sel = LEDC_TIMER_0,
+        .duty = 0,
+        .hpoint = 0,
+        .flags = {
+            .output_invert = true
+        }
+    };
+    const ledc_timer_config_t backlight_timer = {
+        .speed_mode = LEDC_LOW_SPEED_MODE,
+        .duty_resolution = LEDC_TIMER_10_BIT,
+        .timer_num = LEDC_TIMER_0,
+        .freq_hz = 5000,
+        .clk_cfg = LEDC_AUTO_CLK,
+        .deconfigure = false
+    };
+
+    ESP_ERROR_CHECK(ledc_timer_config(&backlight_timer));
+    ESP_ERROR_CHECK(ledc_channel_config(&backlight_channel));
+}
+
+void St7789Display::SetBacklight(uint8_t brightness) {
+    if (brightness > 100) {
+        brightness = 100;
+    }
+
+    ESP_LOGI(TAG, "Setting LCD backlight: %d%%", brightness);
+    // LEDC resolution set to 10bits, thus: 100% = 1023
+    uint32_t duty_cycle = (1023 * brightness) / 100;
+    ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LCD_LEDC_CH, duty_cycle));
+    ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LCD_LEDC_CH));
+}
+
+void St7789Display::Lock() {
+    lvgl_port_lock(0);
+}
+
+void St7789Display::Unlock() {
+    lvgl_port_unlock();
+}
--- a/main/display/st7789_display.h
+++ b/main/display/st7789_display.h
@@ -0,0 +1,29 @@
+#ifndef ST7789_DISPLAY_H
+#define ST7789_DISPLAY_H
+
+#include "display.h"
+
+#include <driver/gpio.h>
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_panel_ops.h>
+
+class St7789Display : public Display {
+private:
+    esp_lcd_panel_io_handle_t panel_io_ = nullptr;
+    esp_lcd_panel_handle_t panel_ = nullptr;
+    bool mirror_x_ = false;
+    bool mirror_y_ = false;
+
+    void InitializeBacklight(gpio_num_t backlight_pin);
+    void SetBacklight(uint8_t brightness);
+
+    virtual void Lock() override;
+    virtual void Unlock() override;
+
+public:
+    St7789Display(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel, gpio_num_t backlight_pin,
+                  int width, int height, bool mirror_x, bool mirror_y);
+    ~St7789Display();
+};
+
+#endif // ST7789_DISPLAY_H
--- a/main/idf_component.yml
+++ b/main/idf_component.yml
@@ -1,8 +1,8 @@
 ## IDF Component Manager Manifest File
 dependencies:
-  78/esp-wifi-connect: "~1.2.0"
-  78/esp-opus-encoder: "~1.0.2"
-  78/esp-ml307: "~1.3.0"
+  78/esp-wifi-connect: "~1.3.0"
+  78/esp-opus-encoder: "~1.1.0"
+  78/esp-ml307: "~1.4.0"
  espressif/led_strip: "^2.4.1"
  espressif/esp_codec_dev: "^1.3.1"
  espressif/esp-sr: "^1.9.0"
--- a/main/BuiltinLed.cc
+++ b/main/BuiltinLed.cc
@@ -1,24 +1,37 @@
-#include "BuiltinLed.h"
-#include "Board.h"
+#include "led.h"
+#include "board.h"
+
 #include <cstring>
 #include <esp_log.h>

-#define TAG "builtin_led"
+#define TAG "Led"

-BuiltinLed::BuiltinLed() {
+Led::Led(gpio_num_t gpio) {
    mutex_ = xSemaphoreCreateMutex();
    blink_event_group_ = xEventGroupCreate();
    xEventGroupSetBits(blink_event_group_, BLINK_TASK_STOPPED_BIT);

-    if (BUILTIN_LED_GPIO == GPIO_NUM_NC) {
+    if (gpio == GPIO_NUM_NC) {
        ESP_LOGI(TAG, "Builtin LED not connected");
        return;
    }
-    Initialize();
+    
+    led_strip_config_t strip_config = {};
+    strip_config.strip_gpio_num = gpio;
+    strip_config.max_leds = 1;
+    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_);
+
    SetGrey();
 }

-BuiltinLed::~BuiltinLed() {
+Led::~Led() {
    StopBlinkInternal();
    if (led_strip_ != nullptr) {
        led_strip_del(led_strip_);
@@ -31,32 +44,13 @@ BuiltinLed::~BuiltinLed() {
    }
 }

-BuiltinLed& BuiltinLed::GetInstance() {
-    static BuiltinLed instance;
-    return instance;
-}
-
-void BuiltinLed::Initialize() {
-    led_strip_config_t strip_config = {};
-    strip_config.strip_gpio_num = BUILTIN_LED_GPIO;
-    strip_config.max_leds = 1;
-    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_);
-}
-
-void BuiltinLed::SetColor(uint8_t r, uint8_t g, uint8_t b) {
+void Led::SetColor(uint8_t r, uint8_t g, uint8_t b) {
    r_ = r;
    g_ = g;
    b_ = b;
 }

-void BuiltinLed::TurnOn() {
+void Led::TurnOn() {
    if (led_strip_ == nullptr) {
        return;
    }
@@ -67,7 +61,7 @@ void BuiltinLed::TurnOn() {
    xSemaphoreGive(mutex_);
 }

-void BuiltinLed::TurnOff() {
+void Led::TurnOff() {
    if (led_strip_ == nullptr) {
        return;
    }
@@ -77,19 +71,19 @@ void BuiltinLed::TurnOff() {
    xSemaphoreGive(mutex_);
 }

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

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

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

-void BuiltinLed::StartBlinkTask(int times, int interval_ms) {
+void Led::StartBlinkTask(int times, int interval_ms) {
    if (led_strip_ == nullptr) {
        return;
    }
@@ -104,7 +98,7 @@ void BuiltinLed::StartBlinkTask(int times, int interval_ms) {
    xEventGroupSetBits(blink_event_group_, BLINK_TASK_RUNNING_BIT);

    xTaskCreate([](void* obj) {
-        auto this_ = static_cast<BuiltinLed*>(obj);
+        auto this_ = static_cast<Led*>(obj);
        int count = 0;
        while (this_->should_blink_ && (this_->blink_times_ == BLINK_INFINITE || count < this_->blink_times_)) {
            xSemaphoreTake(this_->mutex_, portMAX_DELAY);
@@ -131,7 +125,7 @@ void BuiltinLed::StartBlinkTask(int times, int interval_ms) {
    xSemaphoreGive(mutex_);
 }

-void BuiltinLed::StopBlinkInternal() {
+void Led::StopBlinkInternal() {
    should_blink_ = false;
    xEventGroupWaitBits(blink_event_group_, BLINK_TASK_STOPPED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
 }
--- a/main/BuiltinLed.h
+++ b/main/BuiltinLed.h
@@ -1,5 +1,5 @@
-#ifndef _BUILTIN_LED_H_
-#define _BUILTIN_LED_H_
+#ifndef _LED_H_
+#define _LED_H_

 #include <led_strip.h>
 #include <freertos/semphr.h>
@@ -13,9 +13,10 @@

 #define DEFAULT_BRIGHTNESS 16

-class BuiltinLed {
+class Led {
 public:
-    static BuiltinLed& GetInstance();
+    Led(gpio_num_t gpio);
+    ~Led();

    void BlinkOnce();
    void Blink(int times, int interval_ms);
@@ -30,11 +31,6 @@ public:
    void SetBlue(uint8_t brightness = DEFAULT_BRIGHTNESS) { SetColor(0, 0, brightness); }

 private:
-    BuiltinLed();
-    ~BuiltinLed();
-    BuiltinLed(const BuiltinLed&) = delete;
-    BuiltinLed& operator=(const BuiltinLed&) = delete;
-
    SemaphoreHandle_t mutex_;
    EventGroupHandle_t blink_event_group_;
    TaskHandle_t blink_task_ = nullptr;
@@ -44,9 +40,8 @@ private:
    int blink_interval_ms_ = 0;
    std::atomic<bool> should_blink_{false};

-    void Initialize();
    void StartBlinkTask(int times, int interval_ms);
    void StopBlinkInternal();
 };

-#endif // _BUILTIN_LED_H_
+#endif // _LED_H_
--- a/main/main.cc
+++ b/main/main.cc
@@ -5,8 +5,8 @@
 #include <driver/gpio.h>
 #include <esp_event.h>

-#include "Application.h"
-#include "SystemInfo.h"
+#include "application.h"
+#include "system_info.h"

 #define TAG "main"

--- a/main/FirmwareUpgrade.cc
+++ b/main/FirmwareUpgrade.cc
@@ -1,37 +1,40 @@
-#include "FirmwareUpgrade.h"
-#include "SystemInfo.h"
-#include "Board.h"
+#include "ota.h"
+#include "system_info.h"
+#include "board.h"

 #include <cJSON.h>
 #include <esp_log.h>
 #include <esp_partition.h>
-#include <esp_http_client.h>
 #include <esp_ota_ops.h>
 #include <esp_app_format.h>
-#include <esp_chip_info.h>

+#include <cstring>
 #include <vector>
 #include <sstream>
 #include <algorithm>

-#define TAG "FirmwareUpgrade"
+#define TAG "Ota"


-FirmwareUpgrade::FirmwareUpgrade() {
+Ota::Ota() {
 }

-FirmwareUpgrade::~FirmwareUpgrade() {
+Ota::~Ota() {
 }

-void FirmwareUpgrade::SetCheckVersionUrl(std::string check_version_url) {
+void Ota::SetCheckVersionUrl(std::string check_version_url) {
    check_version_url_ = check_version_url;
 }

-void FirmwareUpgrade::SetHeader(const std::string& key, const std::string& value) {
+void Ota::SetHeader(const std::string& key, const std::string& value) {
    headers_[key] = value;
 }

-void FirmwareUpgrade::CheckVersion() {
+void Ota::SetPostData(const std::string& post_data) {
+    post_data_ = post_data;
+}
+
+void Ota::CheckVersion() {
    std::string current_version = esp_app_get_description()->version;
    ESP_LOGI(TAG, "Current version: %s", current_version.c_str());

@@ -46,8 +49,12 @@ void FirmwareUpgrade::CheckVersion() {
    }

    http->SetHeader("Content-Type", "application/json");
-    http->SetContent(GetPostData());
-    http->Open("POST", check_version_url_);
+    if (post_data_.length() > 0) {
+        http->SetContent(post_data_);
+        http->Open("POST", check_version_url_);
+    } else {
+        http->Open("GET", check_version_url_);
+    }

    auto response = http->GetBody();
    http->Close();
@@ -94,7 +101,7 @@ void FirmwareUpgrade::CheckVersion() {
    }
 }

-void FirmwareUpgrade::MarkCurrentVersionValid() {
+void Ota::MarkCurrentVersionValid() {
    auto partition = esp_ota_get_running_partition();
    if (strcmp(partition->label, "factory") == 0) {
        ESP_LOGI(TAG, "Running from factory partition, skipping");
@@ -114,7 +121,7 @@ void FirmwareUpgrade::MarkCurrentVersionValid() {
    }
 }

-void FirmwareUpgrade::Upgrade(const std::string& firmware_url) {
+void Ota::Upgrade(const std::string& firmware_url) {
    ESP_LOGI(TAG, "Upgrading firmware from %s", firmware_url.c_str());
    esp_ota_handle_t update_handle = 0;
    auto update_partition = esp_ota_get_next_update_partition(NULL);
@@ -145,6 +152,7 @@ void FirmwareUpgrade::Upgrade(const std::string& firmware_url) {
    size_t total_read = 0, recent_read = 0;
    auto last_calc_time = esp_timer_get_time();
    while (true) {
+        taskYIELD(); // Avoid watchdog timeout
        int ret = http->Read(buffer, sizeof(buffer));
        if (ret < 0) {
            ESP_LOGE(TAG, "Failed to read HTTP data: %s", esp_err_to_name(ret));
@@ -225,12 +233,12 @@ void FirmwareUpgrade::Upgrade(const std::string& firmware_url) {
    esp_restart();
 }

-void FirmwareUpgrade::StartUpgrade(std::function<void(int progress, size_t speed)> callback) {
+void Ota::StartUpgrade(std::function<void(int progress, size_t speed)> callback) {
    upgrade_callback_ = callback;
    Upgrade(firmware_url_);
 }

-std::vector<int> FirmwareUpgrade::ParseVersion(const std::string& version) {
+std::vector<int> Ota::ParseVersion(const std::string& version) {
    std::vector<int> versionNumbers;
    std::stringstream ss(version);
    std::string segment;
@@ -242,7 +250,7 @@ std::vector<int> FirmwareUpgrade::ParseVersion(const std::string& version) {
    return versionNumbers;
 }

-bool FirmwareUpgrade::IsNewVersionAvailable(const std::string& currentVersion, const std::string& newVersion) {
+bool Ota::IsNewVersionAvailable(const std::string& currentVersion, const std::string& newVersion) {
    std::vector<int> current = ParseVersion(currentVersion);
    std::vector<int> newer = ParseVersion(newVersion);
    
@@ -256,99 +264,3 @@ bool FirmwareUpgrade::IsNewVersionAvailable(const std::string& currentVersion, c
    
    return newer.size() > current.size();
 }
-
-void FirmwareUpgrade::SetBoardJson(const std::string& board_json) {
-    board_json_ = board_json;
-}
-
-std::string FirmwareUpgrade::GetPostData() {
-    /* 
-        {
-            "flash_size": 4194304,
-            "psram_size": 0,
-            "minimum_free_heap_size": 123456,
-            "mac_address": "00:00:00:00:00:00",
-            "chip_model_name": "esp32s3",
-            "chip_info": {
-                "model": 1,
-                "cores": 2,
-                "revision": 0,
-                "features": 0
-            },
-            "application": {
-                "name": "my-app",
-                "version": "1.0.0",
-                "compile_time": "2021-01-01T00:00:00Z"
-                "idf_version": "4.2-dev"
-                "elf_sha256": ""
-            },
-            "partition_table": [
-                "app": {
-                    "label": "app",
-                    "type": 1,
-                    "subtype": 2,
-                    "address": 0x10000,
-                    "size": 0x100000
-                }
-            ],
-            "ota": {
-                "label": "ota_0"
-            }
-        }
-    */
-    std::string json = "{";
-    json += "\"flash_size\":" + std::to_string(SystemInfo::GetFlashSize()) + ",";
-    json += "\"minimum_free_heap_size\":" + std::to_string(SystemInfo::GetMinimumFreeHeapSize()) + ",";
-    json += "\"mac_address\":\"" + SystemInfo::GetMacAddress() + "\",";
-    json += "\"chip_model_name\":\"" + SystemInfo::GetChipModelName() + "\",";
-    json += "\"chip_info\":{";
-
-    esp_chip_info_t chip_info;
-    esp_chip_info(&chip_info);
-    json += "\"model\":" + std::to_string(chip_info.model) + ",";
-    json += "\"cores\":" + std::to_string(chip_info.cores) + ",";
-    json += "\"revision\":" + std::to_string(chip_info.revision) + ",";
-    json += "\"features\":" + std::to_string(chip_info.features);
-    json += "},";
-
-    json += "\"application\":{";
-    auto app_desc = esp_app_get_description();
-    json += "\"name\":\"" + std::string(app_desc->project_name) + "\",";
-    json += "\"version\":\"" + std::string(app_desc->version) + "\",";
-    json += "\"compile_time\":\"" + std::string(app_desc->date) + "T" + std::string(app_desc->time) + "Z\",";
-    json += "\"idf_version\":\"" + std::string(app_desc->idf_ver) + "\",";
-
-    char sha256_str[65];
-    for (int i = 0; i < 32; i++) {
-        snprintf(sha256_str + i * 2, sizeof(sha256_str) - i * 2, "%02x", app_desc->app_elf_sha256[i]);
-    }
-    json += "\"elf_sha256\":\"" + std::string(sha256_str) + "\"";
-    json += "},";
-
-    json += "\"partition_table\": [";
-    esp_partition_iterator_t it = esp_partition_find(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, NULL);
-    while (it) {
-        const esp_partition_t *partition = esp_partition_get(it);
-        json += "{";
-        json += "\"label\":\"" + std::string(partition->label) + "\",";
-        json += "\"type\":" + std::to_string(partition->type) + ",";
-        json += "\"subtype\":" + std::to_string(partition->subtype) + ",";
-        json += "\"address\":" + std::to_string(partition->address) + ",";
-        json += "\"size\":" + std::to_string(partition->size);
-        json += "},";
-        it = esp_partition_next(it);
-    }
-    json.pop_back(); // Remove the last comma
-    json += "],";
-
-    json += "\"ota\":{";
-    auto ota_partition = esp_ota_get_running_partition();
-    json += "\"label\":\"" + std::string(ota_partition->label) + "\"";
-    json += "},";
-
-    json += "\"board\":" + board_json_;
-
-    // Close the JSON object
-    json += "}";
-    return json;
-}
--- a/main/FirmwareUpgrade.h
+++ b/main/FirmwareUpgrade.h
@@ -1,18 +1,18 @@
-#ifndef _FIRMWARE_UPGRADE_H
-#define _FIRMWARE_UPGRADE_H
+#ifndef _OTA_H
+#define _OTA_H

 #include <functional>
 #include <string>
 #include <map>

-class FirmwareUpgrade {
+class Ota {
 public:
-    FirmwareUpgrade();
-    ~FirmwareUpgrade();
+    Ota();
+    ~Ota();

-    void SetBoardJson(const std::string& board_json);
    void SetCheckVersionUrl(std::string check_version_url);
    void SetHeader(const std::string& key, const std::string& value);
+    void SetPostData(const std::string& post_data);
    void CheckVersion();
    bool HasNewVersion() { return has_new_version_; }
    void StartUpgrade(std::function<void(int progress, size_t speed)> callback);
@@ -23,14 +23,13 @@ private:
    bool has_new_version_ = false;
    std::string firmware_version_;
    std::string firmware_url_;
-    std::string board_json_;
+    std::string post_data_;
    std::map<std::string, std::string> headers_;

    void Upgrade(const std::string& firmware_url);
    std::function<void(int progress, size_t speed)> upgrade_callback_;
    std::vector<int> ParseVersion(const std::string& version);
    bool IsNewVersionAvailable(const std::string& currentVersion, const std::string& newVersion);
-    std::string GetPostData();
 };

-#endif // _FIRMWARE_UPGRADE_H
+#endif // _OTA_H
--- a/main/system_info.cc
+++ b/main/system_info.cc
@@ -1,4 +1,5 @@
-#include "SystemInfo.h"
+#include "system_info.h"
+
 #include <freertos/task.h>
 #include <esp_log.h>
 #include <esp_flash.h>
--- a/main/system_info.h
+++ b/main/system_info.h
--- a/main/system_reset.cc
+++ b/main/system_reset.cc
@@ -1,4 +1,5 @@
-#include "SystemReset.h"
+#include "system_reset.h"
+
 #include <esp_log.h>
 #include <nvs_flash.h>
 #include <driver/gpio.h>
--- a/main/system_reset.h
+++ b/main/system_reset.h
--- a/main/wake_word_detect.cc
+++ b/main/wake_word_detect.cc
@@ -1,10 +1,10 @@
+#include "wake_word_detect.h"
+#include "application.h"
+
 #include <esp_log.h>
 #include <model_path.h>
 #include <arpa/inet.h>

-#include "WakeWordDetect.h"
-#include "Application.h"
-
 #define DETECTION_RUNNING_EVENT 1
 #define WAKE_WORD_ENCODED_EVENT 2

@@ -26,6 +26,9 @@ WakeWordDetect::~WakeWordDetect() {
    if (wake_word_encode_task_stack_ != nullptr) {
        free(wake_word_encode_task_stack_);
    }
+    if (audio_detection_task_stack_ != nullptr) {
+        heap_caps_free(audio_detection_task_stack_);
+    }

    vEventGroupDelete(event_group_);
 }
@@ -77,11 +80,13 @@ void WakeWordDetect::Initialize(int channels, bool reference) {

    afe_detection_data_ = esp_afe_sr_v1.create_from_config(&afe_config);

-    xTaskCreate([](void* arg) {
+    const size_t audio_detection_task_stack_size = 4096 * 2;
+    audio_detection_task_stack_ = (StackType_t*)heap_caps_malloc(audio_detection_task_stack_size, MALLOC_CAP_SPIRAM);
+    xTaskCreateStatic([](void* arg) {
        auto this_ = (WakeWordDetect*)arg;
        this_->AudioDetectionTask();
        vTaskDelete(NULL);
-    }, "audio_detection", 4096 * 2, this, 1, NULL);
+    }, "audio_detection", audio_detection_task_stack_size, this, 1, audio_detection_task_stack_, &audio_detection_task_buffer_);
 }

 void WakeWordDetect::OnWakeWordDetected(std::function<void()> callback) {
--- a/main/wake_word_detect.h
+++ b/main/wake_word_detect.h
@@ -1,13 +1,13 @@
 #ifndef WAKE_WORD_DETECT_H
 #define WAKE_WORD_DETECT_H

-#include <esp_afe_sr_models.h>
-#include <esp_nsn_models.h>
-
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 #include <freertos/event_groups.h>

+#include <esp_afe_sr_models.h>
+#include <esp_nsn_models.h>
+
 #include <list>
 #include <string>
 #include <vector>
@@ -40,6 +40,10 @@ private:
    int channels_;
    bool reference_;

+    TaskHandle_t audio_detection_task_ = nullptr;
+    StaticTask_t audio_detection_task_buffer_;
+    StackType_t* audio_detection_task_stack_ = nullptr;
+
    TaskHandle_t wake_word_encode_task_ = nullptr;
    StaticTask_t wake_word_encode_task_buffer_;
    StackType_t* wake_word_encode_task_stack_ = nullptr;
--- a/release.py
+++ b/release.py
@@ -0,0 +1,48 @@
+import sys
+import os
+import json
+
+
+def get_board_type():
+    with open("build/compile_commands.json") as f:
+        data = json.load(f)
+        for item in data:
+            if not item["file"].endswith("main.cc"):
+                continue
+            command = item["command"]
+            # extract -DBOARD_TYPE=xxx
+            board_type = command.split("-DBOARD_TYPE=\\\"")[1].split("\\\"")[0].strip()
+            return board_type
+    return None
+
+def get_project_version():
+    with open("CMakeLists.txt") as f:
+        for line in f:
+            if line.startswith("set(PROJECT_VER"):
+                return line.split("\"")[1].split("\"")[0].strip()
+    return None
+
+def merge_bin():
+    if os.system("idf.py merge-bin") != 0:
+        print("merge bin failed")
+        sys.exit(1)
+
+def zip_bin(board_type, project_version):
+    if not os.path.exists("releases"):
+        os.makedirs("releases")
+    output_path = f"releases/v{project_version}_{board_type}.zip"
+    if os.path.exists(output_path):
+        os.remove(output_path)
+    if os.system(f"zip -j {output_path} build/merged-binary.bin") != 0:
+        print("zip bin failed")
+        sys.exit(1)
+    print(f"zip bin to {output_path} done")
+    
+
+if __name__ == "__main__":
+    merge_bin()
+    board_type = get_board_type()
+    print("board type:", board_type)
+    project_version = get_project_version()
+    print("project version:", project_version)
+    zip_bin(board_type, project_version)
--- a/sdkconfig.defaults
+++ b/sdkconfig.defaults
@@ -16,3 +16,6 @@ CONFIG_USE_MULTINET=n

 CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=y
 CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS=y
+
+CONFIG_LV_COLOR_16_SWAP=y
+CONFIG_LV_MEM_CUSTOM=y
--- a/versions.py
+++ b/versions.py
@@ -60,8 +60,12 @@ def get_board_name(folder):
    if basename.startswith("v0.3") or basename.startswith("v0.4") or basename.startswith("v0.5") or basename.startswith("v0.6"):
        if "ML307" in basename:
            return "bread-compact-ml307"
-        else:
+        elif "WiFi" in basename:
            return "bread-compact-wifi"
+        elif "KevinBox1" in basename:
+            return "kevin-box-1"
+    if basename.startswith("v0.7"):
+        return basename.split("_")[1]
    raise Exception(f"Unknown board name: {basename}")

 def read_binary(dir_path):
Author	SHA1	Message	Date
Terrence	35cd80feb7	fixbug: internal memory not enough	2024-11-06 22:48:21 +08:00
Terrence	20deb2b777	add st7789	2024-11-06 10:06:05 +08:00
Terrence	3575448373	move all hardware init to boards	2024-11-06 06:18:56 +08:00
Terrence	55ff4e1f74	move wifi/ml307 to boards folder	2024-11-06 03:40:49 +08:00
Terrence	82030d003d	rename CreateAudioDevice to GetAudioDevice	2024-11-05 21:17:56 +08:00
Terrence	458ac2c999	rename files	2024-11-05 20:15:00 +08:00
Terrence	bc4b0a0bb1	move audio enable/disable in ws connect/discconect	2024-11-05 16:50:29 +08:00
Terrence	8fccef2c52	remove unnecessary mutex (use Schedule)	2024-11-05 13:55:42 +08:00
Terrence	92efdc9b64	add Board::GetJson	2024-11-03 05:54:15 +08:00
Terrence	5006e5bda1	add ref resampler	2024-11-03 01:34:18 +08:00