Manticore/Remote_Wifi_Switch
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
2240c57dff
Remote_Wifi_Switch/main/wifi_Init.c
unknown 2240c57dff First Commit
2025-02-21 15:26:53 +05:30

672 lines
19 KiB
C
Raw Blame History

/*
* wifi_Init.c
*
* Created on: 1/8/2023
* Author: Sword
*/
#include "esp_system.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_wifi.h"
#include "esp_mac.h"
#include "lwip/ip4_addr.h"
#include "freertos/event_groups.h"
#include "wifi_Init.h"
#include "wifi_Client.h"
#include "string.h"
#include "main.h"
#include "nvm.h"
#include "data_processing.h"
#if (WIFI_NEEDED == 1)
static const char* TAG = "WIFI";
#define LOG_LOCAL_LEVEL ESP_LOG_INFO
#include "esp_log.h"
#define ESP_MAXIMUM_RETRY 5
#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT BIT1
#define WIFI_SCAN_DONE_BIT BIT2
#define WIFI_AP_CONNECTED_BIT BIT3
#define WIFI_AP_DISCONNECTED_BIT BIT4
#define WIFI_DISCONNECTED_BIT BIT5
#define WIFI_AP_SSID "Sensor Setup "
static char g_pWifiSsidA[MAX_SSID_LEN];
static char g_pWifiPasswordA[MAX_PASSPHRASE_LEN];
static char g_pWifiSsidB[MAX_SSID_LEN];
static char g_pWifiPasswordB[MAX_PASSPHRASE_LEN];
/* WIFI connection TIME */
uint32_t g_wifiStartTime;
extern uint32_t g_wifiConnectTime;
/* WIFI SSID's & PASSWORDS */
static char Sta_Ssid[MAX_SSID_LEN];
static char Sta_Pwd[MAX_PASSPHRASE_LEN] = {0};
RTC_DATA_ATTR uint32_t wifiSelection;
wifi_ap_record_t scanned_networks[20];
uint8_t device_wifi_onboarded;
/* WIFI RSSI & STATUS */
static uint8_t isStaConnected;
static bool isStarted;
static bool isInitialized;
static bool isHandlerRegister;
/* FreeRTOS event group to signal when we are connected*/
static EventGroupHandle_t s_wifi_event_group;
static bool set_wifi_bits;
static int s_retry_num = 0;
static bool turnOffStation;
/* This structure holds the WIFI configurations (modes, ip's, ssid&pwd ...etc )*/
esp_netif_t *sta_netif;
esp_netif_t *ap_netif;
wifi_config_t wifi_config;
esp_netif_ip_info_t wifi_sta_ip_infos;
/* This is the handler that will be executed when receiving any WIFI-events or IP-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)
{
/* This Log will be printed as a result of esp_wifi_start (when the wifi mode is STA or AP&STA )*/
ESP_LOGI(TAG, " -----> Station(Client) mode Start");
}
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_START)
{
/* This Log will be printed as a result of esp_wifi_start (when the wifi mode is AP or AP&STA )*/
ESP_LOGI(TAG, " -----> ACCESS-POINT Start");
}
else if(event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_CONNECTED)
{
/* This Log will be printed as a result of esp_wifi_connect (when the wifi mode is STA or AP&STA )
* Indicates successful connection to the wifi-network or to the access point */
ESP_LOGI(TAG, " -----> Station(client) Connected to the registered AP");
}
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED)
{
if(turnOffStation)
{
if(set_wifi_bits)
{
xEventGroupSetBits(s_wifi_event_group, WIFI_DISCONNECTED_BIT);
}
ESP_LOGI(TAG, " ---> Disconnecting wifi-station successfully");
}
else
{
isStaConnected = 0;
if (s_retry_num < ESP_MAXIMUM_RETRY)
{
esp_wifi_connect();
s_retry_num++;
ESP_LOGI(TAG, " ---> Retry to connect to the AP !!!");
}
else
{
if(set_wifi_bits)
{
xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
}
}
ESP_LOGI(TAG, " ---> Connecting to the registered AP failed !!!");
}
}
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, "------> The Device got the ip-address:" IPSTR, IP2STR(&event->ip_info.ip));
s_retry_num = 0;
if(set_wifi_bits)
{
xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
}
/* 1- Take and store the ip-address infos */
data_set_local_ip_addr(&event->ip_info);
}
else if(event_base == WIFI_EVENT && event_id == WIFI_EVENT_SCAN_DONE)
{
if(set_wifi_bits)
{
xEventGroupSetBits(s_wifi_event_group, WIFI_SCAN_DONE_BIT);
}
}
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STACONNECTED)
{
wifi_event_ap_staconnected_t* event = (wifi_event_ap_staconnected_t*) event_data;
ESP_LOGI(TAG, "station "MACSTR" join, AID=%d", MAC2STR(event->mac), event->aid);
if(set_wifi_bits)
{
xEventGroupSetBits(s_wifi_event_group, WIFI_AP_CONNECTED_BIT);
}
}
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STADISCONNECTED)
{
wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data;
ESP_LOGI(TAG, "station "MACSTR" leave, AID=%d", MAC2STR(event->mac), event->aid);
if(set_wifi_bits)
{
xEventGroupSetBits(s_wifi_event_group, WIFI_AP_DISCONNECTED_BIT);
}
}
}
/* Functions for Starting WIFI as Client, Server and Scan nearby networks */
esp_err_t Connect_wifi_sta(uint8_t mode)
{
/* Create the return variable */
esp_err_t retval = ESP_FAIL;
time_t timeNow;
time(&timeNow);
uint32_t temp_time=0;
g_wifiStartTime = (uint32_t)timeNow;
/* Check if the esp-32 was connected to network before. If so then disconnect it and reconnect again after 3sec */
if(isStaConnected)
{
wifi_sta_disconnecting();
vTaskDelay(3000/portTICK_PERIOD_MS);
}
/* Create a WIFI-event group and create its corresponding bits */
s_wifi_event_group = xEventGroupCreate();
set_wifi_bits = true;
EventBits_t bits;
/* Set the wifi_disconnecting flag to be false */
turnOffStation = false;
// 2 - Wi-Fi Configuration Phase
/* Assign a handler that will be executed when receiving any WIFI-events */
//esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, event_handler, NULL);
/* Update the SSID and Password that ESP32 will use them to connect to the network when acting acting as WIFI-STATION */
/*if(wifiSelection)
{
strcpy((char *)wifi_config.sta.ssid, g_pWifiSsidB);
strcpy((char *)wifi_config.sta.password, g_pWifiPasswordB);
}
else*/
{
#ifdef STORING_TO_NVM
//device_wifi_onboarded = nvm_read_onboarding_flag(WIFI_ONBOARDING_KEY);
if(device_wifi_onboarded)
{
/* Connecting to the network that has been registered since the last onboarding process
* This if-block will be executed when doing the CHECK-IN process */
nvm_read_wifi_credentials(Sta_Ssid,Sta_Pwd);
}
#endif
/* Copying the network credentials to the wifi_config structure so that the esp-client can connect to */
strcpy((char *)wifi_config.sta.ssid, Sta_Ssid);
strcpy((char *)wifi_config.sta.password, Sta_Pwd);
}
/* Make sure that there's a valid entered SSID to connect to */
if((Sta_Ssid[0] == 0))
{
//ESP_LOGE(TAG,"----> There's no valid SSID to connect to");
return ESP_FAIL;
}
/* Set the WIFI-mode & WIFI-configs then start and connect to the WIFI network */
ESP_LOGI(TAG," Initializing and starting WIFI-Client ");
ESP_ERROR_CHECK(esp_wifi_set_mode(mode));
wifi_config.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
if(!isStarted)
ESP_ERROR_CHECK(esp_wifi_start());
/**/
ESP_ERROR_CHECK(esp_wifi_connect());
//ESP_LOGI(TAG, "wifi_init_sta finished.");
ESP_LOGI(TAG, "WIFI STA connection Start...");
/* block to wait for one or more bits to be set within a previously created event group (s_wifi_event_group) */
bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
/* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually
* happened. */
if (bits & WIFI_CONNECTED_BIT)
{
/* Set the WIFI connect Time */
time(&timeNow);
temp_time = (timeNow - g_wifiStartTime);
g_wifiConnectTime = (uint8_t)((temp_time > 255)? 255 : temp_time);
/* Get the RSSI value of WIFI */
/*int wifi_rssi;
esp_wifi_sta_get_rssi((int*)&wifi_rssi);*/
wifi_ap_record_t ap_info;
esp_wifi_sta_get_ap_info(&ap_info);
data_set_wifi_rssi(ap_info.rssi);
ESP_LOGI(TAG, "Connected to AP SSID:%s password:%s", Sta_Ssid, Sta_Pwd);
/* 2- Take and store the dns-server info */
esp_netif_dns_info_t dns1, dns2;
esp_netif_get_dns_info(sta_netif,ESP_NETIF_DNS_MAIN,&dns1);
esp_netif_get_dns_info(sta_netif,ESP_NETIF_DNS_BACKUP,&dns2);
data_set_main_and_backup_dns(&dns1,&dns2);
/* 3- Take and store the mac-address of connected AP */
data_set_ap_mac_addr((uint8_t*)&wifi_config.sta.bssid);
/* 4- Take and store the wifi-channel */
data_set_wifi_channel(wifi_config.sta.channel);
/* Set the connection flag */
isStaConnected = 1;
/* set the return value to be ESP_OK */
retval = ESP_OK;
}
else if (bits & WIFI_FAIL_BIT)
{
ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s", Sta_Ssid, Sta_Pwd);
isStaConnected = 0;
/* set the return value to be ESP_FAIL */
retval = ESP_FAIL;
}
else
{
ESP_LOGE(TAG, "UNEXPECTED EVENT");
}
/* Delete the created event group after receiving the required bits or "UNEXPECTED EVENT" */
vEventGroupDelete(s_wifi_event_group);
set_wifi_bits = false;
/* return this value */
return retval;
}
void Wifi_Init_SoftAp(void)
{
char ap_ssid[32];
char mac_str[15];
uint8_t mac_base[6] = {0};
/* Check if the onboarded-flag is false (Don't start AP unless the device hasn't been on-boarded) */
//if(!device_wifi_onboarded)
{
/* Read the device mac-address */
esp_efuse_mac_get_default(mac_base);
esp_read_mac(mac_base, ESP_MAC_WIFI_SOFTAP);
/* Set the SSID-name of the esp32-AP (Sensor Setup -deviceID-) */
strcpy(ap_ssid, WIFI_AP_SSID);
sprintf(mac_str, "%02X%02X%02X", mac_base[3], mac_base[4], mac_base[5]);
strcat(ap_ssid, mac_str);
ESP_LOGI(TAG, "AP SSID: %s", ap_ssid);
/* Start event group to read the connection bits */
s_wifi_event_group = xEventGroupCreate();
set_wifi_bits = true;
/* Set the configurations for the esp-32 AP */
wifi_config.ap.max_connection = 4;
wifi_config.ap.authmode = WIFI_AUTH_OPEN;
strcpy((char *)wifi_config.sta.ssid, "");
strcpy((char *)wifi_config.sta.password, "");
wifi_config.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
/* Set the SSID and PASSWORD of the esp-32 AP */
strcpy((char *)wifi_config.ap.ssid, ap_ssid);
wifi_config.ap.ssid_len = strlen(ap_ssid);
/* Set the WIFI-mode to be AP&STA */
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_config));
ESP_ERROR_CHECK(esp_wifi_start());
isStarted = true;
ESP_LOGI(TAG, "Access-Point Initialization finished.");
/* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed for the maximum
* number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see above) */
EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_AP_CONNECTED_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
/* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually
* happened. */
if (bits & WIFI_AP_CONNECTED_BIT)
{
ESP_LOGI(TAG, "AP Connected");
}
else if (bits & WIFI_FAIL_BIT)
{
ESP_LOGI(TAG, "AP failed to connect");
}
else
{
ESP_LOGE(TAG, "UNEXPECTED EVENT");
}
vEventGroupDelete(s_wifi_event_group);
set_wifi_bits = false;
}
}
void wifi_scan_start(uint16_t *apCount, wifi_ap_record_t **list)
{
s_wifi_event_group = xEventGroupCreate();
set_wifi_bits = true;
wifi_scan_config_t scan_config = {
.ssid = NULL,
.bssid = NULL,
.channel = 0,
.show_hidden = true,
.scan_type = WIFI_SCAN_TYPE_ACTIVE,
.scan_time.active.min = 10,
.scan_time.active.max = 10000
};
ESP_LOGI(TAG, "Start Scan");
esp_wifi_scan_start(&scan_config, true);
EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_SCAN_DONE_BIT, pdFALSE, pdFALSE, 5000 / portTICK_PERIOD_MS);
esp_wifi_scan_stop();
ESP_LOGI(TAG, "Stop Scan");
vTaskDelay(100/portTICK_PERIOD_MS);
if (bits & WIFI_SCAN_DONE_BIT)
{
esp_wifi_scan_get_ap_num(apCount);
if(apCount)
{
//*list = (wifi_ap_record_t *)pvPortMalloc(sizeof(wifi_ap_record_t) * (*apCount));
*list = scanned_networks;
if((*apCount)<20)
ESP_ERROR_CHECK((esp_wifi_scan_get_ap_records(apCount, *list)));
else
{
*apCount = 20;
ESP_ERROR_CHECK((esp_wifi_scan_get_ap_records(apCount, *list)));
}
}
}
vEventGroupDelete(s_wifi_event_group);
set_wifi_bits = false;
}
/* Update the wifi credentials (SSID&PWD) of the target network */
void wifi_update_credentials(char *ssid, char *pwd)
{
/* Update the SSID and password that the ESP will use when acting as wifi-client (station) */
strcpy(Sta_Ssid, ssid);
strcpy(Sta_Pwd, pwd);
}
uint8_t wifi_station_connected(void)
{
return isStaConnected;
}
bool wifi_isStarted(void)
{
return isStarted;
}
char *wifi_get_ssid(void)
{
return Sta_Ssid;
}
char *wifi_get_pswd(void)
{
return Sta_Pwd;
}
void wifi_switchToPrimaryNetwork(void)
{
if(0 != wifiSelection)
{
wifiSelection = 0; // Primary WiFi
data_clearWifiConnectionSettings();
}
} // End of switchToPrimaryWifiNetwork()
/* Functions to Set/get WIFI-credentials of networkA */
char *wifi_get_ssidA(void)
{
return g_pWifiSsidA;
}
char *wifi_get_pswdA(void)
{
return g_pWifiPasswordA;
}
void wifi_set_ssidA(char* ssid)
{
strcpy(g_pWifiSsidA,ssid);
}
void wifi_set_pswdA(char* pswd)
{
strcpy(g_pWifiPasswordA,pswd);
}
/* Functions to Set/get WIFI-credentials of networkA */
char *wifi_get_ssidB(void)
{
return g_pWifiSsidB;
}
char *wifi_get_pswdB(void)
{
return g_pWifiPasswordB;
}
void wifi_set_ssidB(char* ssid)
{
strcpy(g_pWifiSsidB,ssid);
}
void wifi_set_pswdB(char* pswd)
{
strcpy(g_pWifiPasswordB,pswd);
}
/* WIFI functions for Initialization and De-initialization */
esp_err_t wifi_first_init(void)
{
/* Create the return variable */
esp_err_t retval = ESP_FAIL;
if(isInitialized)
{
return ESP_OK;
}
/* Initialize the underlying TCP/IP stack */
retval = esp_netif_init();
/* Create default event loop */
retval = esp_event_loop_create_default();
/* Do the required initialization for setting the device -esp32- to act as WiFi-station and WIFI-AP */
sta_netif = esp_netif_create_default_wifi_sta();
// if(!device_wifi_onboarded)
{
esp_netif_t *ap_netif = esp_netif_create_default_wifi_ap();
/* Stop the DHCP server to change the IP address of AP-gateway */
retval = esp_netif_dhcps_stop(ap_netif);
/* Create the structure of the new IP-address of the AP */
esp_netif_ip_info_t ip_info;
/* Set the IP-address to [10.10.1.1] and the same thing for gateway and subnet-mask is [255.255.255.0] */
IP4_ADDR(&ip_info.ip, 10, 10, 1, 1);
IP4_ADDR(&ip_info.gw, 10, 10, 1, 1);
IP4_ADDR(&ip_info.netmask, 255, 255, 255, 0);
/* Update the IP-address info with the new ones */
retval = esp_netif_set_ip_info(ap_netif, &ip_info);
ESP_LOGI(TAG, "esp_netif_set_ip_info(): 0x%X", retval);
/* Restart the DHCP server again */
retval = esp_netif_dhcps_start(ap_netif);
}
/* Load the default init_configurations */
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
retval = esp_wifi_init(&cfg);
/* Set the initialization flag */
isInitialized = true;
/* Initialize and register the wifi and ip event-handler */
wifi_register_event_handlers();
/* return the result */
return retval;
}
/* function for registering the handler for the received wifi or ip events (called once at the beginning of the program)*/
void wifi_register_event_handlers(void)
{
if(!isHandlerRegister)
{
/* 1- Assign the handler for receiving any wifi-event */
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
/* 2- Assign a handler that will be executed when receiving the STA_GOT_IP event (when the ESP32 receive an IP from the DHCP of the router or the Access-Point) */
esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, event_handler, NULL);
isHandlerRegister = true;
}
}
esp_err_t wifi_stop(void)
{
/* Create the return variable */
esp_err_t retval = ESP_FAIL;
/* Create a WIFI-event group and create its corresponding bits */
s_wifi_event_group = xEventGroupCreate();
set_wifi_bits = true;
EventBits_t bits;
//esp_wifi_restore();
//esp_wifi_deinit();
esp_wifi_stop();
/* block to wait for one or more bits to be set within a previously created event group (s_wifi_event_group) */
bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_AP_DISCONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
/* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually
* happened. */
if (bits & WIFI_AP_DISCONNECTED_BIT)
{
ESP_LOGI(TAG, "WIFI has been Stopped");
retval = ESP_OK;
}
else
{
ESP_LOGE(TAG, "Failed to Stop WIFI. UNEXPECTED EVENT");
retval = ESP_FAIL;
}
/* Delete the created event group after receiving the required bits or "UNEXPECTED EVENT" */
vEventGroupDelete(s_wifi_event_group);
set_wifi_bits = false;
//ESP_ERROR_CHECK(esp_event_handler_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler));
isStaConnected = 0;
isStarted = false;
ap_netif = NULL;
//isInitialized = false;
/* return the result */
return retval;
}
void wifi_sta_disconnecting(void)
{
EventBits_t bits;
if(isStaConnected)
{
/* Create a WIFI-event group and create its corresponding bits */
s_wifi_event_group = xEventGroupCreate();
set_wifi_bits = true;
/* Set the station turn-off flag to be true */
turnOffStation = true;
/* Disconnect the WIFI-Station */
ESP_ERROR_CHECK(esp_wifi_disconnect());
/* block to wait for one or more bits to be set within a previously created event group (s_wifi_event_group) */
bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_DISCONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
/* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually
* happened. */
if (bits & WIFI_DISCONNECTED_BIT)
{
ESP_LOGI(TAG, "WIFI has been disconnected");
//ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP,&event_handler));
//isHandlerRegister = false;
isStaConnected = 0;
}
else
{
ESP_LOGE(TAG, "Failed to disconnect WIFI-Station. UNEXPECTED EVENT");
}
/* Delete the created event group after receiving the required bits or "UNEXPECTED EVENT" */
vEventGroupDelete(s_wifi_event_group);
set_wifi_bits = false;
}
}
bool safeStrCat(char *dest, uint16_t destSize, char *source)
{
if(strlen(source) > (destSize - 1 - strlen(dest)))
return(false);
strcat(dest, source);
return(true);
} // End of safeStrCat
#endif
Reference in New Issue View Git Blame Copy Permalink