Rdzleo/toy-Kapi_Rtc
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1、本次修改了关于BluFi关键字的日志和方法名称替换为Ble关键字

Browse Source
This commit is contained in:
Rdzleo 2026-02-10 15:00:57 +08:00
parent 77c7283d09
commit 94067d4adc
9 changed files with 144 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dzbj Submodule

@ -0,0 +1 @@
Subproject commit 99aef2c4e50894af43b8b93483f8d788f572b3c4

8
main/application.cc
View File

@ -2231,12 +2231,12 @@ void Application::SetDeviceState(DeviceState state) {
auto led = board.GetLed();
led->OnStateChanged();
// 检查是否正在进行BluFi配网，配网时禁止播放待命音效(新增代码)
// 检查是否正在进行BLE配网，配网时禁止播放待命音效(新增代码)
// =================================================================
bool is_blufi_provisioning = false;
bool is_ble_provisioning = false;
if (Board::GetInstance().GetBoardType() == "wifi") {
auto& wifi_board = static_cast<WifiBoard&>(Board::GetInstance());
is_blufi_provisioning = wifi_board.IsBluFiProvisioningActive();
is_ble_provisioning = wifi_board.IsBleProvisioningActive();
}
// =================================================================
@ -2257,7 +2257,7 @@ void Application::SetDeviceState(DeviceState state) {
// 开机后 进入待命状态 播报 卡卡正在待命(配网模式下不播报“卡卡正在待命”)-新增代码
//=====================================================================================
if (previous_state != kDeviceStateIdle && previous_state != kDeviceStateUnknown &&
previous_state != kDeviceStateWifiConfiguring && !is_blufi_provisioning && !IsLowBatteryTransition()) {
previous_state != kDeviceStateWifiConfiguring && !is_ble_provisioning && !IsLowBatteryTransition()) {
ESP_LOGI(TAG, "Entering idle state, playing standby sound");
// PlaySound(Lang::Sounds::P3_DAIMING); 原有 待命 播报
if(strcmp(CONFIG_DEVICE_ROLE, "KAKA") == 0){

10
main/ble_service.cc
View File

@ -124,7 +124,7 @@ bool BleJsonService::Initialize() {
esp_err_t ret;
// 检查 Bluedroid 栈是否已启动 (可能由 BluFi 配网模块启动过)
// 检查 Bluedroid 栈是否已启动 (可能由 BLE 配网模块启动过)
// 如果未启动，则自行初始化整个 BLE 栈
esp_bluedroid_status_t bt_status = esp_bluedroid_get_status();
if (bt_status != ESP_BLUEDROID_STATUS_ENABLED) {
@ -170,18 +170,18 @@ bool BleJsonService::Initialize() {
}
// 注册 GAP 回调 (广播事件需要此回调才能启动)
// 注意: ESP-IDF 仅支持一个全局 GAP 回调，此处会覆盖 BluFi 的回调
// 但 BluFi 配网流程在 StartNetwork() 中已完成，不影响后续使用
// 注意: ESP-IDF 仅支持一个全局 GAP 回调，此处会覆盖配网模块的回调
// 但 BLE 配网流程在 StartNetwork() 中已完成，不影响后续使用
ret = esp_ble_gap_register_callback(GapEventHandler);
if (ret != ESP_OK) {
ESP_LOGW(TAG, "GAP callback register: %s", esp_err_to_name(ret));
}
// 注册 GATTS 回调 (全局只能有一个，但 Bluedroid 支持按 gatts_if 分发)
// BluFi 已经注册了自己的回调，我们通过 app_register 获得独立的 gatts_if
// 配网模块已经注册了自己的回调，我们通过 app_register 获得独立的 gatts_if
ret = esp_ble_gatts_register_callback(GattsEventHandler);
if (ret != ESP_OK) {
ESP_LOGW(TAG, "GATTS callback register: %s (may share with BluFi)", esp_err_to_name(ret));
ESP_LOGW(TAG, "GATTS callback register: %s (may share with provisioning)", esp_err_to_name(ret));
}
// 注册独立的 GATTS App，获得自己的 gatts_if

2
main/ble_service_config.h
View File

@ -8,7 +8,7 @@ extern "C" {
// BLE JSON 通讯服务 - 配置参数
// ============================================================
// GATT App ID (BluFi 使用 0，本模块使用 1)
// GATT App ID (配网模块使用 0，本模块使用 1)
#define BLE_JSON_APP_ID 1
// Service UUID (16-bit)

4
main/bluetooth_provisioning.cc
View File

@ -2,7 +2,7 @@
* @file bluetooth_provisioning.cc
* @brief 蓝牙配网模块实现（基于自定义 GATT Server）
*
* 使用自定义 BLE GATT Server + 原始广播数据（raw advertising）替代 BluFi API。
* 使用自定义 BLE GATT Server + 原始广播数据（raw advertising）实现配网。
* 采用 dzbj 项目验证的 esp_ble_gap_config_adv_data_raw() 方式，
* 确保手机系统蓝牙可搜索到设备名称。
*
@ -244,7 +244,7 @@ bool BluetoothProvisioning::Initialize() {
return false;
}
// 步骤4: 注册 GAP 和 GATTS 回调 (替代 BluFi 回调)
// 步骤4: 注册 GAP 和 GATTS 回调
ESP_LOGI(TAG, "注册 BLE GAP/GATTS 回调...");
ret = esp_ble_gap_register_callback(GapEventHandler);

4
main/bluetooth_provisioning.h
View File

@ -4,7 +4,7 @@
* @file bluetooth_provisioning.h
* @brief 蓝牙配网模块头文件（基于自定义 GATT Server）
*
* 使用自定义 BLE GATT Server 替代 BluFi API 实现配网通讯，
* 使用自定义 BLE GATT Server 实现配网通讯，
* 采用原始广播数据（raw advertising）确保手机系统蓝牙可发现。
* 保留完整的 WiFi 配网业务逻辑、状态机和事件回调。
*/
@ -104,7 +104,7 @@ using BluetoothProvisioningCallback = std::function<void(BluetoothProvisioningEv
/**
* @brief 蓝牙配网封装类（基于自定义 GATT Server）
*
* 使用自定义 BLE GATT Server + 原始广播数据替代 BluFi API，
* 使用自定义 BLE GATT Server + 原始广播数据，
* 手机系统蓝牙可直接搜索到设备。保留完整的 WiFi 配网业务逻辑。
*/
class BluetoothProvisioning {

170
main/boards/common/wifi_board.cc
View File

@ -3,7 +3,7 @@
* @brief WiFi板级管理模块实现文件
*
* 本文件实现了WiFi板级管理的相关功能，包括WiFi连接管理、
* BluFi蓝牙配网流程控制、网络状态监控等核心功能。
* BLE蓝牙配网流程控制、网络状态监控等核心功能。
* 提供完整的网络连接解决方案实现。
*/
@ -65,33 +65,33 @@ std::string WifiBoard::GetBoardType() {
/**
* @brief 进入WiFi配置模式
*
* 启动BluFi蓝牙配网流程，等待用户通过手机APP配置WiFi信息。
* 如果BluFi配网启动失败，会持续重试直到成功。
* 启动BLE蓝牙配网流程，等待用户通过手机APP配置WiFi信息。
* 如果BLE配网启动失败，会持续重试直到成功。
* 不再使用传统的WiFi AP配网模式。
*/
void WifiBoard::EnterWifiConfigMode() {
ESP_LOGI(TAG, "🔵 进入配网模式 - 使用BluFi蓝牙配网");
ESP_LOGI(TAG, "🔵 进入配网模式 - 使用BLE蓝牙配网");
// 使用 BluFi 蓝牙配网
bool success = StartBluFiProvisioning();
ESP_LOGI(TAG, "🔍 BluFi配网启动结果: %s", success ? "成功" : "失败");
// 使用 BLE 蓝牙配网
bool success = StartBleProvisioning();
ESP_LOGI(TAG, "🔍 BLE配网启动结果: %s", success ? "成功" : "失败");
if (success) {
ESP_LOGI(TAG, "✅ BluFi配网启动成功，等待手机连接");
ESP_LOGI(TAG, "✅ BLE配网启动成功，等待手机连接");
return;
}
ESP_LOGW(TAG, "⚠️ BluFi配网启动失败，将持续重试");
ESP_LOGW(TAG, "⚠️ BLE配网启动失败，将持续重试");
// 持续重试
while (true) {
vTaskDelay(pdMS_TO_TICKS(5000));
ESP_LOGI(TAG, "🔄 重试启动BluFi配网...");
if (StartBluFiProvisioning()) {
ESP_LOGI(TAG, "✅ BluFi配网重试成功，等待手机连接");
ESP_LOGI(TAG, "🔄 重试启动BLE配网...");
if (StartBleProvisioning()) {
ESP_LOGI(TAG, "✅ BLE配网重试成功，等待手机连接");
return;
}
ESP_LOGW(TAG, "❌ BluFi配网重试失败，继续重试...");
ESP_LOGW(TAG, "❌ BLE配网重试失败，继续重试...");
}
// 以下代码保留但不会执行，用于将来可能重新启用WiFi AP配网
@ -134,32 +134,32 @@ void WifiBoard::EnterWifiConfigMode() {
/**
* @brief 启动网络连接
*
* 根据配置启动WiFi连接或BluFi配网流程。
* 如果设置了配网模式或没有WiFi凭据，则启动BluFi配网；
* 根据配置启动WiFi连接或BLE配网流程。
* 如果设置了配网模式或没有WiFi凭据，则启动BLE配网；
* 否则尝试连接已保存的WiFi网络。
*/
void WifiBoard::StartNetwork() {
// 用户可以在启动时按BOOT按钮进入WiFi配置模式
// 开机按BOOT进入配网模式
if (wifi_config_mode_) {
ESP_LOGI(TAG, "🔵 进入配网模式 - BluFi蓝牙配网");
ESP_LOGI(TAG, "🔵 进入配网模式 - BLE蓝牙配网");
EnterWifiConfigMode();
return;
}
// 如果没有配置WiFi SSID，优先尝试BluFi配网
// 如果没有配置WiFi SSID，优先尝试BLE配网
auto& ssid_manager = SsidManager::GetInstance(); // 获取SSID管理器实例
auto ssid_list = ssid_manager.GetSsidList(); // 获取SSID列表
if (ssid_list.empty()) {
ESP_LOGI(TAG, "🔍 未找到WiFi凭据，启动BluFi配网...");
if (StartBluFiProvisioning()) {
ESP_LOGI(TAG, "✅ BluFi配网启动成功，等待手机连接...");
ESP_LOGI(TAG, "🔍 未找到WiFi凭据，启动BLE配网...");
if (StartBleProvisioning()) {
ESP_LOGI(TAG, "✅ BLE配网启动成功，等待手机连接...");
return;
} else {
ESP_LOGW(TAG, "❌ BluFi配网启动失败，将重试");
ESP_LOGW(TAG, "❌ BLE配网启动失败，将重试");
vTaskDelay(pdMS_TO_TICKS(5000));
ESP_LOGI(TAG, "🔄 重试启动BluFi配网...");
StartBluFiProvisioning();
ESP_LOGI(TAG, "🔄 重试启动BLE配网...");
StartBleProvisioning();
return;
}
}
@ -223,8 +223,8 @@ void WifiBoard::StartNetwork() {
// 启动WiFi站点模式
wifi_station.Start();
// 尝试连接WiFi，如果失败则尝试BluFi配网
// 尝试连接WiFi，如果失败则尝试BluFi配网
// 尝试连接WiFi，如果失败则尝试BLE配网
// 尝试连接WiFi，如果失败则尝试BLE配网
// 增加WiFi连接超时时间，避免过快进入配网模式
// if (!wifi_station.WaitForConnected(90 * 1000)) {
if (!wifi_station.WaitForConnected(10 * 1000)) {
@ -318,8 +318,8 @@ std::string WifiBoard::GetBoardJson() {
// 设置低功耗模式 新增配网模式下禁用省电模式
void WifiBoard::SetPowerSaveMode(bool enabled) {
// 如果正在进行 BluFi 配网，强制禁用省电模式以确保 MAC 地址能正常发送到手机端
if (enabled && IsBluFiProvisioningActive()) {
// 如果正在进行 BLE 配网，强制禁用省电模式以确保 MAC 地址能正常发送到手机端
if (enabled && IsBleProvisioningActive()) {
ESP_LOGI(TAG, "🔵 配网模式下，已强制禁用省电模式!");
enabled = false;
}
@ -350,71 +350,71 @@ void WifiBoard::ResetWifiConfiguration() {
esp_restart(); // 重启设备，重启后会进入配网模式
}
// 启动BluFi配网服务
bool WifiBoard::StartBluFiProvisioning() {
ESP_LOGI(TAG, "🔵 正在启动BluFi蓝牙配网服务...");
// 启动BLE配网服务
bool WifiBoard::StartBleProvisioning() {
ESP_LOGI(TAG, "🔵 正在启动BLE蓝牙配网服务...");
Application::GetInstance().StopAudioProcessor();// 停止音频处理器，确保在配网过程中不处理音频数据
Application::GetInstance().ClearAudioQueue();// 清空音频队列，移除所有待处理的音频数据
// 初始化BluFi配网服务
// 初始化BLE配网服务
if (!bluetooth_provisioning_.Initialize()) {
ESP_LOGE(TAG, "❌ BluFi蓝牙配网初始化失败");
ESP_LOGI(TAG, "🔍 BluFi Initialize返回结果: false");
ESP_LOGE(TAG, "❌ BLE蓝牙配网初始化失败");
ESP_LOGI(TAG, "🔍 BLE Initialize返回结果: false");
return false;
}
ESP_LOGI(TAG, "🔍 BluFi Initialize返回结果: true");
ESP_LOGI(TAG, "🔍 BLE Initialize返回结果: true");
// 为BluFi事件设置回调函数
// 为BLE事件设置回调函数
bluetooth_provisioning_.SetCallback([this](BluetoothProvisioningEvent event, void* data) {
OnBluFiProvisioningEvent(event, data);
OnBleProvisioningEvent(event, data);
});
// 使用设备名称启动BluFi配网服务（2.设备发现，设备名称 Airhub777）
// 使用设备名称启动BLE配网服务（2.设备发现，设备名称 Airhub777）
std::string device_name = BLU_NAME;
// 蓝牙配网服务启动失败，StartProvisioning为蓝牙服务启动函数
if (!bluetooth_provisioning_.StartProvisioning(device_name.c_str())) {
ESP_LOGE(TAG, "❌ BluFi蓝牙配网启动失败");
ESP_LOGE(TAG, "❌ BLE蓝牙配网启动失败");
return false;
}
ESP_LOGI(TAG, "✅ BluFi蓝牙配网启动成功，设备名称: %s", device_name.c_str());
ESP_LOGI(TAG, "📱 请使用支持BluFi的手机APP连接设备进行配网");
ESP_LOGI(TAG, "✅ BLE蓝牙配网启动成功，设备名称: %s", device_name.c_str());
ESP_LOGI(TAG, "📱 请使用支持BLE的手机APP连接设备进行配网");
blufi_provisioning_active_ = true; // 标记BluFi配网服务已激活
blufi_provisioning_success_ = false;// 标记BluFi配网服务未成功
blufi_start_time_ = xTaskGetTickCount();// 记录启动时间，用于超时检测
ble_provisioning_active_ = true; // 标记BLE配网服务已激活
ble_provisioning_success_ = false;// 标记BLE配网服务未成功
ble_start_time_ = xTaskGetTickCount();// 记录启动时间，用于超时检测
// 显示BluFi配网通知
// 显示BLE配网通知
auto display = GetDisplay();
if (display) {
std::string notification = "BluFi配网模式\n设备名: " + device_name;
std::string notification = "BLE配网模式\n设备名: " + device_name;
display->ShowNotification(notification.c_str(), 30000);
}
// Play BluFi provisioning sound
// Play BLE provisioning sound
auto& application = Application::GetInstance();
// application.Alert("BluFi配网模式", ("请使用手机APP连接设备: " + device_name).c_str(), "", Lang::Sounds::P3_WIFICONFIG); 原有蜡笔小新音色
// application.Alert("BLE配网模式", ("请使用手机APP连接设备: " + device_name).c_str(), "", Lang::Sounds::P3_WIFICONFIG); 原有蜡笔小新音色
if(strcmp(CONFIG_DEVICE_ROLE, "KAKA") == 0){
application.Alert("BluFi配网模式", ("请使用手机APP连接设备: " + device_name).c_str(), "", Lang::Sounds::P3_KAKA_WIFICONFIG);
application.Alert("BLE配网模式", ("请使用手机APP连接设备: " + device_name).c_str(), "", Lang::Sounds::P3_KAKA_WIFICONFIG);
}
else if(strcmp(CONFIG_DEVICE_ROLE, "RTC_Test") == 0){
application.Alert("BluFi配网模式", ("请使用手机APP连接设备: " + device_name).c_str(), "", Lang::Sounds::P3_LALA_WIFICONFIG);
application.Alert("BLE配网模式", ("请使用手机APP连接设备: " + device_name).c_str(), "", Lang::Sounds::P3_LALA_WIFICONFIG);
}
// 创建任务，用于监控BluFi配网状态
// 创建任务，用于监控BLE配网状态
xTaskCreate([](void* param) {
WifiBoard* board = static_cast<WifiBoard*>(param); // 转换参数为WifiBoard指针
board->MonitorBluFiProvisioning();// 监控BluFi配网状态
board->MonitorBleProvisioning();// 监控BLE配网状态
vTaskDelete(nullptr);// 删除任务，因为任务只执行一次
}, "blufi_monitor", 4096, this, 5, nullptr);// 创建任务，优先级为5，栈大小为4096字节
}, "ble_prov_monitor", 4096, this, 5, nullptr);// 创建任务，优先级为5，栈大小为4096字节
return true;// 启动成功，返回true
}
// 使用 BLE JSON Service 进行配网 (替代 BluFi)
// 使用 BLE JSON Service 进行配网 (替代 BLE)
bool WifiBoard::StartBleJsonProvisioning() {
ESP_LOGI(TAG, "🔵 正在启动BLE JSON配网服务...");
@ -433,7 +433,7 @@ bool WifiBoard::StartBleJsonProvisioning() {
Application::GetInstance().HandleBleJsonCommand(cmd, msg_id, data, ble_json_service_);
});
// 使用与 BluFi 相同的设备名启动
// 使用与 BLE 相同的设备名启动
std::string device_name = BLU_NAME;
if (!ble_json_service_.Start(device_name.c_str())) {
ESP_LOGE(TAG, "❌ BLE JSON服务启动失败");
@ -442,8 +442,8 @@ bool WifiBoard::StartBleJsonProvisioning() {
ESP_LOGI(TAG, "✅ BLE JSON配网启动成功，设备名称: %s", device_name.c_str());
blufi_provisioning_active_ = true;
blufi_start_time_ = xTaskGetTickCount();
ble_provisioning_active_ = true;
ble_start_time_ = xTaskGetTickCount();
// 显示配网通知
auto display = GetDisplay();
@ -471,34 +471,34 @@ bool WifiBoard::StartBleJsonProvisioning() {
return true;
}
// 监控BluFi配网状态
void WifiBoard::MonitorBluFiProvisioning() {
ESP_LOGI(TAG, "Starting BluFi provisioning monitor...");
// 监控BLE配网状态
void WifiBoard::MonitorBleProvisioning() {
ESP_LOGI(TAG, "Starting BLE provisioning monitor...");
while (blufi_provisioning_active_) {
while (ble_provisioning_active_) {
TickType_t current_time = xTaskGetTickCount();
TickType_t elapsed_time = current_time - blufi_start_time_;
TickType_t elapsed_time = current_time - ble_start_time_;
// Check for timeout (2 minutes) - 仅记录日志，不再切换到WiFi配网
if (elapsed_time >= pdMS_TO_TICKS(BLUFI_TIMEOUT_MS)) {
ESP_LOGW(TAG, "BluFi provisioning timeout, but continuing BluFi mode (no fallback to WiFi AP)");
if (elapsed_time >= pdMS_TO_TICKS(BLE_PROV_TIMEOUT_MS)) {
ESP_LOGW(TAG, "BLE provisioning timeout, but continuing BLE mode (no fallback to WiFi AP)");
// 增加延迟避免快速重新进入配网循环
ESP_LOGI(TAG, "🔵 BluFi配网超时，等待10秒后重置计时器继续等待配网");
ESP_LOGI(TAG, "🔵 BLE配网超时，等待10秒后重置计时器继续等待配网");
vTaskDelay(pdMS_TO_TICKS(10000)); // 等待10秒,冷却期
// 重置计时器，继续等待BluFi配网
blufi_start_time_ = xTaskGetTickCount();
ESP_LOGI(TAG, "🔵 计时器已重置，继续等待BluFi配网");
// 重置计时器，继续等待BLE配网
ble_start_time_ = xTaskGetTickCount();
ESP_LOGI(TAG, "🔵 计时器已重置，继续等待BLE配网");
}
// Check if provisioning was successful
if (blufi_provisioning_success_) {
ESP_LOGI(TAG, "BluFi provisioning completed successfully");
blufi_provisioning_active_ = false;
if (ble_provisioning_success_) {
ESP_LOGI(TAG, "BLE provisioning completed successfully");
ble_provisioning_active_ = false;
// Stop BluFi provisioning
// 停止BluFi配网
// Stop BLE provisioning
// 停止BLE配网
bluetooth_provisioning_.StopProvisioning();
// Try to connect to the configured WiFi
@ -512,11 +512,11 @@ void WifiBoard::MonitorBluFiProvisioning() {
// 重试连接WiFi
while (retry_count < max_retries) {
ESP_LOGI(TAG, "WiFi connection attempt %d/%d after BluFi provisioning", retry_count + 1, max_retries);
ESP_LOGI(TAG, "WiFi connection attempt %d/%d after BLE provisioning", retry_count + 1, max_retries);
// 等待WiFi连接成功
if (wifi_station.WaitForConnected(retry_timeout)) {
ESP_LOGI(TAG, "WiFi connection successful after BluFi provisioning (attempt %d)", retry_count + 1);
ESP_LOGI(TAG, "WiFi connection successful after BLE provisioning (attempt %d)", retry_count + 1);
auto display = GetDisplay();
if (display) {
display->ShowNotification("WiFi连接成功", 5000);
@ -546,11 +546,11 @@ void WifiBoard::MonitorBluFiProvisioning() {
}
}
// 处理BluFi配网事件
void WifiBoard::OnBluFiProvisioningEvent(BluetoothProvisioningEvent event, void* data) {
// 处理BLE配网事件
void WifiBoard::OnBleProvisioningEvent(BluetoothProvisioningEvent event, void* data) {
switch (event) {
case BluetoothProvisioningEvent::CLIENT_CONNECTED:
ESP_LOGI(TAG, "BluFi client connected");
ESP_LOGI(TAG, "BLE client connected");
{
auto display = GetDisplay();
if (display) {
@ -561,7 +561,7 @@ void WifiBoard::OnBluFiProvisioningEvent(BluetoothProvisioningEvent event, void*
// 客户端断开事件
case BluetoothProvisioningEvent::CLIENT_DISCONNECTED:
ESP_LOGI(TAG, "BluFi client disconnected");
ESP_LOGI(TAG, "BLE client disconnected");
{
auto display = GetDisplay();
if (display) {
@ -572,7 +572,7 @@ void WifiBoard::OnBluFiProvisioningEvent(BluetoothProvisioningEvent event, void*
// 接收WiFi凭据事件
case BluetoothProvisioningEvent::WIFI_CREDENTIALS:
ESP_LOGI(TAG, "WiFi credentials received via BluFi");
ESP_LOGI(TAG, "WiFi credentials received via BLE");
{
auto display = GetDisplay();
if (display) {
@ -584,7 +584,7 @@ void WifiBoard::OnBluFiProvisioningEvent(BluetoothProvisioningEvent event, void*
// 连接成功事件
case BluetoothProvisioningEvent::WIFI_CONNECTED:
ESP_LOGI(TAG, "设备配网成功,已连接到WiFi网络!");
blufi_provisioning_success_ = true;
ble_provisioning_success_ = true;
{
auto display = GetDisplay();
if (display) {
@ -603,8 +603,8 @@ void WifiBoard::OnBluFiProvisioningEvent(BluetoothProvisioningEvent event, void*
// 连接失败事件
case BluetoothProvisioningEvent::WIFI_FAILED:
ESP_LOGW(TAG, "WiFi connection failed via BluFi");
blufi_provisioning_active_ = false;
ESP_LOGW(TAG, "WiFi connection failed via BLE");
ble_provisioning_active_ = false;
{
auto display = GetDisplay();
if (display) {
@ -618,10 +618,10 @@ void WifiBoard::OnBluFiProvisioningEvent(BluetoothProvisioningEvent event, void*
}
}
// BluFi配网回调函数
void WifiBoard::BluFiProvisioningCallback(BluetoothProvisioningEvent event, void* data, void* user_data) {
// BLE配网回调函数
void WifiBoard::BleProvisioningCallback(BluetoothProvisioningEvent event, void* data, void* user_data) {
WifiBoard* board = static_cast<WifiBoard*>(user_data);
if (board) {
board->OnBluFiProvisioningEvent(event, data);
board->OnBleProvisioningEvent(event, data);
}
}

97
main/boards/common/wifi_board.h
View File

@ -4,9 +4,9 @@
/**
* @file wifi_board.h
* @brief WiFi板级管理模块头文件
*
*
* 本文件定义了WiFi板级管理的相关接口，包括WiFi连接管理、
* BluFi蓝牙配网流程控制、网络状态监控等功能。
* BLE蓝牙配网流程控制、网络状态监控等功能。
* 集成了蓝牙配网功能，提供完整的网络连接解决方案。
*/
@ -23,18 +23,18 @@ class Application;
/**
* @class WifiBoard
* @brief WiFi板级管理类
*
* 继承自Board基类，负责管理ESP32的WiFi连接、BluFi蓝牙配网流程和网络状态监控。
*
* 继承自Board基类，负责管理ESP32的WiFi连接、BLE蓝牙配网流程和网络状态监控。
* 提供完整的网络连接解决方案，包括自动连接、配网模式切换、网络状态监控等功能。
*/
class WifiBoard : public Board {
protected:
bool wifi_config_mode_ = false; ///< WiFi配置模式标志，true表示进入配网模式
bool blufi_provisioning_active_ = false; ///< BluFi配网激活状态标志
bool blufi_provisioning_success_ = false; ///< BluFi配网成功状态标志
TickType_t blufi_start_time_ = 0; ///< BluFi配网开始时间戳
static const TickType_t BLUFI_TIMEOUT_MS = 300000; ///< BluFi配网超时时间（5分钟），避免过快重新进入配网
BluetoothProvisioning bluetooth_provisioning_; ///< BluFi蓝牙配网实例对象（暂停使用）
bool ble_provisioning_active_ = false; ///< BLE配网激活状态标志
bool ble_provisioning_success_ = false; ///< BLE配网成功状态标志
TickType_t ble_start_time_ = 0; ///< BLE配网开始时间戳
static const TickType_t BLE_PROV_TIMEOUT_MS = 300000; ///< BLE配网超时时间（5分钟）
BluetoothProvisioning bluetooth_provisioning_; ///< BLE蓝牙配网实例对象
BleJsonService ble_json_service_; ///< BLE JSON 配网服务实例
/**
@ -45,7 +45,7 @@ protected:
/**
* @brief 进入WiFi配置模式
* 启动BluFi蓝牙配网流程，等待用户通过手机APP配置WiFi信息
* 启动BLE蓝牙配网流程，等待用户通过手机APP配置WiFi信息
*/
void EnterWifiConfigMode();
@ -58,38 +58,38 @@ protected:
void BroadcastVerificationCode(const std::string& code, Application& application);
/**
* @brief 启动BluFi蓝牙配网
* @brief 启动BLE蓝牙配网
* @return true 启动成功
* @return false 启动失败
* 初始化并启动BluFi蓝牙配网服务，等待手机连接
* 初始化并启动BLE蓝牙配网服务，等待手机连接
*/
bool StartBluFiProvisioning();
bool StartBleProvisioning();
// 使用 BLE JSON Service 替代 BluFi 进行配网
// 使用 BLE JSON Service 进行配网
bool StartBleJsonProvisioning();
/**
* @brief 监控BluFi配网进程
* @brief 监控BLE配网进程
* 监控配网状态变化，处理超时和异常情况
*/
void MonitorBluFiProvisioning();
void MonitorBleProvisioning();
/**
* @brief BluFi配网事件处理函数
* @brief BLE配网事件处理函数
* @param event 配网事件类型
* @param data 事件数据指针
* 处理BluFi配网过程中的各种事件
* 处理BLE配网过程中的各种事件
*/
void OnBluFiProvisioningEvent(BluetoothProvisioningEvent event, void* data);
void OnBleProvisioningEvent(BluetoothProvisioningEvent event, void* data);
/**
* @brief BluFi配网静态回调函数
* @brief BLE配网静态回调函数
* @param event 配网事件类型
* @param data 事件数据指针
* @param user_data 用户数据指针
* 静态回调函数，用于处理BluFi配网事件
* 静态回调函数，用于处理BLE配网事件
*/
static void BluFiProvisioningCallback(BluetoothProvisioningEvent event, void* data, void* user_data);
static void BleProvisioningCallback(BluetoothProvisioningEvent event, void* data, void* user_data);
/**
* @brief 清理现有蓝牙服务
@ -99,7 +99,7 @@ protected:
/**
* @brief 清理现有WiFi服务
* 在进入配网模式前，清理现有的WiFi服务，为BluFi重新初始化做准备
* 在进入配网模式前，清理现有的WiFi服务，为BLE重新初始化做准备
*/
void CleanupExistingWiFiService();
@ -120,66 +120,25 @@ public:
/**
* @brief 启动网络连接
* 根据配置启动WiFi连接或BluFi配网流程
* 根据配置启动WiFi连接或BLE配网流程
* 重写基类方法，实现WiFi网络的启动逻辑
*/
virtual void StartNetwork() override;
/**
* @brief 创建HTTP客户端对象
* @return Http* HTTP客户端对象指针
* 重写基类方法，创建适用于WiFi网络的HTTP客户端
*/
virtual Http* CreateHttp() override;
/**
* @brief 创建WebSocket客户端对象
* @return WebSocket* WebSocket客户端对象指针
* 重写基类方法，创建适用于WiFi网络的WebSocket客户端
*/
virtual WebSocket* CreateWebSocket() override;
/**
* @brief 创建MQTT客户端对象
* @return Mqtt* MQTT客户端对象指针
* 重写基类方法，创建适用于WiFi网络的MQTT客户端
*/
virtual Mqtt* CreateMqtt() override;
/**
* @brief 创建UDP客户端对象
* @return Udp* UDP客户端对象指针
* 重写基类方法，创建适用于WiFi网络的UDP客户端
*/
virtual Udp* CreateUdp() override;
/**
* @brief 获取网络状态图标
* @return const char* 网络状态图标字符串
* 重写基类方法，返回当前WiFi网络状态对应的图标
*/
virtual const char* GetNetworkStateIcon() override;
/**
* @brief 设置省电模式
* @param enabled true启用省电模式，false禁用省电模式
* 重写基类方法，控制WiFi模块的省电模式
*/
virtual void SetPowerSaveMode(bool enabled) override;
/**
* @brief 重置WiFi配置
* 清除已保存的WiFi凭据，重新进入配网模式
*/
virtual void ResetWifiConfiguration();
/**
* @brief 检查BluFi配网是否激活
* @return true BluFi配网正在进行中
* @return false BluFi配网未激活
* BluFi配网状态检查方法，用于外部查询配网状态
* @brief 检查BLE配网是否激活
* @return true BLE配网正在进行中
* @return false BLE配网未激活
*/
bool IsBluFiProvisioningActive() const { return blufi_provisioning_active_; }
bool IsBleProvisioningActive() const { return ble_provisioning_active_; }
};
#endif // WIFI_BOARD_H

32
main/boards/movecall-moji-esp32s3/movecall_moji_esp32s3.cc
View File

@ -523,9 +523,9 @@ public:
auto &app = Application::GetInstance();
auto current_state = app.GetDeviceState();
// 检查是否处于BluFi配网状态，如果是则屏蔽按键响应（生产测试模式下除外）
// 检查是否处于BLE配网状态，如果是则屏蔽按键响应（生产测试模式下除外）
auto* wifi_board = dynamic_cast<WifiBoard*>(this);
if (wifi_board && wifi_board->IsBluFiProvisioningActive() && !production_test_mode_) {
if (wifi_board && wifi_board->IsBleProvisioningActive() && !production_test_mode_) {
ESP_LOGI(Pro_TAG, "🔵 当前为蓝牙配网模式,[BOOT按键]被按下，长按BOOT按键5秒可进入生产测试模式!");// 生产测试打印
ESP_LOGI("WiFiMAC", "Wi-Fi MAC Address: %s", SystemInfo::GetMacAddress().c_str());// 生产测试打印
ESP_LOGI(Pro_TAG, "当前电量值: %" PRIu32 "%%", battery_level_);// 生产测试打印
@ -606,10 +606,10 @@ public:
power_save_timer_->WakeUp();
}
else {
// 检查是否在BluFi配网模式下，如果是则屏蔽单独的BOOT按键功能
// 检查是否在BLE配网模式下，如果是则屏蔽单独的BOOT按键功能
auto* wifi_board = dynamic_cast<WifiBoard*>(this);
if (wifi_board && wifi_board->IsBluFiProvisioningActive() && !production_test_mode_) {
ESP_LOGI(TAG, "🔵 BluFi配网模式下，屏蔽单独BOOT按键功能");
if (wifi_board && wifi_board->IsBleProvisioningActive() && !production_test_mode_) {
ESP_LOGI(TAG, "🔵 BLE配网模式下，屏蔽单独BOOT按键功能");
return;
}
@ -695,10 +695,10 @@ public:
boot_button_.OnLongPress([this]() {
//ESP_LOGI(TAG, "🔧 BOOT button long pressed - checking if in provisioning mode");
// 检查是否处于BluFi配网状态，只有在配网模式下才允许进入测试模式
// 检查是否处于BLE配网状态，只有在配网模式下才允许进入测试模式
auto* wifi_board = dynamic_cast<WifiBoard*>(this);
if (wifi_board && wifi_board->IsBluFiProvisioningActive()) {
// ESP_LOGI(TAG, "🔧 设备正在进行BluFi配网，长按5秒进入生产测试模式");
if (wifi_board && wifi_board->IsBleProvisioningActive()) {
// ESP_LOGI(TAG, "🔧 设备正在进行BLE配网，长按5秒进入生产测试模式");
EnterProductionTestMode();
} else {
ESP_LOGI(TAG, "🔵 非配网模式下，BOOT长按被屏蔽，无法进入测试模式");
@ -712,10 +712,10 @@ public:
volume_up_button_.OnClick([this]() {
ESP_LOGI(TAG, "Volume up button clicked!");
// 检查是否处于BluFi配网状态，如果是则屏蔽按键响应（生产测试模式下除外）
// 检查是否处于BLE配网状态，如果是则屏蔽按键响应（生产测试模式下除外）
auto* wifi_board = dynamic_cast<WifiBoard*>(this);
if (wifi_board && wifi_board->IsBluFiProvisioningActive() && !production_test_mode_) {
ESP_LOGI(TAG, "🔵 设备正在进行BluFi配网，音量加按键被屏蔽");
if (wifi_board && wifi_board->IsBleProvisioningActive() && !production_test_mode_) {
ESP_LOGI(TAG, "🔵 设备正在进行BLE配网，音量加按键被屏蔽");
return;
}
@ -752,10 +752,10 @@ public:
volume_down_button_.OnClick([this]() {
ESP_LOGI(TAG, "Volume down button clicked!");
// 检查是否处于BluFi配网状态，如果是则屏蔽按键响应（生产测试模式下除外）
// 检查是否处于BLE配网状态，如果是则屏蔽按键响应（生产测试模式下除外）
auto* wifi_board = dynamic_cast<WifiBoard*>(this);
if (wifi_board && wifi_board->IsBluFiProvisioningActive() && !production_test_mode_) {
ESP_LOGI(TAG, "🔵 设备正在进行BluFi配网，音量减按键被屏蔽");
if (wifi_board && wifi_board->IsBleProvisioningActive() && !production_test_mode_) {
ESP_LOGI(TAG, "🔵 设备正在进行BLE配网，音量减按键被屏蔽");
return;
}
@ -1270,9 +1270,9 @@ public:
story_button_.OnClick([this]() {
ESP_LOGI(TAG, "Story button clicked!");
// 检查是否处于BluFi配网状态，如果是则屏蔽按键响应（生产测试模式下除外）
// 检查是否处于BLE配网状态，如果是则屏蔽按键响应（生产测试模式下除外）
auto* wifi_board = dynamic_cast<WifiBoard*>(this);
if (wifi_board && wifi_board->IsBluFiProvisioningActive() && !production_test_mode_) {
if (wifi_board && wifi_board->IsBleProvisioningActive() && !production_test_mode_) {
//ESP_LOGI(Pro_TAG, "🔵 设备正在进行蓝牙配网，长按BOOT按键5秒可进入生产测试模式!");
ESP_LOGI(Pro_TAG, "🔵 当前为蓝牙配网模式,[故事按键]被按下，长按BOOT按键5秒可进入生产测试模式!");
ESP_LOGI("WiFiMAC", "Wi-Fi MAC Address: %s", SystemInfo::GetMacAddress().c_str());// 生产测试打印