wifi leak

gistfile1.txt

/* Hello World 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.
 */
// C programming
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/unistd.h>
#include <sys/stat.h>
// freertos
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
// system
#include "esp_log.h"
#include "nvs_flash.h"
#include "sdkconfig.h"
#include "esp_err.h"
#include "esp_event_loop.h"

// STORAGE
#include "esp_partition.h"
#include "nvs_flash.h"
#include "nvs.h"

// NETWORK
#include "esp_wifi.h"
#include "lwip/sockets.h"
#include "lwip/dns.h"
#include "lwip/netdb.h"
#include "lwip/dhcp.h"
#include "mdns.h"
#include "tcpip_adapter.h"
#include "freertos/event_groups.h"



EventGroupHandle_t event_group;

int WIFI_CONNECTED_BIT=BIT0;
int count = 0;



esp_err_t storage_NVSflash_init() {

	esp_err_t ret;
	static const char *tag="NVS_INIT";

	switch((ret = nvs_flash_init())){

	case ESP_OK:
		ESP_LOGI(tag, "NVS storage initialized successfully");
		break;

	case ESP_ERR_NVS_NO_FREE_PAGES:
		ESP_LOGE(tag,"Could not initialize NVS NO_FREE_PAGES");

		// try to find the NVS partition
		const esp_partition_t *nvs_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_NVS, NULL);
		if(!nvs_partition) {
			ESP_LOGE(tag,"FATAL ERROR: No NVS partition found");
			return ESP_ERR_NOT_FOUND;
		}
		else{
			ESP_LOGD(tag, "NVS Storage found, formatting");
			if((ret = esp_partition_erase_range(nvs_partition, 0, nvs_partition->size)) == ESP_OK){
				ret = storage_NVSflash_init();
			}
		}

		break;

	case ESP_ERR_NOT_FOUND:
		ESP_LOGE(tag,"FATAL ERROR: No NVS partition found");

		// FATAL
		return ESP_ERR_NOT_FOUND;

	default:
		ESP_LOGE(tag,"Fatal Error in NVS initialization, err: %s",esp_err_to_name(ret));
		return ret;
	}

	return ret;


}


void wificonnect_killer(){
	esp_err_t ret;
	static const char* tag = "WIFI_KILLER";


	if((ret = 	esp_wifi_disconnect()) != ESP_OK){
		ESP_LOGE(tag,"could not disconnect form network due to error: %s",esp_err_to_name(ret));
	}
	else ESP_LOGD(tag,"successfully disconnected form network");


	if((ret = esp_wifi_stop()) != ESP_OK){
		ESP_LOGE(tag,"could not stop wifi due to error: %s",esp_err_to_name(ret));
	}
	else ESP_LOGD(tag,"successfully stopped wifi");


	if((ret = esp_wifi_deinit()) != ESP_OK){
		ESP_LOGE(tag,"could not deinit wifi due to error: %s",esp_err_to_name(ret));
	}
	else ESP_LOGD(tag,"successfully deinit wifi");


	if((ret = tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA)) != ESP_OK){
		ESP_LOGE(tag,"could not stop dhcp client due to error: %s",esp_err_to_name(ret));
	}
	else ESP_LOGD(tag,"successfully stopped dhcp client");

	if((ret = tcpip_adapter_stop(TCPIP_ADAPTER_IF_STA)) != ESP_OK){
		ESP_LOGE(tag,"could not stop tcpip adapter due to error: %s",esp_err_to_name(ret));
	}
	else ESP_LOGD(tag,"successfully stopped tcpip adapter");

	if((ret = tcpip_adapter_down(TCPIP_ADAPTER_IF_STA)) != ESP_OK){
		ESP_LOGE(tag,"could not take down wifi station due to error: %s",esp_err_to_name(ret));
	}
	else ESP_LOGD(tag,"successfully take down wifi station");

	if((ret = tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA)) != ESP_OK){
		ESP_LOGE(tag,"could not stop dhcp due to error: %s",esp_err_to_name(ret));
	}

}


esp_err_t wificonnect_enforcer(){

	esp_err_t ret;
	static const char *tag = "WIFI_ENFORCER";

	tcpip_adapter_init();


	if((ret = tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA)) != ESP_OK){
		ESP_LOGE(tag,"could not start DHCP due to error: %s",esp_err_to_name(ret));
		return ret;
	}


	wifi_init_config_t wifi_init_config = WIFI_INIT_CONFIG_DEFAULT();
	ESP_ERROR_CHECK(esp_wifi_init(&wifi_init_config));
	ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));



	if((ret = esp_wifi_set_mode(WIFI_MODE_STA)) != ESP_OK){
		ESP_LOGE(tag,"Can't set wifi as station, error: %s", esp_err_to_name(ret));
		return ret;
	}

	if((ret = esp_wifi_set_bandwidth(ESP_IF_WIFI_STA , WIFI_BW_HT20)) != ESP_OK){
		ESP_LOGE(tag,"Can't set wifi Bandwidth, error: %s", esp_err_to_name(ret));
	}
	else ESP_LOGI(tag,"BANDWIDTH SET!!!");


	wifi_sta_config_t myconf= {.ssid = "Note5", .password = "ABCDEF123456"};

	wifi_config_t wifi_config = {.sta = myconf
	};


	if((ret = esp_wifi_set_config(WIFI_IF_STA,&wifi_config)) != ESP_OK){
		ESP_LOGE(tag,"Can't set wifi configurations, error: %s", esp_err_to_name(ret));
		return ret;
	}



	if((ret = esp_wifi_start()) != ESP_OK){
		ESP_LOGE(tag,"Can't start WIFI, error: %s", esp_err_to_name(ret));
		return ret;
	}

	return ret;
}








// Wifi event handler
esp_err_t event_handler(void *ctx, system_event_t *event){
	esp_err_t ret;
	static const char *tag = "HANDLERRR";


	switch(event->event_id) {

	case SYSTEM_EVENT_STA_START:
		ESP_LOGI(tag,"trying connection");
		esp_wifi_connect();
		break;


	case SYSTEM_EVENT_STA_GOT_IP:

		ESP_LOGI(tag,"CONNECTED!!!");
		xEventGroupSetBits(event_group, WIFI_CONNECTED_BIT);
		ESP_LOGI(tag,"WIFI bit set");
		count = 0;

		break;

	case SYSTEM_EVENT_STA_LOST_IP:

		ESP_LOGW(tag,"LOST IP!!!");

		break;

	case SYSTEM_EVENT_STA_DISCONNECTED:

		ESP_LOGW(tag,"DISCONNECTED!!!");
		xEventGroupClearBits(event_group, WIFI_CONNECTED_BIT);


		if(count < 10){
			esp_wifi_connect();
			count++;
		}
		else if(count == 10){
			wificonnect_killer();
			if((ret = wificonnect_enforcer()) != ESP_OK){
				ESP_LOGE(tag,"Could not connect to network due to error %s", esp_err_to_name(ret));
				esp_restart();
			}
			else count = 11;
		}
		else if((10 < count) && (count < 20)){
			esp_wifi_connect();
			count++;
		}
		else if(count == 20){
			wificonnect_killer();
			vTaskDelay(60000/portTICK_PERIOD_MS);
			if((ret = wificonnect_enforcer()) != ESP_OK){
				ESP_LOGE(tag,"Could not connect to network due to error %s", esp_err_to_name(ret));
				esp_restart();
			}
			else count = 0;
		}

		break;

	default:

		ESP_LOGI(tag,"Event %d unhandled\n", event->event_id);

		break;
	}
	return ESP_OK;
}

void network_starter(){
	esp_err_t ret;
	static const char* tag = "NETWORK_STARTER";


	event_group = xEventGroupCreate();

	esp_event_loop_init(event_handler,NULL);
	ESP_LOGI(tag,"event loop initialized ALLEGEDLY");


	if((ret = wificonnect_enforcer()) != ESP_OK){
		ESP_LOGE(tag,"Could not connect to network");
	}
}



void task1(void* pvParameters){
	while(1){
		printf("task 1\n");
		vTaskDelay(5000/portTICK_PERIOD_MS);
	}
}

void task2(void* pvParameters){
	while(1){
		printf("task 2\n");
		vTaskDelay(5000/portTICK_PERIOD_MS);
	}
}

void task3(void* pvParameters){
	while(1){
		printf("Higher priority task 3\n");
		vTaskDelay(5000/portTICK_PERIOD_MS);
	}
}

void static4(){
	printf("static task in main loop\n");
}


void monitoring_task(void *pvParameters)
{
	while(1){
		printf("free heap: %d\n",esp_get_free_heap_size());
		vTaskDelay(5000 / portTICK_PERIOD_MS);
	}
}



void app_main()
{
	printf("Hello world!\n");
	static const char *tag = "HELLO WORLD";

	ESP_LOGI(tag, "[APP] IDF version: %s", esp_get_idf_version());


	storage_NVSflash_init();

	network_starter();


	xTaskCreate(&task1,"task 1",2048,NULL,3,NULL);

	xTaskCreate(&task2,"task 2",2048,NULL,3,NULL);

	xTaskCreate(&task3,"task 3",2048,NULL,5,NULL);

	xTaskCreatePinnedToCore(&monitoring_task, "monitoring_task", 2048, NULL, 1, NULL, 1);



	while(1){
		static4();
		vTaskDelay(5000/portTICK_PERIOD_MS);
	}

}