ESP-C3入门15. SmartConfig配网测试

一、ESP32 配网简介

ESP32主要有以下配网方式：

1. SmartConfig

采用组播/广播方式，将WIFI信息编码到IEEE802.11底层通讯帧实现配网。

• 优点：易于使用，用户只需要通过 APP 将配置信息发送给设备即可。
• 缺点：需要额外的 APP，有一定的安全风险，不支持 WPA3 安全协议。

2. SoftAp 配网

配网时将ESP32置于AP热点模式，手机连接此热点建立通讯，把WIFI账号和密码发给模块。

3. AirKiss

微信提出的一种配网方式，支持通过微信小程序配网。

4. 蓝牙配网

通过低功耗蓝牙来传输WIFI账号与密码实现配网。

5. 其它配网方式

• ESP32 Easy ConnectTM(DPP) 配网：支持NFC等辅助配网；
• NFC辅助配网：需要增加支持NFC的芯片；
• 直接配网：通过SPI,UART,I2C,SDIO等接口传输配网信息；
• WPS路由器配网；
• 零配网：ZeroConfig，通过一台已配网设备给另一台设备配网；
• 手机AP配网：手机启动AP热点，让模块连接此热点实现配网。

二、使用ESP32的一键配网

ESP32的example有完整的SmartConfig demo，可以直接创建项目使用。

1. 流程分析

配网主要执行以下流程：

（1）初始化网络接口并为应用程序创建事件组。

    ESP_ERROR_CHECK(esp_netif_init());
    s_wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_event_loop_create_default());

（2）注册事件处理函数

为 WIFI_EVENT、IP_EVENT 和 SC_EVENT 注册事件处理函数。

    ESP_ERROR_CHECK( esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL) );
    ESP_ERROR_CHECK( esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL) );
    ESP_ERROR_CHECK( esp_event_handler_register(SC_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL) );

（3）启动 WiFi 站点模式

设置站点模式的事件处理函数。

（4）创建 smartconfig 任务

当使用STA模式时，连接到WiFi网络时触发事件 WIFI_EVENT_STA_START ，这时创建一个名为“smartconfig_example_task”的新任务。

（5）查找到信道事件

当 SC_EVENT_FOUND_CHANNEL 事件被触发时，表示 smartconfig 已经找到一个信道。一键配网一般通过先找到信道、再通讯的方式以提高配网效率 。

（6）获取到SSID和密码事件

当 SC_EVENT_GOT_SSID_PSWD 事件被触发时，就可以从事件数据中获取 SSID 和密码，配置 WiFi 接口并连接到 AP。
这时要记录 SSID 和密码，如果 smartconfig 类型为 ESPTOUCH_V2，则获取 RVD_DATA 并记录它。

（7）记录WIFI已经连接

在“smartconfig_example_task”函数中，将 smartconfig 类型设置为 SC_TYPE_ESPTOUCH，启动 smartconfig，并等待事件组中的 CONNECTED_BIT 和 ESPTOUCH_DONE_BIT。

如果两个位都设置了，则记录一条消息，指示 WiFi 已连接并且 smartconfig 已结束。停止 smartconfig 并删除任务。

（8）调用

在 app_main 函数中初始化 NVS 闪存并调用 initialize_wifi 函数。

2. 源码

/* Esptouch example

   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/

#include <string.h>
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_wifi.h"
#include "esp_wpa2.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_system.h"
#include "nvs_flash.h"
#include "esp_netif.h"
#include "esp_smartconfig.h"

/* FreeRTOS event group to signal when we are connected & ready to make a request */
static EventGroupHandle_t s_wifi_event_group;

/* The event group allows multiple bits for each event,
   but we only care about one event - are we connected
   to the AP with an IP? */
static const int CONNECTED_BIT = BIT0;
static const int ESPTOUCH_DONE_BIT = BIT1;
static const char *TAG = "smartconfig_example";

static void smartconfig_example_task(void * parm);

static void event_handler(void* arg, esp_event_base_t event_base,
                                int32_t event_id, void* event_data)
{
    
    
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
    
    
        xTaskCreate(smartconfig_example_task, "smartconfig_example_task", 4096, NULL, 3, NULL);
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
    
    
        esp_wifi_connect();
        xEventGroupClearBits(s_wifi_event_group, CONNECTED_BIT);
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
    
    
        xEventGroupSetBits(s_wifi_event_group, CONNECTED_BIT);
    } else if (event_base == SC_EVENT && event_id == SC_EVENT_SCAN_DONE) {
    
    
        ESP_LOGI(TAG, "Scan done");
    } else if (event_base == SC_EVENT && event_id == SC_EVENT_FOUND_CHANNEL) {
    
    
        ESP_LOGI(TAG, "Found channel");
    } else if (event_base == SC_EVENT && event_id == SC_EVENT_GOT_SSID_PSWD) {
    
    
        ESP_LOGI(TAG, "Got SSID and password");

        smartconfig_event_got_ssid_pswd_t *evt = (smartconfig_event_got_ssid_pswd_t *)event_data;
        wifi_config_t wifi_config;
        uint8_t ssid[33] = {
    
     0 };
        uint8_t password[65] = {
    
     0 };
        uint8_t rvd_data[33] = {
    
     0 };

        bzero(&wifi_config, sizeof(wifi_config_t));
        memcpy(wifi_config.sta.ssid, evt->ssid, sizeof(wifi_config.sta.ssid));
        memcpy(wifi_config.sta.password, evt->password, sizeof(wifi_config.sta.password));
        wifi_config.sta.bssid_set = evt->bssid_set;
        if (wifi_config.sta.bssid_set == true) {
    
    
            memcpy(wifi_config.sta.bssid, evt->bssid, sizeof(wifi_config.sta.bssid));
        }

        memcpy(ssid, evt->ssid, sizeof(evt->ssid));
        memcpy(password, evt->password, sizeof(evt->password));
        ESP_LOGI(TAG, "SSID:%s", ssid);
        ESP_LOGI(TAG, "PASSWORD:%s", password);
        if (evt->type == SC_TYPE_ESPTOUCH_V2) {
    
    
            ESP_ERROR_CHECK( esp_smartconfig_get_rvd_data(rvd_data, sizeof(rvd_data)) );
            ESP_LOGI(TAG, "RVD_DATA:");
            for (int i=0; i<33; i++) {
    
    
                printf("%02x ", rvd_data[i]);
            }
            printf("\n");
        }

        ESP_ERROR_CHECK( esp_wifi_disconnect() );
        ESP_ERROR_CHECK( esp_wifi_set_config(WIFI_IF_STA, &wifi_config) );
        esp_wifi_connect();
    } else if (event_base == SC_EVENT && event_id == SC_EVENT_SEND_ACK_DONE) {
    
    
        xEventGroupSetBits(s_wifi_event_group, ESPTOUCH_DONE_BIT);
    }
}

static void initialise_wifi(void)
{
    
    
    ESP_ERROR_CHECK(esp_netif_init());
    s_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);

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK( esp_wifi_init(&cfg) );

    ESP_ERROR_CHECK( esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL) );
    ESP_ERROR_CHECK( esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL) );
    ESP_ERROR_CHECK( esp_event_handler_register(SC_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL) );

    ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );
    ESP_ERROR_CHECK( esp_wifi_start() );
}

static void smartconfig_example_task(void * parm)
{
    
    
    EventBits_t uxBits;
    ESP_ERROR_CHECK( esp_smartconfig_set_type(SC_TYPE_ESPTOUCH) );
    smartconfig_start_config_t cfg = SMARTCONFIG_START_CONFIG_DEFAULT();
    ESP_ERROR_CHECK( esp_smartconfig_start(&cfg) );
    while (1) {
    
    
        uxBits = xEventGroupWaitBits(s_wifi_event_group, CONNECTED_BIT | ESPTOUCH_DONE_BIT, true, false, portMAX_DELAY);
        if(uxBits & CONNECTED_BIT) {
    
    
            ESP_LOGI(TAG, "WiFi Connected to ap");
        }
        if(uxBits & ESPTOUCH_DONE_BIT) {
    
    
            ESP_LOGI(TAG, "smartconfig over");
            esp_smartconfig_stop();
            vTaskDelete(NULL);
        }
    }
}

void app_main(void)
{
    
    
    ESP_ERROR_CHECK( nvs_flash_init() );
    initialise_wifi();
}

3. 执行效果

三、安卓端

1. ESP32提供的测试APP

2. 使用SDK

从官方找到下载地址：
https://www.espressif.com.cn/zh-hans/support/download/apps
下载 aar文件集成到自己项目中使用，主要是以下几步：

（1）添加Smart Config SDK库

设置build.gradle

allprojects {
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}

添加引用，esptouch:

implementation 'com.github.EspressifApp:lib-esptouch-android:1.1.1'

或 esptouch-v2

implementation 'com.github.EspressifApp:lib-esptouch-v2-android:2.2.1'

（2）添加权限

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>

（3）API

EspTouch v1

// 创建任务实例
Context context; // Set Applicatioin context
byte[] apSsid = {
    
    }; // Set AP's SSID
byte[] apBssid = {
    
    }; // Set AP's BSSID
byte[] apPassword = {
    
    }; // Set AP's password

EsptouchTask task = new EsptouchTask(apSsid, apBssid, apPassword, context);
task.setPackageBroadcast(true); // if true send broadcast packets, else send multicast packets
// 设置回调
task.setEsptouchListener(new IEsptouchListener() {
    
    
    @Override
    public void onEsptouchResultAdded(IEsptouchResult result) {
    
    
        // Result callback
    }
});
// 执行任务
int expectResultCount = 1;
List<IEsptouchResult> results = task.executeForResults(expectResultCount);
IEsptouchResult first = results.get(0);
if (first.isCancelled()) {
    
    
  // User cancel the task
  return;
}
if (first.isSuc()) {
    
    
  // EspTouch successfully
}
// 取消任务

ESP touch v2

// 创建实例
Context context; // Set Application Context
EspProvisioner provisioner = new EspProvisioner(context);
// 设置监听 
EspSyncListener listener = new EspSyncListener() {
    
    
    @Override
    public void onStart() {
    
    
    }

    @Override
    public void onStop() {
    
    
    }

    @Override
    public void onError(Exception e) {
    
    
    }
};
// 发同步包
provisioner.startSync(listener); // listener is nullable

// 停止同步包
provisioner.stopSync();

// 开始
Context context; // Set Application Context
EspProvisioningRequest request = new EspProvisioningRequest.Builder(context)
                .setSSID(ssid) // AP's SSID, nullable
                .setBSSID(bssid) // AP's BSSID, nonnull
                .setPassword(password) // AP's password, nullable if the AP is open
                .setReservedData(customData) // User's custom data, nullable. If not null, the max length is 64
                .setAESKey(aesKey) // nullable, if not null, it must be 16 bytes. App developer should negotiate an AES key with Device developer first.
                .build();
EspProvisioningListener listener = new EspProvisioningListener() {
    
    
    @Override
    public void onStart() {
    
    
    }

    @Override
    public void onResponse(EspProvisionResult result) {
    
    
        // Result callback
    }

    @Override
    public void onStop() {
    
    
    }

    @Override
    public void onError(Exception e) {
    
    
    }
};
provisioner.startProvisioning(request, listener); // request is nonnull, listener is nullable

// 停止配网
provisioner.stopProvisioning();
// 关闭配网
provisioner.close()