misakiotoha/Bionic_sphere
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. 完成了语音识别的C++业务层封装，测试通过

Browse Source 
2. 试着测试了一下LVGL_GIF渲染+音乐播放+语音识别的组合简单优化后，
          发现lvgl渲染略显卡顿，语音识别有缓冲区空警告，不过无伤大雅，还需要进一步深度优化。
This commit is contained in:
Misaki
2025-09-23 03:17:23 +08:00
parent 4cc761aab3
commit 48f208b2e6
19 changed files with 587 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Bionic_Core/CommClass/CommClass.cpp
+65 -45
View File
@@ -9,9 +9,13 @@
#include <esp_log.h>
#include <esp_netif_types.h>
#include "ToolsClass.h"
#include "sys_conf_singleton.h"
// 静态成员初始化
WebSocketManager* WebSocketManager::instance = nullptr;
std::mutex WebSocketManager::instance_mutex;
std::string WebSocketManager::sn = SYS_CONF_JSON().loadSN(); // 获取SN(同时也能初始化文件系统，如果还没有初始化这个文件系统的话)
// 标签用于日志
static const char* TAG = "WebSocketManager";
@@ -51,21 +55,21 @@ WebSocketManager::~WebSocketManager() {
}
WebSocketManager* WebSocketManager::getInstance() {
std::lock_guard<std::mutex> lock(instance_mutex);
std::lock_guard<std::mutex> lock(instance_mutex); // 加锁
if (instance == nullptr) {
instance = new WebSocketManager();
}
return instance;
}
bool WebSocketManager::initialize(const WebSocketConfig& config) {
this->config = config;
bool WebSocketManager::initialize(const WebSocketConfig& ws_config) {
this->config = ws_config;
// 注册WiFi事件处理
esp_event_handler_instance_t instance;
esp_event_handler_instance_t wifi_instance;
esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP,
&WebSocketManager::wifiEventHandler,
this, &instance);
this, &wifi_instance);
// 启动发送线程
threads_running = true;
@@ -159,8 +163,8 @@ bool WebSocketManager::sendJson(cJSON* json) {
}
std::lock_guard<std::mutex> lock(queue_mutex); // 锁定队列
send_queue.push(json_str); // 添加到队列
free(json_str); // 释放内存
send_queue.emplace(json_str); // 添加到队列
free(json_str); // 释放json_str的内存
queue_cv.notify_one(); // 通知发送线程
return true;
@@ -178,11 +182,11 @@ bool WebSocketManager::sendRaw(const std::string& data) {
return true;
}
void WebSocketManager::setJsonCallback(JsonDataCallback callback) {
void WebSocketManager::setJsonCallback(const JsonDataCallback &callback) {
json_callback = callback;
}
void WebSocketManager::setEventCallback(EventCallback callback) {
void WebSocketManager::setEventCallback(const EventCallback &callback) {
event_callback = callback;
}
@@ -194,8 +198,8 @@ WebSocketConfig WebSocketManager::getConfig() const {
return config;
}
void WebSocketManager::updateConfig(const WebSocketConfig& config) {
this->config = config;
void WebSocketManager::updateConfig(const WebSocketConfig& ws_config) {
this->config = ws_config;
}
WebSocketManager::Stats WebSocketManager::getStats() const {
@@ -204,55 +208,57 @@ WebSocketManager::Stats WebSocketManager::getStats() const {
void WebSocketManager::websocketEventHandler(void* handler_args, esp_event_base_t base,
int32_t event_id, void* event_data) {
WebSocketManager* instance = static_cast<WebSocketManager*>(handler_args);
esp_websocket_event_data_t* data = (esp_websocket_event_data_t*)event_data;
auto* ws_instance = static_cast<WebSocketManager*>(handler_args);
auto* data = static_cast<esp_websocket_event_data_t *>(event_data);
switch(event_id) {
case WEBSOCKET_EVENT_CONNECTED:
instance->connected = true;
instance->connecting = false;
instance->reconnect_attempts = 0;
instance->stats.successful_connections++;
ws_instance->connected = true;
ws_instance->connecting = false;
ws_instance->reconnect_attempts = 0;
ws_instance->stats.successful_connections++;
ESP_LOGI(TAG, "WebSocket connected");
if (instance->event_callback) {
instance->event_callback(WebSocketEvent::CONNECTED, "Connected successfully");
if (ws_instance->event_callback) {
ws_instance->event_callback(WebSocketEvent::CONNECTED, "Connected successfully");
}
break;
case WEBSOCKET_EVENT_DISCONNECTED:
instance->connected = false;
instance->connecting = false;
ws_instance->connected = false;
ws_instance->connecting = false;
ESP_LOGI(TAG, "WebSocket disconnected");
if (instance->event_callback) {
instance->event_callback(WebSocketEvent::DISCONNECTED, "Disconnected");
if (ws_instance->event_callback) {
ws_instance->event_callback(WebSocketEvent::DISCONNECTED, "Disconnected");
}
break;
case WEBSOCKET_EVENT_DATA:
if (data->data_len > 0) {
instance->stats.messages_received++;
instance->handleReceivedData((const char*)data->data_ptr, data->data_len);
ws_instance->stats.messages_received++;
ws_instance->handleReceivedData((const char*)data->data_ptr, data->data_len);
}
break;
case WEBSOCKET_EVENT_ERROR:
instance->connected = false;
instance->connecting = false;
ws_instance->connected = false;
ws_instance->connecting = false;
ESP_LOGE(TAG, "WebSocket error");
if (instance->event_callback) {
instance->event_callback(WebSocketEvent::ERROR, "WebSocket error occurred");
if (ws_instance->event_callback) {
ws_instance->event_callback(WebSocketEvent::ERROR, "WebSocket error occurred");
}
break;
default:
ESP_LOGW(TAG, "Unhandled WebSocket event: %ld", event_id);
break;
}
}
void WebSocketManager::handleReceivedData(const char* data, int len) {
void WebSocketManager::handleReceivedData(const char* data, const int len) const {
// 尝试解析JSON
cJSON* json = cJSON_ParseWithLength(data, len);
if (json) {
if (cJSON* json = cJSON_ParseWithLength(data, len)) {
// 成功解析为JSON
if (json_callback) {
json_callback(json);
@@ -298,16 +304,16 @@ void WebSocketManager::reconnectThread() {
void WebSocketManager::heartbeatThread() {
while (threads_running) {
if (connected && config.heartbeat_interval > 0) {
if (connected && config.heartbeat_interval > 0) { // 如果处于连接状态且心跳间隔大于0
// 发送心跳消息
cJSON* heartbeat = cJSON_CreateObject();
cJSON_AddStringToObject(heartbeat, "type", "heartbeat");
cJSON_AddNumberToObject(heartbeat, "timestamp", esp_log_timestamp());
cJSON_AddNumberToObject(heartbeat, "timestamp", static_cast<double>(esp_log_timestamp()));
sendJson(heartbeat);
std::this_thread::sleep_for(std::chrono::milliseconds(config.heartbeat_interval));
} else {
} else { // 否则就让出CPU
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
}
@@ -316,23 +322,24 @@ void WebSocketManager::heartbeatThread() {
void WebSocketManager::sendThread() {
while (threads_running) {
std::unique_lock<std::mutex> lock(queue_mutex);
queue_cv.wait(lock, [this]() {
queue_cv.wait(lock, // 传入已持有的 unique_lock
[this]() { // 等待队列非空或者线程停止
return !send_queue.empty() || !threads_running;
});
if (!threads_running) {
if (!threads_running) { // 其实永远不会进入这里，写上只是保险起见
break;
}
if (!send_queue.empty() && connected) {
if (!send_queue.empty() && connected) { // 如果队列非空且已连接
std::string data = std::move(send_queue.front());
send_queue.pop();
lock.unlock();
lock.unlock(); // 释放锁
// 发送数据
int sent = esp_websocket_client_send_text(client, data.c_str(), static_cast<int>(data.length()), portMAX_DELAY);
if (sent >= 0) {
stats.messages_sent++;
stats.messages_sent++; // 发送成功
} else {
ESP_LOGE(TAG, "Failed to send data");
// 将数据重新放回队列
@@ -355,6 +362,19 @@ bool WebSocketManager::createWebSocketClient() {
return false;
}
// 处理sn码逻辑
// 一般情况下sn码会在开机的时候从flash当中读出，因此此处判断是否为空
if (!sn.empty()) { // 如果sn码不为空
// 则在头部加入sn码提交
esp_websocket_client_append_header(client, "sn", sn.c_str());
}
else {
// 否则在头部加入mac码和芯片序列号
esp_websocket_client_append_header(client, "mac", ToolsClass::getChipMAC().c_str());
esp_websocket_client_append_header(client, "chip_id", ToolsClass::getChipSerialNumber().c_str());
}
// 注册事件处理
esp_websocket_register_events(client, WEBSOCKET_EVENT_ANY,
&WebSocketManager::websocketEventHandler, this);
@@ -371,14 +391,14 @@ void WebSocketManager::destroyWebSocketClient() {
}
void WebSocketManager::wifiEventHandler(void* arg, esp_event_base_t event_base,
int32_t event_id, void* event_data) {
WebSocketManager* instance = static_cast<WebSocketManager*>(arg);
int32_t event_Id, void* event_data) {
auto* ws_instance = static_cast<WebSocketManager*>(arg);
if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
if (event_base == IP_EVENT && event_Id == IP_EVENT_STA_GOT_IP) {
// WiFi已连接，尝试重新连接WebSocket
if (instance->config.auto_reconnect && !instance->connected) {
if (ws_instance->config.auto_reconnect && !ws_instance->connected) {
ESP_LOGI(TAG, "WiFi connected, attempting to reconnect WebSocket");
instance->connect();
ws_instance->connect();
}
}
}