1.引言

網路通信中使用最多的就是廣播、組播、單播幾種通信方式了，今天我們拋開具體的標準和知識，簡單聊聊單播、組播、廣播的區別與使用，

2.單播、組播、廣播區別與聯系

單播：在同一網路內，兩個設備點對點的通信就是單播通信，

組播：在同一網路可達范圍內，一個網路設備與關心其資料的部分設備進行通信就是組播，

廣播：在同一網路可達范圍內，一個網路設備向本網路內所有設備進行通信就是廣播，

具體如下：

簡單地說，單播->組播->廣播，是通信數量不斷增加的通信方式，當然，通信數量的增多，帶來的是通信設備的資源消耗更大，整體網路環境的復雜度更高，

通常，我們使用組播、廣播完成兩件事：

1）將同一份資料互動到多個目的地，比如，視頻會議、新聞分發，都需要將一份資料同時傳輸到多個設備上，供大家使用，

2）通過客戶端請求或發現服務器，有時，我們并不知道服務器的具體資訊（如IP地址），這時，我們可以采取“盲發”的方式去廣播或組播資訊，等待服務器收到訊息盲發的訊息后，回傳資料，如此找到對應目標設備，

眾所周知，TCP是可靠傳輸（先與另一個通信端點建立可靠連接，再傳輸資料），因此TCP一般只支持單播這種通信方式，而DUP通信不需要建立連接就可以發送資料，因此，通常我們說的廣播、組播，都是在UDP下概念，

此外，廣播又可以分為兩類：本地廣播、定向廣播，

1）本地廣播：廣播地址為255.255.255.255.

2）定向廣播：廣播地址類似192.168.4.255.

這兩種廣播功能類似，但具體區別說來話長，有感興趣的可以留言，我再出篇帖子來介紹一下，

3.編程與測驗

廣播、單播在實作方式，以及使用方式上的區別不大，僅僅是目標IP，以及Socket屬性的細微差別，我們先來看兩者的區別與使用，

具體可參考以下代碼：（開發板仍然是便宜且好用的ESP32開發板，開發環境是release V4.2,實際上，任何平臺，以下代碼都是可以參考滴，客官慢用）

/* BSD Socket API 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.
*/
#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 "esp_netif.h"
#include "protocol_examples_common.h"

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

#if defined(CONFIG_EXAMPLE_IPV4)
#define HOST_IP_ADDR CONFIG_EXAMPLE_IPV4_ADDR
#elif defined(CONFIG_EXAMPLE_IPV6)
#define HOST_IP_ADDR CONFIG_EXAMPLE_IPV6_ADDR
#else
#define HOST_IP_ADDR ""
#endif

#define PORT CONFIG_EXAMPLE_PORT

static const char *TAG = "example";
static const char *payload = "Message from ESP32 ";

static int udp_creat(uint16_t port, char* bind_ip)
{
    struct sockaddr_in6 unicast_dest_addr = {0};
    struct sockaddr_in *unicast_dest_addr_ip4 = (struct sockaddr_in *)&unicast_dest_addr;
    int ip_protocol = 0;
    const int on = 1;
    inet_aton(bind_ip, &unicast_dest_addr_ip4->sin_addr.s_addr);//bind sta ip
    unicast_dest_addr_ip4->sin_family = AF_INET;
    unicast_dest_addr_ip4->sin_port = htons(port);
    ip_protocol = IPPROTO_IP;

    int sock = socket(AF_INET, SOCK_DGRAM, ip_protocol);
    if (sock < 0) {
        ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
        return -1;
    }

    int err = bind(sock, (struct sockaddr *)&unicast_dest_addr, sizeof(unicast_dest_addr));
    if (err < 0) {
        ESP_LOGE(TAG, "Socket unable to bind: errno %d", errno);
        shutdown(sock, 0);
        close(sock);
        return -1;
    }
    
    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0) {
        ESP_LOGE(TAG, "reuse addr fail");
        close(sock);
        return -1;
    }

    if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) != 0) {
        ESP_LOGE(TAG, "broadcast enable fail");
        close(sock);
        return -1;
    }

    return sock;
}

static void udp_client_task(void *pvParameters)
{
    char rx_buffer[128];
    char host_ip[] = HOST_IP_ADDR;
    int addr_family = 0;
    int ip_protocol = 0;
    tcpip_adapter_ip_info_t sta_info;
    while (1) {

#if defined(CONFIG_EXAMPLE_IPV4)
        struct sockaddr_in unicast_dest_addr;
        unicast_dest_addr.sin_addr.s_addr = inet_addr(HOST_IP_ADDR);
        unicast_dest_addr.sin_family = AF_INET;
        unicast_dest_addr.sin_port = htons(PORT);
        addr_family = AF_INET;
        ip_protocol = IPPROTO_IP;
#elif defined(CONFIG_EXAMPLE_IPV6)
        struct sockaddr_in6 unicast_dest_addr = { 0 };
        inet6_aton(HOST_IP_ADDR, &unicast_dest_addr.sin6_addr);
        unicast_dest_addr.sin6_family = AF_INET6;
        unicast_dest_addr.sin6_port = htons(PORT);
        unicast_dest_addr.sin6_scope_id = esp_netif_get_netif_impl_index(EXAMPLE_INTERFACE);
        addr_family = AF_INET6;
        ip_protocol = IPPROTO_IPV6;
#elif defined(CONFIG_EXAMPLE_SOCKET_IP_INPUT_STDIN)
        struct sockaddr_in6 unicast_dest_addr = { 0 };
        ESP_ERROR_CHECK(get_addr_from_stdin(PORT, SOCK_DGRAM, &ip_protocol, &addr_family, &unicast_dest_addr));
#endif
        char sta_ip_str[32] = {0};
        esp_err_t ret = tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &sta_info);
        if (ret != ESP_OK) {
            ESP_LOGE(TAG, "get sta ip fail");
        }
        printf(IPSTR, IP2STR(&sta_info.ip));
        sprintf(sta_ip_str, IPSTR, IP2STR(&sta_info.ip));
        int sock = udp_creat(3333,sta_ip_str);
        if (sock < 0) {
            ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
            break;
        }

        ESP_LOGI(TAG, "Socket created, sending to %s:%d", HOST_IP_ADDR, PORT);
        struct sockaddr_in broadcast_dest_addr;//for broadcast
        char sendline[32] = {"Hello"};
        char temp_str[32] = "255.255.255.255";
        bzero(&broadcast_dest_addr, sizeof(broadcast_dest_addr));
        broadcast_dest_addr.sin_family = AF_INET;
        broadcast_dest_addr.sin_addr.s_addr = inet_addr(temp_str); //廣播地址(192.168.43.255 can be work, too.)
        broadcast_dest_addr.sin_port = htons(3333);//target port

        while (1) {
            int err = sendto(sock, sendline, strlen(sendline), 0, (struct sockaddr*)&broadcast_dest_addr, sizeof(broadcast_dest_addr));//broadcast
            if (err < 0) {
                ESP_LOGE(TAG, "Error occurred during sending: errno %d", errno);
                break;
            }
            ESP_LOGI(TAG, "Message sent");

            err = sendto(sock, payload, strlen(payload), 0, (struct sockaddr *)&unicast_dest_addr, sizeof(unicast_dest_addr));//unicast
            if (err < 0) {
                ESP_LOGE(TAG, "Error occurred during sending: errno %d", errno);
                break;
            }
            ESP_LOGI(TAG, "Message sent");

            struct sockaddr_in source_addr; // Large enough for both IPv4 or IPv6
            socklen_t socklen = sizeof(source_addr);
            int len = recvfrom(sock, rx_buffer, sizeof(rx_buffer) - 1, 0, (struct sockaddr *)&source_addr, &socklen);

            // Error occurred during receiving
            if (len < 0) {
                ESP_LOGE(TAG, "recvfrom failed: errno %d", errno);
                break;
            }
            // Data received
            else {
                rx_buffer[len] = 0; // Null-terminate whatever we received and treat like a string
                ESP_LOGI(TAG, "Received %s", rx_buffer);
                if (strncmp(rx_buffer, "OK: ", 4) == 0) {
                    ESP_LOGI(TAG, "Received expected message, reconnecting");
                    break;
                }
            }

            vTaskDelay(2000 / portTICK_PERIOD_MS);
        }

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

void app_main(void)
{
    ESP_ERROR_CHECK(nvs_flash_init());
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());

    /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
     * Read "Establishing Wi-Fi or Ethernet Connection" section in
     * examples/protocols/README.md for more information about this function.
     */
    ESP_ERROR_CHECK(example_connect());

    xTaskCreate(udp_client_task, "udp_client", 4096, NULL, 5, NULL);
}

上述代碼，通過UDP，實作廣播、單播一次，然后進入接收一次資料；依次回圈的功能，

4.組播實作介紹

組播的實作就略微復雜了，要實作組播，至少要經過以下步驟:

1）建立socket_fd

2）socket_fd和指定本地埠系結

3）加入一個組播組

4）通過sendto / recvfrom進行資料的收發

5）離開組播組

6）關閉socket

注意：服務器和客戶端必須都要加入相同的組播地址才可以，涉及到的socket屬性主要是以下三個：

感興趣的小伙伴可以留言，我將再出一篇關于組播的博客，謝謝點贊或收藏，