Chapter 92: Multicast and Broadcast Communication

#include <stdio.h>
#include <string.h>
#include <sys/param.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"

#include "lwip/err.h"
#include "lwip/sockets.h"
#include "lwip/sys.h"
#include <lwip/netdb.h>

#define WIFI_SSID      CONFIG_EXAMPLE_WIFI_SSID
#define WIFI_PASS      CONFIG_EXAMPLE_WIFI_PASSWORD
#define MAX_FAILURES   10

#define BROADCAST_PORT 3333
#define BROADCAST_MESSAGE "ESP32 BROADCAST DISCOVERY"

static const char *TAG = "broadcast_example";

static EventGroupHandle_t s_wifi_event_group;
#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1
static int s_retry_num = 0;
static esp_netif_t *s_esp_netif = NULL;


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_FAILURES) {
            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);
        if (s_esp_netif == NULL) {
            s_esp_netif = event->esp_netif;
        }
    }
}

void wifi_init_sta(void)
{
    s_wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    s_esp_netif = esp_netif_create_default_wifi_sta(); // Store default STA netif

    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, .threshold.authmode = WIFI_AUTH_WPA2_PSK },
    };
    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.");

    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG, "connected to ap SSID:%s", WIFI_SSID);
    } else if (bits & WIFI_FAIL_BIT) {
        ESP_LOGI(TAG, "Failed to connect to SSID:%s", WIFI_SSID);
    } else { ESP_LOGE(TAG, "UNEXPECTED EVENT"); }
}

void udp_broadcast_receiver_task(void *pvParameters)
{
    char rx_buffer[128];
    int sock;

    ESP_LOGI(TAG, "Waiting for Wi-Fi connection to start UDP broadcast receiver...");
    xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
    ESP_LOGI(TAG, "Wi-Fi connected. Starting UDP broadcast receiver on port %d", BROADCAST_PORT);

    while (1) {
        struct sockaddr_in dest_addr;
        dest_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        dest_addr.sin_family = AF_INET;
        dest_addr.sin_port = htons(BROADCAST_PORT);

        sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
        if (sock < 0) {
            ESP_LOGE(TAG, "Receiver: Unable to create socket: errno %d", errno);
            vTaskDelay(pdMS_TO_TICKS(1000));
            continue;
        }
        ESP_LOGI(TAG, "Receiver: Socket created");

        // SO_REUSEADDR allows multiple sockets to bind to the same address and port,
        // which can be useful if restarting the task or for multicast.
        int reuse = 1;
        if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
            ESP_LOGE(TAG, "Receiver: setsockopt(SO_REUSEADDR) failed: %s", strerror(errno));
            // Not fatal for this example, but good practice
        }

        int err = bind(sock, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
        if (err < 0) {
            ESP_LOGE(TAG, "Receiver: Socket unable to bind: errno %d, IPPROTO: %d", errno, IPPROTO_IP);
            close(sock);
            vTaskDelay(pdMS_TO_TICKS(1000));
            continue;
        }
        ESP_LOGI(TAG, "Receiver: Socket bound, waiting for data on port %d", BROADCAST_PORT);

        while (1) {
            struct sockaddr_in source_addr;
            socklen_t socklen = sizeof(source_addr);
            int len = recvfrom(sock, rx_buffer, sizeof(rx_buffer) - 1, 0, (struct sockaddr *)&source_addr, &socklen);

            if (len < 0) {
                ESP_LOGE(TAG, "Receiver: recvfrom failed: errno %d", errno);
                break; // Break inner loop, re-create socket
            } else {
                rx_buffer[len] = 0; // Null-terminate whatever we received
                ESP_LOGI(TAG, "Receiver: Received %d bytes from %s:", len, inet_ntoa(source_addr.sin_addr));
                ESP_LOGI(TAG, "Receiver: Data: %s", rx_buffer);
            }
        }

        if (sock != -1) {
            ESP_LOGE(TAG, "Receiver: Shutting down socket and restarting...");
            shutdown(sock, 0);
            close(sock);
        }
    }
    vTaskDelete(NULL);
}

void udp_broadcast_sender_task(void *pvParameters)
{
    int sock;

    ESP_LOGI(TAG, "Waiting for Wi-Fi connection to start UDP broadcast sender...");
    xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
    ESP_LOGI(TAG, "Wi-Fi connected. Starting UDP broadcast sender.");
    
    esp_netif_ip_info_t ip_info;
    ESP_ERROR_CHECK(esp_netif_get_ip_info(s_esp_netif, &ip_info));
    // Construct broadcast address from IP and netmask
    // e.g. IP: 192.168.1.100, Netmask: 255.255.255.0 => Broadcast: 192.168.1.255
    // Or simply use 255.255.255.255 for limited broadcast.
    uint32_t broadcast_ip = (ip_info.ip.addr | (~ip_info.netmask.addr)); // Directed broadcast
    char broadcast_ip_str[16];
    inet_ntoa_r(broadcast_ip, broadcast_ip_str, sizeof(broadcast_ip_str));
    ESP_LOGI(TAG, "Sender: Local IP: " IPSTR ", Netmask: " IPSTR ", Directed Broadcast IP: %s",
             IP2STR(&ip_info.ip), IP2STR(&ip_info.netmask), broadcast_ip_str);
    ESP_LOGI(TAG, "Sender: Using limited broadcast address 255.255.255.255 for wider compatibility.");


    while (1) {
        sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
        if (sock < 0) {
            ESP_LOGE(TAG, "Sender: Unable to create socket: errno %d", errno);
            vTaskDelay(pdMS_TO_TICKS(1000)); // Wait before retrying
            continue;
        }

        int enable_broadcast = 1;
        if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &enable_broadcast, sizeof(enable_broadcast)) < 0) {
            ESP_LOGE(TAG, "Sender: setsockopt(SO_BROADCAST) failed: %s", strerror(errno));
            close(sock);
            vTaskDelay(pdMS_TO_TICKS(1000));
            continue;
        }

        struct sockaddr_in dest_addr;
        dest_addr.sin_family = AF_INET;
        dest_addr.sin_port = htons(BROADCAST_PORT);
        // Use limited broadcast address
        dest_addr.sin_addr.s_addr = inet_addr("255.255.255.255");
        // Or use directed broadcast address:
        // dest_addr.sin_addr.s_addr = broadcast_ip;


        ESP_LOGI(TAG, "Sender: Sending broadcast message: '%s' to 255.255.255.255:%d", BROADCAST_MESSAGE, BROADCAST_PORT);
        int err = sendto(sock, BROADCAST_MESSAGE, strlen(BROADCAST_MESSAGE), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
        if (err < 0) {
            ESP_LOGE(TAG, "Sender: Error occurred during sending: errno %d", errno);
        } else {
            ESP_LOGI(TAG, "Sender: Message sent successfully.");
        }

        close(sock);
        vTaskDelay(pdMS_TO_TICKS(5000)); // Send every 5 seconds
    }
    vTaskDelete(NULL);
}


void app_main(void)
{
    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);

    wifi_init_sta();

    // You can run both on one ESP32 for testing, or sender on one and receiver on another.
    xTaskCreate(udp_broadcast_receiver_task, "udp_broadcast_rx", 4096, NULL, 5, NULL);
    xTaskCreate(udp_broadcast_sender_task, "udp_broadcast_tx", 4096, NULL, 5, NULL);
}

idf_component_register(SRCS "main.c"
                    INCLUDE_DIRS ".")

#include <stdio.h>
#include <string.h>
#include <sys/param.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"

#include "lwip/err.h"
#include "lwip/sockets.h"
#include "lwip/sys.h"
#include <lwip/netdb.h>

#define WIFI_SSID      CONFIG_EXAMPLE_WIFI_SSID
#define WIFI_PASS      CONFIG_EXAMPLE_WIFI_PASSWORD
#define MAX_FAILURES   10

#define MULTICAST_IPV4_ADDR "232.10.10.10" // Choose a valid multicast address
#define MULTICAST_PORT 4444
#define MULTICAST_TTL  1 // Keep TTL=1 for local network initially
#define MULTICAST_MESSAGE "ESP32 MULTICAST TEST"

static const char *TAG = "multicast_example";

static EventGroupHandle_t s_wifi_event_group;
#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1
static int s_retry_num = 0;
static esp_netif_t *s_esp_netif = NULL; // To store the netif handle


// Wi-Fi event handler and init_sta (same as broadcast example)
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) {
        // esp_wifi_connect() will be called by the event loop system if enabled in sdkconfig
        if (s_retry_num < MAX_FAILURES) {
            //esp_wifi_connect(); // Usually handled by system
            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);
        if (s_esp_netif == NULL) { // Store the netif handle
            s_esp_netif = event->esp_netif;
        }
    }
}

void wifi_init_sta(void)
{
    s_wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    s_esp_netif = esp_netif_create_default_wifi_sta(); // Initialize s_esp_netif

    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, .threshold.authmode = WIFI_AUTH_WPA2_PSK },
    };
    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.");

    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG, "connected to ap SSID:%s", WIFI_SSID);
    } else if (bits & WIFI_FAIL_BIT) {
        ESP_LOGI(TAG, "Failed to connect to SSID:%s", WIFI_SSID);
    } else { ESP_LOGE(TAG, "UNEXPECTED EVENT"); }
}


static int create_multicast_ipv4_socket(void)
{
    struct sockaddr_in saddr = { 0 };
    int sock = -1;
    int err = 0;

    sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
    if (sock < 0) {
        ESP_LOGE(TAG, "Failed to create socket. Error %d", errno);
        return -1;
    }

    // Bind the socket to any address
    saddr.sin_family = PF_INET;
    saddr.sin_port = htons(MULTICAST_PORT);
    saddr.sin_addr.s_addr = htonl(INADDR_ANY); // Listen on all interfaces for the port
    err = bind(sock, (struct sockaddr *)&saddr, sizeof(struct sockaddr_in));
    if (err < 0) {
        ESP_LOGE(TAG, "Failed to bind socket. Error %d", errno);
        goto err_out;
    }

    // Allow multiple sockets to bind to the same multicast port
    int reuse = 1;
    err = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
    if (err < 0) {
        ESP_LOGE(TAG, "setsockopt(SO_REUSEADDR) failed. Error %d", errno);
        // Not strictly fatal for receiver, but good practice
    }
    
    // Assign the socket to the ESP_NETIF_DEFAULT_WIFI_STA interface by default
    // This is not strictly necessary for receiving if binding to INADDR_ANY and joining with INADDR_ANY interface
    // but can be useful for sending or more specific scenarios.
    if (s_esp_netif) { // Check if netif handle is available
        err = esp_netif_attach_socket_to_default_if(sock);
        if (err != ESP_OK) {
            ESP_LOGE(TAG, "Failed to attach socket to default if. err=0x%x", err);
            goto err_out;
        }
    } else {
        ESP_LOGW(TAG, "s_esp_netif is NULL, cannot attach socket to default if. May work if INADDR_ANY is used for join.");
    }


    // Join the multicast group
    struct ip_mreq imreq = { 0 };
    struct in_addr iaddr = { 0 };

    inet_aton(MULTICAST_IPV4_ADDR, &imreq.imr_multiaddr.s_addr);

    // Configure the interface to join the multicast group on
    // Using INADDR_ANY will use the default interface
    imreq.imr_interface.s_addr = htonl(INADDR_ANY);
    // Or, to bind to a specific interface:
    // esp_netif_ip_info_t ip_info;
    // ESP_ERROR_CHECK(esp_netif_get_ip_info(s_esp_netif, &ip_info));
    // inet_addr_from_ip4addr(&iaddr, &ip_info.ip);
    // imreq.imr_interface.s_addr = iaddr.s_addr;


    ESP_LOGI(TAG, "Joining IPV4 multicast group %s on interface %s...", MULTICAST_IPV4_ADDR, inet_ntoa(imreq.imr_interface));
    err = setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imreq, sizeof(struct ip_mreq));
    if (err < 0) {
        ESP_LOGE(TAG, "Failed to join multicast group. setsockopt IP_ADD_MEMBERSHIP err=%d", errno);
        goto err_out;
    }
    ESP_LOGI(TAG, "Successfully joined multicast group %s", MULTICAST_IPV4_ADDR);

    // Set Multicast TTL (for sender, but often set on same socket if it might also send)
    unsigned char ttl = MULTICAST_TTL;
    err = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
    if (err < 0) {
        ESP_LOGE(TAG, "setsockopt(IP_MULTICAST_TTL) failed. Error %d", errno);
        // Not fatal for receiver
    }

    // Disable multicast loopback (optional)
    // unsigned char loop = 0;
    // err = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop));
    // if (err < 0) {
    //     ESP_LOGE(TAG, "setsockopt(IP_MULTICAST_LOOP) failed. Error %d", errno);
    // }

    return sock;

err_out:
    close(sock);
    return -1;
}

void udp_multicast_receiver_task(void *pvParameters)
{
    ESP_LOGI(TAG, "Waiting for Wi-Fi connection to start UDP multicast receiver...");
    xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
    ESP_LOGI(TAG, "Wi-Fi connected. Starting UDP multicast receiver for group %s on port %d", MULTICAST_IPV4_ADDR, MULTICAST_PORT);

    int sock = -1;

    while(1) { // Outer loop to recreate socket if needed
        sock = create_multicast_ipv4_socket();
        if (sock < 0) {
            ESP_LOGE(TAG, "Receiver: Failed to create multicast socket. Retrying in 5s...");
            vTaskDelay(pdMS_TO_TICKS(5000));
            continue;
        }
        ESP_LOGI(TAG, "Receiver: Multicast socket created, waiting for data.");

        char rcv_buffer[128];
        struct sockaddr_in raddr; // Large enough for both IPv4 or IPv6
        socklen_t socklen = sizeof(raddr);

        while (1) { // Inner loop for receiving data
            int len = recvfrom(sock, rcv_buffer, sizeof(rcv_buffer) - 1, 0,
                               (struct sockaddr *)&raddr, &socklen);
            if (len < 0) {
                ESP_LOGE(TAG, "Receiver: Multicast recvfrom failed: errno %d", errno);
                // Potentially close and reopen socket or handle error
                break; // Break inner loop, will re-create socket
            }
            rcv_buffer[len] = 0; // Null-terminate
            ESP_LOGI(TAG, "Receiver: Received %d bytes from %s:%u: '%s'", len,
                     inet_ntoa(raddr.sin_addr), ntohs(raddr.sin_port), rcv_buffer);
        }
        
        ESP_LOGI(TAG, "Receiver: Closing socket and will attempt to recreate.");
        close(sock);
        sock = -1; // Ensure it's marked as closed
        vTaskDelay(pdMS_TO_TICKS(1000)); // Small delay before retrying socket creation
    }
    vTaskDelete(NULL);
}


void udp_multicast_sender_task(void *pvParameters)
{
    ESP_LOGI(TAG, "Waiting for Wi-Fi connection to start UDP multicast sender...");
    xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
    ESP_LOGI(TAG, "Wi-Fi connected. Starting UDP multicast sender to group %s on port %d", MULTICAST_IPV4_ADDR, MULTICAST_PORT);

    int sock;
    struct sockaddr_in sdestv4 = { 0 };

    sdestv4.sin_family = PF_INET;
    sdestv4.sin_port = htons(MULTICAST_PORT);
    inet_aton(MULTICAST_IPV4_ADDR, &sdestv4.sin_addr.s_addr);

    while(1) {
        sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
        if (sock < 0) {
            ESP_LOGE(TAG, "Sender: Failed to create socket. Error %d", errno);
            vTaskDelay(pdMS_TO_TICKS(1000));
            continue;
        }
        
        // Set the outgoing interface for multicast packets (optional but good practice)
        if (s_esp_netif) { // Check if netif handle is available
            esp_netif_ip_info_t ip_info;
            ESP_ERROR_CHECK(esp_netif_get_ip_info(s_esp_netif, &ip_info));
            struct in_addr local_if;
            inet_addr_from_ip4addr(&local_if, &ip_info.ip);

            if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF, &local_if, sizeof(local_if)) < 0) {
                ESP_LOGE(TAG, "Sender: setsockopt(IP_MULTICAST_IF) failed: %s", strerror(errno));
                // Non-fatal, system might pick an interface.
            } else {
                ESP_LOGI(TAG, "Sender: Using interface %s for outgoing multicast.", inet_ntoa(local_if));
            }
        } else {
            ESP_LOGW(TAG, "Sender: s_esp_netif is NULL, cannot set IP_MULTICAST_IF. System will choose default.");
        }


        // Set Time To Live (TTL) for multicast packets
        unsigned char ttl = MULTICAST_TTL;
        if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
            ESP_LOGE(TAG, "Sender: setsockopt(IP_MULTICAST_TTL) failed: %s", strerror(errno));
            // Continue anyway, default TTL might be used.
        }

        ESP_LOGI(TAG, "Sender: Sending multicast message: '%s'", MULTICAST_MESSAGE);
        int err = sendto(sock, MULTICAST_MESSAGE, strlen(MULTICAST_MESSAGE), 0,
                         (struct sockaddr *)&sdestv4, sizeof(sdestv4));
        if (err < 0) {
            ESP_LOGE(TAG, "Sender: Error occurred during sending: errno %d: %s", errno, strerror(errno));
        } else {
            ESP_LOGI(TAG, "Sender: Message sent successfully.");
        }

        close(sock);
        vTaskDelay(pdMS_TO_TICKS(5000)); // Send every 5 seconds
    }
    vTaskDelete(NULL);
}


void app_main(void)
{
    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);

    wifi_init_sta();

    xTaskCreate(udp_multicast_receiver_task, "udp_multicast_rx", 4096*2, NULL, 5, NULL); // Increased stack
    xTaskCreate(udp_multicast_sender_task, "udp_multicast_tx", 4096, NULL, 5, NULL);
}