1. 背景

       在很多物联网场景下，设备没有 WiFi 环境，需要通过 4G/2G 蜂窝模组上网。常见模组（如 Quectel EG800K、EC800M 等）支持 PPP 拨号，ESP32 则通过 UART 与模组交互，实现虚拟网卡。这样应用层就能像在 WiFi 下一样使用 socket() 与服务器建立 TCP/UDP 连接。

本文的目标就是：

1. ESP32 → 串口驱动 → 蜂窝模组 → 拨号成功拿到公网 IP

2. 在此基础上运行 TCP 客户端，完成握手、心跳、掉线自动重拨

2. 基础知识

1. PPP (Point-to-Point Protocol, 点对点协议)

        想象一下，你的 ESP32 有一个 TCP/IP 协议栈，它知道如何处理 IP 包、TCP 连接，但它只认识 Wi-Fi 或以太网这样的“网卡”。而 4G 模块通过 UART（串口）与 ESP32 通信，这是一个串行数据流，TCP/IP 协议栈并不直接理解。

        PPP 的作用就是一座桥梁。它允许我们将 IP 数据包“打包”成一种特殊格式，然后通过 UART 这种串行链路发送出去。4G 模块接收到后，再“解包”并将原始的 IP 包发送到蜂窝网络中。反之亦然。通过 PPP，我们可以在 ESP32 内部创建一个虚拟网络接口 。对于上层应用（如我们的 TCP 客户端）来说，这个接口和 Wi-Fi 网卡没什么两样，可以直接使用标准的 Socket API 进行编程，极大地简化了开发。

获取IP地址的步骤：

        ESP32 通过串口向 4G 模块发送 ATD*99# 请求拨号，模块随即与基站及核心网协商，由运营商（本文中为移动）分配一个 PDP 上下文（即 IP 地址）；随后模块与 ESP32 在串口链路上运行 PPP 协议，通过 IPCP 报文将该 IP 告知 ESP32；ESP32 的 lwIP 栈据此生成 ppp0 接口，使设备直接获得运营商分配的 IP 并用于后续网络通信。

2. AT 命令 (AT Commands)

        AT 命令是用于控制调制解调器（Modem，即我们的 4G 模块）的标准语言。在 PPP 连接建立之前，我们需要用 AT 命令来“配置和指挥”4G 模块，例如：

• AT: 测试模块是否在线。

• AT+CPIN?: 检查 SIM 卡状态。

• AT+CGDCONT=...: 设置 APN（接入点名称），告诉模块要连接哪个运营商网络。

• ATD*99#: 核心命令，指示模块启动数据连接（进入 PPP 模式）。一旦此命令成功，模块就不再响应大多数 AT 命令，而是进入纯粹的数据透传模式，开始 PPP 协商。

3. esp_netif (ESP-IDF 网络接口)

  esp_netif 是 ESP-IDF v4.x 之后引入的网络接口抽象层。它提供了一套统一的 API 来管理各种网络接口（Wi-Fi, Ethernet, PPP 等）。我们的代码通过 esp_netif_new() 创建一个 PPP 类型的接口，并将其与底层的 UART 驱动绑定，从而完成了从硬件到协议栈的连接。

4. EventGroup (事件组)

        本案例有两个任务：ppp_dial_task和tcp_client_task 。在PPP拨号上网成功获取IP地址后才可以进行TCP连接，如何通知 tcp_client_task “网络已就绪，可以开始工作了”？答案就是使用 FreeRTOS 的 EventGroup。

• 拨号任务成功后，会设置事件组中的一个特定标志位 (NETWORK_CONNECTED_BIT)。

• TCP 任务则会一直阻塞等待这个标志位。一旦标志位被设置，它就从等待中被唤醒，开始执行后续的 TCP 连接操作。

3. 代码架构解析

本文ESP-IDF版本为v5.5.0，主控为ESP32-C5，4G模块为移远的EC800K-CN,运营商为移动。

#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/socket.h>
#include <errno.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <time.h>

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "freertos/timers.h"
#include "esp_system.h"
#include "esp_log.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_netif_ppp.h"
#include <sys/socket.h>
#include <netinet/tcp.h>
#include "esp_netif_ppp.h"

#include "driver/uart.h"

// ------------------ 配置常量 ----------------------------------
#define SERVER_IP               "自己要连接的服务器IP地址"
#define SERVER_PORT             端口号

#define UART_PORT_NUM           UART_NUM_1
#define UART_TX_PIN             1
#define UART_RX_PIN             0
#define BUF_SIZE                1024

// ------------------ 协议帧常量 --------------------------------
#define FRAME_HEADER            0x7E7E
#define FRAME_TAIL              0xE7E7
#define FUNC_CODE_REPORT        0x2A
#define FUNC_CODE_CONFIG        0x2C
#define FUNC_CODE_HEARTBEAT     0x2B
#define SYNC_TIMEOUT_MS         5000          // 等一单帧最大 5 s
#define HEARTBEAT_2C_MS         (3*60*1000)   // 3 min

// ----------------- FreeRTOS Synchronization -------------------
EventGroupHandle_t network_event_group;
#define NETWORK_CONNECTED_BIT (1 << 0)

//------------------状态查询-------------------------------------
#define QUECTEL_ENG             0
#define MAX_FAST_RECONNECTS     1          

// ----------------- 全局变量 -----------------------------------
static const char *TAG = "PPP_TCP_CLIENT";
static esp_netif_t *ppp_netif = NULL;
static int sock = -1;
//static TimerHandle_t heartbeat_timer = NULL;
//static bool ppp_alive = true;
static int tcp_reconnect_count = 0; 

// ---------------- Forward Declarations -----------------------
static void ppp_dial_task(void *pvParameters);
static void tcp_client_task(void *pvParameters);
static void send_2a_frame(int s);
static void send_2c_frame(int s);
static void send_2b_frame(int s);
static int recv_frame_wait(int s, uint8_t *rxbuf, size_t rxbuf_len, int timeout_ms);
static uint16_t crc16_modbus(const uint8_t *data, size_t len);

//===================================================================================================================================
// --------------------------------------------------       拨号任务       -----------------------------------------------------------
//===================================================================================================================================
static void uart_init(void)
{
    const uart_config_t uart_config =
    {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_DEFAULT,
    };
    ESP_ERROR_CHECK(uart_driver_install(UART_PORT_NUM, BUF_SIZE * 2, BUF_SIZE * 2, 0, NULL, 0));
    ESP_ERROR_CHECK(uart_param_config(UART_PORT_NUM, &uart_config));
    ESP_ERROR_CHECK(uart_set_pin(UART_PORT_NUM, UART_TX_PIN, UART_RX_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
}


//发送AT指令并打印响应
static void send_at_cmd(const char *cmd,int wait_ms)
{
    char rxbuf[BUF_SIZE];
    int len;

    ESP_LOGI(TAG,"Send: %s",cmd);
    uart_write_bytes(UART_PORT_NUM,cmd,strlen(cmd));
    uart_write_bytes(UART_PORT_NUM,"\r\n",2);

    vTaskDelay(pdMS_TO_TICKS(wait_ms));

    len = uart_read_bytes(UART_PORT_NUM,(uint8_t*)rxbuf,BUF_SIZE - 1,pdMS_TO_TICKS(1000));
    if (len > 0)
    {
        rxbuf[len] = 0;
        ESP_LOGI(TAG,"at resp: %s",rxbuf);
    }
}

static void quectel_eng_once(void)
{
    const char cmd[] = "AT+QENG=\"SERVINGCELL\"\r\n";
    char   buf[512] = {0};          // ① 加大到 512，防止回显过长
    int    pos = 0;

    uart_flush(UART_PORT_NUM);
    uart_write_bytes(UART_PORT_NUM, cmd, strlen(cmd));

    TickType_t xStop = xTaskGetTickCount() + pdMS_TO_TICKS(3000);
    while (xTaskGetTickCount() < xStop && pos < sizeof(buf) - 3) {
        uint8_t ch;
        if (uart_read_bytes(UART_PORT_NUM, &ch, 1, pdMS_TO_TICKS(100)) == 1) {
            buf[pos++] = ch;

            /* ② 必须看到结果行的头 "+QENG:" 才开始判尾 */
            if (pos >= 7 && memcmp(&buf[pos - 7], "\r\n+QENG", 7) == 0) {
                /* 从结果头开始重新计数，丢弃前面回显 */
                memmove(buf, &buf[pos - 7], 7);
                pos = 7;
            }

            /* ③ 只在结果行里找 \r\n 结束 */
            if (pos >= 2 && buf[pos - 2] == '\r' && buf[pos - 1] == '\n' &&
                strstr(buf, "+QENG:") != NULL) {
                break;
            }
        }
    }
    buf[pos] = 0;
    if (pos && buf[pos - 1] == '\n') buf[pos - 1] = 0;
    if (pos && buf[pos - 2] == '\r') buf[pos - 2] = 0;

    if (strstr(buf, "+QENG:"))
        ESP_LOGI("ENG", "%s", buf);
    else
        ESP_LOGW("ENG", "无 +QENG 返回，原始=%s", buf);
}

//ppp驱动上下文
typedef struct 
{
    int uart_port;
    esp_netif_t *netif;    
}ppp_uart_ctx_t;

static ppp_uart_ctx_t ppp_ctx;

//ppp发送数据，esp32->eg800k
static esp_err_t ppp_uart_transmit(void *h,void *buffer,size_t len)
{
    //ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_INFO);
    ppp_uart_ctx_t *ctx = (ppp_uart_ctx_t*)h;
    uart_write_bytes(ctx->uart_port,buffer,len);
    return ESP_OK;
}

//ppp驱动api
static esp_netif_driver_ifconfig_t driver_ifconfig = 
{
    .handle = &ppp_ctx,
    .transmit = ppp_uart_transmit,
    .driver_free_rx_buffer = NULL,
};

//PPP事件回调
static void on_ppp_changed(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
{
    if (event_base != IP_EVENT) return;   // 只处理 IP 事件

    switch (event_id) 
    {
        case IP_EVENT_PPP_GOT_IP: 
        {           // 拨号成功
            ESP_LOGI(TAG, "PPP connected, got IP!");
            //ppp_alive = true;
            xEventGroupSetBits(network_event_group, NETWORK_CONNECTED_BIT);
            tcp_reconnect_count = 0; // 重置快速重连计数
            break;
        }
        case IP_EVENT_PPP_LOST_IP:            // 断线
        {
            ESP_LOGW(TAG, "PPP connection lost IP!");
            //ppp_alive = false;
            xEventGroupClearBits(network_event_group, NETWORK_CONNECTED_BIT);
            tcp_reconnect_count = MAX_FAST_RECONNECTS; // 触发快速重连机制
            break;
        }
        default:
            break;
    }
}

//uart接收任务：eg800k->esp->ppp
static void uart_rx_task(void *arg)
{
    uint8_t *data = malloc(BUF_SIZE);

    // esp_event_handler_register(IP_EVENT, IP_EVENT_PPP_GOT_IP, esp_netif_action_connected, ppp_netif);
    // esp_netif_action_start(ppp_netif, 0, 0, 0);
    // esp_netif_action_connected(ppp_netif, 0, 0, 0);

    while(1)
    {
        size_t len = 0;
        uart_get_buffered_data_len(UART_PORT_NUM, &len);
        if(len>0 && ppp_ctx.netif)
        {
            len = uart_read_bytes(UART_PORT_NUM, data, BUF_SIZE, 100);
            esp_netif_receive(ppp_netif, data, len, NULL);//将从硬件（UART）接收到的原始数据，喂给 PPP 网络接口
        }
        vTaskDelay(10 / portTICK_PERIOD_MS); 
    }
    free(data);
    vTaskDelete(NULL);
}

//拨号任务
static void ppp_dial_task(void *pvParameters)
{
    ESP_LOGI(TAG, "Starting PPP dial task...");
    uart_init();

    // 尝试转义回命令模式
    uart_flush(UART_PORT_NUM);
    uart_write_bytes(UART_PORT_NUM, "+++", 3); 
    vTaskDelay(pdMS_TO_TICKS(3000));           // 等模组就绪

    // 模块基本检测
    send_at_cmd("AT", 500);
    send_at_cmd("AT+CPIN?", 500);
    send_at_cmd("AT+CREG?", 500);
    send_at_cmd("AT+CGREG?", 500);

    // 设置 APN
    send_at_cmd("AT+CGDCONT=1,\"IP\",\"CMNET\"", 500);

#if QUECTEL_ENG
    quectel_eng_once();      // 初始快照
    vTaskDelay(pdMS_TO_TICKS(500)); 
#endif

    // 拨号
    send_at_cmd("ATD*99#", 1000);

    ppp_ctx.uart_port = UART_PORT_NUM;
    esp_netif_config_t ppp_cfg = ESP_NETIF_DEFAULT_PPP();
    ppp_cfg.driver = &driver_ifconfig;
    ppp_netif = esp_netif_new(&ppp_cfg);//创建一个 PPP 类型的网络接口，此时，一个代表“PPP连接”的虚拟网卡在系统中诞生了。
    ppp_ctx.netif = ppp_netif;

    // 注册 PPP 事件
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, ESP_EVENT_ANY_ID, &on_ppp_changed, NULL,NULL));

    // 启动 PPP
    esp_netif_action_start(ppp_netif, 0, 0, 0);
    esp_netif_set_default_netif(ppp_netif);//告诉操作系统，如果有数据包需要发往外部网络（不是本地局域网），默认就通过这个新创建的 PPP 网卡发送

    // 开启 UART -> PPP 转发
    xTaskCreate(uart_rx_task, "uart_rx_task", 4096, NULL, 5, NULL);

    ESP_LOGI(TAG, "PPP dial task finished its job. Deleting task.");
    vTaskDelete(NULL);

}

//===================================================================================================================================
// --------------------------------------------------       TCP客户端任务       ------------------------------------------------------
//===================================================================================================================================
uint16_t crc16_modbus(const uint8_t *data, size_t len) {
    uint16_t crc = 0xFFFF;
    while (len--) {
        crc ^= *data++;
        for (int i = 0; i < 8; i++) {
            if (crc & 0x0001)
                crc = (crc >> 1) ^ 0xA001;
            else
                crc >>= 1;
        }
    }
    return crc; // 本身就是低位在前
}

static void send_frame(int s, uint8_t func_code, const uint8_t *payload, uint16_t payload_len) 
{
    if (s < 0) 
    {
        ESP_LOGE(TAG, "Socket not connected, cannot send frame.");
        return;
    }

    uint8_t frame[256];
    uint16_t frame_index = 0;
    //uint32_t timestamp = esp_log_timestamp(); // Simple timestamp
    uint32_t timestamp = (uint32_t)time(NULL);
    // 1. Frame Header
    frame[frame_index++] = (FRAME_HEADER >> 8) & 0xFF;
    frame[frame_index++] = FRAME_HEADER & 0xFF;

    // 2. Function Code
    frame[frame_index++] = func_code;

    // 3. Timestamp (4 bytes, Big-Endian)
    frame[frame_index++] = (timestamp >> 24) & 0xFF;
    frame[frame_index++] = (timestamp >> 16) & 0xFF;
    frame[frame_index++] = (timestamp >> 8) & 0xFF;
    frame[frame_index++] = timestamp & 0xFF;

    // 4. Data Length (2 bytes, Big-Endian)
    frame[frame_index++] = (payload_len >> 8) & 0xFF;
    frame[frame_index++] = payload_len & 0xFF;

    // 5. User Data (Payload)
    if (payload && payload_len > 0) 
    {
        memcpy(&frame[frame_index], payload, payload_len);
        frame_index += payload_len;
    }

    // 6. crc
    uint16_t crc = crc16_modbus(&frame[2], frame_index - 2);
    frame[frame_index++] = crc & 0xFF;
    frame[frame_index++] = crc >> 8;

    // 7. Frame Tail
    frame[frame_index++] = (FRAME_TAIL >> 8) & 0xFF;
    frame[frame_index++] = FRAME_TAIL & 0xFF;

    // Send the frame
    if (send(s, frame, frame_index, 0) < 0) 
    {
        ESP_LOGE(TAG, "Error sending frame: %d", errno);
    } 
    else 
    {
        ESP_LOGI(TAG, "Sent frame (Func: 0x%02X, Len: %d bytes)", func_code, frame_index);
        ESP_LOG_BUFFER_HEX(TAG, frame, frame_index);
    }
}

// Function 0x2A: Module Info Report
static void send_2a_frame(int s) 
{
    uint8_t payload[64];
    uint16_t payload_index = 0;

    // 1. 硬件版本号
    payload[payload_index++] = 0x10;
    payload[payload_index++] = 0x00;
    // 2. 软件版本号
    payload[payload_index++] = 0x01;
    payload[payload_index++] = 0x34;

    // 3. SN序列号串的长(1 byte)
    uint8_t sn_len = 15; 
    payload[payload_index++] = sn_len;
    // 4. 模块SN序列号串 (ASCII)
    const char *sn_str = "123456789012345";
    memcpy(&payload[payload_index], sn_str, sn_len);
    payload_index += sn_len;

    // 5.1 2g&4g模块IMEI序列长度 (1 byte)
    uint8_t imei_len = 15; // Example: "123456789012345"
    payload[payload_index++] = imei_len;
    // 6.1 2g&4g模块IMEI序列串 (ASCII)
    const char *imei_str = "123456789012345";
    memcpy(&payload[payload_index], imei_str, imei_len);
    payload_index += imei_len;

    // 7.1 2g&4g模块iccid序列长度
    uint8_t iccid_len = 20; 
    payload[payload_index++] = iccid_len;
    // 8.1 ICCID String (ASCII)
    const char *iccid_str = "89860000000000000000";
    memcpy(&payload[payload_index], iccid_str, iccid_len);
    payload_index += iccid_len;

    // 9. Signal Strength (1 byte)
    payload[payload_index++] = 85; // Example: 85%

    send_frame(s, FUNC_CODE_REPORT, payload, payload_index);
}

// Function 0x2C: Module Configuration Report
static void send_2c_frame(int s) 
{
    uint8_t payload[64];
    uint16_t payload_index = 0;
    
    payload[payload_index++] = 0x00; // Example: ESP32-WROOM-32
    payload[payload_index++] = 0x00;
    payload[payload_index++] = 0x00;
    payload[payload_index++] = 0x00;

    send_frame(s, FUNC_CODE_CONFIG, payload, payload_index);
}

static void send_2b_frame(int s) 
{
    uint8_t payload[1];
    payload[0] = 0x00; // Request to enter transparent mode

    send_frame(s, FUNC_CODE_HEARTBEAT, payload, sizeof(payload));
}

static int recv_frame_wait(int s, uint8_t *rxbuf, size_t rxbuf_len, int timeout_ms)
{
    int len;
    TickType_t xTicks = pdMS_TO_TICKS(timeout_ms);
    /* 这里只做最简单实现：收任意长度≥8 的数据，取第 2 字节当功能码 */
    len = recv(s, rxbuf, rxbuf_len, 0);
    if (len < 8) return -1;          
    return rxbuf[2];                 
}

//----------------------------------------主TCP客户端逻辑-------------------------------------------------
static void tcp_client_task(void *pvParameters)
{
    uint8_t rx_buffer[128];
    struct addrinfo hints = { .ai_family = AF_INET, .ai_socktype = SOCK_STREAM };
    struct addrinfo *res;
    int err;
    int keep_alive = 1, idle = 30, interval = 5, probes = 3;

    while (1) 
    {
        if (ppp_netif == NULL || tcp_reconnect_count >= MAX_FAST_RECONNECTS)
        {
            ESP_LOGI(TAG, "Waiting for new PPP IP address (ppp_netif=%s, attempts=%d)...", ppp_netif == NULL ? "NULL" : "OK", tcp_reconnect_count);
            
            // 阻塞等待 PPP 拨号任务设置 NETWORK_CONNECTED_BIT
            xEventGroupWaitBits(network_event_group, NETWORK_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
            
            // 确保等待完成后，计数器归零 (如果是因为 ppp_netif == NULL 进来，则在 on_ppp_changed 中已归零)
        }
        ESP_LOGI(TAG, "Network is up! Attempting to connect to server (Attempt %d).", tcp_reconnect_count + 1);

        // DNS解析（阻塞式）把服务器地址转换为链表，供socket()与connect()使用
        err = getaddrinfo(SERVER_IP, NULL, &hints, &res);//既能解析点分十进制，也能解析域名，返回res链表，包含family、port、addr、scope_id 等字段
        if (err != 0 || res == NULL) 
        {
            ESP_LOGE(TAG, "DNS lookup failed for %s", SERVER_IP);
            // If DNS fails, wait a bit and retry the whole process
            tcp_reconnect_count++;
            vTaskDelay(pdMS_TO_TICKS(5000));
            goto reconnect;
        }

        // Create socket
        sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if (sock < 0) 
        {
            ESP_LOGE(TAG, "Failed to create socket: %d", errno);
            freeaddrinfo(res);
            tcp_reconnect_count++;
            vTaskDelay(pdMS_TO_TICKS(5000));
            goto reconnect;
        }

        // Set server port
        ((struct sockaddr_in *)res->ai_addr)->sin_port = htons(SERVER_PORT);
        err = connect(sock, res->ai_addr, res->ai_addrlen);
        freeaddrinfo(res);
        if (err != 0) 
        {
            ESP_LOGE(TAG, "Socket unable to connect to %s:%d (errno %d)", SERVER_IP, SERVER_PORT, errno);
            close(sock);
            sock = -1;
            tcp_reconnect_count++;
            vTaskDelay(pdMS_TO_TICKS(5000));
            goto reconnect;
        }
        ESP_LOGI(TAG, "Successfully connected to server %s:%d, Enable KeepAlive!", SERVER_IP, SERVER_PORT);

        setsockopt(sock, SOL_SOCKET,  SO_KEEPALIVE, &keep_alive, sizeof(keep_alive));
        setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE,  &idle,      sizeof(idle));
        setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &interval,  sizeof(interval));
        setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT,   &probes,    sizeof(probes));

        // --- Connection Established, Send Initial Frames ---
        send_2a_frame(sock);
        if (recv_frame_wait(sock, rx_buffer, sizeof(rx_buffer), SYNC_TIMEOUT_MS) != 0xAA)
            goto reconnect;

        send_2c_frame(sock);
        if (recv_frame_wait(sock, rx_buffer, sizeof(rx_buffer), SYNC_TIMEOUT_MS) != 0xAC)
            goto reconnect;

        send_2b_frame(sock);
        if (recv_frame_wait(sock, rx_buffer, sizeof(rx_buffer), SYNC_TIMEOUT_MS) != 0xAB)
            goto reconnect;

        ESP_LOGI(TAG, "Handshake completed, entering heartbeat loop.");
        
        /* ---------- 4 min 循环只发 2C ---------- */
        TickType_t xLastWake = xTaskGetTickCount();
        while (1) 
        {
            vTaskDelayUntil(&xLastWake, pdMS_TO_TICKS(HEARTBEAT_2C_MS));//绝对周期延时函数，参考点为上一次唤醒通时刻

            int error = 0;
            socklen_t len = sizeof(error);
            if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len) != 0 || error != 0)
            {
                ESP_LOGE(TAG, "TCP KeepAlive death errno=%d, reconnection!", error);
                break;
            }
            send_2c_frame(sock);
            if(recv_frame_wait(sock, rx_buffer, sizeof(rx_buffer), SYNC_TIMEOUT_MS) != 0xAC)
            {
                ESP_LOGE(TAG,"No response at 2C in the cycle, reconnection!");
                break;
            }
            ESP_LOGI(TAG, "2C Heartbeat response received");
        }

        // --- Cleanup and Reconnect ---
        reconnect:

        if(sock >= 0)
        {
            ESP_LOGE(TAG, "Shutting down TCP socket...");
            shutdown(sock, 0);
            close(sock);
            sock = -1;
        }
        if (ppp_netif != NULL && tcp_reconnect_count < MAX_FAST_RECONNECTS)
        {
            ESP_LOGW(TAG, "LEVEL 1: Fast TCP Reconnect (Attempt %d/%d). PPP is assumed alive.", tcp_reconnect_count, MAX_FAST_RECONNECTS);
            vTaskDelay(pdMS_TO_TICKS(1000));
            continue;
        }
        else if(ppp_netif != NULL)
        {
            ESP_LOGE(TAG, "LEVEL 2: Max fast reconnects reached or PPP lost. Executing full redial!");
            esp_netif_destroy(ppp_netif);
            ppp_netif = NULL;
            ppp_ctx.netif = NULL;
            vTaskDelay(pdMS_TO_TICKS(200));

        #if QUECTEL_ENG
            /* 1. 先让 PPP 停掉，模组回到 AT 模式 */

            uart_flush(UART_PORT_NUM);
            uart_write_bytes(UART_PORT_NUM, "+++", 3); // 转义回命令态
            vTaskDelay(pdMS_TO_TICKS(3000));           // 等模组就绪

            /* 2. 直接打印当前小区 */
            quectel_eng_once();
        #endif
        
            //ppp_alive = false;
            xEventGroupClearBits(network_event_group,NETWORK_CONNECTED_BIT);

            ESP_LOGI(TAG, "Restart PPP dial ...");
            xTaskCreate(ppp_dial_task, "ppp_dial_task", 4096, NULL, 5, NULL);

            ESP_LOGI(TAG, "Wait for PPP re-dial ...");
            xEventGroupWaitBits(network_event_group, NETWORK_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
            ESP_LOGI(TAG, "PPP re-dial OK, try TCP again");
            continue;
        }
        else
        {
            ESP_LOGW(TAG, "PPP netif is NULL. Waiting for PPP task to finish redialing.");
            continue;
        }
    }
    vTaskDelete(NULL);
}

//===================================================================================================================================
// --------------------------------------------------       主函数         -----------------------------------------------------------
//===================================================================================================================================
void app_main(void)
{
    ESP_LOGI(TAG, "Starting PPP TCP Client Application...");

    // Initialize networking and event loop
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());

    // Create event group for network status synchronization
    network_event_group = xEventGroupCreate();

    // Create the PPP dialing task
    xTaskCreate(ppp_dial_task, "ppp_dial_task", 4096, NULL, 5, NULL);

    // Create the TCP client task. It will wait for the network_event_group signal.
    xTaskCreate(tcp_client_task, "tcp_client_task", 8192, NULL, 4, NULL);

    ESP_LOGI(TAG, "Tasks created. Application running.");
}

send_2a_frame、send_2b_frame、send_2c_frame是我自定义的数据协议，仅适用我连接的TCP服务器，勿全盘照抄。

执行流程：

1. 启动流程 (app_main)

• 初始化 esp_netif 和默认事件循环。

• 创建一个 EventGroupHandle_t 用于任务间同步。

• 启动 ppp_dial_task: 开始进行拨号。

• 启动 tcp_client_task: 它会立即运行，但在 xEventGroupWaitBits 处被阻塞，等待网络连接成功的信号。

2. 拨号任务 (ppp_dial_task)

这是建立网络连接的第一步。

1. 初始化 UART: 配置与 4G 模块通信的串口参数（波特率、引脚等）。

2. 发送 AT 命令序列:

   • +++: 尝试将模块从数据模式切换回命令模式（这是一个保险操作）。

   • AT, AT+CPIN?, AT+CGREG?: 检查模块和网络状态。

   • AT+CGDCONT=1,"IP","CMNET": 设置 APN。

   • ATD*99#: 发起拨号，请求进入 PPP 数据模式。

3. 创建并配置 esp_netif:

   • 调用 esp_netif_new() 创建一个 PPP 类型的虚拟网卡。

   • 设置其驱动函数，其中 ppp_uart_transmit 函数告诉 esp_netif：“当你需要发送数据时，调用这个函数，它会通过 UART 把数据写给 4G 模块”。

4. 注册事件回调 (on_ppp_changed):

   • 监听 IP_EVENT_PPP_GOT_IP（获取到 IP）和 IP_EVENT_PPP_LOST_IP（连接丢失）事件。

   • 当获取到 IP 时，设置 NETWORK_CONNECTED_BIT，唤醒 TCP 任务。

   • 当连接丢失时，清除该标志位。

5. 启动 uart_rx_task: 这个小任务像一个搬运工，循环地从 UART 读取 4G 模块发来的数据，然后通过 esp_netif_receive() 喂给 PPP 协议栈进行处理。

当 ppp_dial_task 完成上述配置后，它的历史使命就完成了，可以自我删除 (vTaskDelete(NULL))。但它创建的 uart_rx_task 和 esp_netif 实例会持续在后台运行。

3. TCP 客户端任务 (tcp_client_task)

这是应用的核心，一个永不退出的循环。

1. 等待网络: xEventGroupWaitBits 阻塞，直到 NETWORK_CONNECTED_BIT 被设置。

2. TCP 连接:

   • getaddrinfo(): DNS 解析服务器 IP。

   • socket(): 创建套接字。

   • connect(): 连接服务器。

3. 设置 TCP KeepAlive:

   • setsockopt 调用非常关键。它开启了 TCP 的 KeepAlive 机制，让 TCP 协议栈在连接空闲时，自动发送探测包来检查对端是否存活。这能有效检测到“假死”连接，比纯粹的应用层心跳更可靠。

4. 应用层握手:

   • 依次发送 0x2A (上报信息), 0x2C (上报配置), 0x2B (心跳) 帧，并等待服务器对应的 0xAA, 0xAC, 0xAB 响应。这是一个自定义的设备上线认证流程。

5. 心跳循环:

   • 进入主循环，使用 vTaskDelayUntil 精准地每隔 HEARTBEAT_2C_MS（3分钟）执行一次。

   • 在发送心跳前，通过 getsockopt(sock, SOL_SOCKET, SO_ERROR, ...) 检查 socket 是否出错。这是检查 TCP KeepAlive 探测结果的标准方法。如果连接已断开，error 会非零。

   • 发送 0x2C 帧作为周期性心跳，并等待 0xAC 响应。

6. 异常处理与重连 (核心):

   • 任何环节出错（连接失败、握手超时、心跳无响应），都会跳转到 reconnect 标签处。

   • 首先关闭旧的 socket。

   • 然后进入分级重连逻辑

4.补充

• 为什么需要 esp_netif_receive()?
  ESP32 自带的 TCP/IP 栈并不会直接读 UART，而是等你“喂”数据进去。模组发来的 PPP 数据包要交给 esp_netif_receive() 才能被 lwIP 处理。

• KeepAlive 与自定义心跳的区别

  • TCP KeepAlive：用来维持底层 TCP 链路

  • 自定义心跳：业务层协议，用来检测服务端是否还响应（即便 TCP 还活着，应用层也可能掉了）

• 为什么要“快速重连 + 完全重拨”两级策略？

  • 运营商可能只是 TCP NAT 掉了，此时 PPP 链路还活着 → 快速重连即可

  • 如果 PPP 链路丢失（基站切换/信号消失） → 必须重新拨号

• 串口 +++ 的作用
  从数据模式（PPP）切回命令模式（AT），这是 PPP 链路彻底断开的关键，否则模组还停留在数据态。