bump to 0.6.2

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.5.0")
+set(PROJECT_VER "0.6.2")
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(xiaozhi)

convert_audio_to_p3.py

@@ -0,0 +1,40 @@
+# convert audio files to protocol v3 stream
+import librosa
+import opuslib
+import struct
+import sys
+import tqdm
+import numpy as np
+
+def encode_audio_to_opus(input_file, output_file):
+    # Load audio file using librosa
+    audio, sample_rate = librosa.load(input_file, sr=None, mono=False, dtype=np.int16)
+    
+    # Get left channel if stereo
+    if audio.ndim == 2:
+        audio = audio[0]
+    
+    # Initialize Opus encoder
+    encoder = opuslib.Encoder(sample_rate, 1, opuslib.APPLICATION_VOIP)
+
+    # Encode audio data to Opus packets
+    # Save encoded data to file
+    with open(output_file, 'wb') as f:
+        sample_rate = 16000 # 16000Hz
+        duration = 60 # 60ms every frame
+        frame_size = int(sample_rate * duration / 1000)
+        for i in tqdm.tqdm(range(0, len(audio) - frame_size, frame_size)):
+            frame = audio[i:i + frame_size]
+            opus_data = encoder.encode(frame.tobytes(), frame_size=frame_size)
+            # protocol format, [1u type, 1u reserved, 2u len, data]
+            packet = struct.pack('>BBH', 0, 0, len(opus_data)) + opus_data
+            f.write(packet)
+
+# Example usage
+if len(sys.argv) != 3:
+    print('Usage: python convert.py <input_file> <output_file>')
+    sys.exit(1)
+
+input_file = sys.argv[1]
+output_file = sys.argv[2]
+encode_audio_to_opus(input_file, output_file)

main/Application.cc

@@ -14,6 +14,13 @@
 
 #define TAG "Application"
 
+extern const char p3_err_reg_start[] asm("_binary_err_reg_p3_start");
+extern const char p3_err_reg_end[] asm("_binary_err_reg_p3_end");
+extern const char p3_err_pin_start[] asm("_binary_err_pin_p3_start");
+extern const char p3_err_pin_end[] asm("_binary_err_pin_p3_end");
+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),
@@ -48,7 +55,10 @@ Application::~Application() {
         opus_decoder_destroy(opus_decoder_);
     }
     if (audio_encode_task_stack_ != nullptr) {
-        free(audio_encode_task_stack_);
+        heap_caps_free(audio_encode_task_stack_);
+    }
+    if (main_loop_task_stack_ != nullptr) {
+        heap_caps_free(main_loop_task_stack_);
     }
     if (audio_device_ != nullptr) {
         delete audio_device_;
@@ -80,6 +90,41 @@ void Application::CheckNewVersion() {
     }
 }
 
+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));
+
+    if (message == "PIN is not ready") {
+        PlayLocalFile(p3_err_pin_start, p3_err_pin_end - p3_err_pin_start);
+    } else if (message == "Configuring WiFi") {
+        PlayLocalFile(p3_err_wificonfig_start, p3_err_wificonfig_end - p3_err_wificonfig_start);
+    } else if (message == "Registration denied") {
+        PlayLocalFile(p3_err_reg_start, p3_err_reg_end - p3_err_reg_start);
+    }
+}
+
+void Application::PlayLocalFile(const char* data, size_t size) {
+    ESP_LOGI(TAG, "PlayLocalFile: %zu bytes", size);
+    SetDecodeSampleRate(16000);
+
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto packet = new AudioPacket();
+        packet->type = kAudioPacketTypeStart;
+        audio_decode_queue_.push_back(packet);
+    }
+
+    ParseBinaryProtocol3(data, size);
+
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto packet = new AudioPacket();
+        packet->type = kAudioPacketTypeStop;
+        audio_decode_queue_.push_back(packet);
+        cv_.notify_all();
+    }
+}
+
 void Application::Start() {
     auto& builtin_led = BuiltinLed::GetInstance();
     builtin_led.SetBlue();
@@ -90,6 +135,8 @@ void Application::Start() {
 
     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) {
@@ -134,7 +181,7 @@ void Application::Start() {
 
     // OPUS encoder / decoder use a lot of stack memory
     const size_t opus_stack_size = 4096 * 8;
-    audio_encode_task_stack_ = (StackType_t*)malloc(opus_stack_size);
+    audio_encode_task_stack_ = (StackType_t*)heap_caps_malloc(opus_stack_size, MALLOC_CAP_SPIRAM);
     audio_encode_task_ = xTaskCreateStatic([](void* arg) {
         Application* app = (Application*)arg;
         app->AudioEncodeTask();
@@ -147,68 +194,7 @@ void Application::Start() {
         vTaskDelete(NULL);
     }, "play_audio", 4096 * 4, this, 4, NULL);
 
-#ifdef CONFIG_USE_AFE_SR
-    wake_word_detect_.Initialize(audio_device_->input_channels(), audio_device_->input_reference());
-    wake_word_detect_.OnVadStateChange([this](bool speaking) {
-        Schedule([this, speaking]() {
-            auto& builtin_led = BuiltinLed::GetInstance();
-            if (chat_state_ == kChatStateListening) {
-                if (speaking) {
-                    builtin_led.SetRed(32);
-                } else {
-                    builtin_led.SetRed(8);
-                }
-                builtin_led.TurnOn();
-            }
-        });
-    });
-
-    wake_word_detect_.OnWakeWordDetected([this]() {
-        Schedule([this]() {
-            if (chat_state_ == kChatStateIdle) {
-                // Encode the wake word data and start websocket client at the same time
-                // They both consume a lot of time (700ms), so we can do them in parallel
-                wake_word_detect_.EncodeWakeWordData();
-
-                SetChatState(kChatStateConnecting);
-                if (ws_client_ == nullptr) {
-                    StartWebSocketClient();
-                }
-                if (ws_client_ && ws_client_->IsConnected()) {
-                    auto encoded = wake_word_detect_.GetWakeWordStream();
-                    // Send the wake word data to the server
-                    ws_client_->Send(encoded.data(), encoded.size(), true);
-                    opus_encoder_.ResetState();
-                    // Send a ready message to indicate the server that the wake word data is sent
-                    SetChatState(kChatStateWakeWordDetected);
-                    // If connected, the hello message is already sent, so we can start communication
-                    audio_processor_.Start();
-                    ESP_LOGI(TAG, "Audio processor started");
-                } else {
-                    SetChatState(kChatStateIdle);
-                }
-            } else if (chat_state_ == kChatStateSpeaking) {
-                break_speaking_ = true;
-            }
-
-            // Resume detection
-            wake_word_detect_.StartDetection();
-        });
-    });
-    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
-
+    board.StartNetwork();
     // Blink the LED to indicate the device is running
     builtin_led.SetGreen();
     builtin_led.BlinkOnce();
@@ -230,7 +216,7 @@ void Application::Start() {
                     SetChatState(kChatStateIdle);
                 }
             } else if (chat_state_ == kChatStateSpeaking) {
-                break_speaking_ = true;
+                AbortSpeaking();
             } else if (chat_state_ == kChatStateListening) {
                 if (ws_client_ && ws_client_->IsConnected()) {
                     ws_client_->Close();
@@ -275,11 +261,13 @@ void Application::Start() {
         });
     });
 
-    xTaskCreate([](void* arg) {
+    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);
+    xTaskCreateStatic([](void* arg) {
         Application* app = (Application*)arg;
         app->MainLoop();
         vTaskDelete(NULL);
-    }, "main_loop", 4096 * 2, this, 5, NULL);
+    }, "main_loop", main_loop_stack_size, this, 1, main_loop_task_stack_, &main_loop_task_buffer_);
 
     // Launch a task to check for new firmware version
     xTaskCreate([](void* arg) {
@@ -288,7 +276,69 @@ void Application::Start() {
         vTaskDelete(NULL);
     }, "check_new_version", 4096 * 2, this, 1, NULL);
 
-    chat_state_ = kChatStateIdle;
+#ifdef CONFIG_USE_AFE_SR
+    wake_word_detect_.Initialize(audio_device_->input_channels(), audio_device_->input_reference());
+    wake_word_detect_.OnVadStateChange([this](bool speaking) {
+        Schedule([this, speaking]() {
+            auto& builtin_led = BuiltinLed::GetInstance();
+            if (chat_state_ == kChatStateListening) {
+                if (speaking) {
+                    builtin_led.SetRed(32);
+                } else {
+                    builtin_led.SetRed(8);
+                }
+                builtin_led.TurnOn();
+            }
+        });
+    });
+
+    wake_word_detect_.OnWakeWordDetected([this]() {
+        Schedule([this]() {
+            if (chat_state_ == kChatStateIdle) {
+                // Encode the wake word data and start websocket client at the same time
+                // They both consume a lot of time (700ms), so we can do them in parallel
+                wake_word_detect_.EncodeWakeWordData();
+
+                SetChatState(kChatStateConnecting);
+                if (ws_client_ == nullptr) {
+                    StartWebSocketClient();
+                }
+                if (ws_client_ && ws_client_->IsConnected()) {
+                    auto encoded = wake_word_detect_.GetWakeWordStream();
+                    // Send the wake word data to the server
+                    ws_client_->Send(encoded.data(), encoded.size(), true);
+                    opus_encoder_.ResetState();
+                    // Send a ready message to indicate the server that the wake word data is sent
+                    SetChatState(kChatStateWakeWordDetected);
+                    // If connected, the hello message is already sent, so we can start communication
+                    audio_processor_.Start();
+                    ESP_LOGI(TAG, "Audio processor started");
+                } else {
+                    SetChatState(kChatStateIdle);
+                }
+            } else if (chat_state_ == kChatStateSpeaking) {
+                AbortSpeaking();
+            }
+
+            // Resume detection
+            wake_word_detect_.StartDetection();
+        });
+    });
+    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();
 }
 
@@ -314,6 +364,22 @@ void Application::MainLoop() {
     }
 }
 
+void Application::AbortSpeaking() {
+    ESP_LOGI(TAG, "Abort speaking");
+    skip_to_end_ = true;
+
+    if (ws_client_ && ws_client_->IsConnected()) {
+        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);
+    }
+}
+
 void Application::SetChatState(ChatState state) {
     const char* state_str[] = {
         "unknown",
@@ -326,6 +392,10 @@ void Application::SetChatState(ChatState state) {
         "upgrading",
         "invalid_state"
     };
+    if (chat_state_ == state) {
+        // No need to update the state
+        return;
+    }
     chat_state_ = state;
     ESP_LOGI(TAG, "STATE: %s", state_str[chat_state_]);
 
@@ -334,6 +404,7 @@ void Application::SetChatState(ChatState state) {
         case kChatStateUnknown:
         case kChatStateIdle:
             builtin_led.TurnOff();
+            audio_device_->EnableOutput(false);
             break;
         case kChatStateConnecting:
             builtin_led.SetBlue();
@@ -346,6 +417,7 @@ void Application::SetChatState(ChatState state) {
         case kChatStateSpeaking:
             builtin_led.SetGreen();
             builtin_led.TurnOn();
+            audio_device_->EnableOutput(true);
             break;
         case kChatStateWakeWordDetected:
             builtin_led.SetBlue();
@@ -370,15 +442,12 @@ void Application::SetChatState(ChatState state) {
     }
 }
 
-BinaryProtocol* Application::AllocateBinaryProtocol(const uint8_t* payload, size_t payload_size) {
-    auto last_timestamp = 0;
-    auto protocol = (BinaryProtocol*)heap_caps_malloc(sizeof(BinaryProtocol) + payload_size, MALLOC_CAP_SPIRAM);
-    protocol->version = htons(PROTOCOL_VERSION);
-    protocol->type = htons(0);
+BinaryProtocol3* Application::AllocateBinaryProtocol3(const uint8_t* payload, size_t payload_size) {
+    auto protocol = (BinaryProtocol3*)heap_caps_malloc(sizeof(BinaryProtocol3) + payload_size, MALLOC_CAP_SPIRAM);
+    protocol->type = 0;
     protocol->reserved = 0;
-    protocol->timestamp = htonl(last_timestamp);
-    protocol->payload_size = htonl(payload_size);
-    assert(sizeof(BinaryProtocol) == 16);
+    protocol->payload_size = htons(payload_size);
+    assert(sizeof(BinaryProtocol3) == 4UL);
     memcpy(protocol->payload, payload, payload_size);
     return protocol;
 }
@@ -400,10 +469,10 @@ void Application::AudioEncodeTask() {
 
             // Encode audio data
             opus_encoder_.Encode(pcm, [this](const uint8_t* opus, size_t opus_size) {
-                auto protocol = AllocateBinaryProtocol(opus, opus_size);
+                auto protocol = AllocateBinaryProtocol3(opus, opus_size);
                 Schedule([this, protocol, opus_size]() {
                     if (ws_client_ && ws_client_->IsConnected()) {
-                        if (!ws_client_->Send(protocol, sizeof(BinaryProtocol) + opus_size, true)) {
+                        if (!ws_client_->Send(protocol, sizeof(BinaryProtocol3) + opus_size, true)) {
                             ESP_LOGE(TAG, "Failed to send audio data");
                         }
                     }
@@ -415,21 +484,23 @@ void Application::AudioEncodeTask() {
             audio_decode_queue_.pop_front();
             lock.unlock();
 
-            int frame_size = opus_decode_sample_rate_ * opus_duration_ms_ / 1000;
-            packet->pcm.resize(frame_size);
+            if (packet->type == kAudioPacketTypeData && !skip_to_end_) {
+                int frame_size = opus_decode_sample_rate_ * opus_duration_ms_ / 1000;
+                packet->pcm.resize(frame_size);
 
-            int ret = opus_decode(opus_decoder_, packet->opus.data(), packet->opus.size(), packet->pcm.data(), frame_size, 0);
-            if (ret < 0) {
-                ESP_LOGE(TAG, "Failed to decode audio, error code: %d", ret);
-                delete packet;
-                continue;
-            }
+                int ret = opus_decode(opus_decoder_, packet->opus.data(), packet->opus.size(), packet->pcm.data(), frame_size, 0);
+                if (ret < 0) {
+                    ESP_LOGE(TAG, "Failed to decode audio, error code: %d", ret);
+                    delete packet;
+                    continue;
+                }
 
-            if (opus_decode_sample_rate_ != AUDIO_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());
-                packet->pcm = std::move(resampled);
+                if (opus_decode_sample_rate_ != AUDIO_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());
+                    packet->pcm = std::move(resampled);
+                }
             }
 
             std::lock_guard<std::mutex> lock(mutex_);
@@ -449,16 +520,6 @@ void Application::HandleAudioPacket(AudioPacket* packet) {
 
         // This will block until the audio device has finished playing the audio
         audio_device_->OutputData(packet->pcm);
-
-        if (break_speaking_) {
-            skip_to_end_ = true;
-            
-            // Play a silence and skip to the end
-            int frame_size = opus_decode_sample_rate_ / 1000 * opus_duration_ms_;
-            std::vector<int16_t> silence(frame_size);
-            bzero(silence.data(), silence.size() * sizeof(int16_t));
-            audio_device_->OutputData(silence);
-        }
         break;
     }
     case kAudioPacketTypeStart:
@@ -470,13 +531,20 @@ void Application::HandleAudioPacket(AudioPacket* packet) {
         break;
     case kAudioPacketTypeStop:
         Schedule([this]() {
-            SetChatState(kChatStateListening);
+            if (ws_client_ && ws_client_->IsConnected()) {
+                SetChatState(kChatStateListening);
+            } else {
+                SetChatState(kChatStateIdle);
+            }
         });
         break;
     case kAudioPacketTypeSentenceStart:
         ESP_LOGI(TAG, "<< %s", packet->text.c_str());
         break;
     case kAudioPacketTypeSentenceEnd:
+        if (break_speaking_) {
+            skip_to_end_ = true;
+        }
         break;
     default:
         ESP_LOGI(TAG, "Unknown packet type: %d", packet->type);
@@ -517,6 +585,23 @@ void Application::SetDecodeSampleRate(int sample_rate) {
     }
 }
 
+void Application::ParseBinaryProtocol3(const char* data, size_t size) {
+    for (const char* p = data; p < data + size; ) {
+        auto protocol = (BinaryProtocol3*)p;
+        p += sizeof(BinaryProtocol3);
+
+        auto packet = new AudioPacket();
+        packet->type = kAudioPacketTypeData;
+        auto payload_size = ntohs(protocol->payload_size);
+        packet->opus.resize(payload_size);
+        memcpy(packet->opus.data(), protocol->payload, payload_size);
+        p += payload_size;
+
+        std::lock_guard<std::mutex> lock(mutex_);
+        audio_decode_queue_.push_back(packet);
+    }
+}
+
 void Application::StartWebSocketClient() {
     if (ws_client_ != nullptr) {
         ESP_LOGW(TAG, "WebSocket client already exists");
@@ -545,17 +630,7 @@ void Application::StartWebSocketClient() {
 
     ws_client_->OnData([this](const char* data, size_t len, bool binary) {
         if (binary) {
-            auto protocol = (BinaryProtocol*)data;
-
-            auto packet = new AudioPacket();
-            packet->type = kAudioPacketTypeData;
-            packet->timestamp = ntohl(protocol->timestamp);
-            auto payload_size = ntohl(protocol->payload_size);
-            packet->opus.resize(payload_size);
-            memcpy(packet->opus.data(), protocol->payload, payload_size);
-
-            std::lock_guard<std::mutex> lock(mutex_);
-            audio_decode_queue_.push_back(packet);
+            ParseBinaryProtocol3(data, len);
             cv_.notify_all();
         } else {
             // Parse JSON data
@@ -572,8 +647,7 @@ void Application::StartWebSocketClient() {
                             SetDecodeSampleRate(sample_rate->valueint);
                         }
 
-                        // If the device is speaking, we need to break the speaking
-                        break_speaking_ = true;
+                        // If the device is speaking, we need to skip the last session
                         skip_to_end_ = true;
                     } else if (strcmp(state->valuestring, "stop") == 0) {
                         packet->type = kAudioPacketTypeStop;

main/Application.h

@@ -28,13 +28,11 @@
 #define DETECTION_RUNNING 1
 #define COMMUNICATION_RUNNING 2
 
-#define PROTOCOL_VERSION 2
-struct BinaryProtocol {
-    uint16_t version;
-    uint16_t type;
-    uint32_t reserved;
-    uint32_t timestamp;
-    uint32_t payload_size;
+#define PROTOCOL_VERSION 3
+struct BinaryProtocol3 {
+    uint8_t type;
+    uint8_t reserved;
+    uint16_t payload_size;
     uint8_t payload[];
 } __attribute__((packed));
 
@@ -78,7 +76,8 @@ public:
     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();
     // 删除拷贝构造函数和赋值运算符
     Application(const Application&) = delete;
     Application& operator=(const Application&) = delete;
@@ -123,12 +122,13 @@ private:
     OpusResampler input_resampler_;
     OpusResampler output_resampler_;
 
-    TaskHandle_t check_new_version_task_ = nullptr;
-    StaticTask_t check_new_version_task_buffer_;
-    StackType_t* check_new_version_task_stack_ = nullptr;
+    TaskHandle_t main_loop_task_ = nullptr;
+    StaticTask_t main_loop_task_buffer_;
+    StackType_t* main_loop_task_stack_ = nullptr;
 
     void MainLoop();
-    BinaryProtocol* AllocateBinaryProtocol(const uint8_t* payload, size_t payload_size);
+    BinaryProtocol3* AllocateBinaryProtocol3(const uint8_t* payload, size_t payload_size);
+    void ParseBinaryProtocol3(const char* data, size_t size);
     void SetDecodeSampleRate(int sample_rate);
     void StartWebSocketClient();
     void CheckNewVersion();
@@ -136,6 +136,7 @@ private:
     void AudioEncodeTask();
     void AudioPlayTask();
     void HandleAudioPacket(AudioPacket* packet);
+    void PlayLocalFile(const char* data, size_t size);
 };
 
 #endif // _APPLICATION_H_

main/AudioDevice.cc

@@ -95,7 +95,7 @@ void AudioDevice::CreateSimplexChannels() {
         .role = I2S_ROLE_MASTER,
         .dma_desc_num = 6,
         .dma_frame_num = 240,
-        .auto_clear_after_cb = false,
+        .auto_clear_after_cb = true,
         .auto_clear_before_cb = false,
         .intr_priority = 0,
     };
@@ -176,15 +176,15 @@ int AudioDevice::Write(const int16_t* data, int samples) {
 int AudioDevice::Read(int16_t* dest, int samples) {
     size_t bytes_read;
 
-    int32_t bit32_buffer_[samples];
-    if (i2s_channel_read(rx_handle_, bit32_buffer_, samples * sizeof(int32_t), &bytes_read, portMAX_DELAY) != ESP_OK) {
+    int32_t bit32_buffer[samples];
+    if (i2s_channel_read(rx_handle_, bit32_buffer, samples * sizeof(int32_t), &bytes_read, portMAX_DELAY) != ESP_OK) {
         ESP_LOGE(TAG, "Read Failed!");
         return 0;
     }
 
     samples = bytes_read / sizeof(int32_t);
     for (int i = 0; i < samples; i++) {
-        int32_t value = bit32_buffer_[i] >> 12;
+        int32_t value = bit32_buffer[i] >> 12;
         dest[i] = (value > INT16_MAX) ? INT16_MAX : (value < -INT16_MAX) ? -INT16_MAX : (int16_t)value;
     }
     return samples;
@@ -224,3 +224,19 @@ 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");
+}

main/AudioDevice.h

@@ -17,6 +17,8 @@ public:
     void OnInputData(std::function<void(std::vector<int16_t>&& data)> callback);
     void OutputData(std::vector<int16_t>& data);
     virtual void SetOutputVolume(int volume);
+    virtual void EnableInput(bool enable);
+    virtual void EnableOutput(bool enable);
 
     inline bool duplex() const { return duplex_; }
     inline bool input_reference() const { return input_reference_; }
@@ -36,6 +38,8 @@ private:
 protected:
     bool duplex_ = false;
     bool input_reference_ = false;
+    bool input_enabled_ = false;
+    bool output_enabled_ = false;
     int input_sample_rate_ = 0;
     int output_sample_rate_ = 0;
     int input_channels_ = 1;

main/Board.cc

@@ -2,3 +2,7 @@
 #include <esp_log.h>
 
 // static const char *TAG = "Board";
+
+bool Board::GetBatteryVoltage(int &voltage, bool& charging) {
+    return false;
+}

main/Board.h

@@ -20,11 +20,13 @@ public:
     }
 
     virtual void Initialize() = 0;
+    virtual void StartNetwork() = 0;
     virtual ~Board() = default;
     virtual AudioDevice* CreateAudioDevice() = 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:

main/BoxAudioDevice.cc

@@ -32,7 +32,7 @@ void BoxAudioDevice::Initialize() {
 
     // Initialize I2C peripheral
     i2c_master_bus_config_t i2c_bus_cfg = {
-        .i2c_port = I2C_NUM_0,
+        .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,
@@ -47,6 +47,28 @@ void BoxAudioDevice::Initialize() {
 
     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
+
     // Do initialize of related interface: data_if, ctrl_if and gpio_if
     audio_codec_i2s_cfg_t i2s_cfg = {
         .port = I2S_NUM_0,
@@ -58,8 +80,8 @@ void BoxAudioDevice::Initialize() {
 
     // Output
     audio_codec_i2c_cfg_t i2c_cfg = {
-        .port = I2C_NUM_0,
-        .addr = ES8311_CODEC_DEFAULT_ADDR,
+        .port = I2C_NUM_1,
+        .addr = AUDIO_CODEC_ES8311_ADDR,
         .bus_handle = i2c_master_handle_,
     };
     out_ctrl_if_ = audio_codec_new_i2c_ctrl(&i2c_cfg);
@@ -87,20 +109,8 @@ void BoxAudioDevice::Initialize() {
     output_dev_ = esp_codec_dev_new(&dev_cfg);
     assert(output_dev_ != NULL);
 
-    ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, output_volume_));
-
-    // Play 16bit 1 channel
-    esp_codec_dev_sample_info_t fs = {
-        .bits_per_sample = 16,
-        .channel = 1,
-        .channel_mask = 0,
-        .sample_rate = (uint32_t)output_sample_rate_,
-        .mclk_multiple = 0,
-    };
-    ESP_ERROR_CHECK(esp_codec_dev_open(output_dev_, &fs));
-
     // Input
-    i2c_cfg.addr = ES7210_CODEC_DEFAULT_ADDR;
+    i2c_cfg.addr = AUDIO_CODEC_ES7210_ADDR;
     in_ctrl_if_ = audio_codec_new_i2c_ctrl(&i2c_cfg);
     assert(in_ctrl_if_ != NULL);
 
@@ -115,16 +125,6 @@ void BoxAudioDevice::Initialize() {
     input_dev_ = esp_codec_dev_new(&dev_cfg);
     assert(input_dev_ != NULL);
 
-    fs.channel = 4;
-    if (input_channels_ == 1) {
-        fs.channel_mask = ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0);
-    } else {
-        fs.channel_mask = ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0) | ESP_CODEC_DEV_MAKE_CHANNEL_MASK(1);
-    }
-    ESP_ERROR_CHECK(esp_codec_dev_open(input_dev_, &fs));
-
-    ESP_ERROR_CHECK(esp_codec_dev_set_in_channel_gain(input_dev_, ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0), 30.0));
-
     ESP_LOGI(TAG, "BoxAudioDevice initialized");
 }
 
@@ -219,12 +219,16 @@ void BoxAudioDevice::CreateDuplexChannels() {
 }
 
 int BoxAudioDevice::Read(int16_t *buffer, int samples) {
-    ESP_ERROR_CHECK(esp_codec_dev_read(input_dev_, (void*)buffer, samples * sizeof(int16_t)));
+    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) {
-    ESP_ERROR_CHECK(esp_codec_dev_write(output_dev_, (void*)buffer, samples * sizeof(int16_t)));
+    if (output_enabled_) {
+        ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void*)buffer, samples * sizeof(int16_t)));
+    }
     return samples;
 }
 
@@ -232,3 +236,47 @@ void BoxAudioDevice::SetOutputVolume(int volume) {
     ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, volume));
     AudioDevice::SetOutputVolume(volume);
 }
+
+void BoxAudioDevice::EnableInput(bool enable) {
+    if (enable == input_enabled_) {
+        return;
+    }
+    if (enable) {
+        esp_codec_dev_sample_info_t fs = {
+            .bits_per_sample = 16,
+            .channel = 4,
+            .channel_mask = ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0),
+            .sample_rate = (uint32_t)output_sample_rate_,
+            .mclk_multiple = 0,
+        };
+        if (input_reference_) {
+            fs.channel_mask |= ESP_CODEC_DEV_MAKE_CHANNEL_MASK(1);
+        }
+        ESP_ERROR_CHECK(esp_codec_dev_open(input_dev_, &fs));
+        ESP_ERROR_CHECK(esp_codec_dev_set_in_channel_gain(input_dev_, ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0), 30.0));
+    } else {
+        ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
+    }
+    AudioDevice::EnableInput(enable);
+}
+
+void BoxAudioDevice::EnableOutput(bool enable) {
+    if (enable == output_enabled_) {
+        return;
+    }
+    if (enable) {
+        // Play 16bit 1 channel
+        esp_codec_dev_sample_info_t fs = {
+            .bits_per_sample = 16,
+            .channel = 1,
+            .channel_mask = 0,
+            .sample_rate = (uint32_t)output_sample_rate_,
+            .mclk_multiple = 0,
+        };
+        ESP_ERROR_CHECK(esp_codec_dev_open(output_dev_, &fs));
+        ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, output_volume_));
+    } else {
+        ESP_ERROR_CHECK(esp_codec_dev_close(output_dev_));
+    }
+    AudioDevice::EnableOutput(enable);
+}

main/BoxAudioDevice.h

@@ -12,8 +12,10 @@ class BoxAudioDevice : public AudioDevice {
 public:
     BoxAudioDevice();
     virtual ~BoxAudioDevice();
-    void Initialize() override;
-    void SetOutputVolume(int volume) override;
+    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;

main/CMakeLists.txt

@@ -38,6 +38,20 @@ elseif(CONFIG_BOARD_TYPE_KEVIN_BOX_0)
     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()
 
 if(CONFIG_USE_AFE_SR)
@@ -45,6 +59,7 @@ if(CONFIG_USE_AFE_SR)
 endif()
 
 idf_component_register(SRCS ${SOURCES}
+                    EMBED_FILES "assets/err_reg.p3" "assets/err_pin.p3" "assets/err_wificonfig.p3"
                     INCLUDE_DIRS ${INCLUDE_DIRS}
                     )
 

main/Display.cc

@@ -17,15 +17,14 @@ Display::Display(int sda_pin, int scl_pin) : sda_pin_(sda_pin), scl_pin_(scl_pin
         ESP_LOGI(TAG, "Display not connected");
         return;
     }
-    ESP_LOGI(TAG, "Display Pins: %d, %d", sda_pin_, scl_pin_);
 
     i2c_master_bus_config_t bus_config = {
-        .i2c_port = I2C_NUM_1,
+        .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 = 1,
+        .intr_priority = 0,
         .trans_queue_depth = 0,
         .flags = {
             .enable_internal_pullup = 1,
@@ -47,7 +46,7 @@ Display::Display(int sda_pin, int scl_pin) : sda_pin_(sda_pin), scl_pin_(scl_pin
             .dc_low_on_data = 0,
             .disable_control_phase = 0,
         },
-        .scl_speed_hz = 400 * 1000,
+        .scl_speed_hz = 100 * 1000,
     };
 
     ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c_v2(i2c_bus_, &io_config, &panel_io_));
@@ -71,7 +70,6 @@ Display::Display(int sda_pin, int scl_pin) : sda_pin_(sda_pin), scl_pin_(scl_pin
         ESP_LOGE(TAG, "Failed to initialize display");
         return;
     }
-    ESP_ERROR_CHECK(esp_lcd_panel_mirror(panel_, true, true));
 
     ESP_LOGI(TAG, "Initialize LVGL");
     lvgl_port_cfg_t port_cfg = ESP_LVGL_PORT_INIT_CONFIG();
@@ -94,8 +92,8 @@ Display::Display(int sda_pin, int scl_pin) : sda_pin_(sda_pin), scl_pin_(scl_pin
         .monochrome = true,
         .rotation = {
             .swap_xy = false,
-            .mirror_x = true,
-            .mirror_y = true,
+            .mirror_x = DISPLAY_MIRROR_X,
+            .mirror_y = DISPLAY_MIRROR_Y,
         },
         .flags = {
             .buff_dma = 1,
@@ -220,8 +218,19 @@ void Display::UpdateDisplay() {
         if (!board.GetNetworkState(network_name, signal_quality, signal_quality_text)) {
             text = "No network";
         } else {
-            ESP_LOGI(TAG, "%s CSQ: %d", network_name.c_str(), signal_quality);
-            text = network_name + "\n" + signal_quality_text + " (" + std::to_string(signal_quality) + ")";
+            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);
     }

main/Kconfig.projbuild

@@ -31,6 +31,10 @@ choice BOARD_TYPE
         bool "ESP BOX 3"
     config BOARD_TYPE_KEVIN_BOX_0
         bool "Kevin Box 0"
+    config BOARD_TYPE_KEVIN_BOX_1
+        bool "Kevin Box 1"
+    config BOARD_TYPE_LICHUANG_DEV
+        bool "立创开发板"
 endchoice
 
 config USE_AFE_SR

main/Ml307Board.cc

@@ -30,28 +30,39 @@ static std::string csq_to_string(int csq) {
 Ml307Board::Ml307Board() : modem_(ML307_TX_PIN, ML307_RX_PIN, 4096) {
 }
 
-void Ml307Board::StartModem() {
+void Ml307Board::StartNetwork() {
     auto& application = Application::GetInstance();
     auto& display = application.GetDisplay();
-    modem_.SetDebug(false);
-    modem_.SetBaudRate(921600);
+    display.SetText(std::string("Wait for network\n"));
+    int result = modem_.WaitForNetworkReady();
+    if (result == -1) {
+        application.Alert("Error", "PIN is not ready");
+    } else if (result == -2) {
+        application.Alert("Error", "Registration denied");
+    }
+
     // Print the ML307 modem information
     std::string module_name = modem_.GetModuleName();
-    ESP_LOGI(TAG, "ML307 Module: %s", module_name.c_str());
-    display.SetText(std::string("Wait for network\n") + module_name);
-    modem_.ResetConnections();
-    modem_.WaitForNetworkReady();
-
     std::string imei = modem_.GetImei();
     std::string iccid = modem_.GetIccid();
+    ESP_LOGI(TAG, "ML307 Module: %s", module_name.c_str());
     ESP_LOGI(TAG, "ML307 IMEI: %s", imei.c_str());
     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([&application]() {
+    modem_.OnMaterialReady([this, &application]() {
         ESP_LOGI(TAG, "ML307 material ready");
-        application.Schedule([&application]() {
+        application.Schedule([this, &application]() {
             application.SetChatState(kChatStateIdle);
+            StartNetwork();
         });
     });
 }
@@ -74,6 +85,9 @@ WebSocket* Ml307Board::CreateWebSocket() {
 }
 
 bool Ml307Board::GetNetworkState(std::string& network_name, int& signal_quality, std::string& signal_quality_text) {
+    if (!modem_.network_ready()) {
+        return false;
+    }
     network_name = modem_.GetCarrierName();
     signal_quality = modem_.GetCsq();
     signal_quality_text = csq_to_string(signal_quality);

main/Ml307Board.h

@@ -13,6 +13,7 @@ protected:
 public:
     Ml307Board();
     virtual void Initialize() override;
+    virtual void StartNetwork() override;
     virtual AudioDevice* CreateAudioDevice() override;
     virtual Http* CreateHttp() override;
     virtual WebSocket* CreateWebSocket() override;

main/SystemReset.cc

@@ -41,6 +41,10 @@ void SystemReset::ResetNvsFlash() {
     if (ret != ESP_OK) {
         ESP_LOGE(TAG, "Failed to erase NVS flash");
     }
+    ret = nvs_flash_init();
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to initialize NVS flash");
+    }
 }
 
 void SystemReset::ResetToFactory() {

main/WakeWordDetect.cc

@@ -180,14 +180,12 @@ void WakeWordDetect::EncodeWakeWordData() {
 
         for (auto& pcm: this_->wake_word_pcm_) {
             encoder->Encode(pcm, [this_, &offset](const uint8_t* opus, size_t opus_size) {
-                size_t protocol_size = sizeof(BinaryProtocol) + opus_size;
+                size_t protocol_size = sizeof(BinaryProtocol3) + opus_size;
                 if (offset + protocol_size < this_->wake_word_opus_.size()) {
-                    auto protocol = (BinaryProtocol*)(&this_->wake_word_opus_[offset]);
-                    protocol->version = htons(PROTOCOL_VERSION);
-                    protocol->type = htons(0);
+                    auto protocol = (BinaryProtocol3*)(&this_->wake_word_opus_[offset]);
+                    protocol->type = 0;
                     protocol->reserved = 0;
-                    protocol->timestamp = 0;
-                    protocol->payload_size = htonl(opus_size);
+                    protocol->payload_size = htons(opus_size);
                     memcpy(protocol->payload, opus, opus_size);
                     offset += protocol_size;
                 }

main/WifiBoard.cc

@@ -29,7 +29,7 @@ static std::string rssi_to_string(int rssi) {
     }
 }
 
-void WifiBoard::StartWifi() {
+void WifiBoard::StartNetwork() {
     auto& application = Application::GetInstance();
     auto& display = application.GetDisplay();
     auto& builtin_led = BuiltinLed::GetInstance();
@@ -39,13 +39,13 @@ void WifiBoard::StartWifi() {
     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);
         auto& wifi_ap = WifiConfigurationAp::GetInstance();
         wifi_ap.SetSsidPrefix("Xiaozhi");
-        display.SetText(wifi_ap.GetSsid() + "\n" + wifi_ap.GetWebServerUrl());
         wifi_ap.Start();
-        // Wait until the WiFi configuration is finished
+        // Wait forever until reset after configuration
         while (true) {
             vTaskDelay(pdMS_TO_TICKS(1000));
         }
@@ -54,7 +54,6 @@ void WifiBoard::StartWifi() {
 
 void WifiBoard::Initialize() {
     ESP_LOGI(TAG, "Initializing WifiBoard");
-    StartWifi();
 }
 
 Http* WifiBoard::CreateHttp() {
@@ -71,6 +70,13 @@ WebSocket* WifiBoard::CreateWebSocket() {
 }
 
 bool WifiBoard::GetNetworkState(std::string& network_name, int& signal_quality, std::string& signal_quality_text) {
+    if (wifi_config_mode_) {
+        auto& wifi_ap = WifiConfigurationAp::GetInstance();
+        network_name = wifi_ap.GetSsid();
+        signal_quality = -99;
+        signal_quality_text = wifi_ap.GetWebServerUrl();
+        return true;
+    }
     auto& wifi_station = WifiStation::GetInstance();
     if (!wifi_station.IsConnected()) {
         return false;
@@ -86,10 +92,12 @@ std::string WifiBoard::GetJson() {
     auto& wifi_station = WifiStation::GetInstance();
     std::string board_type = BOARD_TYPE;
     std::string board_json = std::string("{\"type\":\"" + board_type + "\",");
-    board_json += "\"ssid\":\"" + wifi_station.GetSsid() + "\",";
-    board_json += "\"rssi\":" + std::to_string(wifi_station.GetRssi()) + ",";
-    board_json += "\"channel\":" + std::to_string(wifi_station.GetChannel()) + ",";
-    board_json += "\"ip\":\"" + wifi_station.GetIpAddress() + "\",";
+    if (!wifi_config_mode_) {
+        board_json += "\"ssid\":\"" + wifi_station.GetSsid() + "\",";
+        board_json += "\"rssi\":" + std::to_string(wifi_station.GetRssi()) + ",";
+        board_json += "\"channel\":" + std::to_string(wifi_station.GetChannel()) + ",";
+        board_json += "\"ip\":\"" + wifi_station.GetIpAddress() + "\",";
+    }
     board_json += "\"mac\":\"" + SystemInfo::GetMacAddress() + "\"}";
     return board_json;
 }

main/WifiBoard.h

@@ -5,10 +5,11 @@
 
 class WifiBoard : public Board {
 protected:
-    virtual void StartWifi();
+    bool wifi_config_mode_ = false;
 
 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;

main/boards/bread-compact-ml307/CompactMl307Board.cc

@@ -1,4 +1,5 @@
 #include "Ml307Board.h"
+#include "SystemReset.h"
 #include <esp_log.h>
 
 #define TAG "CompactMl307Board"
@@ -7,6 +8,9 @@ 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();
     }
 

main/boards/bread-compact-ml307/config.h

@@ -31,11 +31,12 @@
 #define VOLUME_UP_BUTTON_GPIO   GPIO_NUM_40
 #define VOLUME_DOWN_BUTTON_GPIO GPIO_NUM_39
 
-
-#define DISPLAY_WIDTH   128
-#define DISPLAY_HEIGHT  32
 #define DISPLAY_SDA_PIN GPIO_NUM_41
 #define DISPLAY_SCL_PIN GPIO_NUM_42
+#define DISPLAY_WIDTH   128
+#define DISPLAY_HEIGHT  32
+#define DISPLAY_MIRROR_X true
+#define DISPLAY_MIRROR_Y true
 
 
 #define ML307_RX_PIN GPIO_NUM_11

main/boards/bread-compact-wifi/CompactWifiBoard.cc

@@ -1,5 +1,5 @@
 #include "WifiBoard.h"
-
+#include "SystemReset.h"
 #include <esp_log.h>
 
 #define TAG "CompactWifiBoard"
@@ -8,6 +8,9 @@ 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();
     }
 

main/boards/bread-compact-wifi/config.h

@@ -32,9 +32,11 @@
 #define VOLUME_UP_BUTTON_GPIO   GPIO_NUM_40
 #define VOLUME_DOWN_BUTTON_GPIO GPIO_NUM_39
 
-#define DISPLAY_WIDTH   128
-#define DISPLAY_HEIGHT  32
 #define DISPLAY_SDA_PIN GPIO_NUM_41
 #define DISPLAY_SCL_PIN GPIO_NUM_42
+#define DISPLAY_WIDTH   128
+#define DISPLAY_HEIGHT  32
+#define DISPLAY_MIRROR_X true
+#define DISPLAY_MIRROR_Y true
 
 #endif // _BOARD_CONFIG_H_

main/boards/esp-box-3/config.h

@@ -17,16 +17,20 @@
 #define AUDIO_CODEC_PA_PIN       GPIO_NUM_46
 #define AUDIO_CODEC_I2C_SDA_PIN  GPIO_NUM_8
 #define AUDIO_CODEC_I2C_SCL_PIN  GPIO_NUM_18
+#define AUDIO_CODEC_ES8311_ADDR  ES8311_CODEC_DEFAULT_ADDR
+#define AUDIO_CODEC_ES7210_ADDR  ES7210_CODEC_DEFAULT_ADDR
 
 #define BUILTIN_LED_GPIO        GPIO_NUM_NC
 #define BOOT_BUTTON_GPIO        GPIO_NUM_0
 #define VOLUME_UP_BUTTON_GPIO   GPIO_NUM_NC
 #define VOLUME_DOWN_BUTTON_GPIO GPIO_NUM_NC
 
-#define DISPLAY_WIDTH   128
-#define DISPLAY_HEIGHT  64
 #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 true
+#define DISPLAY_MIRROR_Y true
 
 
 #endif // _BOARD_CONFIG_H_

main/boards/kevin-box-0/KevinBoxBoard.cc

@@ -4,11 +4,17 @@
 #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 = {
@@ -32,9 +38,31 @@ private:
         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();
@@ -43,6 +71,14 @@ public:
     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);

main/boards/kevin-box-0/config.h

@@ -17,16 +17,20 @@
 #define AUDIO_CODEC_PA_PIN       GPIO_NUM_40
 #define AUDIO_CODEC_I2C_SDA_PIN  GPIO_NUM_39
 #define AUDIO_CODEC_I2C_SCL_PIN  GPIO_NUM_38
+#define AUDIO_CODEC_ES8311_ADDR  ES8311_CODEC_DEFAULT_ADDR
+#define AUDIO_CODEC_ES7210_ADDR  ES7210_CODEC_DEFAULT_ADDR
 
 #define BUILTIN_LED_GPIO        GPIO_NUM_8
 #define BOOT_BUTTON_GPIO        GPIO_NUM_0
 #define VOLUME_UP_BUTTON_GPIO   GPIO_NUM_6
 #define VOLUME_DOWN_BUTTON_GPIO GPIO_NUM_7
 
-#define DISPLAY_WIDTH   128
-#define DISPLAY_HEIGHT  64
 #define DISPLAY_SDA_PIN GPIO_NUM_4
 #define DISPLAY_SCL_PIN GPIO_NUM_5
+#define DISPLAY_WIDTH   128
+#define DISPLAY_HEIGHT  64
+#define DISPLAY_MIRROR_X true
+#define DISPLAY_MIRROR_Y true
 
 #define ML307_RX_PIN GPIO_NUM_17
 #define ML307_TX_PIN GPIO_NUM_16

main/boards/kevin-box-1/KevinBoxBoard.cc

@@ -0,0 +1,93 @@
+#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);

main/boards/kevin-box-1/config.h

@@ -0,0 +1,39 @@
+#ifndef _BOARD_CONFIG_H_
+#define _BOARD_CONFIG_H_
+
+#include <driver/gpio.h>
+
+#define AUDIO_INPUT_SAMPLE_RATE  24000
+#define AUDIO_OUTPUT_SAMPLE_RATE 24000
+
+#define AUDIO_INPUT_REFERENCE    true
+
+#define AUDIO_I2S_GPIO_MCLK GPIO_NUM_42
+#define AUDIO_I2S_GPIO_LRCK 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
+
+#define AUDIO_CODEC_PA_PIN       GPIO_NUM_17
+#define AUDIO_CODEC_I2C_SDA_PIN  GPIO_NUM_39
+#define AUDIO_CODEC_I2C_SCL_PIN  GPIO_NUM_38
+#define AUDIO_CODEC_ES8311_ADDR  ES8311_CODEC_DEFAULT_ADDR
+#define AUDIO_CODEC_ES7210_ADDR  ES7210_CODEC_DEFAULT_ADDR
+
+#define BUILTIN_LED_GPIO        GPIO_NUM_8
+#define BOOT_BUTTON_GPIO        GPIO_NUM_0
+#define VOLUME_UP_BUTTON_GPIO   GPIO_NUM_6
+#define VOLUME_DOWN_BUTTON_GPIO GPIO_NUM_7
+
+#define DISPLAY_SDA_PIN GPIO_NUM_4
+#define DISPLAY_SCL_PIN GPIO_NUM_5
+#define DISPLAY_WIDTH   128
+#define DISPLAY_HEIGHT  64
+#define DISPLAY_MIRROR_X false
+#define DISPLAY_MIRROR_Y false
+
+#define ML307_RX_PIN GPIO_NUM_20
+#define ML307_TX_PIN GPIO_NUM_19
+
+
+#endif // _BOARD_CONFIG_H_

main/boards/lichuang-dev/LiChuangDevBoard.cc

@@ -0,0 +1,20 @@
+#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);

main/boards/lichuang-dev/config.h

@@ -0,0 +1,37 @@
+#ifndef _BOARD_CONFIG_H_
+#define _BOARD_CONFIG_H_
+
+#include <driver/gpio.h>
+
+#define AUDIO_INPUT_SAMPLE_RATE  24000
+#define AUDIO_OUTPUT_SAMPLE_RATE 24000
+
+#define AUDIO_INPUT_REFERENCE    true
+
+#define AUDIO_I2S_GPIO_MCLK GPIO_NUM_38
+#define AUDIO_I2S_GPIO_LRCK 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
+#define AUDIO_CODEC_ES7210_ADDR  0x82
+
+#define BUILTIN_LED_GPIO        GPIO_NUM_48
+#define BOOT_BUTTON_GPIO        GPIO_NUM_0
+#define VOLUME_UP_BUTTON_GPIO   GPIO_NUM_NC
+#define VOLUME_DOWN_BUTTON_GPIO GPIO_NUM_NC
+
+#define DISPLAY_SDA_PIN GPIO_NUM_NC
+#define DISPLAY_SCL_PIN GPIO_NUM_NC
+#define DISPLAY_WIDTH   128
+#define DISPLAY_HEIGHT  64
+#define DISPLAY_MIRROR_X false
+#define DISPLAY_MIRROR_Y false
+
+
+#endif // _BOARD_CONFIG_H_

main/idf_component.yml

@@ -1,14 +1,14 @@
 ## IDF Component Manager Manifest File
 dependencies:
-  78/esp-wifi-connect: "^1.2.0"
-  78/esp-opus-encoder: "^1.0.2"
-  78/esp-ml307: "^1.2.2"
+  78/esp-wifi-connect: "~1.2.0"
+  78/esp-opus-encoder: "~1.0.2"
+  78/esp-ml307: "~1.3.0"
   espressif/led_strip: "^2.4.1"
   espressif/esp_codec_dev: "^1.3.1"
   espressif/esp-sr: "^1.9.0"
   espressif/button: "^3.3.1"
-  lvgl/lvgl: "^8.4.0"
-  esp_lvgl_port: "^2.4.1"
+  lvgl/lvgl: "~8.4.0"
+  esp_lvgl_port: "~2.4.1"
   ## Required IDF version
   idf:
     version: ">=5.3"

main/main.cc

@@ -7,15 +7,11 @@
 
 #include "Application.h"
 #include "SystemInfo.h"
-#include "SystemReset.h"
 
 #define TAG "main"
 
 extern "C" void app_main(void)
 {
-    // Check if the reset button is pressed
-    SystemReset::GetInstance().CheckButtons();
-
     // Initialize the default event loop
     ESP_ERROR_CHECK(esp_event_loop_create_default());
 

versions.py

@@ -56,12 +56,12 @@ def get_app_desc(data):
 def get_board_name(folder):
     basename = os.path.basename(folder)
     if basename.startswith("v0.2"):
-        return "simple"
-    if basename.startswith("v0.3") or basename.startswith("v0.4") or basename.startswith("v0.5"):
+        return "bread-simple"
+    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 "compact.4g"
+            return "bread-compact-ml307"
         else:
-            return "compact.wifi"
+            return "bread-compact-wifi"
     raise Exception(f"Unknown board name: {basename}")
 
 def read_binary(dir_path):