ESP32智能配网笔记

#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事件组在连接并准备发送请求时提供一个信号

static EventGroupHandle_t s_wifi_event_group;

//事件组允许每个事件有多个比特位，我们只关心一个事件-是否连接上了热点

static const int CONNECTED_BIT = BIT0;

static const int ESPTOUCH_DONE_BIT = BIT1;

static const char *TAG = "smartconfig_example";

static void smartconfig_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_task, "smartconfig_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 };

        //将参数&wifi_config所指的内存区域前sizeof(wifi_config_t)个字节，全部设为零值。

        bzero(&wifi_config, sizeof(wifi_config_t));

        //从源evt->ssid中拷贝sizeof(wifi_config.sta.ssid)个字节到目标wifi_config.sta.ssid中

        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);

        ESP_ERROR_CHECK( esp_wifi_disconnect() );

        ESP_ERROR_CHECK( esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config) );

        ESP_ERROR_CHECK( esp_wifi_connect() );

    } else if (event_base == SC_EVENT && event_id == SC_EVENT_SEND_ACK_DONE) {

        xEventGroupSetBits(s_wifi_event_group, ESPTOUCH_DONE_BIT);

    }

}

//初始化wifi

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_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();

}