rcrf-wifi/rx_esp32/src/main.c

#include <stdbool.h>
#include <stdint.h>

#include "nvs_flash.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "esp_event.h"

#include "../lib/cli/CLI/CLI.h"
#include "../lib/cli/CMDList/CMDList.h"

#include "commands.h"

#define WIFI_SSID "UPC46273"
#define WIFI_PASS "SPHZHKRY"
#define UDP_PORT 1234

static const char *TAG = "FR_rx-esp32";

#define MAX_RETRY_ATTEMPTS 2
static int s_ap_creds_num = 0;
static int s_retry_num = 0;

uint8_t BoatId = 1;

bool running = true;
CMDList_t* cmdList;

bool rxBuffer_overflow = false;

static EventGroupHandle_t s_wifi_event_group;
/* The event group allows multiple bits for each event, but we only care about two events:
 * - we are connected to the AP with an IP
 * - we failed to connect after the maximum amount of retries */
#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1

/*
 * CLI char out function. used to print back to a CLI, but the lib
 * is only used for reciving command and not having a full cli
 */
int charOut(const char* line)
{
	// don't print anything
	return 0;
}

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_wifi_connect();
	}
	else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED)
	{
		if (s_retry_num < MAX_RETRY_ATTEMPTS)
		{
			esp_wifi_connect();
			s_retry_num++;
			ESP_LOGI(TAG, "retry to connect to the AP");
		}
		else
		{
			xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
		}
		ESP_LOGI(TAG,"connect to the AP fail");
	}
	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));
		s_retry_num = 0;
		xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
	}
}

void app_main() {
	/* Initialize NVS — it is used to store PHY calibration data */
	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);
	
	s_wifi_event_group = xEventGroupCreate();

	ESP_ERROR_CHECK(esp_netif_init());

	ESP_ERROR_CHECK(esp_event_loop_create_default());
	esp_netif_create_default_wifi_sta();

	wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
	ESP_ERROR_CHECK(esp_wifi_init(&cfg));

	esp_event_handler_instance_t instance_any_id;
	esp_event_handler_instance_t instance_got_ip;
	ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
																		ESP_EVENT_ANY_ID,
																		&event_handler,
																		NULL,
																		&instance_any_id));
	ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
																		IP_EVENT_STA_GOT_IP,
																		&event_handler,
																		NULL,
																		&instance_got_ip));

	wifi_config_t wifi_config = {
		.sta = {
			.ssid = WIFI_SSID,
			.password = WIFI_PASS,
			/* Authmode threshold resets to WPA2 as default if password matches WPA2 standards (pasword len => 8).
				* If you want to connect the device to deprecated WEP/WPA networks, Please set the threshold value
				* to WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK and set the password with length and format matching to
				* WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK standards.
				*/
			.threshold.authmode = WIFI_AUTH_WPA_WPA2_PSK,
			.sae_pwe_h2e = WPA3_SAE_PWE_HUNT_AND_PECK,
			.sae_h2e_identifier = "",
		},
	};
	ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
	ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
	ESP_ERROR_CHECK(esp_wifi_start());

	ESP_LOGI(TAG, "wifi_init_sta 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_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) {
		ESP_LOGI(TAG, "connected to ap SSID:%s password:%s", WIFI_SSID, WIFI_PASS);
	} else if (bits & WIFI_FAIL_BIT) {
		ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s", WIFI_SSID, WIFI_PASS);
	} else {
		ESP_LOGE(TAG, "UNEXPECTED EVENT");
	}

	// running = true;

	// cmdList = getCMDList();
	
	// // init cli
	// CLI_init((CLI_charOutFn)&charOut, cmdList);

	// while (running)
	// {
	// 	int packetSize = UDP.parsePacket();
	// 	while (packetSize) {
	// 		char c;
	// 		int len = UDP.read(&c, 1);
	// 		if (len == 1)
	// 		{
	// 			CLI_charIn(c);
	// 			packetSize -= c;
	// 		}
	// 	}
	// }

	// CLI_deinit();
	// CMDList_deinit(cmdList);

	return;
}