text: /* 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 "tcpip_adapter.h"
  #include "esp_smartconfig.h"
  
  #include <time.h>
  #include <sys/time.h>
  #include "esp_sntp.h"
  #include "sdkconfig.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 };
  
          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);
  
          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);
      }
  }
  void time_sync_notification_cb(struct timeval *tv)
  {
      ESP_LOGI(TAG, "SNTP OK ");
  }
  static void initialize_sntp(void)
  {
      ESP_LOGI(TAG, "Initializing SNTP");
      sntp_setoperatingmode(SNTP_OPMODE_POLL);
      sntp_setservername(0, "pool.ntp.org");
      sntp_set_time_sync_notification_cb(time_sync_notification_cb);
  #ifdef CONFIG_SNTP_TIME_SYNC_METHOD_SMOOTH
      sntp_set_sync_mode(SNTP_SYNC_MODE_SMOOTH);
  #endif
      sntp_init();
  }
  
  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");
  #if CONFIG_ESP_SNTP_ENABLED
              {
              initialize_sntp();
  
              // wait for time to be set
              time_t now = 0;
              struct tm timeinfo = { 0 };
              int retry = 0;
              const int retry_count = 10;
              while (sntp_get_sync_status() == SNTP_SYNC_STATUS_RESET && ++retry < retry_count) {
                  //ESP_LOGI(TAG, "Waiting for system time to be set... (%d/%d)", retry, retry_count);
                  vTaskDelay(1000 / portTICK_PERIOD_MS);
              }
              
              time(&now);
              localtime_r(&now, &timeinfo);
              }
  #endif
              esp_smartconfig_stop();
              vTaskDelete(NULL);
          }
      }
  }
  
  void initialise_wifi(void)
  {
      tcpip_adapter_init();
      s_wifi_event_group = xEventGroupCreate();
      ESP_ERROR_CHECK(esp_event_loop_create_default());
  
      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() );
  }
  