网络编程与应用

1. 概述

1.1 功能简介

网络编程是嵌入式 Linux 系统中最基础且最重要的应用开发方向之一。RK3576 平台内置双千兆以太网控制器（GMAC），支持 10/100/1000Mbps 自适应以太网连接，配合 Linux 6.1 内核提供的完整 TCP/IP 协议栈，可实现高性能的网络通信应用。本文档涵盖网络环境配置、TCP/UDP 套接字编程、多线程并发服务器、HTTP 请求、MQTT 通信、NFS 远程挂载、网络性能测试以及 SSH 远程访问等核心网络编程主题，所有示例均基于 C 语言和 RK3576 平台验证。

1.2 应用场景

• 工业网关：Modbus TCP/RTU 网关、协议转换
• 边缘计算节点：MQTT 数据采集与上报、HTTP REST API 服务
• 远程管理：SSH 远程登录、NFS 文件共享、OTA 远程升级
• 数据传输：大文件 TCP/UDP 传输、实时流媒体推送
• 网络测试：带宽测试、延迟测量、丢包率分析
• 物联网终端：传感器数据采集、云端连接、远程控制

1.3 工作原理

RK3576 网络通信架构：

┌─────────────────────────────────────────────────────────────┐
│                     应用层                                    │
│  TCP Server/Client  UDP Socket  HTTP(libcurl)  MQTT         │
│  SSH  NFS  iperf3                                           │
├─────────────────────────────────────────────────────────────┤
│                   传输层                                      │
│  TCP (可靠流)  UDP (不可靠数据报)                              │
├─────────────────────────────────────────────────────────────┤
│                   网络层                                      │
│  IPv4 / IPv6  ICMP  ARP                                     │
├─────────────────────────────────────────────────────────────┤
│                 Linux 内核网络栈 (6.1)                        │
│  Socket API  Netfilter  /proc/net  网络设备管理              │
├─────────────────────────────────────────────────────────────┤
│                   驱动层                                      │
│  stmmac (Synopsys DesignWare MAC)                           │
│  GMAC0 / GMAC1 — 双千兆以太网 MAC                            │
├─────────────────────────────────────────────────────────────┤
│                   硬件层                                      │
│  RK3576 GMAC ──► RGMII ──► PHY ──► RJ45 网口 (eth0/eth1)    │
└─────────────────────────────────────────────────────────────┘

RK3576 网络相关硬件信息（以下为 RK 平台通用结构示例，具体数值以实际发布的 RK3576 SDK 设备树为准）：

模块	设备树节点	寄存器基地址	功能
GMAC0	ethernet@...	待确认	千兆以太网 MAC（eth0）
GMAC1	ethernet@...	待确认	千兆以太网 MAC（eth1）

M4-R2 底板提供双千兆 RJ45 网口（S-01 已验证），对应内核网络接口通常为 eth0/eth1，综合设备接口序号以实际 SDK 内核配置为准。

---

2. 硬件准备

2.1 硬件清单

组件	型号/规格	数量	备注
主控板	C-3576BQ 核心板 + M4-R2 底板	1	运行 Linux 6.1 系统
网线	标准 CAT5e/CAT6 RJ45	1~2	连接路由器/交换机或 PC 直连
调试串口线	USB 转 TTL（3.3V）	1	波特率 1500000
电源适配器	5V/2A DC（Type-C 或 6pin 供电）	1	空载最小 1000mA
电脑（测试机）	x86 Linux/Windows/macOS	1	用于交叉编译和网络测试
路由器/交换机（可选）	支持 DHCP	1	多设备组网测试

2.2 硬件连接

M4-R2 底板网络连接：

方案一：连接路由器（DHCP 自动获取 IP）
  ├── RJ45 网口 (eth0) ──► 路由器 LAN 口
  ├── USB 调试口 ──► PC（串口调试）
  └── DC 5V 电源 ──► 电源适配器

方案二：PC 直连（静态 IP）
  ├── RJ45 网口 (eth0) ──► PC 网口（交叉网线或直连线）
  ├── USB 调试口 ──► PC（串口调试）
  └── DC 5V 电源 ──► 电源适配器

2.3 硬件确认

# 确认系统架构
uname -m
# 输出：aarch64

# 确认内核版本
uname -r
# 输出：6.1.xx

# 确认网卡是否存在
ip link show
# 输出中应包含 eth0/eth1（GMAC0/GMAC1 对应的网络接口）

# 确认网卡驱动
dmesg | grep -i gmac
# 应看到 stmmac 驱动加载信息

# 确认网络接口详细信息
ip addr show eth0
# 查看 MAC 地址、IP 地址等

---

3. 软件准备

3.1 交叉编译工具链

RK3576 Linux SDK 使用 GCC 10.3 交叉编译工具链：

# SDK 工具链路径
SDK_DIR/prebuilts/gcc/linux-x86/aarch64/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu/bin/

# 添加到 PATH
export PATH=$SDK_DIR/prebuilts/gcc/linux-x86/aarch64/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu/bin:$PATH

# 验证
aarch64-linux-gnu-gcc --version
# 输出：aarch64-linux-gnu-gcc (GCC) 10.3.1 20210621

也可以使用系统安装的交叉编译器：

# Ubuntu/Debian
sudo apt-get install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu

# 验证
aarch64-linux-gnu-gcc --version

3.2 目标板依赖安装

在目标板上安装网络编程相关开发库：

# 更新软件源
sudo apt-get update

# 安装基础网络工具
sudo apt-get install -y net-tools iputils-ping

# 安装 libcurl 开发库（HTTP 请求）
sudo apt-get install -y libcurl4-openssl-dev curl

# 安装 mosquitto 客户端和开发库（MQTT）
sudo apt-get install -y mosquitto-clients libmosquitto-dev

# 安装 iperf3（网络性能测试）
sudo apt-get install -y iperf3

# 安装 OpenSSH 服务端
sudo apt-get install -y openssh-server

# 安装 NFS 工具
sudo apt-get install -y nfs-common nfs-kernel-server

# 安装 pthread 开发支持（通常已内置）
# 编译时使用 -lpthread 参数即可

3.3 主机端工具

# 主机端安装交叉编译器和网络调试工具
sudo apt-get install -y \
    gcc-aarch64-linux-gnu \
    g++-aarch64-linux-gnu \
    iperf3 \
    net-tools \
    openssh-client \
    nfs-kernel-server

---

4. 操作步骤

4.1 网络环境配置

DHCP 自动获取 IP

# 查看当前网络接口状态
ip addr show

# 使用 DHCP 获取 IP（接口名以实际为准，通常为 eth0 或 eth1）
sudo dhclient eth0

# 或使用 systemd-networkd
sudo systemctl enable systemd-networkd
sudo systemctl start systemd-networkd

# 查看获取的 IP 地址
ip addr show eth0
# 输出示例：
# inet 192.168.1.100/24 brd 192.168.1.255 scope global dynamic eth0

# 查看默认网关
ip route show default
# 输出示例：default via 192.168.1.1 dev eth0

# 查看 DNS 配置
cat /etc/resolv.conf

静态 IP 配置

# 方法一：使用 ip 命令临时配置
sudo ip addr add 192.168.1.100/24 dev eth0
sudo ip link set eth0 up
sudo ip route add default via 192.168.1.1

# 方法二：写入网络配置文件（以 systemd-networkd 为例）
sudo mkdir -p /etc/systemd/network
sudo tee /etc/systemd/network/10-eth0.network << 'EOF'
[Match]
Name=eth0

[Network]
Address=192.168.1.100/24
Gateway=192.168.1.1
DNS=8.8.8.8
DNS=114.114.114.114

[Link]
_MTU=1500"
EOF

sudo systemctl restart systemd-networkd

网络连通性测试

# 测试网关连通性
ping -c 4 192.168.1.1

# 测试外网连通性
ping -c 4 8.8.8.8

# 测试 DNS 解析
nslookup www.baidu.com

# 查看网络路由
ip route show

# 查看网络接口统计
cat /proc/net/dev

4.2 TCP 服务器与客户端

TCP 服务器

/* tcp_server.c — RK3576 TCP 服务器示例 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define SERVER_PORT 8080
#define BUFFER_SIZE 1024

int main(void)
{
    int server_fd, client_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[BUFFER_SIZE];
    ssize_t recv_len;

    /* 创建 TCP 套接字 */
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        return EXIT_FAILURE;
    }

    /* 允许端口复用 */
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    /* 绑定地址和端口 */
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(SERVER_PORT);

    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_fd);
        return EXIT_FAILURE;
    }

    /* 监听 */
    if (listen(server_fd, 5) < 0) {
        perror("listen");
        close(server_fd);
        return EXIT_FAILURE;
    }

    printf("TCP Server listening on port %d...\n", SERVER_PORT);

    /* 接受客户端连接 */
    client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
    if (client_fd < 0) {
        perror("accept");
        close(server_fd);
        return EXIT_FAILURE;
    }

    printf("Client connected: %s:%d\n",
           inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

    /* 接收并回显数据 */
    while ((recv_len = recv(client_fd, buffer, BUFFER_SIZE - 1, 0)) > 0) {
        buffer[recv_len] = '\0';
        printf("Received: %s", buffer);

        /* 回显给客户端 */
        send(client_fd, buffer, recv_len, 0);
    }

    printf("Client disconnected.\n");

    close(client_fd);
    close(server_fd);
    return EXIT_SUCCESS;
}

TCP 客户端

/* tcp_client.c — RK3576 TCP 客户端示例 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define SERVER_IP "192.168.1.100"
#define SERVER_PORT 8080
#define BUFFER_SIZE 1024

int main(void)
{
    int sock_fd;
    struct sockaddr_in server_addr;
    char buffer[BUFFER_SIZE];
    ssize_t recv_len;

    /* 创建 TCP 套接字 */
    sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd < 0) {
        perror("socket");
        return EXIT_FAILURE;
    }

    /* 设置服务器地址 */
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    if (inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr) <= 0) {
        perror("inet_pton");
        close(sock_fd);
        return EXIT_FAILURE;
    }

    /* 连接服务器 */
    if (connect(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("connect");
        close(sock_fd);
        return EXIT_FAILURE;
    }

    printf("Connected to server %s:%d\n", SERVER_IP, SERVER_PORT);

    /* 发送数据并接收回显 */
    const char *msg = "Hello from RK3576 TCP Client!\n";
    send(sock_fd, msg, strlen(msg), 0);
    printf("Sent: %s", msg);

    recv_len = recv(sock_fd, buffer, BUFFER_SIZE - 1, 0);
    if (recv_len > 0) {
        buffer[recv_len] = '\0';
        printf("Echo: %s", buffer);
    }

    close(sock_fd);
    return EXIT_SUCCESS;
}

编译与测试

# 交叉编译（在主机上执行）
aarch64-linux-gnu-gcc -Wall -O2 -o tcp_server tcp_server.c
aarch64-linux-gnu-gcc -Wall -O2 -o tcp_client tcp_client.c

# 传输到目标板
scp tcp_server tcp_client root@192.168.1.100:/root/

# 在目标板上运行
# 终端 1：启动服务器
./tcp_server
# 输出：TCP Server listening on port 8080...

# 终端 2（另一台设备或同一板上新开终端）：启动客户端
./tcp_client
# 输出：Connected to server 192.168.1.100:8080
# 输出：Sent: Hello from RK3576 TCP Client!
# 输出：Echo: Hello from RK3576 TCP Client!

4.3 UDP 通信

UDP 服务器

/* udp_server.c — RK3576 UDP 服务器示例 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define SERVER_PORT 9090
#define BUFFER_SIZE 1024

int main(void)
{
    int sock_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[BUFFER_SIZE];
    ssize_t recv_len;

    /* 创建 UDP 套接字 */
    sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock_fd < 0) {
        perror("socket");
        return EXIT_FAILURE;
    }

    /* 绑定地址和端口 */
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(SERVER_PORT);

    if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(sock_fd);
        return EXIT_FAILURE;
    }

    printf("UDP Server listening on port %d...\n", SERVER_PORT);

    /* 循环接收和回复 */
    while (1) {
        recv_len = recvfrom(sock_fd, buffer, BUFFER_SIZE - 1, 0,
                            (struct sockaddr *)&client_addr, &client_len);
        if (recv_len < 0) {
            perror("recvfrom");
            continue;
        }

        buffer[recv_len] = '\0';
        printf("Received from %s:%d: %s",
               inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), buffer);

        /* 回显给客户端 */
        sendto(sock_fd, buffer, recv_len, 0,
               (struct sockaddr *)&client_addr, client_len);
    }

    close(sock_fd);
    return EXIT_SUCCESS;
}

UDP 客户端

/* udp_client.c — RK3576 UDP 客户端示例 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define SERVER_IP "192.168.1.100"
#define SERVER_PORT 9090
#define BUFFER_SIZE 1024

int main(void)
{
    int sock_fd;
    struct sockaddr_in server_addr;
    char buffer[BUFFER_SIZE];
    socklen_t addr_len = sizeof(server_addr);
    ssize_t recv_len;

    /* 创建 UDP 套接字 */
    sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock_fd < 0) {
        perror("socket");
        return EXIT_FAILURE;
    }

    /* 设置服务器地址 */
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr);

    /* 发送数据 */
    const char *msg = "Hello from RK3576 UDP Client!\n";
    sendto(sock_fd, msg, strlen(msg), 0,
           (struct sockaddr *)&server_addr, sizeof(server_addr));
    printf("Sent: %s", msg);

    /* 接收回显 */
    recv_len = recvfrom(sock_fd, buffer, BUFFER_SIZE - 1, 0, NULL, NULL);
    if (recv_len > 0) {
        buffer[recv_len] = '\0';
        printf("Echo: %s", buffer);
    }

    close(sock_fd);
    return EXIT_SUCCESS;
}

# 交叉编译
aarch64-linux-gnu-gcc -Wall -O2 -o udp_server udp_server.c
aarch64-linux-gnu-gcc -Wall -O2 -o udp_client udp_client.c

# 传输到目标板
scp udp_server udp_client root@192.168.1.100:/root/

# 运行测试
./udp_server   # 终端 1
./udp_client   # 终端 2

4.4 多线程并发服务器

RK3576 配备 4 核 Cortex-A72 + 4 核 Cortex-A53，共 8 个 CPU 核心，适合运行多线程并发服务器处理大量客户端连接。

/* threaded_server.c — RK3576 多线程并发 TCP 服务器 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sched.h>

#define SERVER_PORT 8080
#define BUFFER_SIZE 1024
#define MAX_CLIENTS 64

/* 客户端线程参数 */
typedef struct {
    int client_fd;
    struct sockaddr_in client_addr;
    int thread_id;
} client_info_t;

/* 客户端处理线程 */
void *handle_client(void *arg)
{
    client_info_t *info = (client_info_t *)arg;
    char buffer[BUFFER_SIZE];
    ssize_t recv_len;

    printf("[Thread-%d] Handling client %s:%d on CPU %d\n",
           info->thread_id,
           inet_ntoa(info->client_addr.sin_addr),
           ntohs(info->client_addr.sin_port),
           sched_getcpu());

    /* 接收并回显数据 */
    while ((recv_len = recv(info->client_fd, buffer, BUFFER_SIZE - 1, 0)) > 0) {
        buffer[recv_len] = '\0';
        printf("[Thread-%d] Received: %s", info->thread_id, buffer);
        send(info->client_fd, buffer, recv_len, 0);
    }

    printf("[Thread-%d] Client disconnected.\n", info->thread_id);

    close(info->client_fd);
    free(info);
    pthread_detach(pthread_self());
    return NULL;
}

int main(void)
{
    int server_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    int thread_count = 0;

    /* 创建 TCP 套接字 */
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        return EXIT_FAILURE;
    }

    /* 允许端口复用 */
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    /* 绑定地址和端口 */
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(SERVER_PORT);

    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_fd);
        return EXIT_FAILURE;
    }

    if (listen(server_fd, MAX_CLIENTS) < 0) {
        perror("listen");
        close(server_fd);
        return EXIT_FAILURE;
    }

    printf("Threaded TCP Server listening on port %d (max %d clients)...\n",
           SERVER_PORT, MAX_CLIENTS);

    /* 循环接受客户端连接 */
    while (1) {
        client_info_t *info = malloc(sizeof(client_info_t));
        if (!info) {
            perror("malloc");
            continue;
        }

        info->client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
        if (info->client_fd < 0) {
            perror("accept");
            free(info);
            continue;
        }

        info->client_addr = client_addr;
        info->thread_id = thread_count++;

        /* 创建处理线程 */
        pthread_t tid;
        if (pthread_create(&tid, NULL, handle_client, info) != 0) {
            perror("pthread_create");
            close(info->client_fd);
            free(info);
            continue;
        }
    }

    close(server_fd);
    return EXIT_SUCCESS;
}

# 交叉编译（链接 pthread 库）
aarch64-linux-gnu-gcc -Wall -O2 -o threaded_server threaded_server.c -lpthread

# 传输到目标板
scp threaded_server root@192.168.1.100:/root/

# 运行
./threaded_server
# 输出：Threaded TCP Server listening on port 8080 (max 64 clients)...

4.5 HTTP 请求（libcurl）

/* http_client.c — RK3576 HTTP 请求示例（基于 libcurl） */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>

/* 回调函数：接收 HTTP 响应数据 */
static size_t write_callback(void *contents, size_t size, size_t nmemb, void *userp)
{
    size_t total = size * nmemb;
    char **response = (char **)userp;
    char *ptr = realloc(*response, strlen(*response) + total + 1);
    if (!ptr) {
        fprintf(stderr, "realloc failed\n");
        return 0;
    }
    *response = ptr;
    strncat(*response, contents, total);
    return total;
}

/* GET 请求 */
static int http_get(const char *url)
{
    CURL *curl;
    CURLcode res;
    char *response = NULL;

    curl = curl_easy_init();
    if (!curl) {
        fprintf(stderr, "curl_easy_init failed\n");
        return -1;
    }

    response = calloc(1, 1);
    if (!response) {
        curl_easy_cleanup(curl);
        return -1;
    }

    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);

    res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        fprintf(stderr, "GET failed: %s\n", curl_easy_strerror(res));
    } else {
        long http_code = 0;
        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
        printf("HTTP GET %s (status %ld)\n", url, http_code);
        printf("Response length: %zu bytes\n", strlen(response));
        /* 打印前 200 字符 */
        if (strlen(response) > 0) {
            printf("Response preview: %.200s\n", response);
        }
    }

    free(response);
    curl_easy_cleanup(curl);
    return (res == CURLE_OK) ? 0 : -1;
}

/* POST 请求 */
static int http_post(const char *url, const char *data)
{
    CURL *curl;
    CURLcode res;
    char *response = NULL;

    curl = curl_easy_init();
    if (!curl)
        return -1;

    response = calloc(1, 1);

    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, "Content-Type: application/json");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

    res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        fprintf(stderr, "POST failed: %s\n", curl_easy_strerror(res));
    } else {
        long http_code = 0;
        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
        printf("HTTP POST %s (status %ld)\n", url, http_code);
        printf("Response: %s\n", response);
    }

    curl_slist_free_all(headers);
    free(response);
    curl_easy_cleanup(curl);
    return (res == CURLE_OK) ? 0 : -1;
}

int main(int argc, char *argv[])
{
    curl_global_init(CURL_GLOBAL_DEFAULT);

    if (argc < 2) {
        printf("Usage: %s <url> [post_data]\n", argv[0]);
        printf("  GET  example: %s http://httpbin.org/get\n", argv[0]);
        printf("  POST example: %s http://httpbin.org/post '{\"key\":\"value\"}'\n", argv[0]);
        curl_global_cleanup();
        return 1;
    }

    if (argc >= 3) {
        http_post(argv[1], argv[2]);
    } else {
        http_get(argv[1]);
    }

    curl_global_cleanup();
    return 0;
}

# 交叉编译（链接 libcurl 和 libssl）
aarch64-linux-gnu-gcc -Wall -O2 -o http_client http_client.c \
    -lcurl -lssl -lcrypto

# 传输到目标板
scp http_client root@192.168.1.100:/root/

# 运行
./http_client http://httpbin.org/get
# 输出：HTTP GET http://httpbin.org/get (status 200)
# 输出：Response preview: { "args": {}, "headers": { ... }, ...

# POST 请求
./http_client http://httpbin.org/post '{"device":"rk3576","status":"online"}'

4.6 MQTT 通信（mosquitto）

安装与启动 MQTT Broker

# 在目标板上安装 mosquitto
sudo apt-get install -y mosquitto mosquitto-clients libmosquitto-dev

# 启动 MQTT Broker（默认端口 1883）
sudo systemctl start mosquitto
sudo systemctl enable mosquitto

# 或手动启动（前台模式，方便调试）
mosquitto -v
# 输出：Opening ipv4 listen socket on port 1883.
# 输出：mosquitto version 2.x.x running

MQTT 发布/订阅测试

# 终端 1：订阅主题
mosquitto_sub -h 127.0.0.1 -t "rk3576/sensor" -v
# 等待接收消息...

# 终端 2：发布消息
mosquitto_pub -h 127.0.0.1 -t "rk3576/sensor" -m "temperature=36.5"
# 终端 1 输出：rk3576/sensor temperature=36.5

MQTT 客户端 C 代码

/* mqtt_client.c — RK3576 MQTT 客户端示例（基于 libmosquitto） */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <mosquitto.h>

#define MQTT_BROKER "127.0.0.1"
#define MQTT_PORT 1883
#define MQTT_TOPIC_PUB "rk3576/status"
#define MQTT_TOPIC_SUB "rk3576/command"
#define CLIENT_ID "rk3576_client"

/* 消息回调 */
static void on_message(struct mosquitto *mosq, void *userdata,
                       const struct mosquitto_message *msg)
{
    printf("Received on topic [%s]: %s\n", msg->topic, (char *)msg->payload);

    /* 处理命令 */
    if (strcmp(msg->topic, MQTT_TOPIC_SUB) == 0) {
        if (strcmp((char *)msg->payload, "reboot") == 0) {
            printf("Received reboot command!\n");
        } else if (strcmp((char *)msg->payload, "status") == 0) {
            /* 回复状态 */
            mosquitto_publish(mosq, NULL, MQTT_TOPIC_PUB, 7, "online", 0, false);
            printf("Published status: online\n");
        }
    }
}

/* 连接回调 */
static void on_connect(struct mosquitto *mosq, void *userdata, int rc)
{
    if (rc == 0) {
        printf("Connected to MQTT broker.\n");
        /* 订阅命令主题 */
        mosquitto_subscribe(mosq, NULL, MQTT_TOPIC_SUB, 0);
        printf("Subscribed to: %s\n", MQTT_TOPIC_SUB);
    } else {
        fprintf(stderr, "Connection failed: %d\n", rc);
    }
}

int main(void)
{
    struct mosquitto *mosq;
    int rc;

    /* 初始化 mosquitto 库 */
    mosquitto_lib_init();

    /* 创建客户端实例 */
    mosq = mosquitto_new(CLIENT_ID, true, NULL);
    if (!mosq) {
        fprintf(stderr, "mosquitto_new failed\n");
        mosquitto_lib_cleanup();
        return EXIT_FAILURE;
    }

    /* 设置回调 */
    mosquitto_connect_callback_set(mosq, on_connect);
    mosquitto_message_callback_set(mosq, on_message);

    /* 连接到 Broker */
    rc = mosquitto_connect(mosq, MQTT_BROKER, MQTT_PORT, 60);
    if (rc != MOSQ_ERR_SUCCESS) {
        fprintf(stderr, "mosquitto_connect failed: %s\n", mosquitto_strerror(rc));
        mosquitto_destroy(mosq);
        mosquitto_lib_cleanup();
        return EXIT_FAILURE;
    }

    printf("MQTT client started, broker: %s:%d\n", MQTT_BROKER, MQTT_PORT);

    /* 发布上线消息 */
    mosquitto_publish(mosq, NULL, MQTT_TOPIC_PUB, 10, "connecting", 0, false);

    /* 主循环：处理网络事件 */
    while (1) {
        rc = mosquitto_loop(mosq, 1000, 1);
        if (rc != MOSQ_ERR_SUCCESS) {
            fprintf(stderr, "Connection lost, reconnecting...\n");
            usleep(5000000);
            mosquitto_reconnect(mosq);
        }
    }

    /* 清理 */
    mosquitto_disconnect(mosq);
    mosquitto_destroy(mosq);
    mosquitto_lib_cleanup();
    return EXIT_SUCCESS;
}

# 交叉编译
aarch64-linux-gnu-gcc -Wall -O2 -o mqtt_client mqtt_client.c -lmosquitto

# 传输到目标板
scp mqtt_client root@192.168.1.100:/root/

# 运行
./mqtt_client
# 输出：Connected to MQTT broker.
# 输出：Subscribed to: rk3576/command

4.7 NFS 远程挂载

NFS（Network File System）允许目标板通过网络挂载主机目录，便于开发调试时快速共享文件。

主机端配置（NFS 服务器）

# 安装 NFS 服务器
sudo apt-get install -y nfs-kernel-server

# 创建共享目录
sudo mkdir -p /srv/nfs/rk3576_rootfs

# 配置导出目录
sudo tee -a /etc/exports << 'EOF'
/srv/nfs/rk3576_rootfs *(rw,sync,no_subtree_check,no_root_squash)
EOF

# 重新加载导出配置
sudo exportfs -ra

# 启动 NFS 服务
sudo systemctl restart nfs-kernel-server

# 查看导出目录
sudo exportfs -v
# 输出：/srv/nfs/rk3576_rootfs  0.0.0.0/0(rw,async,wdelay,hide,...)

目标板端配置（NFS 客户端）

# 安装 NFS 客户端工具
sudo apt-get install -y nfs-common

# 创建挂载点
sudo mkdir -p /mnt/nfs_share

# 手动挂载（假设主机 IP 为 192.168.1.200）
sudo mount -t nfs 192.168.1.200:/srv/nfs/rk3576_rootfs /mnt/nfs_share

# 验证挂载
ls /mnt/nfs_share
df -h /mnt/nfs_share
# 输出：192.168.1.200:/srv/nfs/rk3576_rootfs  xxxG  xxxG  xxxG  xx% /mnt/nfs_share

# 卸载
sudo umount /mnt/nfs_share

开机自动挂载

# 写入 fstab 实现开机自动挂载
echo "192.168.1.200:/srv/nfs/rk3576_rootfs /mnt/nfs_share nfs defaults,_netdev 0 0" | \
    sudo tee -a /etc/fstab

4.8 iperf3 网络性能测试

iperf3 用于测量网络带宽、延迟和丢包率。

安装

# 目标板（服务端）
sudo apt-get install -y iperf3

# 主机（客户端）
sudo apt-get install -y iperf3

TCP 带宽测试

# 目标板作为服务端
iperf3 -s
# 输出：-----------------------------------------------------------
# 输出：Server listening on 5201

# 主机作为客户端（目标板 IP 为 192.168.1.100）
iperf3 -c 192.168.1.100
# 输出示例：
# [ ID] Interval       Transfer     Bitrate
# [  5] 0.00-10.00  sec  1.09 GBytes  930 Mbits/sec

# 反向测试（主机作为服务端，目标板作为客户端）
iperf3 -c 192.168.1.100 -R

UDP 测试

# 目标板服务端
iperf3 -s

# 主机客户端（UDP 模式，目标带宽 100Mbps）
iperf3 -c 192.168.1.100 -u -b 100M
# 输出示例：
# [ ID] Interval       Transfer     Bitrate         Jitter   Lost/Total
# [  5] 0.00-10.00  sec   119 MBytes   100 Mbits/sec  0.034 ms  0/122058 (0%)

并发连接测试

# 4 线程并发 TCP 测试
iperf3 -c 192.168.1.100 -P 4

4.9 SSH 远程访问

安装与配置 SSH 服务

# 安装 OpenSSH 服务端
sudo apt-get install -y openssh-server

# 启动 SSH 服务
sudo systemctl start ssh
sudo systemctl enable ssh

# 查看 SSH 服务状态
sudo systemctl status ssh

# 修改 SSH 端口（可选）
sudo sed -i 's/#Port 22/Port 2222/' /etc/ssh/sshd_config
sudo systemctl restart ssh

SSH 密钥登录

# 主机端：生成密钥对
ssh-keygen -t ed25519 -C "rk3576_dev"

# 主机端：复制公钥到目标板
ssh-copy-id -p 22 root@192.168.1.100

# 主机端：免密码登录
ssh root@192.168.1.100

SSH 文件传输

# 从主机传输文件到目标板
scp file.txt root@192.168.1.100:/root/

# 从目标板传输文件到主机
scp root@192.168.1.100:/root/data.txt ./

# 递归复制目录
scp -r ./project root@192.168.1.100:/root/

# 使用 rsync 同步（支持增量同步）
rsync -avz ./project/ root@192.168.1.100:/root/project/

SSH 远程端口转发

# 将目标板的 8080 端口转发到主机的 8080
ssh -L 8080:localhost:8080 root@192.168.1.100

# 远程端口转发（将主机的 3000 端口暴露给目标板访问）
ssh -R 3000:localhost:3000 root@192.168.1.100

---

5. 代码详解

5.1 Socket 编程模型

TCP 通信流程：

  客户端                              服务器
    │                                   │
    │  socket()                         │  socket()
    │                                   │  bind()
    │                                   │  listen()
    │  connect() ──────────────────────►│  accept()
    │  ◄────────────────────────────────│
    │  send()/recv() ◄──────────────► send()/recv()
    │  close()                         │  close()
    │                                   │

UDP 通信流程：

  客户端                              服务器
    │                                   │
    │  socket()                         │  socket()
    │                                   │  bind()
    │  sendto() ──────────────────────►│  recvfrom()
    │  recvfrom() ◄────────────────────│  sendto()
    │  close()                         │  close()
    │                                   │

5.2 并发服务器模型对比

┌─────────────────────────────────────────────────────────────┐
│                  并发模型对比                                 │
├──────────────┬──────────────┬──────────────┬────────────────┤
│              │ 多线程        │ 多进程        │ IO 多路复用     │
├──────────────┼──────────────┼──────────────┼────────────────┤
│ 实现方式      │ pthread      │ fork()       │ select/poll/   │
│              │              │              │ epoll          │
├──────────────┼──────────────┼──────────────┼────────────────┤
│ 资源开销      │ 中等          │ 高           │ 低             │
├──────────────┼──────────────┼──────────────┼────────────────┤
│ 编程复杂度    │ 中等          │ 中等          │ 高             │
├──────────────┼──────────────┼──────────────┼────────────────┤
│ 适用场景      │ CPU 密集     │ 隔离性强      │ 高并发 IO      │
│              │ 计算任务      │ 不稳定进程     │ 连接数多        │
├──────────────┼──────────────┼──────────────┼────────────────┤
│ RK3576 适配   │ 推荐（8核）   │ 一般          │ 推荐           │
│              │ 线程亲和性强  │ 开销大         │ 性能最优        │
└──────────────┴──────────────┴──────────────┴────────────────┘

RK3576 的 8 核 CPU（4×Cortex-A72 + 4×Cortex-A53）在多线程并发服务器中有天然优势。可通过 pthread_setaffinity_np() 将线程绑定到指定 CPU 核心，避免线程迁移带来的缓存失效。

5.3 libcurl 工作原理

libcurl 请求流程：

  curl_easy_init()           初始化 curl 句柄
      │
  curl_easy_setopt()         设置 URL、回调、超时等参数
      │
  curl_easy_perform()        执行请求（阻塞直到完成）
      │
      ├── DNS 解析
      ├── TCP 连接
      ├── TLS 握手（HTTPS）
      ├── 发送 HTTP 请求
      ├── 接收 HTTP 响应
      └── 回调写入数据
      │
  curl_easy_getinfo()        获取状态码、耗时等信息
      │
  curl_easy_cleanup()        释放资源

5.4 MQTT 协议架构

MQTT 发布/订阅模型：

  ┌──────────┐     ┌──────────────┐     ┌──────────┐
  │ Publisher │────►│              │────►│Subscriber│
  │ (发布者)  │     │  MQTT Broker │     │ (订阅者)  │
  └──────────┘     │  (代理服务器) │     └──────────┘
                    │              │
  ┌──────────┐     │  Port: 1883  │     ┌──────────┐
  │Subscriber │◄────│              │◄────│Publisher │
  └──────────┘     └──────────────┘     └──────────┘

  Topic（主题）示例：
    rk3576/sensor/temperature
    rk3576/sensor/humidity
    rk3576/command/reboot

  QoS 等级：
    QoS 0 — 最多一次（不确认）
    QoS 1 — 至少一次（确认重传）
    QoS 2 — 恰好一次（四步握手）

---

6. 常见问题

6.1 网络接口无法获取 IP 地址

现象： ip addr show eth0 无 inet 地址

解决方案：

# 检查网卡是否处于 UP 状态
ip link show eth0

# 如果是 DOWN 状态，手动启动
sudo ip link set eth0 up

# 检查 DHCP 客户端
sudo dhclient eth0

# 检查网线物理连接
ethtool eth0
# 确认 Link detected: yes

# 检查网卡驱动加载
dmesg | grep -i eth

6.2 TCP 连接被拒绝

现象： 客户端 connect() 返回 ECONNREFUSED

解决方案：

# 检查服务器是否在监听
ss -tlnp | grep 8080
# 或
netstat -tlnp | grep 8080

# 检查防火墙规则
sudo iptables -L -n

# 临时关闭防火墙
sudo iptables -F

# 检查 SELinux（如有）
getenforce
sudo setenforce 0

6.3 iperf3 测试带宽异常低

现象： TCP 带宽远低于千兆预期

解决方案：

# 检查网卡协商速率
ethtool eth0 | grep Speed
# 应显示：Speed: 1000Mb/s

# 检查网卡双工模式
ethtool eth0 | grep Duplex
# 应显示：Duplex: Full

# 强制千兆全双工
sudo ethtool -s eth0 speed 1000 duplex full autoneg off

# 检查网卡中断亲和性（多核优化）
cat /proc/interrupts | grep eth

# 关闭 TCP Segmentation Offload 进行对比测试
sudo ethtool -K eth0 tso off

6.4 SSH 连接超时

现象： SSH 连接卡在 "Connecting..." 不响应

解决方案：

# 检查目标板 SSH 服务是否运行
sudo systemctl status ssh

# 使用串口登录目标板，检查网络连通性
ping 192.168.1.100

# 检查 SSH 配置
sudo cat /etc/ssh/sshd_config | grep -v "^#"

# 指定 SSH 协议版本
ssh -o ConnectTimeout=10 -4 root@192.168.1.100

# 调试模式连接
ssh -vvv root@192.168.1.100

6.5 MQTT 连接失败

现象： mosquitto_sub/pub 报 "Connection refused"

解决方案：

# 检查 mosquitto 服务状态
sudo systemctl status mosquitto

# 检查监听端口
ss -tlnp | grep 1883

# 手动启动 mosquitto 并查看日志
mosquitto -v -c /etc/mosquitto/mosquitto.conf

# 检查配置文件是否允许匿名连接
cat /etc/mosquitto/conf.d/default.conf
# 确认包含：allow_anonymous true

# 修改配置后重启
sudo systemctl restart mosquitto

6.6 NFS 挂载失败

现象： mount.nfs: mount system call failed

解决方案：

# 检查 NFS 服务器是否可达
ping 192.168.1.200

# 检查 NFS 端口是否开放
rpcinfo -p 192.168.1.200

# 检查共享目录是否导出
showmount -e 192.168.1.200

# 使用 NFSv3 挂载（默认可能使用 v4）
sudo mount -t nfs -o vers=3,nolock 192.168.1.200:/srv/nfs/rk3576_rootfs /mnt/nfs_share

# 主机端重启 NFS 服务
sudo systemctl restart nfs-kernel-server

---

相关文档

• C/C++应用开发入门 — C/C++ 交叉编译基础
• Python应用开发 — Python 网络编程
• Qt嵌入式开发实战 — Qt 网络编程
• GStreamer多媒体开发 — 多媒体流网络传输
• 内核配置与裁剪 — 网络相关内核配置
• 以太网GMAC驱动 — 千兆以太网驱动
• WiFi-蓝牙驱动 — 无线网络