基于ESP-IDF框架，ESP32串口连接4G模块，实现PPP拨号上网，连接TCP服务器

1. 背景

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

本文的目标就是：

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)

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

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

3. TCP 客户端任务 (tcp_client_task)

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

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 链路彻底断开的关键，否则模组还停留在数据态。