SmartConfig Esp32

SmartConfig e' un metodo per configurare il WiFi di una Esp32 utilizzando una app su smartphone scaricabile dagli store o personalizzabile tramite sorgenti  (EspTouch, Github ) 

https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/network/esp_smartconfig.html 

Esistono due versioni. In V1 vengono configurati inviando le credenziali di rete a tutti i dispositivi in ascolto 

V1

In V2 si puo' usare il Custom Data per inviare un codice riconosciuto da un solo dispositivo
 

V2

Dopo la configurazione i dati vengono salvati nella memoria NVS cosi' che al prossimo riavvio l'Esp32 riesca a connettersi in automatico al WiFi. Per cancellare la NVS si usa

idf.py erase-flash
 

 // Change from:
ESP_ERROR_CHECK( esp_smartconfig_set_type(SC_TYPE_ESPTOUCH) );

// To:
ESP_ERROR_CHECK( esp_smartconfig_set_type(SC_TYPE_ESPTOUCH_V2) );

menu "SmartConfig Example Configuration"

config LED_GPIO

int "LED GPIO Pin"

default 2

help

GPIO pin for LED status indicator.

Default is GPIO 2 for most ESP32 boards.

ESP32-C3: Try GPIO 8

ESP32-S2/S3: Try GPIO 18 or 48

endmenu

 

 

/*

* ESP32 SmartConfig Example - ESP-IDF

*

* File: main/smartconfig_main.c

*/

#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_event.h"

#include "esp_log.h"

#include "esp_system.h"

#include "nvs_flash.h"

#include "esp_netif.h"

#include "esp_smartconfig.h"

#include "driver/gpio.h"

/* LED GPIO */

#define LED_GPIO CONFIG_LED_GPIO

#define LED_GPIO_DEFAULT 2

/* FreeRTOS event group to signal when we are connected/disconnected */

static EventGroupHandle_t s_wifi_event_group;

/* Event bits */

#define CONNECTED_BIT BIT0

#define ESPTOUCH_DONE_BIT BIT1

static const char *TAG = "smartconfig";

static void smartconfig_task(void * parm);

/* Event handler for WiFi and SmartConfig events */

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

ESP_LOGI(TAG, "WiFi station started");

} else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {

ESP_LOGI(TAG, "Disconnected from AP");

esp_wifi_connect();

xEventGroupClearBits(s_wifi_event_group, CONNECTED_BIT);

} else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {

ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;

ESP_LOGI(TAG, "Got IP:" IPSTR, IP2STR(&event->ip_info.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);

}

}

/* Initialize WiFi in station mode */

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

}

/* SmartConfig task */

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

ESP_LOGI(TAG, "SmartConfig started");

ESP_LOGI(TAG, "Use ESPTouch app to configure WiFi");

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

}

}

}

/* LED blink task */

static void led_task(void *pvParameters)

{

gpio_reset_pin(LED_GPIO);

gpio_set_direction(LED_GPIO, GPIO_MODE_OUTPUT);

while(1) {

EventBits_t bits = xEventGroupGetBits(s_wifi_event_group);

if (bits & CONNECTED_BIT) {

/* Slow blink when connected */

gpio_set_level(LED_GPIO, 1);

vTaskDelay(100 / portTICK_PERIOD_MS);

gpio_set_level(LED_GPIO, 0);

vTaskDelay(900 / portTICK_PERIOD_MS);

} else {

/* Fast blink during configuration */

gpio_set_level(LED_GPIO, 1);

vTaskDelay(200 / portTICK_PERIOD_MS);

gpio_set_level(LED_GPIO, 0);

vTaskDelay(200 / portTICK_PERIOD_MS);

}

}

}

void app_main(void)

{

ESP_LOGI(TAG, "=== ESP32 SmartConfig Example ===");

/* Initialize NVS */

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

/* Initialize WiFi */

initialise_wifi();

/* Try to connect with saved credentials */

ESP_LOGI(TAG, "Attempting connection with saved credentials...");

esp_wifi_connect();

/* Wait 10 seconds for connection */

EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,

CONNECTED_BIT,

pdFALSE,

pdFALSE,

10000 / portTICK_PERIOD_MS);

if (bits & CONNECTED_BIT) {

ESP_LOGI(TAG, "Connected with saved credentials!");

} else {

ESP_LOGI(TAG, "No saved credentials or connection failed");

ESP_LOGI(TAG, "Starting SmartConfig...");

xTaskCreate(smartconfig_task, "smartconfig_task", 4096, NULL, 3, NULL);

}

/* Start LED task */

xTaskCreate(led_task, "led_task", 2048, NULL, 2, NULL);

}