1182 lines
47 KiB
C++
1182 lines
47 KiB
C++
/**
|
||
* @file bluetooth_provisioning.cc
|
||
* @brief BluFi蓝牙配网模块实现文件
|
||
*
|
||
* 本文件实现了BluFi蓝牙配网的核心功能，包括：
|
||
* - 蓝牙控制器和协议栈的初始化与管理
|
||
* - BluFi服务的启动、停止和事件处理
|
||
* - WiFi凭据的接收、验证和连接管理
|
||
* - 配网状态机的管理和事件回调
|
||
* - WiFi连接状态的监控和报告
|
||
* - 配网成功后的自动保存和重启机制
|
||
*
|
||
* 该实现基于ESP-IDF的BluFi API，提供了完整的蓝牙配网解决方案。
|
||
*/
|
||
|
||
#include "bluetooth_provisioning.h"
|
||
#include "esp_log.h"
|
||
#include "esp_bt.h"
|
||
#include "esp_bt_main.h"
|
||
#include "esp_bt_device.h"
|
||
#include "esp_gap_ble_api.h"
|
||
#include "esp_blufi.h"
|
||
#include "esp_blufi_api.h"
|
||
#include "esp_wifi.h"
|
||
#include "esp_netif.h"
|
||
#include "freertos/event_groups.h"
|
||
#include "freertos/timers.h"
|
||
#include "freertos/task.h"
|
||
#include "esp_system.h"
|
||
#include "application.h"
|
||
#include "assets/lang_config.h"
|
||
#include <ssid_manager.h>
|
||
#include "nvs_flash.h"
|
||
#include "nvs.h"
|
||
#include <cstring>
|
||
|
||
/// 日志标签，用于ESP_LOG系列函数的日志输出
|
||
#define TAG "BluetoothProvisioning"
|
||
|
||
/// WiFi连接成功事件位
|
||
#define WIFI_CONNECTED_BIT BIT0
|
||
/// WiFi连接失败事件位
|
||
#define WIFI_FAIL_BIT BIT1
|
||
|
||
/// 静态单例实例指针，用于C回调函数访问类成员
|
||
BluetoothProvisioning* BluetoothProvisioning::instance_ = nullptr;
|
||
|
||
/// WiFi事件组句柄，用于同步WiFi连接状态
|
||
static EventGroupHandle_t s_wifi_event_group = nullptr;
|
||
|
||
/// WiFi连接重试计数器
|
||
static int s_retry_num = 0;
|
||
/// 最大重试次数
|
||
static const int MAX_RETRY = 2;//Wi-Fi连接最大重试次数(wifi连接失败最大重试次数)
|
||
/// WiFi连接超时时间（毫秒）
|
||
static const int WIFI_CONNECT_TIMEOUT_MS = 30000; // 增强：从15秒延长到30秒
|
||
/// WiFi连接超时定时器句柄
|
||
static TimerHandle_t wifi_connect_timer = nullptr;
|
||
|
||
/**
|
||
* @brief BLUFI回调函数配置结构体
|
||
*
|
||
* 配置BluFi服务的各种回调函数，包括事件处理、数据协商、
|
||
* 加密解密和校验等功能。当前实现仅使用事件回调。
|
||
*/
|
||
static esp_blufi_callbacks_t blufi_callbacks = {
|
||
.event_cb = BluetoothProvisioning::BlufiEventCallback, ///< 事件回调函数
|
||
.negotiate_data_handler = nullptr, ///< 数据协商处理器（可选）
|
||
.encrypt_func = nullptr, ///< 加密函数（可选）
|
||
.decrypt_func = nullptr, ///< 解密函数（可选）
|
||
.checksum_func = nullptr, ///< 校验函数（可选）
|
||
};
|
||
|
||
/**
|
||
* @brief 构造函数
|
||
*
|
||
* 初始化蓝牙配网对象的所有成员变量，设置初始状态，
|
||
* 清空WiFi凭据，并设置静态实例指针用于回调函数访问。
|
||
*/
|
||
BluetoothProvisioning::BluetoothProvisioning()
|
||
: state_(BluetoothProvisioningState::IDLE) ///< 初始状态为空闲
|
||
, callback_(nullptr) ///< 回调函数指针初始化为空
|
||
, client_connected_(false) ///< 客户端连接状态初始化为未连接
|
||
, initialized_(false) ///< 初始化状态标志为未初始化
|
||
, delayed_disconnect_(false) ///< 延迟断开标志初始化为false
|
||
, wifi_connecting_(false) ///< WiFi连接状态标志初始化为false
|
||
, mac_address_sent_(false) { ///< MAC地址发送状态初始化为未发送
|
||
|
||
// 清空WiFi凭据结构体
|
||
wifi_credentials_.ssid.clear();
|
||
wifi_credentials_.password.clear();
|
||
memset(wifi_credentials_.bssid, 0, sizeof(wifi_credentials_.bssid));
|
||
wifi_credentials_.bssid_set = false;
|
||
|
||
// 设置静态实例指针，用于C风格回调函数访问类成员
|
||
instance_ = this;
|
||
|
||
ESP_LOGI(TAG, "蓝牙配网对象创建完成");
|
||
}
|
||
|
||
/**
|
||
* @brief 析构函数
|
||
*
|
||
* 清理蓝牙配网对象的所有资源，包括停止配网服务、
|
||
* 释放蓝牙资源、清空静态实例指针等。
|
||
*/
|
||
BluetoothProvisioning::~BluetoothProvisioning() {
|
||
// 确保资源被正确释放，如果已初始化则进行反初始化
|
||
if (initialized_) {
|
||
Deinitialize();
|
||
}
|
||
|
||
// 清空静态实例指针
|
||
instance_ = nullptr;
|
||
ESP_LOGI(TAG, "蓝牙配网对象销毁完成");
|
||
}
|
||
|
||
/**
|
||
* @brief 初始化蓝牙配网功能
|
||
*
|
||
* 按顺序初始化以下组件：
|
||
* 1. WiFi模块（STA模式）
|
||
* 2. 蓝牙控制器
|
||
* 3. Bluedroid协议栈
|
||
* 4. BluFi服务和回调
|
||
* 5. WiFi事件处理器
|
||
*
|
||
* @return true 初始化成功，false 初始化失败
|
||
*/
|
||
bool BluetoothProvisioning::Initialize() {
|
||
if (initialized_) {
|
||
ESP_LOGW(TAG, "蓝牙配网已经初始化");
|
||
return true;
|
||
}
|
||
|
||
SetState(BluetoothProvisioningState::INITIALIZING);
|
||
|
||
esp_err_t ret;
|
||
|
||
// 步骤1: 初始化WiFi模块
|
||
ESP_LOGI(TAG, "初始化WiFi...");
|
||
|
||
// 创建默认WiFi STA网络接口
|
||
esp_netif_create_default_wifi_sta();
|
||
|
||
// 使用默认配置初始化WiFi
|
||
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
|
||
ret = esp_wifi_init(&cfg);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "WiFi初始化失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 设置WiFi工作模式为STA（Station）模式
|
||
ret = esp_wifi_set_mode(WIFI_MODE_STA);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "WiFi模式设置失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 启动WiFi服务
|
||
ret = esp_wifi_start();
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "WiFi启动失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
ESP_LOGI(TAG, "WiFi初始化完成");
|
||
|
||
// 步骤2: 初始化蓝牙控制器
|
||
ESP_LOGI(TAG, "初始化蓝牙控制器...");
|
||
|
||
#if CONFIG_IDF_TARGET_ESP32
|
||
// ESP32芯片需要释放经典蓝牙内存以节省空间
|
||
ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));
|
||
#endif
|
||
|
||
// 使用默认配置初始化蓝牙控制器
|
||
esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
|
||
ret = esp_bt_controller_init(&bt_cfg);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "蓝牙控制器初始化失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 启用蓝牙控制器，仅使用BLE模式
|
||
ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "蓝牙控制器启用失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 步骤3: 初始化Bluedroid协议栈
|
||
ESP_LOGI(TAG, "初始化Bluedroid协议栈...");
|
||
|
||
// 初始化Bluedroid蓝牙协议栈
|
||
ret = esp_bluedroid_init();
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "Bluedroid初始化失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 启用Bluedroid协议栈
|
||
ret = esp_bluedroid_enable();
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "Bluedroid启用失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 注意：设备名称将在StartProvisioning中设置
|
||
ESP_LOGI(TAG, "蓝牙初始化完成，设备名称将在启动配网时设置");
|
||
|
||
// 步骤4: 注册BluFi服务和回调函数
|
||
ESP_LOGI(TAG, "注册BLUFI回调函数...");
|
||
|
||
// 注册BluFi事件回调函数
|
||
ret = esp_blufi_register_callbacks(&blufi_callbacks);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "BLUFI回调注册失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 注册BLE GAP（Generic Access Profile）事件处理器
|
||
ret = esp_ble_gap_register_callback(esp_blufi_gap_event_handler);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "BLE GAP事件处理器注册失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 初始化BluFi配置文件
|
||
ret = esp_blufi_profile_init();
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "BLUFI配置文件初始化失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);//BLUFI配置文件初始化失败，设置状态为FAILED
|
||
return false;
|
||
}
|
||
|
||
// 步骤5: 创建WiFi事件同步机制
|
||
if (s_wifi_event_group == nullptr) {
|
||
s_wifi_event_group = xEventGroupCreate();
|
||
if (s_wifi_event_group == nullptr) {
|
||
ESP_LOGE(TAG, "WiFi事件组创建失败");
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 步骤6: 注册WiFi和IP事件处理器
|
||
ESP_LOGI(TAG, "注册WiFi事件处理器...");
|
||
|
||
// 注册WiFi事件处理器，监听所有WiFi相关事件
|
||
ret = esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &WiFiEventHandler, this);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "WiFi事件处理器注册失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 注册IP事件处理器，监听IP地址获取事件
|
||
ret = esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &IPEventHandler, this);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "IP事件处理器注册失败: %s", esp_err_to_name(ret));
|
||
SetState(BluetoothProvisioningState::FAILED);
|
||
return false;
|
||
}
|
||
|
||
// 标记初始化完成，设置状态为空闲
|
||
initialized_ = true;
|
||
SetState(BluetoothProvisioningState::IDLE);
|
||
|
||
ESP_LOGI(TAG, "蓝牙配网初始化完成");
|
||
ESP_LOGI(TAG, "蓝牙MAC地址: " ESP_BD_ADDR_STR, ESP_BD_ADDR_HEX(esp_bt_dev_get_address()));
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 反初始化蓝牙配网功能
|
||
*
|
||
* 按相反顺序清理所有初始化的组件和资源：
|
||
* 1. 停止配网服务
|
||
* 2. 注销事件处理器
|
||
* 3. 销毁WiFi事件组
|
||
* 4. 反初始化BluFi服务
|
||
* 5. 反初始化Bluedroid协议栈
|
||
* 6. 反初始化蓝牙控制器
|
||
*
|
||
* @return true 反初始化成功，false 反初始化失败
|
||
*/
|
||
bool BluetoothProvisioning::Deinitialize() {
|
||
if (!initialized_) {
|
||
ESP_LOGW(TAG, "蓝牙配网未初始化");
|
||
return true;
|
||
}
|
||
|
||
ESP_LOGI(TAG, "开始反初始化蓝牙配网...");
|
||
|
||
// 步骤1: 停止配网服务（如果正在运行）
|
||
if (state_ != BluetoothProvisioningState::IDLE &&
|
||
state_ != BluetoothProvisioningState::STOPPED) {
|
||
StopProvisioning();
|
||
}
|
||
|
||
// 步骤2: 注销事件处理器
|
||
esp_event_handler_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, &WiFiEventHandler);
|
||
esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, &IPEventHandler);
|
||
|
||
// 步骤3: 销毁WiFi事件同步机制
|
||
if (s_wifi_event_group != nullptr) {
|
||
vEventGroupDelete(s_wifi_event_group);
|
||
s_wifi_event_group = nullptr;
|
||
}
|
||
|
||
// 步骤4: 反初始化BluFi服务
|
||
esp_blufi_profile_deinit();
|
||
|
||
// 步骤5: 反初始化Bluedroid协议栈
|
||
esp_bluedroid_disable();
|
||
esp_bluedroid_deinit();
|
||
|
||
// 步骤6: 反初始化蓝牙控制器
|
||
esp_bt_controller_disable();
|
||
esp_bt_controller_deinit();
|
||
|
||
// 标记为未初始化状态
|
||
initialized_ = false;
|
||
SetState(BluetoothProvisioningState::STOPPED);
|
||
|
||
ESP_LOGI(TAG, "蓝牙配网反初始化完成");
|
||
return true;
|
||
}
|
||
// 开始配网
|
||
bool BluetoothProvisioning::StartProvisioning(const char* device_name) {
|
||
ESP_LOGI(TAG, "🔵 开始启动BluFi配网服务...");
|
||
ESP_LOGI(TAG, "🔍 检查初始化状态: initialized_ = %s", initialized_ ? "true" : "false");
|
||
|
||
if (!initialized_) {
|
||
ESP_LOGE(TAG, "❌ 蓝牙配网未初始化，无法启动");
|
||
return false;
|
||
}
|
||
|
||
if (state_ == BluetoothProvisioningState::ADVERTISING ||
|
||
state_ == BluetoothProvisioningState::CONNECTED ||
|
||
state_ == BluetoothProvisioningState::PROVISIONING) {
|
||
ESP_LOGW(TAG, "⚠️ 蓝牙配网已在运行中");
|
||
return true;
|
||
}
|
||
|
||
ESP_LOGI(TAG, "🚀 开始蓝牙配网，设备名称: %s", device_name);
|
||
|
||
// 重置状态
|
||
client_connected_ = false;
|
||
s_retry_num = 0;
|
||
|
||
// 重置MAC地址发送状态，为新的配网会话做准备
|
||
ResetMacSendingState();
|
||
ESP_LOGI(TAG, "🔄 MAC地址发送状态已重置");
|
||
|
||
// 清空之前的WiFi凭据
|
||
ESP_LOGI(TAG, "🧹 清除之前的WiFi凭据...");
|
||
if (!wifi_credentials_.ssid.empty()) {
|
||
ESP_LOGI(TAG, "🗑️ 删除已保存的SSID: %s", wifi_credentials_.ssid.c_str());
|
||
}
|
||
if (!wifi_credentials_.password.empty()) {
|
||
ESP_LOGI(TAG, "🗑️ 删除已保存的WiFi密码 (长度: %d)", wifi_credentials_.password.length());
|
||
}
|
||
wifi_credentials_.ssid.clear();
|
||
wifi_credentials_.password.clear();
|
||
wifi_credentials_.bssid_set = false;
|
||
ESP_LOGI(TAG, "✅ WiFi凭据清除完成，准备接收新的配网信息");
|
||
|
||
// 开始BLUFI广播
|
||
esp_blufi_adv_start();
|
||
ESP_LOGI(TAG, "BLUFI广播已启动");
|
||
|
||
// // 配置自定义广播数据包以确保设备名称正确显示（改蓝牙名称 必备操作）
|
||
// //=====================================================================================================
|
||
// esp_ble_adv_data_t adv_data = {};
|
||
// adv_data.set_scan_rsp = false;
|
||
// adv_data.include_name = true; // 包含设备名称
|
||
// adv_data.include_txpower = true;
|
||
// adv_data.min_interval = 0x0006;
|
||
// adv_data.max_interval = 0x0010;
|
||
// adv_data.appearance = 0x00;
|
||
|
||
// // 添加厂商特定数据
|
||
// static uint8_t manufacturer_data[] = {0xFF, 0xFF, 0x00, 0x00}; // ESP厂商ID
|
||
// adv_data.manufacturer_len = sizeof(manufacturer_data);
|
||
// adv_data.p_manufacturer_data = manufacturer_data;
|
||
|
||
// adv_data.service_data_len = 0;
|
||
// adv_data.p_service_data = NULL;
|
||
// // 添加BluFi服务UUID，确保ESP官方APP能够识别
|
||
// // UUID: 0000FFFF-0000-1000-8000-00805F9B34FB (小端序)
|
||
// static uint8_t blufi_service_uuid128[16] = {
|
||
// 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x10,
|
||
// 0x00, 0x80, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb
|
||
// };
|
||
// adv_data.service_uuid_len = sizeof(blufi_service_uuid128);
|
||
// adv_data.p_service_uuid = blufi_service_uuid128;
|
||
// adv_data.flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT);
|
||
// //===================================================
|
||
|
||
// // 重新设置设备名称并配置广播数据
|
||
// esp_err_t ret = esp_ble_gap_set_device_name(device_name);
|
||
// if (ret != ESP_OK) {
|
||
// ESP_LOGE(TAG, "❌ 设置蓝牙设备名称失败: %s", esp_err_to_name(ret));
|
||
// return false;
|
||
// }
|
||
|
||
// ret = esp_ble_gap_config_adv_data(&adv_data);
|
||
// if (ret != ESP_OK) {
|
||
// ESP_LOGE(TAG, "❌ 配置广播数据失败: %s", esp_err_to_name(ret));
|
||
// return false;
|
||
// }
|
||
|
||
// // 配置广播参数（按官方示例设置）
|
||
// //==================================================
|
||
// esp_ble_adv_params_t adv_params = {};
|
||
// adv_params.adv_int_min = 0x100; // 100ms间隔
|
||
// adv_params.adv_int_max = 0x100; // 100ms间隔
|
||
// adv_params.adv_type = ADV_TYPE_IND;
|
||
// adv_params.own_addr_type = BLE_ADDR_TYPE_PUBLIC;
|
||
// adv_params.channel_map = ADV_CHNL_ALL;
|
||
// adv_params.adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
|
||
// // 配置完所有广播数据后再启动广播
|
||
// //==================================================
|
||
|
||
// ret = esp_ble_gap_start_advertising(&adv_params);
|
||
// if (ret != ESP_OK) {
|
||
// ESP_LOGE(TAG, "❌ 启动广播失败: %s", esp_err_to_name(ret));
|
||
// return false;
|
||
// }
|
||
// ESP_LOGI(TAG, "✅ 蓝牙设备名称和广播数据配置成功: %s", device_name);
|
||
// //=====================================================================================================
|
||
|
||
SetState(BluetoothProvisioningState::ADVERTISING);// 设置蓝牙状态为广播中
|
||
ESP_LOGI(TAG, "蓝牙配网广播已启动，等待客户端连接...");
|
||
|
||
return true;
|
||
}
|
||
|
||
// 停止蓝牙配网
|
||
bool BluetoothProvisioning::StopProvisioning() {
|
||
if (state_ == BluetoothProvisioningState::IDLE ||
|
||
state_ == BluetoothProvisioningState::STOPPED) {
|
||
ESP_LOGW(TAG, "蓝牙配网未在运行");
|
||
return true;
|
||
}
|
||
|
||
ESP_LOGI(TAG, "停止蓝牙配网...");
|
||
|
||
// 停止BLUFI广播
|
||
esp_blufi_adv_stop();
|
||
|
||
// 如果有客户端连接，断开连接
|
||
if (client_connected_) {
|
||
esp_blufi_disconnect();
|
||
}
|
||
|
||
SetState(BluetoothProvisioningState::IDLE);
|
||
ESP_LOGI(TAG, "蓝牙配网已停止");
|
||
|
||
return true;
|
||
}
|
||
|
||
// 向客户端/小程序 报告WiFi连接状态
|
||
void BluetoothProvisioning::ReportWiFiStatus(bool success, uint8_t reason) {
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] ReportWiFiStatus调用: success=%s, client_connected_=%s",
|
||
success ? "true" : "false", client_connected_ ? "true" : "false");
|
||
if (!client_connected_) {
|
||
ESP_LOGW(TAG, "客户端未连接，无法发送WiFi状态");
|
||
return;
|
||
}
|
||
|
||
wifi_mode_t mode;
|
||
esp_wifi_get_mode(&mode);//获取当前WiFi模式
|
||
|
||
if (success) {
|
||
ESP_LOGI(TAG, "向客户端报告设备连接WiFi成功!");
|
||
esp_err_t ret = esp_blufi_send_wifi_conn_report(mode, ESP_BLUFI_STA_CONN_SUCCESS, 0, nullptr);
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] WiFi成功报告发送结果: %s", esp_err_to_name(ret));
|
||
} else {
|
||
ESP_LOGI(TAG, "向客户端报告连接WiFi失败，原因: %d", reason);
|
||
esp_blufi_extra_info_t info;
|
||
memset(&info, 0, sizeof(info));
|
||
info.sta_conn_end_reason_set = true;
|
||
info.sta_conn_end_reason = reason;
|
||
esp_err_t ret = esp_blufi_send_wifi_conn_report(mode, ESP_BLUFI_STA_CONN_FAIL, 0, &info);
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] WiFi失败报告发送结果: %s", esp_err_to_name(ret));
|
||
}
|
||
}
|
||
|
||
// 将WI-FI扫描列表 发送给客户端（Wi-Fi扫描）
|
||
void BluetoothProvisioning::SendWiFiList(const wifi_ap_record_t* ap_list, uint16_t ap_count) {
|
||
if (!client_connected_) {
|
||
ESP_LOGW(TAG, "客户端未连接，无法发送WiFi列表");
|
||
return;
|
||
}
|
||
|
||
if (ap_list == nullptr || ap_count == 0) {
|
||
ESP_LOGW(TAG, "WiFi列表为空");
|
||
return;
|
||
}
|
||
|
||
// 转换为BLUFI格式
|
||
esp_blufi_ap_record_t* blufi_ap_list = new esp_blufi_ap_record_t[ap_count];
|
||
if (blufi_ap_list == nullptr) {
|
||
ESP_LOGE(TAG, "内存分配失败");
|
||
return;
|
||
}
|
||
|
||
// 用于SSID去重的映射表
|
||
std::map<std::string, int> ssid_map;
|
||
|
||
uint16_t valid_ap_count = 0;
|
||
for (uint16_t i = 0; i < ap_count; i++) {
|
||
// ESP32-S3只支持2.4GHz WiFi（信道1-14），过滤掉5GHz WiFi
|
||
if (ap_list[i].primary < 1 || ap_list[i].primary > 14) {
|
||
ESP_LOGD(TAG, "跳过5GHz WiFi: %s, Channel: %d (ESP32-S3只支持2.4GHz)",
|
||
ap_list[i].ssid, ap_list[i].primary);
|
||
continue;
|
||
}
|
||
|
||
// SSID去重：只保留RSSI最强的AP
|
||
std::string ssid_str((char*)ap_list[i].ssid);
|
||
if (ssid_map.find(ssid_str) != ssid_map.end()) {
|
||
// 检查是否比已保存的AP信号更强
|
||
if (ap_list[i].rssi > ssid_map[ssid_str]) {
|
||
ESP_LOGD(TAG, "发现更强信号的同名AP: %s, 新RSSI=%d, 旧RSSI=%d",
|
||
ssid_str.c_str(), ap_list[i].rssi, ssid_map[ssid_str]);
|
||
// 替换为更强的信号
|
||
for (uint16_t j = 0; j < valid_ap_count; j++) {
|
||
if (strcmp((char*)blufi_ap_list[j].ssid, ssid_str.c_str()) == 0) {
|
||
blufi_ap_list[j].rssi = ap_list[i].rssi;
|
||
ssid_map[ssid_str] = ap_list[i].rssi;
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
ESP_LOGD(TAG, "跳过较弱信号的同名AP: %s, RSSI=%d, 已有RSSI=%d",
|
||
ssid_str.c_str(), ap_list[i].rssi, ssid_map[ssid_str]);
|
||
continue;
|
||
}
|
||
} else {
|
||
// 首次遇到该SSID，直接添加
|
||
blufi_ap_list[valid_ap_count].rssi = ap_list[i].rssi;
|
||
memcpy(blufi_ap_list[valid_ap_count].ssid, ap_list[i].ssid, sizeof(ap_list[i].ssid));
|
||
ssid_map[ssid_str] = ap_list[i].rssi;
|
||
valid_ap_count++;
|
||
}
|
||
}
|
||
|
||
ESP_LOGI(TAG, "向客户端发送WiFi列表，共%d个AP（过滤后%d个2.4GHz AP，去重后%d个唯一SSID）",
|
||
ap_count, valid_ap_count, ssid_map.size());
|
||
esp_blufi_send_wifi_list(valid_ap_count, blufi_ap_list);
|
||
|
||
delete[] blufi_ap_list;
|
||
}
|
||
|
||
bool BluetoothProvisioning::SendMacAddressReliably() {
|
||
// 第一重检查：基本连接状态
|
||
if (!client_connected_) {
|
||
ESP_LOGW(TAG, "客户端未连接，无法发送MAC地址");
|
||
return false;
|
||
}
|
||
|
||
// 获取设备MAC地址
|
||
uint8_t mac[6];
|
||
esp_err_t ret = esp_wifi_get_mac(WIFI_IF_STA, mac);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "获取MAC地址失败: %s", esp_err_to_name(ret));
|
||
return false;
|
||
}
|
||
|
||
// 格式化MAC地址字符串
|
||
char mac_str[18];
|
||
snprintf(mac_str, sizeof(mac_str), "%02X:%02X:%02X:%02X:%02X:%02X",
|
||
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
||
|
||
// 检查是否已经发送过MAC地址（WiFi MAC地址不会因重启而变化）
|
||
if (mac_address_sent_) {
|
||
ESP_LOGI(TAG, "MAC地址已发送过，跳过重复发送: %s", mac_str);
|
||
return true;
|
||
}
|
||
|
||
ESP_LOGI(TAG, "开始可靠发送MAC地址: %s", mac_str);
|
||
|
||
// 多次重试发送机制
|
||
const int MAX_SEND_ATTEMPTS = 3;
|
||
const int RETRY_DELAY_MS = 50;
|
||
|
||
for (int attempt = 1; attempt <= MAX_SEND_ATTEMPTS; attempt++) {
|
||
// 第二重检查：发送前再次确认连接状态
|
||
if (!client_connected_) {
|
||
ESP_LOGW(TAG, "发送前检查发现客户端已断开连接 (尝试 %d/%d)", attempt, MAX_SEND_ATTEMPTS);
|
||
return false;
|
||
}
|
||
|
||
ESP_LOGI(TAG, "发送MAC地址尝试 %d/%d: %s", attempt, MAX_SEND_ATTEMPTS, mac_str);
|
||
|
||
// 创建包含MAC地址的自定义数据（还原原有格式）
|
||
char mac_data[32];
|
||
snprintf(mac_data, sizeof(mac_data), "STA_MAC:%02x:%02x:%02x:%02x:%02x:%02x",
|
||
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
||
|
||
// 发送带前缀的MAC地址数据
|
||
ret = esp_blufi_send_custom_data((uint8_t*)mac_data, strlen(mac_data));
|
||
|
||
if (ret == ESP_OK) {
|
||
ESP_LOGI(TAG, "✅ MAC地址发送成功 (尝试 %d/%d): %s", attempt, MAX_SEND_ATTEMPTS, mac_str);
|
||
|
||
// 记录发送状态
|
||
mac_address_sent_ = true;
|
||
|
||
// 发送成功后的确认延迟
|
||
vTaskDelay(pdMS_TO_TICKS(100));
|
||
|
||
// 第三重检查：发送后确认连接仍然有效
|
||
if (client_connected_) {
|
||
ESP_LOGI(TAG, "MAC地址发送完成，连接状态正常");
|
||
return true;
|
||
} else {
|
||
ESP_LOGW(TAG, "MAC地址发送后检测到连接断开");
|
||
return false;
|
||
}
|
||
} else {
|
||
ESP_LOGW(TAG, "❌ MAC地址发送失败 (尝试 %d/%d): %s, 错误: %s",
|
||
attempt, MAX_SEND_ATTEMPTS, mac_str, esp_err_to_name(ret));
|
||
|
||
// 如果不是最后一次尝试，等待后重试
|
||
if (attempt < MAX_SEND_ATTEMPTS) {
|
||
vTaskDelay(pdMS_TO_TICKS(RETRY_DELAY_MS));
|
||
}
|
||
}
|
||
}
|
||
|
||
ESP_LOGE(TAG, "MAC地址发送失败，已达到最大重试次数: %s", mac_str);
|
||
return false;
|
||
}
|
||
|
||
void BluetoothProvisioning::ResetMacSendingState() {
|
||
mac_address_sent_ = false;
|
||
ESP_LOGI(TAG, "MAC地址发送状态已重置");
|
||
}
|
||
|
||
void BluetoothProvisioning::SetState(BluetoothProvisioningState new_state) {
|
||
if (state_ != new_state) {
|
||
BluetoothProvisioningState old_state = state_;
|
||
state_ = new_state;
|
||
|
||
const char* state_names[] = {
|
||
"IDLE", "INITIALIZING", "ADVERTISING", "CONNECTED",
|
||
"PROVISIONING", "SUCCESS", "FAILED", "STOPPED"
|
||
};
|
||
|
||
ESP_LOGI(TAG, "🔄 BluFi状态变化: %s -> %s",
|
||
state_names[static_cast<int>(old_state)],
|
||
state_names[static_cast<int>(new_state)]);
|
||
|
||
TriggerCallback(BluetoothProvisioningEvent::STATE_CHANGED, nullptr);
|
||
}
|
||
}
|
||
|
||
void BluetoothProvisioning::TriggerCallback(BluetoothProvisioningEvent event, void* data) {
|
||
if (callback_) {
|
||
callback_(event, data);
|
||
}
|
||
}
|
||
|
||
std::string BluetoothProvisioning::GetStateString() const {
|
||
const char* state_names[] = {
|
||
"IDLE", "INITIALIZING", "ADVERTISING", "CONNECTED",
|
||
"PROVISIONING", "SUCCESS", "FAILED", "STOPPED"
|
||
};
|
||
return std::string(state_names[static_cast<int>(state_)]);
|
||
}
|
||
|
||
// BLUFI事件回调函数
|
||
void BluetoothProvisioning::BlufiEventCallback(esp_blufi_cb_event_t event, esp_blufi_cb_param_t* param) {
|
||
if (instance_ == nullptr) {
|
||
ESP_LOGE(TAG, "实例指针为空");
|
||
return;
|
||
}
|
||
|
||
// 打印事件详细信息
|
||
const char* event_name = "UNKNOWN";
|
||
switch (event) {
|
||
case ESP_BLUFI_EVENT_INIT_FINISH: event_name = "INIT_FINISH"; break;
|
||
case ESP_BLUFI_EVENT_DEINIT_FINISH: event_name = "DEINIT_FINISH"; break;
|
||
case ESP_BLUFI_EVENT_BLE_CONNECT: event_name = "BLE_CONNECT"; break;
|
||
case ESP_BLUFI_EVENT_BLE_DISCONNECT: event_name = "BLE_DISCONNECT"; break;
|
||
case ESP_BLUFI_EVENT_RECV_CUSTOM_DATA: event_name = "RECV_CUSTOM_DATA"; break;
|
||
case ESP_BLUFI_EVENT_RECV_STA_SSID: event_name = "RECV_STA_SSID"; break;
|
||
case ESP_BLUFI_EVENT_RECV_STA_PASSWD: event_name = "RECV_STA_PASSWD"; break;
|
||
case ESP_BLUFI_EVENT_GET_WIFI_LIST: event_name = "GET_WIFI_LIST"; break;
|
||
default: break;
|
||
}
|
||
// 打印事件参数
|
||
ESP_LOGI(TAG, "🔔 BluFi事件回调: %d (%s), param=%p", event, event_name, param);
|
||
|
||
switch (event) {
|
||
case ESP_BLUFI_EVENT_INIT_FINISH:
|
||
ESP_LOGI(TAG, "✅ BLUFI初始化完成");
|
||
break;
|
||
|
||
case ESP_BLUFI_EVENT_DEINIT_FINISH:
|
||
ESP_LOGI(TAG, "BLUFI反初始化完成");
|
||
break;
|
||
|
||
// 客户端连接事件
|
||
case ESP_BLUFI_EVENT_BLE_CONNECT:
|
||
ESP_LOGI(TAG, "📱 BluFi客户端已连接");//GATT连接成功建立
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] 设置client_connected_为true");
|
||
instance_->client_connected_ = true;//GATT连接成功建立，标志位设置为true
|
||
// 重置MAC地址发送状态，为新的配网会话做准备
|
||
instance_->ResetMacSendingState();
|
||
ESP_LOGI(TAG, "🔄 MAC地址发送状态已重置");
|
||
instance_->SetState(BluetoothProvisioningState::CONNECTED); //GATT连接成功建立，状态设置为CONNECTED
|
||
instance_->TriggerCallback(BluetoothProvisioningEvent::CLIENT_CONNECTED, nullptr);//回调通知，通知上层应用有客户端连接
|
||
|
||
// // 在Wi-Fi连接前向客户端发送Mac地址
|
||
// // 🆕 在BluFi客户端连接成功后立即发送MAC地址
|
||
// ESP_LOGI(TAG, "📡 BluFi客户端连接成功，立即发送设备MAC地址");
|
||
// if (instance_->SendMacAddressReliably()) {
|
||
// ESP_LOGI(TAG, "✅ BluFi连接后MAC地址发送成功");
|
||
// } else {
|
||
// ESP_LOGW(TAG, "⚠️ BluFi连接后MAC地址发送失败，将在Wi-Fi连接成功后重试");
|
||
// }
|
||
|
||
// 停止广播
|
||
esp_blufi_adv_stop();
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] BLE连接处理完成，client_connected_=%s",
|
||
instance_->client_connected_ ? "true" : "false");
|
||
break;
|
||
// 客户端断开连接事件
|
||
case ESP_BLUFI_EVENT_BLE_DISCONNECT:
|
||
ESP_LOGI(TAG, "📱 BluFi客户端已断开连接，当前状态: %s",
|
||
instance_->GetStateString().c_str());
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] 设置client_connected_为false");
|
||
instance_->client_connected_ = false;
|
||
|
||
// 如果正在配网过程中，延迟处理断开事件，给WiFi连接更多时间
|
||
if (instance_->state_ == BluetoothProvisioningState::PROVISIONING) {
|
||
ESP_LOGW(TAG, "⚠️ 配网过程中BLE断开，延迟5秒后处理以等待WiFi连接完成");
|
||
// 设置一个标志，延迟处理断开
|
||
instance_->delayed_disconnect_ = true;
|
||
// 创建延迟任务
|
||
xTaskCreate([](void* param) {
|
||
vTaskDelay(pdMS_TO_TICKS(2000)); // 缩短延迟到2秒
|
||
BluetoothProvisioning* self = static_cast<BluetoothProvisioning*>(param);
|
||
if (self->delayed_disconnect_) {
|
||
if (self->state_ == BluetoothProvisioningState::PROVISIONING && self->wifi_connecting_) {
|
||
ESP_LOGW(TAG, "⏰ BLE延迟断开，但WiFi仍在连接中，继续等待");
|
||
// WiFi仍在连接，不断开BLE，让WiFi超时定时器处理
|
||
} else if (self->state_ == BluetoothProvisioningState::PROVISIONING) {
|
||
ESP_LOGW(TAG, "⏰ 延迟处理BLE断开，WiFi连接可能已超时");
|
||
self->SetState(BluetoothProvisioningState::ADVERTISING);
|
||
self->TriggerCallback(BluetoothProvisioningEvent::CLIENT_DISCONNECTED, nullptr);
|
||
esp_blufi_adv_start();
|
||
}
|
||
self->delayed_disconnect_ = false;
|
||
}
|
||
vTaskDelete(nullptr);
|
||
}, "delayed_disconnect", 2048, instance_, 1, nullptr);
|
||
} else {
|
||
instance_->SetState(BluetoothProvisioningState::ADVERTISING);
|
||
instance_->TriggerCallback(BluetoothProvisioningEvent::CLIENT_DISCONNECTED, nullptr);
|
||
// 重新开始广播
|
||
esp_blufi_adv_start();
|
||
}
|
||
break;
|
||
|
||
// 设置WiFi模式
|
||
case ESP_BLUFI_EVENT_SET_WIFI_OPMODE:
|
||
ESP_LOGI(TAG, "设置WiFi模式: %d", param->wifi_mode.op_mode);
|
||
esp_wifi_set_mode(param->wifi_mode.op_mode);
|
||
break;
|
||
|
||
// 请求连接到AP （Wi-Fi）
|
||
case ESP_BLUFI_EVENT_REQ_CONNECT_TO_AP:
|
||
ESP_LOGI(TAG, "📡 请求连接到AP，SSID: %s", instance_->wifi_credentials_.ssid.c_str());
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] 当前状态: %s, client_connected_: %s",
|
||
instance_->GetStateString().c_str(),
|
||
instance_->client_connected_ ? "true" : "false");
|
||
instance_->SetState(BluetoothProvisioningState::PROVISIONING);
|
||
instance_->delayed_disconnect_ = false; // 重置延迟断开标志
|
||
s_retry_num = 0; // 重置重试计数
|
||
ESP_LOGI(TAG, "🔄 重置WiFi重试计数，开始连接流程");
|
||
// 断开当前WiFi连接（如果有）
|
||
esp_wifi_disconnect();
|
||
vTaskDelay(pdMS_TO_TICKS(100)); // 短暂延迟确保断开完成
|
||
// 连接到新的AP
|
||
esp_wifi_connect();//连接到新的 Wi-Fi
|
||
ESP_LOGI(TAG, "🚀 已发起WiFi连接请求");
|
||
break;
|
||
|
||
// 请求断开AP连接
|
||
case ESP_BLUFI_EVENT_REQ_DISCONNECT_FROM_AP:
|
||
ESP_LOGI(TAG, "请求断开AP连接");
|
||
esp_wifi_disconnect();//断开当前连接的AP
|
||
break;
|
||
|
||
// 接收到WI-FI的 SSID
|
||
case ESP_BLUFI_EVENT_RECV_STA_SSID:
|
||
ESP_LOGI(TAG, "📶 收到WiFi SSID: %.*s", param->sta_ssid.ssid_len, param->sta_ssid.ssid);
|
||
instance_->wifi_credentials_.ssid.assign(
|
||
reinterpret_cast<const char*>(param->sta_ssid.ssid),
|
||
param->sta_ssid.ssid_len);//保存Wi-Fi的 SSID
|
||
|
||
// 设置WiFi配置
|
||
{
|
||
wifi_config_t wifi_config = {};
|
||
strncpy(reinterpret_cast<char*>(wifi_config.sta.ssid),
|
||
instance_->wifi_credentials_.ssid.c_str(),
|
||
sizeof(wifi_config.sta.ssid) - 1);
|
||
esp_wifi_set_config(WIFI_IF_STA, &wifi_config);//设置WiFi配置
|
||
}
|
||
break;
|
||
|
||
// 接收到WI-FI的 密码
|
||
case ESP_BLUFI_EVENT_RECV_STA_PASSWD:
|
||
ESP_LOGI(TAG, "🔐 收到WiFi密码 (长度: %d)", param->sta_passwd.passwd_len);
|
||
instance_->wifi_credentials_.password.assign(
|
||
reinterpret_cast<const char*>(param->sta_passwd.passwd),
|
||
param->sta_passwd.passwd_len);// 保存WI-FI密码凭证
|
||
|
||
// 设置WiFi配置
|
||
{
|
||
wifi_config_t wifi_config = {};
|
||
strncpy(reinterpret_cast<char*>(wifi_config.sta.ssid),
|
||
instance_->wifi_credentials_.ssid.c_str(),
|
||
sizeof(wifi_config.sta.ssid) - 1);
|
||
strncpy(reinterpret_cast<char*>(wifi_config.sta.password),
|
||
instance_->wifi_credentials_.password.c_str(),
|
||
sizeof(wifi_config.sta.password) - 1);
|
||
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));//设置WiFi配置
|
||
}
|
||
|
||
// 重置重试计数器
|
||
s_retry_num = 0;
|
||
instance_->wifi_connecting_ = true;
|
||
|
||
// 启动WiFi连接超时定时器
|
||
if (wifi_connect_timer) {
|
||
xTimerStop(wifi_connect_timer, 0);
|
||
xTimerDelete(wifi_connect_timer, 0);
|
||
}
|
||
wifi_connect_timer = xTimerCreate("wifi_timeout",
|
||
pdMS_TO_TICKS(WIFI_CONNECT_TIMEOUT_MS),
|
||
pdFALSE, nullptr,
|
||
[](TimerHandle_t timer) {
|
||
ESP_LOGW(TAG, "⏰ WiFi连接超时，强制失败处理");
|
||
if (instance_ && instance_->wifi_connecting_) {
|
||
instance_->wifi_connecting_ = false;
|
||
instance_->delayed_disconnect_ = false;
|
||
instance_->SetState(BluetoothProvisioningState::FAILED);
|
||
instance_->TriggerCallback(BluetoothProvisioningEvent::WIFI_FAILED, nullptr);
|
||
instance_->ReportWiFiStatus(false, WIFI_REASON_UNSPECIFIED);
|
||
xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
|
||
}
|
||
});
|
||
xTimerStart(wifi_connect_timer, 0);
|
||
|
||
esp_wifi_connect(); // 核心连接函数，连接到WiFi
|
||
ESP_LOGI(TAG, "📡 已发起WiFi连接请求，启动15秒超时监控");
|
||
|
||
instance_->TriggerCallback(BluetoothProvisioningEvent::WIFI_CREDENTIALS,
|
||
&instance_->wifi_credentials_);
|
||
break;
|
||
|
||
// 接收到WI-FI的 BSSID 特定接入点MAC地址
|
||
case ESP_BLUFI_EVENT_RECV_STA_BSSID:
|
||
ESP_LOGI(TAG, "收到BSSID");
|
||
memcpy(instance_->wifi_credentials_.bssid, param->sta_bssid.bssid, 6);
|
||
instance_->wifi_credentials_.bssid_set = true;// 标记BSSID已设置
|
||
|
||
// 设置WiFi配置
|
||
{
|
||
wifi_config_t wifi_config = {};
|
||
strncpy(reinterpret_cast<char*>(wifi_config.sta.ssid),
|
||
instance_->wifi_credentials_.ssid.c_str(),
|
||
sizeof(wifi_config.sta.ssid) - 1);// 复制SSID到配置
|
||
strncpy(reinterpret_cast<char*>(wifi_config.sta.password),
|
||
instance_->wifi_credentials_.password.c_str(),
|
||
sizeof(wifi_config.sta.password) - 1);// 复制密码到配置
|
||
memcpy(wifi_config.sta.bssid, instance_->wifi_credentials_.bssid, 6);
|
||
wifi_config.sta.bssid_set = true;
|
||
esp_wifi_set_config(WIFI_IF_STA, &wifi_config);//设置WiFi配置
|
||
}
|
||
break;
|
||
|
||
// 客户端请求WiFi状态
|
||
case ESP_BLUFI_EVENT_GET_WIFI_STATUS:
|
||
ESP_LOGI(TAG, "客户端请求WiFi状态");
|
||
// 这里可以发送当前WiFi状态
|
||
break;
|
||
|
||
// 新增代码
|
||
//========================================================================
|
||
// 客户端请求WiFi列表
|
||
case ESP_BLUFI_EVENT_GET_WIFI_LIST:
|
||
ESP_LOGI(TAG, "📱 手机APP请求获取WiFi列表，开始扫描周围WiFi网络");
|
||
// 启动WiFi扫描
|
||
{
|
||
wifi_scan_config_t scan_config = {};
|
||
scan_config.ssid = nullptr; // 扫描所有SSID
|
||
scan_config.bssid = nullptr; // 扫描所有BSSID
|
||
scan_config.channel = 0; // 扫描所有信道
|
||
scan_config.show_hidden = true; // 显示隐藏网络
|
||
scan_config.scan_type = WIFI_SCAN_TYPE_ACTIVE;
|
||
scan_config.scan_time.active.min = 100;
|
||
scan_config.scan_time.active.max = 300;
|
||
|
||
esp_err_t ret = esp_wifi_scan_start(&scan_config, false);
|
||
if (ret == ESP_OK) {
|
||
ESP_LOGI(TAG, "🔍 WiFi扫描已启动，等待扫描结果");
|
||
} else {
|
||
ESP_LOGE(TAG, "❌ WiFi扫描启动失败: %s", esp_err_to_name(ret));
|
||
}
|
||
}
|
||
break;
|
||
//========================================================================
|
||
|
||
// 客户端请求断开BLE连接
|
||
case ESP_BLUFI_EVENT_RECV_SLAVE_DISCONNECT_BLE:
|
||
ESP_LOGI(TAG, "收到断开BLE连接请求");
|
||
esp_blufi_disconnect();
|
||
break;
|
||
|
||
default:
|
||
ESP_LOGD(TAG, "未处理的BLUFI事件: %d", event);
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 处理WiFi事件
|
||
void BluetoothProvisioning::WiFiEventHandler(void* arg, esp_event_base_t event_base,
|
||
int32_t event_id, void* event_data) {
|
||
BluetoothProvisioning* self = static_cast<BluetoothProvisioning*>(arg);
|
||
|
||
if (event_base == WIFI_EVENT) {
|
||
switch (event_id) {
|
||
case WIFI_EVENT_STA_START:
|
||
ESP_LOGI(TAG, "WiFi STA启动");
|
||
break;
|
||
|
||
case WIFI_EVENT_STA_CONNECTED: {
|
||
wifi_event_sta_connected_t* event = static_cast<wifi_event_sta_connected_t*>(event_data);
|
||
ESP_LOGI(TAG, "✅ WiFi连接成功，SSID: %.*s，等待获取IP地址", event->ssid_len, event->ssid);
|
||
|
||
// 停止WiFi连接超时定时器
|
||
if (wifi_connect_timer) {
|
||
xTimerStop(wifi_connect_timer, 0);
|
||
}
|
||
|
||
// 清除连接状态标志
|
||
self->wifi_connecting_ = false;
|
||
self->delayed_disconnect_ = false;
|
||
break;
|
||
}
|
||
|
||
case WIFI_EVENT_STA_DISCONNECTED: {
|
||
wifi_event_sta_disconnected_t* event = static_cast<wifi_event_sta_disconnected_t*>(event_data);
|
||
ESP_LOGI(TAG, "WiFi断开连接，原因: %d", event->reason);
|
||
|
||
// 如果不是在配网状态，不处理断开事件
|
||
if (self->state_ != BluetoothProvisioningState::PROVISIONING) {
|
||
ESP_LOGD(TAG, "非配网状态下的WiFi断开，忽略处理");
|
||
break;
|
||
}
|
||
|
||
if (s_retry_num < MAX_RETRY) {
|
||
// 立即重试连接，不等待
|
||
esp_err_t ret = esp_wifi_connect();//连接到WiFi
|
||
s_retry_num++;
|
||
ESP_LOGI(TAG, "🔄 立即重试连接WiFi (%d/%d)，断开原因: %d，重试结果: %s",
|
||
s_retry_num, MAX_RETRY, event->reason,
|
||
ret == ESP_OK ? "成功" : "失败");
|
||
|
||
// 重新启动超时定时器
|
||
if (wifi_connect_timer && ret == ESP_OK) {
|
||
xTimerReset(wifi_connect_timer, 0);
|
||
}
|
||
} else {
|
||
ESP_LOGE(TAG, "❌ WiFi连接失败，已达到最大重试次数，断开原因: %d", event->reason);
|
||
|
||
// 停止超时定时器
|
||
if (wifi_connect_timer) {
|
||
xTimerStop(wifi_connect_timer, 0);
|
||
}
|
||
|
||
// 清除状态标志
|
||
self->wifi_connecting_ = false;
|
||
self->delayed_disconnect_ = false;
|
||
|
||
xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
|
||
self->SetState(BluetoothProvisioningState::FAILED);
|
||
self->TriggerCallback(BluetoothProvisioningEvent::WIFI_FAILED, &event->reason);
|
||
self->ReportWiFiStatus(false, event->reason);
|
||
}
|
||
break;
|
||
}
|
||
// 新增代码
|
||
//========================================================================
|
||
case WIFI_EVENT_SCAN_DONE: {
|
||
ESP_LOGI(TAG, "📡 WiFi扫描完成，准备发送WiFi列表给手机APP");
|
||
|
||
// 获取扫描结果
|
||
uint16_t ap_count = 0;
|
||
esp_err_t ret = esp_wifi_scan_get_ap_num(&ap_count);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "❌ 获取WiFi扫描结果数量失败: %s", esp_err_to_name(ret));
|
||
break;
|
||
}
|
||
|
||
ESP_LOGI(TAG, "📊 扫描到 %d 个WiFi热点", ap_count);
|
||
|
||
if (ap_count > 0) {
|
||
// 分配内存存储扫描结果
|
||
wifi_ap_record_t* ap_list = (wifi_ap_record_t*)malloc(sizeof(wifi_ap_record_t) * ap_count);
|
||
if (ap_list == nullptr) {
|
||
ESP_LOGE(TAG, "❌ 分配WiFi扫描结果内存失败");
|
||
break;
|
||
}
|
||
|
||
// 获取扫描结果详细信息
|
||
ret = esp_wifi_scan_get_ap_records(&ap_count, ap_list);
|
||
if (ret == ESP_OK) {
|
||
ESP_LOGI(TAG, "✅ 成功获取WiFi扫描结果，准备发送给手机APP");
|
||
|
||
// 打印扫描到的WiFi列表（调试用）
|
||
for (int i = 0; i < ap_count; i++) {
|
||
ESP_LOGD(TAG, "WiFi[%d]: SSID=%s, RSSI=%d, 加密=%d",
|
||
i, ap_list[i].ssid, ap_list[i].rssi, ap_list[i].authmode);
|
||
}
|
||
|
||
// 发送WiFi列表给手机APP
|
||
self->SendWiFiList(ap_list, ap_count);
|
||
ESP_LOGI(TAG, "📤 WiFi列表已发送给手机APP，包含 %d 个热点", ap_count);
|
||
} else {
|
||
ESP_LOGE(TAG, "❌ 获取WiFi扫描结果详细信息失败: %s", esp_err_to_name(ret));
|
||
}
|
||
|
||
// 释放内存
|
||
free(ap_list);
|
||
} else {
|
||
ESP_LOGW(TAG, "⚠️ 未扫描到任何WiFi热点");
|
||
// 发送空列表
|
||
self->SendWiFiList(nullptr, 0);
|
||
}
|
||
break;
|
||
}
|
||
//========================================================================
|
||
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void BluetoothProvisioning::IPEventHandler(void* arg, esp_event_base_t event_base,
|
||
int32_t event_id, void* event_data) {
|
||
BluetoothProvisioning* self = static_cast<BluetoothProvisioning*>(arg);
|
||
|
||
switch (event_id) {
|
||
case IP_EVENT_STA_GOT_IP: {
|
||
ip_event_got_ip_t* event = static_cast<ip_event_got_ip_t*>(event_data);
|
||
ESP_LOGI(TAG, "✅ WiFi获取IP地址成功: " IPSTR, IP2STR(&event->ip_info.ip));
|
||
|
||
s_retry_num = 0;
|
||
|
||
// 停止WiFi连接超时定时器
|
||
if (wifi_connect_timer) {
|
||
xTimerStop(wifi_connect_timer, 0);
|
||
xTimerDelete(wifi_connect_timer, 0);
|
||
wifi_connect_timer = nullptr;
|
||
}
|
||
|
||
// 清除状态标志
|
||
self->wifi_connecting_ = false;
|
||
self->delayed_disconnect_ = false;
|
||
|
||
// 设置WiFi连接成功标志
|
||
if (s_wifi_event_group) {
|
||
xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
|
||
}
|
||
|
||
// 如果BluFi客户端已连接，发送WiFi连接成功报告
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] 检查BluFi客户端连接状态: client_connected_=%s",
|
||
self->client_connected_ ? "true" : "false");
|
||
if (self && self->client_connected_) {
|
||
// ==================================================================================
|
||
// 使用专用的可靠MAC地址发送函数（优化版本2）
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] 使用专用函数发送设备MAC地址...");
|
||
bool mac_sent = self->SendMacAddressReliably();
|
||
if (mac_sent) {
|
||
ESP_LOGI(TAG, "✅ 设备MAC地址发送成功");
|
||
} else {
|
||
ESP_LOGW(TAG, "⚠️ 设备MAC地址发送失败");
|
||
}
|
||
// ==================================================================================
|
||
|
||
// ==================================================================================
|
||
// 注释：由于只需要发送设备MAC地址，暂时注释掉WiFi连接报告相关代码
|
||
// 这样可以避免发送不必要的信息（如SSID等）
|
||
// ==================================================================================
|
||
/*
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] 准备发送WiFi连接成功报告给手机APP");
|
||
wifi_mode_t mode;
|
||
esp_wifi_get_mode(&mode);
|
||
|
||
esp_blufi_extra_info_t info;
|
||
memset(&info, 0, sizeof(esp_blufi_extra_info_t));
|
||
|
||
// 获取当前连接的WiFi信息
|
||
wifi_ap_record_t ap_info;
|
||
if (esp_wifi_sta_get_ap_info(&ap_info) == ESP_OK) {
|
||
// memcpy(info.sta_bssid, ap_info.bssid, 6); // 发送路由器MAC地址
|
||
// info.sta_bssid_set = true; // 设置BSSID已获取
|
||
info.sta_bssid_set = false; // 明确标记不发送BSSID
|
||
|
||
info.sta_ssid = ap_info.ssid;
|
||
info.sta_ssid_len = strlen((char*)ap_info.ssid);
|
||
// ESP_LOGI(TAG, "🔍 [DEBUG] 获取到WiFi信息: SSID=%.*s",info.sta_ssid_len, info.sta_ssid);
|
||
}
|
||
|
||
// 发送WiFi连接成功报告
|
||
esp_err_t ret = esp_blufi_send_wifi_conn_report(mode, ESP_BLUFI_STA_CONN_SUCCESS, 0, &info);
|
||
if (ret == ESP_OK) {
|
||
ESP_LOGI(TAG, "✅ 已向手机APP发送WiFi连接成功报告");
|
||
} else {
|
||
ESP_LOGW(TAG, "⚠️ 发送WiFi连接成功报告失败: %s", esp_err_to_name(ret));
|
||
}
|
||
*/
|
||
ESP_LOGI(TAG, "🔍 [DEBUG] 已跳过WiFi连接报告发送，仅发送设备MAC地址");
|
||
} else {
|
||
ESP_LOGW(TAG, "🔍 [DEBUG] 无法发送WiFi连接成功报告: client_connected_=%s",
|
||
self->client_connected_ ? "true" : "false");
|
||
}
|
||
|
||
// 启用WiFi配置自动保存到NVS存储
|
||
ESP_LOGI(TAG, "💾 启用WiFi配置自动保存到NVS存储...");
|
||
esp_err_t storage_ret = esp_wifi_set_storage(WIFI_STORAGE_FLASH);
|
||
if (storage_ret == ESP_OK) {
|
||
ESP_LOGI(TAG, "✅ WiFi配置将自动保存到NVS存储");
|
||
} else {
|
||
ESP_LOGW(TAG, "⚠️ 设置WiFi存储模式失败: %s", esp_err_to_name(storage_ret));
|
||
}
|
||
|
||
// 手动获取当前WiFi配置并保存到NVS列表
|
||
wifi_config_t wifi_config;
|
||
esp_err_t get_config_ret = esp_wifi_get_config(WIFI_IF_STA, &wifi_config);
|
||
if (get_config_ret == ESP_OK) {
|
||
ESP_LOGI(TAG, "📋 获取当前WiFi配置成功，SSID: %s", wifi_config.sta.ssid);
|
||
auto& ssid_manager = SsidManager::GetInstance();
|
||
ssid_manager.AddSsid((const char*)wifi_config.sta.ssid, (const char*)wifi_config.sta.password);
|
||
ESP_LOGI(TAG, "✅ WiFi凭据已保存到NVS列表");
|
||
} else {
|
||
ESP_LOGW(TAG, "⚠️ 获取当前WiFi配置失败: %s", esp_err_to_name(get_config_ret));
|
||
}
|
||
vTaskDelay(pdMS_TO_TICKS(2000));// 配网成功后,设备重启，会自动连接到新的WiFi网络
|
||
ESP_LOGI(TAG, "🔄 强制重启设备...");
|
||
esp_restart();
|
||
break;
|
||
}
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|