RT-Thread组件生态：SAL网络框架与AT组件实战——网络抽象、AT指令

文章目录

- 每日一句正能量
- 导读
- 一、网络连接的挑战与RT-Thread的解决方案
- - [1.1 嵌入式网络开发的痛点](#1.1 嵌入式网络开发的痛点)
  - [1.2 RT-Thread的解决思路](#1.2 RT-Thread的解决思路)
- 二、SAL网络框架四层架构
- - [2.1 各层职责详解](#2.1 各层职责详解)
  - [2.2 SAL的核心数据结构](#2.2 SAL的核心数据结构)
  - [2.3 协议栈注册机制](#2.3 协议栈注册机制)
- 三、SAL函数调用链深度解析
- - [3.1 以connect()为例的完整调用链](#3.1 以connect()为例的完整调用链)
  - [3.2 协议域（Domain）路由机制](#3.2 协议域（Domain）路由机制)
- 四、AT组件架构与实现原理
- - [4.1 AT组件三层架构](#4.1 AT组件三层架构)
  - [4.2 AT Client核心机制](#4.2 AT Client核心机制)
  - [4.3 URC（Unsolicited Result Code）解析](#4.3 URC（Unsolicited Result Code）解析)
- 五、AT命令交互时序分析
- - [5.1 关键AT命令映射](#5.1 关键AT命令映射)
  - [5.2 数据接收的异步处理](#5.2 数据接收的异步处理)
- [六、SAL + AT组件配置与启用](#六、SAL + AT组件配置与启用)
- - [6.1 Kconfig配置](#6.1 Kconfig配置)
  - [6.2 关键配置项说明](#6.2 关键配置项说明)
  - [6.3 驱动初始化代码](#6.3 驱动初始化代码)
- [七、完整工程案例：MQTT over AT Socket](#七、完整工程案例：MQTT over AT Socket)
- - [7.1 系统架构](#7.1 系统架构)
  - [7.2 完整代码实现](#7.2 完整代码实现)
- 八、调试技巧与常见问题
- - [8.1 AT命令调试](#8.1 AT命令调试)
  - [8.2 网络状态监控](#8.2 网络状态监控)
  - [8.3 常见问题排查](#8.3 常见问题排查)
- 九、SAL与AT组件的设计优势总结
- 十、结语

每日一句正能量

那些不起眼的坚持，会在时光中为你铺就向上的阶梯。

每天微小的坚持，当下看不见变化，但时间会把它们累积成台阶。向上的路从来不是一步登天，而是一级一级走出来的。

导读

在物联网时代，嵌入式设备的网络连接能力已成为标配。然而，不同通信模块（WiFi、4G、NB-IoT）的AT指令集各异，直接操作AT命令不仅开发效率低，更难以在不同硬件平台间迁移。RT-Thread通过SAL（Socket Abstraction Layer，Socket抽象层）和AT组件，实现了"一套Socket API，适配多种网络协议栈"的优雅设计。本文以ESP8266 WiFi模块为实验载体，深入剖析SAL网络框架的四层架构、AT组件的命令交互机制，并给出MQTT over AT Socket的完整工程实践。

一、网络连接的挑战与RT-Thread的解决方案

1.1 嵌入式网络开发的痛点

在资源受限的嵌入式系统中实现网络连接，开发者通常面临以下困境：

痛点	传统方案	问题
协议栈差异	lwIP、AT命令、WIZnet各自独立	应用层代码无法复用
AT命令繁琐	直接串口发送AT指令	需处理响应匹配、超时重试、URC解析
硬件耦合	应用层直接操作通信模块	更换模块需重写大量代码
内存限制	完整TCP/IP协议栈占用大	小容量MCU无法运行lwIP

1.2 RT-Thread的解决思路

RT-Thread通过SAL + AT组件的组合，提供了三层解耦方案：

应用层使用标准BSD Socket API → SAL层路由到具体协议栈 → AT组件将Socket操作翻译为AT命令 → 通信模块执行实际网络操作

这种设计的核心价值：应用层完全无感知底层是lwIP、AT Socket还是WIZnet，代码可在不同网络方案间无缝切换。

二、SAL网络框架四层架构

图1展示了SAL网络框架的完整四层架构。

2.1 各层职责详解

层次	核心组件	职责
应用层	HTTP/MQTT/FTP/WebSocket客户端	业务逻辑，使用标准Socket API
DFS虚拟文件系统层	`dfs_net_getsocket()`	socket描述符统一管理，支持`read/write/close/poll/select`
SAL Socket抽象层	`sal_socket()` / `sal_connect()` / `sal_send()`	根据domain参数路由到对应协议栈
协议栈层	lwIP / AT Socket / WIZnet / Socket CAN	具体协议实现
硬件抽象层	以太网PHY / WiFi模块 / 4G模块	物理网络接口

2.2 SAL的核心数据结构

c 复制代码

/* components/net/sal_socket/include/sal_socket.h */
struct sal_socket
{
    int socket;                 /* 协议栈原生socket描述符 */
    uint32_t magic;             /* 魔数校验 */
    struct sal_proto_family *pf;  /* 所属协议族 */
};

struct sal_proto_family
{
    int family;                 /* 协议族：AF_INET/AF_AT/AF_WIZ */
    const struct sal_socket_ops *skt_ops;  /* Socket操作函数集 */
    const struct sal_netdb_ops *netdb_ops; /* DNS操作函数集 */
    struct netdev *netdev;      /* 关联的网络接口设备 */
};

2.3 协议栈注册机制

c 复制代码

/* SAL协议栈注册 */
int sal_register(const struct sal_proto_family *pf)
{
    /* 将协议族加入全局列表 */
    rt_slist_insert(&proto_family_list, &pf->list);
    
    /* 设置默认协议族（首个注册的AF_INET） */
    if (pf->family == AF_INET && default_pf == RT_NULL)
    {
        default_pf = pf;
    }
    
    return 0;
}

三、SAL函数调用链深度解析

3.1 以connect()为例的完整调用链

图2 展示了从应用层 connect() 到AT命令的完整调用链。

c 复制代码

/* 应用层调用 */
int connect(int s, const struct sockaddr *name, socklen_t namelen)
{
    /* 1. DFS层：将fd转换为sal_socket */
    int socket = dfs_net_getsocket(s);
    
    /* 2. SAL层：路由到具体协议栈 */
    return sal_connect(socket, name, namelen);
}

/* SAL层实现 */
int sal_connect(int s, const struct sockaddr *name, socklen_t namelen)
{
    struct sal_socket *sock = sal_get_socket(s);
    
    /* 根据socket关联的协议族，调用对应的connect */
    if (sock->pf->skt_ops->connect)
    {
        return sock->pf->skt_ops->connect(s, name, namelen);
    }
    
    return -1;
}

/* AT Socket层实现 */
static int at_connect(int socket, const struct sockaddr *name, socklen_t namelen)
{
    struct at_socket *sock = at_get_socket(socket);
    const struct sockaddr_in *sin = (const struct sockaddr_in *)name;
    
    /* 将Socket操作翻译为AT命令 */
    char cmd[128];
    rt_snprintf(cmd, sizeof(cmd), 
                "AT+CIPSTART=%d,\"TCP\",\"%s\",%d",
                sock->link_id,
                inet_ntoa(sin->sin_addr),
                ntohs(sin->sin_port));
    
    /* 发送AT命令并等待响应 */
    return at_obj_exec_cmd(sock->at_dev, RT_NULL, cmd);
}

3.2 协议域（Domain）路由机制

SAL通过 socket() 的 domain 参数决定使用哪个协议栈：

c 复制代码

/* 创建lwIP socket */
int lwip_sock = socket(AF_INET, SOCK_STREAM, 0);  /* domain=AF_INET → lwIP */

/* 创建AT Socket */
int at_sock = socket(AF_AT, SOCK_STREAM, 0);      /* domain=AF_AT → AT Socket */

/* 创建WIZnet socket */
int wiz_sock = socket(AF_WIZ, SOCK_STREAM, 0);   /* domain=AF_WIZ → WIZnet */

兼容性设计 ：AT Socket和WIZnet同时注册 AF_INET 作为次协议域，当应用层使用 AF_INET 创建socket时，SAL优先选择lwIP，若lwIP未启用则自动 fallback 到AT Socket。

四、AT组件架构与实现原理

4.1 AT组件三层架构

图3展示了AT组件的完整架构。

层次	组件	职责
AT Client	命令发送、URC解析、响应匹配	通用AT命令交互框架
AT Socket	`at_socket()` / `at_connect()` / `at_send()`	将Socket API映射为AT命令
AT Device	ESP8266 / SIM800C / EC200X / BC26	具体模块的AT命令适配

4.2 AT Client核心机制

c 复制代码

/* components/at/at_client/at_client.c - AT客户端核心 */

struct at_client
{
    rt_device_t device;         /* 串口设备 */
    rt_sem_t rx_notice;         /* 接收通知信号量 */
    rt_mutex_t lock;            /* 互斥锁 */
    
    char *recv_buffer;          /* 接收缓冲区 */
    rt_size_t recv_bufsz;       /* 缓冲区大小 */
    rt_size_t cur_recv_len;     /* 当前接收长度 */
    
    at_urc_table_t *urc_table;  /* URC解析表 */
    rt_size_t urc_table_size;    /* URC表大小 */
    
    at_status_t status;         /* 客户端状态 */
};

/* 发送AT命令并等待响应 */
rt_err_t at_obj_exec_cmd(at_client_t client, rt_base_t timeout, const char *cmd_expr, ...)
{
    /* 1. 获取互斥锁 */
    rt_mutex_take(client->lock, RT_WAITING_FOREVER);
    
    /* 2. 清空接收缓冲区 */
    client->cur_recv_len = 0;
    rt_memset(client->recv_buffer, 0x00, client->recv_bufsz);
    
    /* 3. 格式化并发送命令 */
    va_list args;
    va_start(args, cmd_expr);
    rt_vsnprintf(client->recv_buffer, client->recv_bufsz, cmd_expr, args);
    va_end(args);
    
    /* 4. 添加回车换行 */
    rt_size_t cmd_len = rt_strlen(client->recv_buffer);
    client->recv_buffer[cmd_len++] = '\r';
    client->recv_buffer[cmd_len++] = '\n';
    
    /* 5. 通过串口发送 */
    rt_device_write(client->device, 0, client->recv_buffer, cmd_len);
    
    /* 6. 等待响应（阻塞） */
    if (rt_sem_take(client->rx_notice, timeout) != RT_EOK)
    {
        rt_mutex_release(client->lock);
        return -RT_ETIMEOUT;
    }
    
    /* 7. 解析响应 */
    rt_err_t result = at_get_resp_status(client->recv_buffer);
    
    rt_mutex_release(client->lock);
    return result;
}

4.3 URC（Unsolicited Result Code）解析

URC是通信模块主动上报的异步消息（如收到数据、连接断开），需要独立解析：

c 复制代码

/* URC解析表示例（ESP8266） */
static const struct at_urc esp8266_urc_table[] =
{
    {\"+IPD\",       \"\\r\\n\",     urc_recv_func},      /* 收到网络数据 */
    {\"0,CONNECT\",  \"\\r\\n\",     urc_connect_func},   /* 连接成功 */
    {\"0,CLOSED\",   \"\\r\\n\",     urc_closed_func},    /* 连接关闭 */
    {\"WIFI \",     \"\\r\\n\",     urc_wifi_func},      /* WiFi状态变化 */
    {\"+PDP DEACT\", \"\\r\\n\",     urc_deact_func},     /* PDP去激活 */
};

/* URC解析线程 */
static void client_parser(at_client_t client)
{
    const struct at_urc *urc;
    char *urc_str;
    
    while (1)
    {
        /* 等待串口数据 */
        rt_sem_take(client->rx_notice, RT_WAITING_FOREVER);
        
        /* 检查是否匹配URC */
        urc = at_get_urc(client->urc_table, client->urc_table_size);
        if (urc != RT_NULL)
        {
            /* 调用URC处理函数 */
            urc->func(client, urc_str);
        }
        else
        {
            /* 普通响应，通知命令发送线程 */
            rt_sem_release(client->resp_notice);
        }
    }
}

五、AT命令交互时序分析

图4 展示了AT Socket connect() 的完整命令交互时序。

5.1 关键AT命令映射

Socket API	AT命令（ESP8266）	说明
`socket()`	`AT+CIPMUX=1`	启用多连接模式
`connect()`	`AT+CIPSTART=id,"TCP","host",port`	建立TCP连接
`send()`	`AT+CIPSEND=id,length` → 发送数据	先通知长度，再发数据
`recv()`	`+IPD,id,length:data`	异步数据上报
`closesocket()`	`AT+CIPCLOSE=id`	关闭连接
`gethostbyname()`	`AT+CIPDOMAIN="hostname"`	DNS解析

5.2 数据接收的异步处理

c 复制代码

/* URC处理函数：收到网络数据 */
static void urc_recv_func(struct at_client *client, const char *data, rt_size_t size)
{
    /* 解析 +IPD,<id>,<length>:<data> */
    int link_id, data_len;
    char *data_ptr;
    
    sscanf(data, \"+IPD,%d,%d:\", &link_id, &data_len);
    data_ptr = rt_strstr(data, \":\") + 1;
    
    /* 将数据存入对应socket的接收缓冲区 */
    struct at_socket *sock = at_get_socket_by_link_id(link_id);
    if (sock != RT_NULL)
    {
        rt_ringbuffer_put(&sock->recv_rb, data_ptr, data_len);
        
        /* 通知应用层有数据可读 */
        if (sock->recv_notice != RT_NULL)
        {
            rt_sem_release(sock->recv_notice);
        }
    }
}

六、SAL + AT组件配置与启用

图5展示了从Kconfig配置到Socket编程的完整启用流程。

6.1 Kconfig配置

bash 复制代码

# 使用 menuconfig 配置
RT-Thread Components  --->
    Network  --->
        [*] Socket abstraction layer
        [*] Enable BSD socket operated by file system API
        [*] Enable sal compile
        Protocol stack implement  --->
            [*] AT Socket stack (v1.3.1)
        AT Commands  --->
            [*] AT socket device modules  --->
                [*] Espressif ESP8266
            (uart2) AT client device name
            (512)   The maximum length of AT command data buff

6.2 关键配置项说明

配置项	默认值	说明
`AT_CLIENT_DEVICE_NAME`	`uart2`	AT客户端使用的串口设备名
`AT_CMD_MAX_LEN`	`512`	AT命令最大长度，需大于最长响应
`AT_RECV_BUFF_LEN`	`512`	AT接收缓冲区大小
`AT_SOCKET_BUFSZ`	`4096`	AT Socket数据缓冲区大小
`AT_DEVICE_ESP8266_SAMPLE`	`y`	启用ESP8266示例代码
`AT_DEVICE_WIFI_SSID`	`\"SSID\"`	WiFi热点名称
`AT_DEVICE_WIFI_PASSWORD`	`\"PWD\"`	WiFi密码

6.3 驱动初始化代码

c 复制代码

/* 系统初始化 */
int network_init(void)
{
    /* 1. 初始化串口 */
    rt_hw_usart_init();
    
    /* 2. 初始化AT客户端 */
    at_client_init(\"uart2\", 512);
    
    /* 3. 初始化ESP8266设备 */
    esp8266_device_init();
    
    /* 4. 注册AT Socket到SAL */
    at_socket_device_register(&esp8266_socket_ops);
    
    /* 5. 连接WiFi */
    wifi_join(\"Your_SSID\", \"Your_Password\");
    
    rt_kprintf(\"Network initialized!\\n\");
    return 0;
}
INIT_APP_EXPORT(network_init);

七、完整工程案例：MQTT over AT Socket

图6展示了MQTT over AT Socket的完整工程架构。

7.1 系统架构

复制代码

应用层：Paho MQTT客户端
    ↓ BSD Socket API
SAL层：socket()/connect()/send()/recv()
    ↓ 协议栈路由
AT Socket层：at_socket()/at_connect()/at_send()/at_recv()
    ↓ AT命令
硬件层：ESP8266 (UART2) → WiFi → MQTT Broker

7.2 完整代码实现

c 复制代码

/* mqtt_at_socket.c - MQTT over AT Socket 完整示例 */

#include <rtthread.h>
#include <rtdevice.h>
#include <sal_socket.h>
#include <netdb.h>
#include <string.h>

/* MQTT包定义 */
#define MQTT_CONNECT     1
#define MQTT_CONNACK     2
#define MQTT_PUBLISH     3
#define MQTT_PUBACK      4
#define MQTT_SUBSCRIBE   8
#define MQTT_SUBACK      9
#define MQTT_PINGREQ    12
#define MQTT_PINGRESP   13

/* MQTT连接信息 */
#define MQTT_BROKER_HOST  \"broker.emqx.io\"
#define MQTT_BROKER_PORT  1883
#define MQTT_CLIENT_ID    \"rtthread_client_001\"
#define MQTT_TOPIC        \"rtthread/sensor/data\"

static int mqtt_sock = -1;
static rt_thread_t mqtt_thread = RT_NULL;

/* ==================== MQTT协议编码 ==================== */

/* 编码MQTT变长整数 */
static int mqtt_encode_length(int length, uint8_t *buf)
{
    int bytes = 0;
    do
    {
        uint8_t byte = length % 128;
        length /= 128;
        if (length > 0) byte |= 0x80;
        buf[bytes++] = byte;
    } while (length > 0);
    return bytes;
}

/* 构建CONNECT包 */
static int mqtt_build_connect(uint8_t *buf, int bufsize,
                               const char *client_id,
                               const char *username,
                               const char *password)
{
    int idx = 0;
    int payload_len = 0;
    int client_id_len = rt_strlen(client_id);
    
    /* 固定报头 */
    buf[idx++] = (MQTT_CONNECT << 4);
    
    /* 计算剩余长度 */
    payload_len = 10;  /* 协议名(6) + 协议级别(1) + 连接标志(1) + 保持时间(2) */
    payload_len += 2 + client_id_len;  /* Client ID长度 + 内容 */
    
    if (username) payload_len += 2 + rt_strlen(username);
    if (password) payload_len += 2 + rt_strlen(password);
    
    idx += mqtt_encode_length(payload_len, &buf[idx]);
    
    /* 可变报头 */
    buf[idx++] = 0x00; buf[idx++] = 0x04;  /* 协议名长度 */
    buf[idx++] = 'M'; buf[idx++] = 'Q';
    buf[idx++] = 'T'; buf[idx++] = 'T';
    buf[idx++] = 0x04;  /* 协议级别 MQTT 3.1.1 */
    buf[idx++] = 0x02;  /* 连接标志：Clean Session */
    buf[idx++] = 0x00; buf[idx++] = 0x3C;  /* 保持连接：60秒 */
    
    /* 有效载荷：Client ID */
    buf[idx++] = (client_id_len >> 8) & 0xFF;
    buf[idx++] = client_id_len & 0xFF;
    rt_memcpy(&buf[idx], client_id, client_id_len);
    idx += client_id_len;
    
    return idx;
}

/* 构建PUBLISH包 */
static int mqtt_build_publish(uint8_t *buf, int bufsize,
                               const char *topic,
                               const uint8_t *payload,
                               int payload_len,
                               int qos)
{
    int idx = 0;
    int topic_len = rt_strlen(topic);
    int remaining_len = 2 + topic_len + payload_len;
    
    /* 固定报头 */
    buf[idx++] = (MQTT_PUBLISH << 4) | (qos << 1);
    idx += mqtt_encode_length(remaining_len, &buf[idx]);
    
    /* 主题 */
    buf[idx++] = (topic_len >> 8) & 0xFF;
    buf[idx++] = topic_len & 0xFF;
    rt_memcpy(&buf[idx], topic, topic_len);
    idx += topic_len;
    
    /* 有效载荷 */
    rt_memcpy(&buf[idx], payload, payload_len);
    idx += payload_len;
    
    return idx;
}

/* 构建PINGREQ包 */
static int mqtt_build_pingreq(uint8_t *buf)
{
    buf[0] = (MQTT_PINGREQ << 4);
    buf[1] = 0x00;
    return 2;
}

/* ==================== 网络操作 ==================== */

/* 连接到MQTT Broker */
static int mqtt_network_connect(const char *host, int port)
{
    struct hostent *server;
    struct sockaddr_in server_addr;
    
    /* DNS解析 */
    server = gethostbyname(host);
    if (server == RT_NULL)
    {
        rt_kprintf(\"DNS resolve failed!\\n\");
        return -1;
n        return -1;\n    }
    
    /* 创建socket */
    mqtt_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (mqtt_sock < 0)
    {
        rt_kprintf(\"Socket create failed!\\n\");
        return -1;
    }
    
    /* 连接服务器 */
    rt_memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    rt_memcpy(&server_addr.sin_addr, server->h_addr, server->h_length);
    
    if (connect(mqtt_sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
    {
        rt_kprintf(\"Connect failed!\\n\");
        closesocket(mqtt_sock);
        mqtt_sock = -1;
        return -1;
    }
    
    rt_kprintf(\"Connected to %s:%d\\n\", host, port);
    return 0;
}

/* 发送MQTT包 */
static int mqtt_send_packet(uint8_t *buf, int len)
{
    int sent = 0;
    while (sent < len)
    {
        int ret = send(mqtt_sock, buf + sent, len - sent, 0);
        if (ret < 0)
        {
            rt_kprintf(\"Send failed!\\n\");
            return -1;
        }
        sent += ret;
    }
    return sent;
}

/* 接收MQTT包 */
static int mqtt_recv_packet(uint8_t *buf, int bufsize, int timeout_ms)
{
    int received = 0;
    int ret;
    
    /* 设置接收超时 */
    struct timeval tv;
    tv.tv_sec = timeout_ms / 1000;
    tv.tv_usec = (timeout_ms % 1000) * 1000;
    setsockopt(mqtt_sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
    
    /* 读取固定报头 */
    ret = recv(mqtt_sock, buf, 1, 0);
    if (ret <= 0) return -1;
    received++;
    
    /* 读取剩余长度 */
    int multiplier = 1;
    int remaining_len = 0;
    uint8_t byte;
    do
    {
        ret = recv(mqtt_sock, &byte, 1, 0);
        if (ret <= 0) return -1;
        buf[received++] = byte;
        remaining_len += (byte & 0x7F) * multiplier;
        multiplier *= 128;
    } while ((byte & 0x80) && received < 5);
    
    /* 读取剩余数据 */
    int to_read = remaining_len;
    while (to_read > 0 && received < bufsize)
    {
        ret = recv(mqtt_sock, buf + received, to_read, 0);
        if (ret <= 0) break;
        received += ret;
        to_read -= ret;
    }
    
    return received;
}

/* ==================== MQTT业务逻辑 ==================== */

/* MQTT连接 */
static int mqtt_connect_broker(void)
{
    uint8_t buf[256];
    int len;
    
    /* 构建CONNECT包 */
    len = mqtt_build_connect(buf, sizeof(buf), MQTT_CLIENT_ID, RT_NULL, RT_NULL);
    
    /* 发送 */
    if (mqtt_send_packet(buf, len) < 0)
        return -1;
    
    /* 等待CONNACK */
    len = mqtt_recv_packet(buf, sizeof(buf), 5000);
    if (len < 0 || (buf[0] >> 4) != MQTT_CONNACK)
    {
        rt_kprintf(\"CONNACK not received!\\n\");
        return -1;
    }
    
    rt_kprintf(\"MQTT connected!\\n\");
    return 0;
}

/* 发布传感器数据 */
static int mqtt_publish_data(float temperature, float humidity)
{
    uint8_t buf[256];
    uint8_t payload[64];
    int payload_len;
    int len;
    
    /* 构建JSON有效载荷 */
    payload_len = rt_snprintf((char *)payload, sizeof(payload),
                              \"{\\\"temp\\\":%.1f,\\\"hum\\\":%.1f}\",
                              temperature, humidity);
    
    /* 构建PUBLISH包 */
    len = mqtt_build_publish(buf, sizeof(buf), MQTT_TOPIC,
                              payload, payload_len, 0);
    
    /* 发送 */
    return mqtt_send_packet(buf, len);
}

/* 发送心跳 */
static int mqtt_ping(void)
{
    uint8_t buf[2];
    int len = mqtt_build_pingreq(buf);
    return mqtt_send_packet(buf, len);
}

/* ==================== 主任务 ==================== */

static void mqtt_task_entry(void *parameter)
{
    float temp = 25.0f;
    float hum = 60.0f;
    int ping_count = 0;
    
    while (1)
    {
        /* 连接网络 */
        if (mqtt_network_connect(MQTT_BROKER_HOST, MQTT_BROKER_PORT) < 0)
        {
            rt_thread_mdelay(5000);
            continue;
        }
        
        /* MQTT连接 */
        if (mqtt_connect_broker() < 0)
        {
            closesocket(mqtt_sock);
            rt_thread_mdelay(5000);
            continue;
        }
        
        /* 主循环 */
        while (1)
        {
            /* 发布数据 */
            if (mqtt_publish_data(temp, hum) < 0)
                break;
            
            /* 模拟数据变化 */
            temp += 0.5f;
            if (temp > 35.0f) temp = 25.0f;
            
            /* 每30秒发送心跳 */
            ping_count++;
            if (ping_count >= 6)
            {
                ping_count = 0;
                if (mqtt_ping() < 0)
                    break;
            }
            
            rt_thread_mdelay(5000);
        }
        
        /* 连接断开，清理 */
        closesocket(mqtt_sock);
        mqtt_sock = -1;
        rt_kprintf(\"MQTT disconnected, retrying...\\n\");
        rt_thread_mdelay(5000);
    }
}

/* 初始化 */
int mqtt_app_init(void)
{
    mqtt_thread = rt_thread_create(\"mqtt\", mqtt_task_entry, RT_NULL,
                                    2048, 10, 10);
    if (mqtt_thread != RT_NULL)
        rt_thread_startup(mqtt_thread);
    
    return 0;
}
INIT_APP_EXPORT(mqtt_app_init);

八、调试技巧与常见问题

8.1 AT命令调试

c 复制代码

/* 开启AT命令调试输出 */
#define DBG_ENABLE
#define DBG_SECTION_NAME \"AT\"
#define DBG_LEVEL DBG_LOG
#include <rtdbg.h>

/* 在AT Client中打印所有收发数据 */
static void at_client_printf(at_client_t client)
{
    rt_kprintf(\"AT TX: %s\", client->send_buffer);
    rt_kprintf(\"AT RX: %s\", client->recv_buffer);
}

8.2 网络状态监控

c 复制代码

/* 通过FinSH命令查看网络状态 */
static int cmd_netstat(void)
{
    struct sal_socket *sock;
    int i;
    
    rt_kprintf(\"Active sockets:\\n\");
    rt_kprintf(\"%-4s %-6s %-10s %-10s %-10s\\n\",
               \"fd\", \"type\", \"local\", \"remote\", \"state\");
    
    for (i = 0; i < SAL_SOCKETS_NUM; i++)
    {
        sock = sal_get_socket(i);
        if (sock && sock->magic == SAL_SOCKET_MAGIC)
        {
            rt_kprintf(\"%-4d %-6d %-10s %-10s %-10s\\n\",
                       i, sock->type,
                       \"0.0.0.0:0\",  /* 简化显示 */
                       \"0.0.0.0:0\",
                       \"ESTABLISHED\");
        }
    }
    
    return 0;
}
MSH_CMD_EXPORT(cmd_netstat, network status);

8.3 常见问题排查

问题	原因	解决方案
`socket()` 返回-1	SAL未初始化或协议栈未注册	检查Kconfig配置，确认AT Socket已启用
`connect()` 超时	WiFi未连接或AT命令错误	检查WiFi配置，使用 `wifi_join()` 先连接
数据接收不完整	URC解析失败或缓冲区溢出	增大 `AT_SOCKET_BUFSZ`，检查URC表配置
DNS解析失败	模块未获取IP或DNS服务器错误	检查 `AT+CIFSR` 响应，确认WiFi已连接
频繁断线	信号弱或心跳间隔过长	缩短MQTT心跳间隔，检查WiFi信号强度

九、SAL与AT组件的设计优势总结

特性	传统AT开发	RT-Thread SAL+AT
API一致性	各模块AT命令不同	统一BSD Socket API
代码可移植性	更换模块需重写	零修改切换lwIP/AT/WIZnet
开发效率	需手动处理AT交互	框架自动处理命令/响应/URC
多连接支持	需手动管理link_id	AT Socket自动映射
内存占用	取决于实现	AT Socket约8KB ROM + 4KB RAM
协议栈选择	单一方案	灵活选择lwIP/AT/WIZnet

十、结语

RT-Thread的SAL网络框架与AT组件，为嵌入式设备提供了一套**"一次编写，到处运行"**的网络解决方案。通过SAL的协议栈抽象，应用层使用标准BSD Socket API开发；通过AT组件的命令翻译，底层通信模块的差异被完全屏蔽。无论是WiFi、4G还是NB-IoT，开发者只需关注业务逻辑，无需陷入AT命令的繁琐细节。

对于资源受限的MCU（如STM32F103，64KB Flash），AT Socket方案相比完整lwIP协议栈可节省约30KB Flash和20KB RAM，是物联网应用的理想选择。

转载自：https://blog.csdn.net/u014727709/article/details/162494919

欢迎 👍点赞✍评论⭐收藏，欢迎指正