[ESP32 IDF+Vscode]蓝牙配网后采用上传温湿度数据至阿里云(MQTT协议)

最新推荐文章于 2024-05-13 07:20:00 发布
最新推荐文章于 2024-05-13 07:20:00 发布
阅读量1.3k 收藏 16
点赞数 2
分类专栏： ESP32 文章标签： vscode 编辑器 阿里云 ESP IDF
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55986434/article/details/132939359
版权

阿里云平台的设置

参考文章：

http://t.csdn.cn/RzLGqicon-default.png?t=N7T8http://t.csdn.cn/RzLGq

Blufi配网

1.简介

BluFi 是一款基于蓝牙通道的 Wi-Fi 网络配置功能，适用于 ESP32。它通过安全协议将 Wi-Fi 配置和证书传输到 ESP32，然后 ESP32 可基于这些信息连接到 AP 或建立 SoftAP。

BluFi 流程的关键部分包括数据的分片、加密、校验和验证。

用户可按需自定义用于对称加密、非对称加密和校验的算法。这里我们采用 DH 算法进行密钥协商、128-AES 算法用于数据加密、CRC16 算法用于校验和验证。

2.BluFi 流程

BluFi 配网流程包含配置 SoftAP 和配置 Station 两部分。

下面以配置 Station 为例，介绍了广播、连接、服务发现、协商共享密钥、传输数据、回传连接状态等关键步骤。

  1. ESP32 开启 GATT Server 模式，发送带有特定 advertising data 的广播。该广播不属于 BluFi Profile，可以按需对其进行自定义。

  2. 使用手机应用程序搜索到该广播后，手机将作为 GATT Client 连接 ESP32。该步骤对具体使用哪款手机应用程序并无特殊要求。

  3. 成功建立 GATT 连接后，手机会向 ESP32 发送数据帧进行密钥协商（详见 BluFi 中定义的帧格式 ）。

  4. ESP32 收到密钥协商的数据帧后，会按照自定义的协商方法进行解析。

  5. 手机与 ESP32 进行密钥协商。协商过程可使用 DH/RSA/ECC 等加密算法。

  6. 协商结束后，手机端向 ESP32 发送控制帧，用于设置安全模式。

  7. ESP32 收到控制帧后，使用共享密钥以及安全配置对通信数据进行加密和解密。

  8. 手机向 ESP32 发送 BluFi 中定义的帧格式 中定义的数据帧，包括 SSID、密码等 Wi-Fi 配置信息。

  9. 手机向 ESP32 发送 Wi-Fi 连接请求的控制帧。ESP32 收到控制帧后，即默认手机已完成必要信息的传输，准备连接 Wi-Fi。

  10. 连接到 Wi-Fi 后，ESP32 发送 Wi-Fi 连接状态报告的控制帧到手机。至此，配网结束。

 BluFi 流程图

 

 蓝牙配网代码

/*通过蓝牙进行配网操作*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_mac.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_bt.h"

#include "esp_blufi_api.h"
#include "blufi_example.h"
#include "blufi_example_main.h"
#include "esp_blufi.h"
#include "smartconfig_led.h"
// WiFi 连接重试次数的常量
#define EXAMPLE_WIFI_CONNECTION_MAXIMUM_RETRY CONFIG_EXAMPLE_WIFI_CONNECTION_MAXIMUM_RETRY
//表示一个无效的原因代码
#define EXAMPLE_INVALID_REASON                255
//表示一个无效的信号强度值（RSSI） 通常用于表示未能成功获取到实际的 RSSI 值
#define EXAMPLE_INVALID_RSSI                  -128
int  is_configured=0;  //判断WiFi连接的标志，因为加入了按键长按清除配网信息
typedef enum {
    wifi_unconfiged = 0x00,
    wifi_configed   = 0xAA,
}wifi_info_storage_t;

//该函数是用作蓝牙低功耗（Bluetooth Low Energy, BLE）的回调函数，用于处理与蓝牙协议相关的事件。
//具体的事件类型和参数可以在 esp_blufi_cb_event_t 和 esp_blufi_cb_param_t 中定义和传递。
static void example_event_callback(esp_blufi_cb_event_t event, esp_blufi_cb_param_t *param);
//表示 Wi-Fi 扫描到的 AP 列表中最多包含的 AP 数量。
#define WIFI_LIST_NUM   10

static wifi_config_t sta_config;//用于存储 Wi-Fi 的配置信息
static wifi_config_t ap_config;

//是一个 FreeRTOS 事件组（Event Group）的句柄（handle）
//该事件组用于在连接成功并准备好发起请求时进行信号传递
static EventGroupHandle_t wifi_event_group;

//表示与接入点（AP）建立连接的状态
const int CONNECTED_BIT = BIT0;
//用于记录 Wi-Fi 连接失败时的重试次数
static uint8_t example_wifi_retry = 0;

/*
这段代码定义了一系列静态变量，用于存储与连接状态和连接相关的信息。下面是对每个变量的说明：

gl_sta_connected：一个布尔类型的变量，用于表示 Wi-Fi 站点（station）是否已连接。
gl_sta_got_ip：一个布尔类型的变量，用于表示 Wi-Fi 站点是否已获取到 IP 地址。
ble_is_connected：一个布尔类型的变量，用于表示 BLE 是否已连接。
gl_sta_bssid：一个长度为 6 的无符号 8 位整数数组，用于存储 Wi-Fi 站点的 BSSID（基本服务集标识符）。
gl_sta_ssid：一个长度为 32 的无符号 8 位整数数组，用于存储 Wi-Fi 站点的 SSID（服务集标识符）。
gl_sta_ssid_len：一个整数变量，用于存储 Wi-Fi 站点的 SSID 长度。
gl_sta_list：一个结构体变量，用于存储 Wi-Fi 站点列表信息。
gl_sta_is_connecting：一个布尔类型的变量，用于表示 Wi-Fi 站点当前是否正在连接中。
gl_sta_conn_info：一个结构体变量，用于存储与 Wi-Fi 站点连接相关的额外信息。
*/
static bool gl_sta_connected = false;
static bool gl_sta_got_ip = false;
static bool ble_is_connected = false;
static uint8_t gl_sta_bssid[6];
static uint8_t gl_sta_ssid[32];
static int gl_sta_ssid_len;
static wifi_sta_list_t gl_sta_list;
static bool gl_sta_is_connecting = false;
static esp_blufi_extra_info_t gl_sta_conn_info;
/*
该函数的作用是记录 Wi-Fi 连接的相关信息，并将其存储在 gl_sta_conn_info 变量中
gl_sta_is_connecting 为真（即 Wi-Fi 正在连接中）
gl_sta_is_connecting 为假，则表示 Wi-Fi 已连接或连接失败
*/
static void example_record_wifi_conn_info(int rssi, uint8_t reason)
{
    memset(&gl_sta_conn_info, 0, sizeof(esp_blufi_extra_info_t));
    if (gl_sta_is_connecting) {
        gl_sta_conn_info.sta_max_conn_retry_set = true;
        gl_sta_conn_info.sta_max_conn_retry = EXAMPLE_WIFI_CONNECTION_MAXIMUM_RETRY;
    } else {
        gl_sta_conn_info.sta_conn_rssi_set = true;
        gl_sta_conn_info.sta_conn_rssi = rssi;
        gl_sta_conn_info.sta_conn_end_reason_set = true;
        gl_sta_conn_info.sta_conn_end_reason = reason;
    }
}
/*启动 Wi-Fi 连接过程
esp_wifi_connect 函数来开始 Wi-Fi 连接。
如果连接成功，
gl_sta_is_connecting 变量会被设置为 true，否则为 false
*/
static void example_wifi_connect(void)
{
    example_wifi_retry = 0;
    gl_sta_is_connecting = (esp_wifi_connect() == ESP_OK);
    example_record_wifi_conn_info(EXAMPLE_INVALID_RSSI, EXAMPLE_INVALID_REASON);
}
/*
尝试重新连接 Wi-Fi
调用 example_record_wifi_conn_info 函数，
将连接信息记录到 gl_sta_conn_info 变量中。
这里传递的 rssi 参数为 EXAMPLE_INVALID_RSSI，表示初始信号强度未知；reason 参数为 EXAMPLE_INVALID_REASON，表示连接结束原因未知。
将 ret 设置为真，表示重新连接成功。
*/
static bool example_wifi_reconnect(void)
{
    bool ret;
    if (gl_sta_is_connecting && example_wifi_retry++ < EXAMPLE_WIFI_CONNECTION_MAXIMUM_RETRY) {
        BLUFI_INFO("BLUFI WiFi starts reconnection\n");
        gl_sta_is_connecting = (esp_wifi_connect() == ESP_OK);
        example_record_wifi_conn_info(EXAMPLE_INVALID_RSSI, EXAMPLE_INVALID_REASON);
        ret = true;
    } else {
        ret = false;
    }
    return ret;
}

static int softap_get_current_connection_number(void)
{
    esp_err_t ret;
    ret = esp_wifi_ap_get_sta_list(&gl_sta_list);
    if (ret == ESP_OK)
    {
        return gl_sta_list.num;
    }

    return 0;
}
/*获取当前连接到 SoftAP（软件接入点）的设备数量。*/
static void ip_event_handler(void* arg, esp_event_base_t event_base,
                                int32_t event_id, void* event_data)
{
    wifi_mode_t mode;

    switch (event_id) {
    case IP_EVENT_STA_GOT_IP: {
        esp_blufi_extra_info_t info;

        xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);
        esp_wifi_get_mode(&mode);

        memset(&info, 0, sizeof(esp_blufi_extra_info_t));
        memcpy(info.sta_bssid, gl_sta_bssid, 6);
        info.sta_bssid_set = true;
        info.sta_ssid = gl_sta_ssid;
        info.sta_ssid_len = gl_sta_ssid_len;
        gl_sta_got_ip = true;
        if (ble_is_connected == true) {
            esp_blufi_send_wifi_conn_report(mode, ESP_BLUFI_STA_CONN_SUCCESS, softap_get_current_connection_number(), &info);
        } else {
            BLUFI_INFO("1BLUFI BLE is not connected yet\n");
            if(is_configured==1)
            {
                printf("Wi-fi Connected\n");
                break;
            }
        }
        break;
    }
    default:
        break;
    }
    return;
}
/*
WiFi事件处理函数
当收到WIFI_EVENT_STA_START事件时，调用delegate_wifi_connecting_status()函数，表示WiFi正在连接，然后调用example_wifi_connect()函数开始连接WiFi。

当收到WIFI_EVENT_STA_CONNECTED事件时，表示WiFi已成功连接。设置gl_sta_connected为true，表示已连接，gl_sta_is_connecting为false，表示连接过程已结束。将连接的BSSID和SSID保存在全局变量gl_sta_bssid和gl_sta_ssid中，并更新gl_sta_ssid_len。然后调用delegate_wifi_connected_status()函数，表示WiFi已连接。

当收到WIFI_EVENT_STA_DISCONNECTED事件时，表示WiFi连接断开。如果gl_sta_connected为false并且example_wifi_reconnect()返回false，表示无法重新连接WiFi，则将gl_sta_is_connecting设置为false，表示连接过程已结束。调用delegate_wifi_disconnect_status()函数，表示WiFi连接失败。同时，记录断开连接的原因和信号强度。然后重置连接相关的全局变量，并清除WiFi连接标志位。

当收到WIFI_EVENT_AP_START事件时，表示启动了SoftAP模式。获取当前的WiFi模式，并根据情况发送连接报告给BLE设备。

当收到WIFI_EVENT_SCAN_DONE事件时，表示WiFi扫描完成。如果扫描到了AP，则将扫描结果发送给BLE设备。然后停止WiFi扫描，并释放扫描结果的内存。

当收到WIFI_EVENT_AP_STACONNECTED事件时，表示有设备连接到SoftAP。记录连接的设备MAC地址和AID。

当收到WIFI_EVENT_AP_STADISCONNECTED事件时，表示有设备断开了与SoftAP的连接。记录断开连接的设备MAC地址和AID。
*/
static void wifi_event_handler(void* arg, esp_event_base_t event_base,
                                int32_t event_id, void* event_data)
{
    wifi_event_sta_connected_t *event;
    wifi_event_sta_disconnected_t *disconnected_event;
    wifi_mode_t mode;

    switch (event_id) {
    case WIFI_EVENT_STA_START:
        delegate_wifi_connecting_status();wifi正在连接LED快闪
        example_wifi_connect();
        break;
    case WIFI_EVENT_STA_CONNECTED:
        is_configured = 1;
        gl_sta_connected = true;
        gl_sta_is_connecting = false;
        event = (wifi_event_sta_connected_t*) event_data;
        memcpy(gl_sta_bssid, event->bssid, 6);
        memcpy(gl_sta_ssid, event->ssid, event->ssid_len);
        gl_sta_ssid_len = event->ssid_len;
        delegate_wifi_connected_status(); wifi连接LED熄灭
        break;
    case WIFI_EVENT_STA_DISCONNECTED:
        /* Only handle reconnection during connecting */
        is_configured = 0;
        if (gl_sta_connected == false && example_wifi_reconnect() == false) {
            gl_sta_is_connecting = false;
            delegate_wifi_disconnect_status(); wifi连接失败LED慢闪
            disconnected_event = (wifi_event_sta_disconnected_t*) event_data;
            example_record_wifi_conn_info(disconnected_event->rssi, disconnected_event->reason);
        }
        /* This is a workaround as ESP32 WiFi libs don't currently
           auto-reassociate. */
        gl_sta_connected = false;
        gl_sta_got_ip = false;
        memset(gl_sta_ssid, 0, 32);
        memset(gl_sta_bssid, 0, 6);
        gl_sta_ssid_len = 0;
        xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);
        break;
    case WIFI_EVENT_AP_START:
        esp_wifi_get_mode(&mode);
        /* TODO: get config or information of softap, then set to report extra_info */
        if (ble_is_connected == true) {
            if (gl_sta_connected) {
                esp_blufi_extra_info_t info;
                memset(&info, 0, sizeof(esp_blufi_extra_info_t));
                memcpy(info.sta_bssid, gl_sta_bssid, 6);
                info.sta_bssid_set = true;
                info.sta_ssid = gl_sta_ssid;
                info.sta_ssid_len = gl_sta_ssid_len;
                esp_blufi_send_wifi_conn_report(mode, gl_sta_got_ip ? ESP_BLUFI_STA_CONN_SUCCESS : ESP_BLUFI_STA_NO_IP, softap_get_current_connection_number(), &info);
            } else if (gl_sta_is_connecting) {
                esp_blufi_send_wifi_conn_report(mode, ESP_BLUFI_STA_CONNECTING, softap_get_current_connection_number(), &gl_sta_conn_info);
            } else {
                esp_blufi_send_wifi_conn_report(mode, ESP_BLUFI_STA_CONN_FAIL, softap_get_current_connection_number(), &gl_sta_conn_info);
            }
        } else {
            BLUFI_INFO("123BLUFI BLE is not connected yet\n");
            printf("123\n");
        }
        break;
    case WIFI_EVENT_SCAN_DONE: {
        uint16_t apCount = 0;
        esp_wifi_scan_get_ap_num(&apCount);
        if (apCount == 0) {
            BLUFI_INFO("Nothing AP found");
            break;
        }
        wifi_ap_record_t *ap_list = (wifi_ap_record_t *)malloc(sizeof(wifi_ap_record_t) * apCount);
        if (!ap_list) {
            BLUFI_ERROR("malloc error, ap_list is NULL");
            break;
        }
        ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&apCount, ap_list));
        esp_blufi_ap_record_t * blufi_ap_list = (esp_blufi_ap_record_t *)malloc(apCount * sizeof(esp_blufi_ap_record_t));
        if (!blufi_ap_list) {
            if (ap_list) {
                free(ap_list);
            }
            BLUFI_ERROR("malloc error, blufi_ap_list is NULL");
            break;
        }
        for (int i = 0; i < apCount; ++i)
        {
            blufi_ap_list[i].rssi = ap_list[i].rssi;
            memcpy(blufi_ap_list[i].ssid, ap_list[i].ssid, sizeof(ap_list[i].ssid));
        }

        if (ble_is_connected == true) {
            esp_blufi_send_wifi_list(apCount, blufi_ap_list);
        } else {
            BLUFI_INFO("12 BLUFI BLE is not connected yet\n");
            printf("12\n");
        }

        esp_wifi_scan_stop();
        free(ap_list);
        free(blufi_ap_list);
        break;
    }
    case WIFI_EVENT_AP_STACONNECTED: {
        wifi_event_ap_staconnected_t* event = (wifi_event_ap_staconnected_t*) event_data;
        BLUFI_INFO("station "MACSTR" join, AID=%d", MAC2STR(event->mac), event->aid);
        break;
    }
    case WIFI_EVENT_AP_STADISCONNECTED: {
        wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data;
        BLUFI_INFO("station "MACSTR" leave, AID=%d", MAC2STR(event->mac), event->aid);
        break;
    }

    default:
        break;
    }
    return;
}
/*
这是一个初始化WiFi的函数，以下是对其操作的简要说明：

调用esp_netif_init()函数进行ESP-NETIF网络接口的初始化。

使用xEventGroupCreate()函数创建一个事件组，用于处理WiFi事件。

调用esp_event_loop_create_default()函数创建默认的事件循环。

调用esp_netif_create_default_wifi_sta()函数创建默认的STA（Station）模式网络接口，并将返回的网络接口指针保存在sta_netif中。

调用esp_netif_create_default_wifi_ap()函数创建默认的AP（Access Point）模式网络接口，并将返回的网络接口指针保存在ap_netif中。

调用esp_event_handler_register()函数注册WiFi事件处理函数wifi_event_handler，以处理所有WiFi事件。

调用esp_event_handler_register()函数注册IP事件处理函数ip_event_handler，以处理STA（Station）获取IP地址的事件。

创建一个默认的WiFi初始化配置结构体cfg，并通过调用esp_wifi_init()函数进行WiFi初始化。

调用esp_wifi_set_mode()函数将WiFi模式设置为STA模式。

调用example_record_wifi_conn_info()函数记录无效的RSSI（信号强度）和无效的连接原因。

调用esp_wifi_start()函数启动WiFi。
*/
static void initialise_wifi(void)
{
    ESP_ERROR_CHECK(esp_netif_init());
    wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_t *sta_netif = esp_netif_create_default_wifi_sta();
    assert(sta_netif);
    esp_netif_t *ap_netif = esp_netif_create_default_wifi_ap();
    assert(ap_netif);
    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &ip_event_handler, NULL));

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK( esp_wifi_init(&cfg) );
    ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );
    example_record_wifi_conn_info(EXAMPLE_INVALID_RSSI, EXAMPLE_INVALID_REASON);
    ESP_ERROR_CHECK( esp_wifi_start() );
}
/*
这是一个ESP-BLE-MESH蓝牙Mesh设备中的蓝牙低功耗（BLE）配置回调函数结构体esp_blufi_callbacks_t的初始化。以下是对其成员函数的简要说明：

.event_cb：指向用于处理蓝牙事件的回调函数example_event_callback的指针。

.negotiate_data_handler：指向用于处理数据协商的回调函数blufi_dh_negotiate_data_handler的指针。

.encrypt_func：指向用于加密数据的回调函数blufi_aes_encrypt的指针。

.decrypt_func：指向用于解密数据的回调函数blufi_aes_decrypt的指针。

.checksum_func：指向用于计算校验和的回调函数blufi_crc_checksum的指针。*/
static esp_blufi_callbacks_t example_callbacks = {
    .event_cb = example_event_callback,
    .negotiate_data_handler = blufi_dh_negotiate_data_handler,
    .encrypt_func = blufi_aes_encrypt,
    .decrypt_func = blufi_aes_decrypt,
    .checksum_func = blufi_crc_checksum,
};
/*
这是一个使用 ESP32 蓝牙功能的示例代码中的事件回调函数。该函数根据不同的事件类型执行相应的操作。

- `ESP_BLUFI_EVENT_INIT_FINISH`：蓝牙功能初始化完成时调用，启动广播。
- `ESP_BLUFI_EVENT_DEINIT_FINISH`：蓝牙功能关闭完成时调用。
- `ESP_BLUFI_EVENT_BLE_CONNECT`：蓝牙连接建立时调用，停止广播，并初始化安全设置。
- `ESP_BLUFI_EVENT_BLE_DISCONNECT`：蓝牙连接断开时调用，重新开始广播，并清除安全设置。
- `ESP_BLUFI_EVENT_SET_WIFI_OPMODE`：设置 Wi-Fi 工作模式时调用，根据参数设置 ESP8266 的 Wi-Fi 模式。
- `ESP_BLUFI_EVENT_REQ_CONNECT_TO_AP`：请求连接到 AP 时调用，断开当前 Wi-Fi 连接并连接到指定 AP。
- `ESP_BLUFI_EVENT_REQ_DISCONNECT_FROM_AP`：请求断开与 AP 的连接时调用。
- `ESP_BLUFI_EVENT_REPORT_ERROR`：报告错误时调用，发送错误信息给手机端。
- `ESP_BLUFI_EVENT_GET_WIFI_STATUS`：获取 Wi-Fi 状态时调用，发送当前 Wi-Fi 连接状态给手机端。
- `ESP_BLUFI_EVENT_RECV_SLAVE_DISCONNECT_BLE`：接收到从设备断开连接的事件时调用，断开与从设备的 GATT 连接。
- `ESP_BLUFI_EVENT_DEAUTHENTICATE_STA`：待实现的事件，用于取消认证的 STA。
- `ESP_BLUFI_EVENT_RECV_STA_BSSID`：接收到 STA 的 BSSID 时调用，设置 STA 配置的 BSSID。
- `ESP_BLUFI_EVENT_RECV_STA_SSID`：接收到 STA 的 SSID 时调用，设置 STA 配置的 SSID。
- `ESP_BLUFI_EVENT_RECV_STA_PASSWD`：接收到 STA 的密码时调用，设置 STA 配置的密码。
- `ESP_BLUFI_EVENT_RECV_SOFTAP_SSID`：接收到 SoftAP 的 SSID 时调用，设置 SoftAP 的 SSID。
- `ESP_BLUFI_EVENT_RECV_SOFTAP_PASSWD`：接收到 SoftAP 的密码时调用，设置 SoftAP 的密码。
- `ESP_BLUFI_EVENT_RECV_SOFTAP_MAX_CONN_NUM`：接收到 SoftAP 的最大连接数时调用，设置 SoftAP 的最大连接数。
- `ESP_BLUFI_EVENT_RECV_SOFTAP_AUTH_MODE`：接收到 SoftAP 的认证模式时调用，设置 SoftAP 的认证模式。
- `ESP_BLUFI_EVENT_RECV_SOFTAP_CHANNEL`：接收到 SoftAP 的信道时调用，设置 SoftAP 的信道。
- `ESP_BLUFI_EVENT_GET_WIFI_LIST`：获取 Wi-Fi 列表时调用，开启 Wi-Fi 扫描并发送扫描结果给手机端。
- `ESP_BLUFI_EVENT_RECV_CUSTOM_DATA`：接收到自定义数据时调用，打印数据内容。
- `ESP_BLUFI_EVENT_RECV_USERNAME`：待处理的事件，用于接收用户名。
- `ESP_BLUFI_EVENT_RECV_CA_CERT`：待处理的事件，用于接收 CA 证书。
- `ESP_BLUFI_EVENT_RECV_CLIENT_CERT`：待处理的事件，用于接收客户端证书。
- `ESP_BLUFI_EVENT_RECV_SERVER_CERT`：待处理的事件，用于接收服务器证书。
- `ESP_BLUFI_EVENT_RECV_CLIENT_PRIV_KEY`：待处理的事件，用于接收客户端私钥。
- `ESP_BLUFI_EVENT_RECV_SERVER_PRIV_KEY`：待处理的事件，用于接收服务器私钥。
*/
static void example_event_callback(esp_blufi_cb_event_t event, esp_blufi_cb_param_t *param)
{
    /* actually, should post to blufi_task handle the procedure,
     * now, as a example, we do it more simply */
    switch (event) {
    case ESP_BLUFI_EVENT_INIT_FINISH:
        BLUFI_INFO("BLUFI init finish\n");
        esp_blufi_adv_start();
        break;
    case ESP_BLUFI_EVENT_DEINIT_FINISH:
        BLUFI_INFO("BLUFI deinit finish\n");
        break;
    case ESP_BLUFI_EVENT_BLE_CONNECT:
        BLUFI_INFO("BLUFI ble connect\n");
        ble_is_connected = true;
        esp_blufi_adv_stop();
        blufi_security_init();
        break;
    case ESP_BLUFI_EVENT_BLE_DISCONNECT:
        BLUFI_INFO("BLUFI ble disconnect\n");
        ble_is_connected = false;
        blufi_security_deinit();
        esp_blufi_adv_start();
        break;
    case ESP_BLUFI_EVENT_SET_WIFI_OPMODE:
        BLUFI_INFO("BLUFI Set WIFI opmode %d\n", param->wifi_mode.op_mode);
        ESP_ERROR_CHECK( esp_wifi_set_mode(param->wifi_mode.op_mode) );
        break;
    case ESP_BLUFI_EVENT_REQ_CONNECT_TO_AP:
        BLUFI_INFO("BLUFI requset wifi connect to AP\n");
        /* there is no wifi callback when the device has already connected to this wifi
        so disconnect wifi before connection.
        */
        esp_wifi_disconnect();
        example_wifi_connect();
        break;
    case ESP_BLUFI_EVENT_REQ_DISCONNECT_FROM_AP:
        BLUFI_INFO("BLUFI requset wifi disconnect from AP\n");
        esp_wifi_disconnect();
        break;
    case ESP_BLUFI_EVENT_REPORT_ERROR:
        BLUFI_ERROR("BLUFI report error, error code %d\n", param->report_error.state);
        esp_blufi_send_error_info(param->report_error.state);
        break;
    case ESP_BLUFI_EVENT_GET_WIFI_STATUS: {
        wifi_mode_t mode;
        esp_blufi_extra_info_t info;

        esp_wifi_get_mode(&mode);

        if (gl_sta_connected) {
            memset(&info, 0, sizeof(esp_blufi_extra_info_t));
            memcpy(info.sta_bssid, gl_sta_bssid, 6);
            info.sta_bssid_set = true;
            info.sta_ssid = gl_sta_ssid;
            info.sta_ssid_len = gl_sta_ssid_len;
            esp_blufi_send_wifi_conn_report(mode, gl_sta_got_ip ? ESP_BLUFI_STA_CONN_SUCCESS : ESP_BLUFI_STA_NO_IP, softap_get_current_connection_number(), &info);
        } else if (gl_sta_is_connecting) {
            esp_blufi_send_wifi_conn_report(mode, ESP_BLUFI_STA_CONNECTING, softap_get_current_connection_number(), &gl_sta_conn_info);
        } else {
            esp_blufi_send_wifi_conn_report(mode, ESP_BLUFI_STA_CONN_FAIL, softap_get_current_connection_number(), &gl_sta_conn_info);
        }
        BLUFI_INFO("BLUFI get wifi status from AP\n");

        break;
    }
    case ESP_BLUFI_EVENT_RECV_SLAVE_DISCONNECT_BLE:
        BLUFI_INFO("blufi close a gatt connection");
        esp_blufi_disconnect();
        break;
    case ESP_BLUFI_EVENT_DEAUTHENTICATE_STA:
        /* TODO */
        break;
	case ESP_BLUFI_EVENT_RECV_STA_BSSID:
        memcpy(sta_config.sta.bssid, param->sta_bssid.bssid, 6);
        sta_config.sta.bssid_set = 1;
        esp_wifi_set_config(WIFI_IF_STA, &sta_config);
        BLUFI_INFO("Recv STA BSSID %s\n", sta_config.sta.ssid);
        break;
	case ESP_BLUFI_EVENT_RECV_STA_SSID:
        strncpy((char *)sta_config.sta.ssid, (char *)param->sta_ssid.ssid, param->sta_ssid.ssid_len);
        sta_config.sta.ssid[param->sta_ssid.ssid_len] = '\0';
        esp_wifi_set_config(WIFI_IF_STA, &sta_config);
        BLUFI_INFO("Recv STA SSID %s\n", sta_config.sta.ssid);
        break;
	case ESP_BLUFI_EVENT_RECV_STA_PASSWD:
        strncpy((char *)sta_config.sta.password, (char *)param->sta_passwd.passwd, param->sta_passwd.passwd_len);
        sta_config.sta.password[param->sta_passwd.passwd_len] = '\0';
        esp_wifi_set_config(WIFI_IF_STA, &sta_config);
        BLUFI_INFO("Recv STA PASSWORD %s\n", sta_config.sta.password);
        break;
	case ESP_BLUFI_EVENT_RECV_SOFTAP_SSID:
        strncpy((char *)ap_config.ap.ssid, (char *)param->softap_ssid.ssid, param->softap_ssid.ssid_len);
        ap_config.ap.ssid[param->softap_ssid.ssid_len] = '\0';
        ap_config.ap.ssid_len = param->softap_ssid.ssid_len;
        esp_wifi_set_config(WIFI_IF_AP, &ap_config);
        BLUFI_INFO("Recv SOFTAP SSID %s, ssid len %d\n", ap_config.ap.ssid, ap_config.ap.ssid_len);
        break;
	case ESP_BLUFI_EVENT_RECV_SOFTAP_PASSWD:
        strncpy((char *)ap_config.ap.password, (char *)param->softap_passwd.passwd, param->softap_passwd.passwd_len);
        ap_config.ap.password[param->softap_passwd.passwd_len] = '\0';
        esp_wifi_set_config(WIFI_IF_AP, &ap_config);
        BLUFI_INFO("Recv SOFTAP PASSWORD %s len = %d\n", ap_config.ap.password, param->softap_passwd.passwd_len);
        break;
	case ESP_BLUFI_EVENT_RECV_SOFTAP_MAX_CONN_NUM:
        if (param->softap_max_conn_num.max_conn_num > 4) {
            return;
        }
        ap_config.ap.max_connection = param->softap_max_conn_num.max_conn_num;
        esp_wifi_set_config(WIFI_IF_AP, &ap_config);
        BLUFI_INFO("Recv SOFTAP MAX CONN NUM %d\n", ap_config.ap.max_connection);
        break;
	case ESP_BLUFI_EVENT_RECV_SOFTAP_AUTH_MODE:
        if (param->softap_auth_mode.auth_mode >= WIFI_AUTH_MAX) {
            return;
        }
        ap_config.ap.authmode = param->softap_auth_mode.auth_mode;
        esp_wifi_set_config(WIFI_IF_AP, &ap_config);
        BLUFI_INFO("Recv SOFTAP AUTH MODE %d\n", ap_config.ap.authmode);
        break;
	case ESP_BLUFI_EVENT_RECV_SOFTAP_CHANNEL:
        if (param->softap_channel.channel > 13) {
            return;
        }
        ap_config.ap.channel = param->softap_channel.channel;
        esp_wifi_set_config(WIFI_IF_AP, &ap_config);
        BLUFI_INFO("Recv SOFTAP CHANNEL %d\n", ap_config.ap.channel);
        break;
    case ESP_BLUFI_EVENT_GET_WIFI_LIST:{
        wifi_scan_config_t scanConf = {
            .ssid = NULL,
            .bssid = NULL,
            .channel = 0,
            .show_hidden = false
        };
        esp_err_t ret = esp_wifi_scan_start(&scanConf, true);
        if (ret != ESP_OK) {
            esp_blufi_send_error_info(ESP_BLUFI_WIFI_SCAN_FAIL);
        }
        break;
    }
    case ESP_BLUFI_EVENT_RECV_CUSTOM_DATA:
        BLUFI_INFO("Recv Custom Data %" PRIu32 "\n", param->custom_data.data_len);
        esp_log_buffer_hex("Custom Data", param->custom_data.data, param->custom_data.data_len);
        break;
	case ESP_BLUFI_EVENT_RECV_USERNAME:
        /* Not handle currently */
        break;
	case ESP_BLUFI_EVENT_RECV_CA_CERT:
        /* Not handle currently */
        break;
	case ESP_BLUFI_EVENT_RECV_CLIENT_CERT:
        /* Not handle currently */
        break;
	case ESP_BLUFI_EVENT_RECV_SERVER_CERT:
        /* Not handle currently */
        break;
	case ESP_BLUFI_EVENT_RECV_CLIENT_PRIV_KEY:
        /* Not handle currently */
        break;;
	case ESP_BLUFI_EVENT_RECV_SERVER_PRIV_KEY:
        /* Not handle currently */
        break;
    default:
        break;
    }
}
/**********************************************
 * *函数名：clearWifiConfigFlag
 * *功能描述：清除配网标记，如果运行这个函数，可以配合esp_restart(),复位系统。重新配网
 * *   --  主要是取代nvs_flash_erase()函数，这个函数把所有的数据都擦除，是不对的。
 * *******************************************/
void clearWifiConfigFlag(void)
{
    nvs_handle my_handle;
    //  0.打开
    nvs_open("WIFI_CONFIG", NVS_READWRITE, &my_handle); 
    //  1.写入标记 0x00,清除配网标记
    nvs_set_u8(my_handle, "WifiConfigFlag", wifi_unconfiged);
    //  2.提交 并保存表的内容
    ESP_ERROR_CHECK(nvs_commit(my_handle)); 
    //  3.退出
    nvs_close(my_handle);  
}

void Init_blufi(void)
{
    //printf("is_configured = %d\n", is_configured);
    if(is_configured==0)
    {
        esp_err_t ret;

        // Initialize NVS
        ret = nvs_flash_init();
        if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
            ESP_ERROR_CHECK(nvs_flash_erase());
            ret = nvs_flash_init();
        }
        ESP_ERROR_CHECK( ret );

        initialise_wifi();
        ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));

        esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
        ret = esp_bt_controller_init(&bt_cfg);
        if (ret) {
            BLUFI_ERROR("%s initialize bt controller failed: %s\n", __func__, esp_err_to_name(ret));
        }

        ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
        if (ret) {
            BLUFI_ERROR("%s enable bt controller failed: %s\n", __func__, esp_err_to_name(ret));
            return;
        }

        ret = esp_blufi_host_and_cb_init(&example_callbacks);
        if (ret) {
            BLUFI_ERROR("%s initialise failed: %s\n", __func__, esp_err_to_name(ret));
            return;
        }

        BLUFI_INFO("BLUFI VERSION %04x\n", esp_blufi_get_version());
        printf("is_configured = %d\n", is_configured);
    }
    else if (is_configured==1) 
    {
        //printf("is_configured = %d\n", is_configured);
        printf("wifi connected\n");
    }
    

    
}

 MQTT连接参数

然后使用MQTT签名工具获取以下信息

将上面的信息进行对应替换

如何计算MQTT签名参数_阿里云物联网平台-阿里云帮助中心 (aliyun.com)

MQTT连接代码


#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include "esp_wifi.h"
#include "esp_system.h"
#include "nvs_flash.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/queue.h"
#include "lwip/sockets.h"
#include "lwip/dns.h"
#include "lwip/netdb.h"
#include "esp_log.h"
#include "mqtt_client.h"
#include "os.h"
#include "driver/gpio.h"
#include "sdkconfig.h"
#include "mqtt.h"
esp_mqtt_client_handle_t client;
static const char *TAG = "MQTT_EXAMPLE";

#define   Aliyun_host       "h54wTCsZDZU.iot-as-mqtt.cn-shanghai.aliyuncs.com"
#define   Aliyun_port       1883

#define   Aliyun_client_id  "LCH|securemode=2,signmethod=hmacsha1,timestamp=1694742596956|"
#define   Aliyun_username   "Device_1&h54wTCsZDZU"
#define   Aliyun_password   "75B16F77A2FA77FF3CA5ACADF984928E7F2AF018"



#define   AliyunSubscribeTopic_user_get     "/h54wTCsZDZU/Device_1/user/get"
#define   AliyunPublishTopic_user_update    "/h54wTCsZDZU/Device_1/user/update"
//#define   AliyunSubscribeTopic_post   "/sys/h54wTCsZDZU/Device_1/thing/event/property/post"
//#define   AliyunSubscribeTopic_post_reply   "/sys/h54wTCsZDZU/Device_1/thing/event/property/post_reply"



char mqtt_message[256]={0};
char mqtt_publish_data1[] = "mqtt connect ok ";
char mqtt_publish_data2[] = "mqtt subscribe successful";
char mqtt_publish_data3[] = "mqtt i am esp32";

/*
这是一个用于检查错误代码并打印错误信息的辅助函数。下面是函数的具体解析：

函数接受两个参数：message 是用于描述错误的字符串，error_code 是要检查的错误代码。
函数会检查 error_code 是否为非零值。如果是非零值，表示发生了错误。
如果发生了错误，函数会使用 ESP-IDF 的日志函数打印错误信息。错误信息包括 message 字符串和十六进制表示的错误代码。
如果 error_code 为零，表示没有发生错误，函数不会执行任何操作。
*/
static void log_error_if_nonzero(const char *message, int error_code)
{
    if (error_code != 0) {
        ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code);
    }
}

/*
 这是一个用于处理 MQTT 事件的回调函数。下面是函数的具体解析：

函数接受四个参数：handler_args 是回调函数的参数，base 是事件基础类型，event_id 是事件 ID，event_data 是事件数据。
函数会使用 ESP-IDF 的日志函数打印事件基础类型和事件 ID。
根据事件 ID 的不同，函数会执行相应的操作：
如果事件 ID 是 MQTT_EVENT_CONNECTED，表示已连接到 MQTT 服务器。
函数会发布一条主题为 AliyunPublishTopic_user_update，负载为 "mqtt_publish_data1" 的消息，并记录消息的 ID。
如果事件 ID 是 MQTT_EVENT_DISCONNECTED，表示与 MQTT 服务器的连接断开。
如果事件 ID 是 MQTT_EVENT_SUBSCRIBED，表示成功订阅了一个主题。
函数会发布一条主题为 AliyunPublishTopic_user_update，负载为 "mqtt_publish_data2" 的消息，并记录消息的 ID。
如果事件 ID 是 MQTT_EVENT_UNSUBSCRIBED，表示成功取消订阅了一个主题。
如果事件 ID 是 MQTT_EVENT_PUBLISHED，表示成功发布了一条消息。
如果事件 ID 是 MQTT_EVENT_DATA，表示接收到了一条消息。函数会打印主题和消息的内容。
如果事件 ID 是 MQTT_EVENT_ERROR，表示发生了 MQTT 错误。函数会根据错误类型打印相应的错误信息。
如果事件 ID 是其他值，表示其他类型的事件，函数会打印事件 ID。
该回调函数通过检测不同的 MQTT 事件来执行相应的操作。在使用 ESP-IDF 的 MQTT 客户端时，你可以将该回调函数注册为事件处理程序，并在接收到 MQTT 事件时进行相应的处理。例如，在连接到 MQTT 服务器后，你可以在 MQTT_EVENT_CONNECTED 事件中发布消息或者订阅主题，在收到消息时处理 MQTT_EVENT_DATA 事件。这样可以方便地与 MQTT 服务器进行通信和处理消息。*/
static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
{
    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id);
    esp_mqtt_event_handle_t event = event_data;
    esp_mqtt_client_handle_t client = event->client;
    int msg_id;
    switch ((esp_mqtt_event_id_t)event_id) {
    case MQTT_EVENT_CONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
        msg_id = esp_mqtt_client_publish(client, AliyunPublishTopic_user_update, mqtt_publish_data1, strlen(mqtt_publish_data1), 1, 0);
        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);

        msg_id = esp_mqtt_client_subscribe(client, AliyunSubscribeTopic_user_get, 0);
        ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
        break;
    case MQTT_EVENT_DISCONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
        break;

    case MQTT_EVENT_SUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
        msg_id = esp_mqtt_client_publish(client, AliyunPublishTopic_user_update, mqtt_publish_data2, strlen(mqtt_publish_data2), 0, 0);
        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);break;
    case MQTT_EVENT_UNSUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_PUBLISHED:
        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_DATA:
        ESP_LOGI(TAG, "MQTT_EVENT_DATA");
        printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
        printf("DATA=%.*s\r\n", event->data_len, event->data);
        break;
    case MQTT_EVENT_ERROR:
        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
        if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
            log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err);
            log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err);
            log_error_if_nonzero("captured as transport's socket errno",  event->error_handle->esp_transport_sock_errno);
            ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno));

        }
        break;
    default:
        ESP_LOGI(TAG, "Other event id:%d", event->event_id);
        break;
    }
}


void user_mqtt_app_start(void)
{

    esp_mqtt_client_config_t mqtt_cfg = {
        .broker.address.hostname = Aliyun_host,
        .broker.address.port = Aliyun_port,
        .broker.address.transport = MQTT_TRANSPORT_OVER_TCP,
        .credentials.client_id = Aliyun_client_id,
        .credentials.username = Aliyun_username,
        .credentials.authentication.password = Aliyun_password,

    };

    client = esp_mqtt_client_init(&mqtt_cfg);
     esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, client);
     esp_mqtt_client_start(client);
}

效果

完整代码：ESP32 IDF Vscode: ESP32开发 (gitee.com)

LCH南安
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
ESP32-C3入门教程 蓝牙篇①——基于Blufi 的 WiFi 智能配网
小康师兄
11-22 6281
文章目录一、前言二、WiFi配网方式三、快速运行四、运行效果五、ESP32-C3程序流程5.1 主程序5.2 回调函数5.3 SmartConfig线程5.4 流程图六、关键函数6.1 设置SmartConfig的协议类型6.2 启动SmartConfig6.3 停止SmartConfig七、其他八、参考 一、前言 本文基于VS Code IDE进行编程、编译、下载、运行等操作 基础知识点请查阅：ESP32-C3入门教程 基础篇①——基于VS Code构建Hello World 二、WiFi配网方式 W
ESP32 蓝牙配网用户指南
02-24
ESP32 蓝牙配网用户指南，ESP32 蓝牙配网用户指南，ESP32 蓝牙配网用户指南
ESP32-S3 Blufi开发学习记录
weixin_38499443的博客
06-26 640
ESP32 的 BluFi 是通过蓝牙通道的 Wi-Fi 网络配置功能。它提供了一个安全协议来将 Wi-Fi 配置和凭据传递给 ESP32。使用这些信息，ESP32 可以连接到一个 AP 或建立一个 SoftAP。
ESP32-S3 Blufi开发学习记录_esp32s3网络开发
最新发布
2301_82242251的博客
05-13 727
代码源路径：Espressif\frameworks\esp-idf-v4.4.2\examples\bluetooth\blufi。此过程事件的处理均按照收到的请求做相应的功能处理，可按照个人需求进行修改。获取网络 IP 地址，完成 IP 接口搭建。主要负责WiFi的连接、断开重连、扫描。
ESP32蓝牙配网
cat_eat_fish
02-27 2895
esp32蓝牙配网流程以及部分功能实现。
ESP32+idf开发—蓝牙通信入门之ble数据收发(notify)
热门推荐
coder_jun的博客
05-12 2万+
​ 1、BLE（低功耗蓝牙）采用了client/server (C/S) 架构来进行数据交互。这里讲的C/S架构和前面tcp/udp编程时所讲的C/S架构是相同的。一般而言蓝牙设备提供服务，因此设备是server，手机使用设备提供的服务，因此手机是client。比如蓝牙体温计，它可以提供 “体温” 数据服务，因此是一个server，而手机则可以请求“体温”数据以显示在手机上，因此手机是一个client。​ 中央设备（主机)即通信的发起者，只能与外围设备通信；
ESP32——WIFI静态IP设置方法（官方）
tsliuch的专栏
10-22 3748
WIFI静态IP设置方法（官方）
乐鑫Esp32学习之旅 21 esp32蓝牙配网blufi的高度封装，集成简单、使用简单、容易上手，提高开发效率！（附带demo）
徐宏的博客 | 修身齐家治国平天下
12-10 6306
本系列博客学习由非官方人员 半颗心脏 潜心所力所写，仅仅做个人技术交流分享，不做任何商业用途。如有不对之处，请留言，本人及时更改。 1、 爬坑学习新旅程，虚拟机搭建esp32开发环境，打印 “Hellow World”。 2、 巧用eclipes编辑器，官方教程在在Windows下搭建esp32开发环境，打印 “Hellow World”。 3、 认识基本esp32的GPIO接口，开...
物联网嵌入式开发-ESP32读取DHT11数字温湿度传感器值（ESP-IDF +VSCode编程）.rar
04-17
1、嵌入式物联网ESP32项目实战开发。例程经过精心编写，简单好用。 2、代码使用Visual Studio Code开发，C语言编程。例程在ESP32-S3上运行。若在其他型号上运行，请自行调整。 3、如果接入其他传感器，请查看发布的...
物联网嵌入式开发-ESP32红外遥控器发射数据（ESP-IDF +VSCode编程）.rar
04-17
1、嵌入式物联网ESP32项目实战开发。例程经过精心编写，简单好用。 2、代码使用Visual Studio Code开发，C语言编程。例程在ESP32-S3上运行。若在其他型号上运行，请自行调整。 3、如果接入其他传感器，请查看发布的...
物联网嵌入式开发-ESP32红外遥控器的信号解码（ESP-IDF +VSCode编程）.rar
04-17
1、嵌入式物联网ESP32项目实战开发。例程经过精心编写，简单好用。 2、代码使用Visual Studio Code开发，C语言编程。例程在ESP32-S3上运行。若在其他型号上运行，请自行调整。 3、如果接入其他传感器，请查看发布的...
物联网嵌入式开发-ESP32独立看门狗WDT的使用（ESP-IDF +VSCode编程）.rar
04-17
1、嵌入式物联网ESP32项目实战开发。例程经过精心编写，简单好用。 2、代码使用Visual Studio Code开发，C语言编程。例程在ESP32-S3上运行。若在其他型号上运行，请自行调整。 3、如果接入其他传感器，请查看发布的...
物联网嵌入式开发-ESP32读取芯片内部温度值（ESP-IDF +VSCode编程）.rar
04-17
1、嵌入式物联网ESP32项目实战开发。例程经过精心编写，简单好用。 2、代码使用Visual Studio Code开发，C语言编程。例程在ESP32-S3上运行。若在其他型号上运行，请自行调整。 3、如果接入其他传感器，请查看发布的...
10- ESP8266自主WiFi配网
dangerqsq的博客
03-01 6561
我们可以看到，串口打印出了连接到WiFI后的IP地址，还有MCU的hostname（来自于芯片id），最后输出WiFi信号的强度值。但是如果场景发生了变化，如果是要销售的产品，如何知道用户的WiFi环境。在有路由器的场合，mcu多数作为从设备来工作即可，也就是STA身份，ESP芯片支持AP主设备、STA从设备、AP+STA主从设备模式。这里需要注意：platformio扩展库下载的WiFimanager比较老旧，里面的案例也未能提供我们所需要的，所以我们将采取导入外部扩展库的方式。
ESP32-C3入门教程 蓝牙篇②——基于EspBlufiForAndroid极简的Blufi配网Demo
小康师兄
01-11 1770
本文知识点讲述主要基于[EspBlufiForAndroid](https://github.com/EspressifApp/EspBlufiForAndroid) Demo源码，只留下和WiFi配网过程中必要代码。
基于VScode的ESP32开发学习（三）：官方例程Station,连接到wifi
Newbie_H的学习之路
04-18 4039
代码 #include <string.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "freertos/event_groups.h" #include "esp_system.h" #include "esp_wifi.h" #include "esp_event.h" #include "esp_log.h" #include "nvs_flash.h" #include "lwip/err.h
esp32 idf4.0接入阿里云iot
qq_25160559的博客
02-18 1005
idf 连接阿里云aliyun : 关于三元组的烧录 在idf 4.0 上面由于 python 变化了command $IDF_PATH/components/nvs_flash/nvs_partition_generator/nvs_partition_gen.py --input my_single_mfg_config.csv --output my_single_mfg.bin --s...
ESP32蓝牙组网之节点配网
liumengyang1992的博客
01-14 5374
在进行这篇文章之前，请确保你已经知道了一个蓝牙节点的组成。 APP链接（这个APP是安卓的）：https://github.com/EspressifApp/EspBLEMeshForAndroid/releases/tag/v1.0.0 源码连接：https://github.com/espressif/espidf/tree/master/examples/bluetooth/esp_ble_...
ESP32-S基于蓝牙配网方案
czcit_ai_cloud的博客
12-31 1041
一 . ESP32-S简介 二 . 示例程序 /*********************导入库*************************/ #include <BluetoothSerial.h> #include <ArduinoJson.h&g...
ESP32 IDF vscode
08-09
ESP32是一款高性能Wi-Fi和蓝牙双模芯片，支持使用Espressif IoT Development Framework (ESP-IDF)进行编程。VSCode是一款轻量级代码编辑器，可以配合ESP-IDF进行ESP32的编程。可以通过在VSCode上安装ESP-IDF插件来集成ESP-IDF开发环境，从而使用VSCode进行ESP32的编程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LCH南安

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值