ESP32 Forum

Code: Select all

#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <assert.h>
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "freertos/timers.h"
#include "freertos/event_groups.h"
#include "nvs_flash.h"
#include "esp_event.h"
#include "tcpip_adapter.h"
#include "esp_wifi.h"
#include "esp_log.h"
#include "esp_system.h"
#include "esp_now.h"
#include "esp32/rom/ets_sys.h"
#include "esp32/rom/crc.h"
#include "espnow_example.h"
#include "lwip/netdb.h"
#include "lwip/sockets.h"

static EventGroupHandle_t wifi_event_group;
const int CONNECTED_BIT = BIT0;
const int DISCONNECTED_BIT = BIT1;
static const char *TAG = "espnow_example";
static xQueueHandle s_example_espnow_queue;
//static uint8_t s_example_broadcast_mac[ESP_NOW_ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
static uint8_t s_example_broadcast_mac[ESP_NOW_ETH_ALEN] = { 0x24, 0x6f, 0x28, 0x10, 0x68, 0x88 };
static uint16_t s_example_espnow_seq[EXAMPLE_ESPNOW_DATA_MAX] = { 0, 0 };
#define WIFI_SSID "Roguenation_2.4G"
#define WIFI_PASS "XXXXXXX"
static const char *REQUEST = "GET "CONFIG_RESOURCE" HTTP/1.1\n"
	"Host: "CONFIG_WEBSITE"\n"
	"User-Agent: ESP32\n"
	"\n";


static void example_espnow_deinit(example_espnow_send_param_t *send_param);

static void example_espnow_send_cb(const uint8_t *mac_addr, esp_now_send_status_t status)
{
	NULL;
}

static void example_espnow_recv_cb(const uint8_t *mac_addr, const uint8_t *data, int len)
{
	NULL;
}

void example_espnow_data_prepare(example_espnow_send_param_t *send_param)
{
    example_espnow_data_t *buf = (example_espnow_data_t *)send_param->buffer;

    assert(send_param->len >= sizeof(example_espnow_data_t));

//    buf->type = IS_BROADCAST_ADDR(send_param->dest_mac) ? EXAMPLE_ESPNOW_DATA_BROADCAST : EXAMPLE_ESPNOW_DATA_UNICAST;
    buf->type = EXAMPLE_ESPNOW_DATA_UNICAST;
    buf->state = send_param->state;
    buf->seq_num = s_example_espnow_seq[buf->type]++;
    buf->crc = 0;
    buf->magic = send_param->magic;
    strcpy(buf->message, "1234");
    /* Fill all remaining bytes after the data with random values */
    esp_fill_random(buf->payload, send_param->len - sizeof(example_espnow_data_t));
    buf->crc = crc16_le(UINT16_MAX, (uint8_t const *)buf, send_param->len);
}

static void example_espnow_task(void *pvParameter)
{
	example_espnow_event_t evt;
	    uint8_t recv_state = 0;
	    uint16_t recv_seq = 0;
	    int recv_magic = 0;
	    bool is_broadcast = false;
	    int ret;

	    vTaskDelay(5000 / portTICK_RATE_MS);
	    ESP_LOGI(TAG, "Start sending broadcast data");

	    /* Start sending broadcast ESPNOW data. */
	while(1){
	    example_espnow_send_param_t *send_param = (example_espnow_send_param_t *)pvParameter;
	    if (esp_now_send(send_param->dest_mac, send_param->buffer, send_param->len) != ESP_OK) {
	        ESP_LOGE(TAG, "Send error");
	        example_espnow_deinit(send_param);
//	        vTaskDelete(NULL);
	    }

	    vTaskDelay(5000/ portTICK_RATE_MS);
}
}


static void event_handler(void* arg, esp_event_base_t event_base,
                          int event_id, void* event_data)
{
    static int s_retry_num = 0;

    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) {
    	xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);
    	xEventGroupSetBits(wifi_event_group, DISCONNECTED_BIT);
        ESP_LOGI(TAG,"connect to the AP fail \n");
    }
    else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
    	xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "got ip:%s",
                 ip4addr_ntoa(&event->ip_info.ip));
        s_retry_num = 0;
    }
}


static void example_wifi_init(void)
{
    tcpip_adapter_init();
    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_wifi_set_storage(WIFI_STORAGE_RAM) );
    ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );
    ESP_ERROR_CHECK( esp_wifi_start());

#if CONFIG_ESPNOW_ENABLE_LONG_RANGE
    ESP_ERROR_CHECK( esp_wifi_set_protocol(ESPNOW_WIFI_IF, WIFI_PROTOCOL_11B|WIFI_PROTOCOL_11G|WIFI_PROTOCOL_11N|WIFI_PROTOCOL_LR) );
#endif
}

static esp_err_t example_espnow_init(void)
{
	 example_espnow_send_param_t *send_param;
	 s_example_espnow_queue = xQueueCreate(ESPNOW_QUEUE_SIZE, sizeof(example_espnow_event_t));
	 if (s_example_espnow_queue == NULL) {
	        ESP_LOGE(TAG, "Create mutex fail");
	        return ESP_FAIL;
	    }
	    /* Initialize ESPNOW and register sending and receiving callback function. */
	    ESP_ERROR_CHECK( esp_now_init() );
	    ESP_ERROR_CHECK( esp_now_register_send_cb(example_espnow_send_cb) );
	    ESP_ERROR_CHECK( esp_now_register_recv_cb(example_espnow_recv_cb) );
	    /* Set primary master key. */
	    ESP_ERROR_CHECK( esp_now_set_pmk((uint8_t *)CONFIG_ESPNOW_PMK) );
	    /* Add broadcast peer information to peer list. */
	        esp_now_peer_info_t *peer = malloc(sizeof(esp_now_peer_info_t));
	        if (peer == NULL) {
	            ESP_LOGE(TAG, "Malloc peer information fail");
	            vSemaphoreDelete(s_example_espnow_queue);
	            esp_now_deinit();
	            return ESP_FAIL;
	        }
		memset(peer, 0, sizeof(esp_now_peer_info_t));
		peer->channel = CONFIG_ESPNOW_CHANNEL;
		peer->ifidx = ESPNOW_WIFI_IF;
		peer->encrypt = false;
		memcpy(peer->peer_addr, s_example_broadcast_mac, ESP_NOW_ETH_ALEN);
		ESP_ERROR_CHECK( esp_now_add_peer(peer) );
		free(peer);

	    /* Initialize sending parameters. */
	    send_param = malloc(sizeof(example_espnow_send_param_t));
	    memset(send_param, 0, sizeof(example_espnow_send_param_t));
	    if (send_param == NULL) {
	        ESP_LOGE(TAG, "Malloc send parameter fail");
	        vSemaphoreDelete(s_example_espnow_queue);
	        esp_now_deinit();
	        return ESP_FAIL;
	    }
	    send_param->unicast = true;
	    send_param->broadcast = false;
	    send_param->state = 0;
	    send_param->magic = esp_random();
	    send_param->count = CONFIG_ESPNOW_SEND_COUNT;
	    send_param->delay = CONFIG_ESPNOW_SEND_DELAY;
	    send_param->len = CONFIG_ESPNOW_SEND_LEN;
	    send_param->buffer = malloc(CONFIG_ESPNOW_SEND_LEN);
	    if (send_param->buffer == NULL) {
	        ESP_LOGE(TAG, "Malloc send buffer fail");
	        free(send_param);
	        vSemaphoreDelete(s_example_espnow_queue);
	        esp_now_deinit();
	        return ESP_FAIL;
	    }
	    memcpy(send_param->dest_mac, s_example_broadcast_mac, ESP_NOW_ETH_ALEN);
	    example_espnow_data_prepare(send_param);
	    xTaskCreate(example_espnow_task, "example_espnow_task", 2048, send_param, 4, NULL);
	    return ESP_OK;

}

static void example_espnow_deinit(example_espnow_send_param_t *send_param)
{
    free(send_param->buffer);
    free(send_param);
    vSemaphoreDelete(s_example_espnow_queue);
    esp_now_deinit();
}

static void wifi_connect(){
	tcpip_adapter_init();
	ESP_ERROR_CHECK(esp_event_loop_create_default());
	// initialize the wifi event handler;
    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));
	// initialize the wifi stack in STAtion mode with config in RAM
	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));
	ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));

	wifi_config_t wifi_config = {
			        .sta = {
			            .ssid = WIFI_SSID,
			            .password = WIFI_PASS,
			        },
			    };
		ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
		ESP_ERROR_CHECK(esp_wifi_start());
		printf("Connecting to %s\n", WIFI_SSID);
		vTaskDelay(1000/portTICK_PERIOD_MS);

			printf("Wifi connected");
//			printf("\n Main task: waiting for connection to the wifi network... ");
			xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY);
			printf("connected!\n");

			// print the local IP address
			tcpip_adapter_ip_info_t ip_info;
			ESP_ERROR_CHECK(tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip_info));
			printf("IP Address:  %s\n", ip4addr_ntoa(&ip_info.ip));
			printf("Subnet mask: %s\n", ip4addr_ntoa(&ip_info.netmask));
			printf("Gateway:     %s\n", ip4addr_ntoa(&ip_info.gw));

			xEventGroupWaitBits(wifi_event_group, DISCONNECTED_BIT, false, true, portMAX_DELAY);
			printf("Wifi Disconnected \n");
			ESP_ERROR_CHECK(esp_event_loop_delete_default());
			vTaskDelay(5000/portTICK_RATE_MS);

}


void app_main()
{
	// 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();
	    }
		wifi_event_group = xEventGroupCreate();
	    ESP_ERROR_CHECK( ret );
	    printf("Router Connection Begin \n");
	    wifi_connect();
	    esp_wifi_disconnect();
		esp_wifi_stop();
		esp_wifi_deinit();

	    printf("ESPNOW WIFI Init Begin \n");
	    example_wifi_init();
	    printf("ESPNOW Init Begin \n");
	    example_espnow_init();

}