embassy-net: Rust嵌入式网络库的异步TCP/IP协议栈实现

介绍

embassy-net是Rust生态中专门为嵌入式设备设计的异步网络协议栈，属于embassy嵌入式运行时的一部分。它为资源受限的物联网设备提供了轻量级的TCP/IP网络功能实现，具有以下特点：

• 专为嵌入式系统优化，内存占用小
• 纯Rust实现，无unsafe代码
• 基于async/await的异步API
• 支持以太网和WiFi等常见接口
• 包含ARP、IPv4、ICMP、TCP和UDP等协议实现

基本使用方法

添加依赖

首先在Cargo.toml中添加依赖：

[dependencies]
embassy-net = { version = "0.1", features = ["tcp", "udp"] }
embassy-executor = { version = "0.1" }
embassy-time = { version = "0.1" }

初始化网络栈

use embassy_net::{Stack, Config};
use embassy_net::driver::Driver;
use embassy_net::wire::{Ipv4Address, Ipv4Cidr};

// 假设有一个实现了Driver trait的网卡驱动实例
let driver = MyNetworkDriver::new();

// 配置网络参数
let config = Config::ipv4_static(embassy_net::StaticConfigV4 {
    address: Ipv4Cidr::new(Ipv4Address::new(192, 168, 1, 100), 24),
    dns_servers: Vec::new(),
    gateway: Some(Ipv4Address::new(192, 168, 1, 1)),
});

// 创建网络栈
let stack = Stack::new(driver, config);

TCP服务器示例

use embassy_net::tcp::TcpSocket;
use embassy_net::IpEndpoint;

#[embassy_executor::task]
async fn tcp_server_task(stack: &'static Stack<MyNetworkDriver>) {
    let mut rx_buffer = [0; 4096];
    let mut tx_buffer = [0; 4096];
    
    loop {
        let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
        socket.listen(8080).unwrap();
        
        let (mut socket, remote_endpoint) = socket.accept().await.unwrap();
        log::info!("Connection from {}", remote_endpoint);
        
        loop {
            let n = socket.read(&mut rx_buffer).await.unwrap();
            if n == 0 {
                break;
            }
            
            log::info!("Received {} bytes: {:?}", n, &rx_buffer[..n]);
            socket.write_all(&rx_buffer[..n].await.unwrap();
        }
    }
}

TCP客户端示例

#[embassy_executor::task]
async fn tcp_client_task(stack: &'static Stack<MyNetworkDriver>) {
    let mut rx_buffer = [0; 4096];
    let mut tx_buffer = [0; 4096];
    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
    
    let remote_endpoint = IpEndpoint::new(Ipv4Address::new(192, 168, 1, 1), 8080);
    socket.connect(remote_endpoint).await.unwrap();
    
    let message = b"Hello from embassy-net!";
    socket.write_all(message).await.unwrap();
    
    let n = socket.read(&mut rx_buffer).await.unwrap();
    log::info!("Received echo: {:?}", &rx_buffer[..n]);
}

UDP示例

use embassy_net::udp::UdpSocket;

#[embassy_executor::task]
async fn udp_task(stack: &'static Stack极简嵌入式网络应用完整示例：

```rust
use embassy_executor::Spawner;
use embassy_net::{Stack, Config};
use embassy_net::driver::Driver;
use embassy_net::wire::{Ipv4Address, Ipv4Cidr};
use embassy_net::tcp::TcpSocket;
use embassy_net::IpEndpoint;
use log::info;

// 定义网络驱动类型
struct MyNetworkDriver;

impl Driver for MyNetworkDriver {
    // 实现必要的驱动方法
    // ...
}

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    // 初始化日志
    env_logger::init();
    
    // 创建网络驱动实例
    let driver = MyNetworkDriver;
    
    // 配置静态IP
    let config = Config::ipv4_static(embassy_net::StaticConfigV4 {
        address: Ipv4Cidr::new(Ipv4Address::new(192, 168, 1, 100), 24),
        dns_servers: Vec::new(),
        gateway: Some(Ipv4Address::new(192, 168, 1, 1)),
    });
    
    // 创建网络栈
    let stack = &*Box::leak(Box::new(Stack::new(driver, config)));
    
    // 启动网络任务
    spawner.spawn(network_task(stack)).unwrap();
    
    // 启动TCP服务器
    spawner.spawn(tcp_server_task(stack)).unwrap();
    
    // 启动TCP客户端(演示用)
    spawner.spawn(tcp_client_task(stack)).unwrap();
}

#[embassy_executor::task]
async fn network_task(stack: &'static Stack<MyNetworkDriver>) {
    stack.run().await
}

#[embassy_executor::task]
async fn tcp_server_task(stack: &'static Stack<MyNetworkDriver>) {
    let mut rx_buffer = [0; 1024];
    let mut tx_buffer = [0; 1024];
    
    loop {
        let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
        socket.listen(8080).unwrap();
        
        let (mut socket, remote_endpoint) = socket.accept().await.unwrap();
        info!("Connection from {}", remote_endpoint);
        
        loop {
            let n = socket.read(&mut rx_buffer).await.unwrap();
            if n == 0 { break; }
            
            info!("Received {} bytes", n);
            socket.write_all(&rx_buffer[..n]).await.unwrap();
        }
    }
}

#[embassy_executor::task]
async fn tcp_client_task(stack: &'static Stack<MyNetworkDriver>) {
    let mut rx_buffer = [0; 1024];
    let mut tx_buffer = [0; 1024];
    
    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
    let remote = IpEndpoint::new(Ipv4Address::new(192, 168, 1, 100), 8080);
    
    socket.connect(remote).await.unwrap();
    socket.write_all(b"Ping").await.unwrap();
    
    let n = socket.read(&mut rx_buffer).await.unwrap();
    info!("Received echo: {:?}", &rx_buffer[..n]);
}

注意事项

1. embassy-net需要与embassy-executor运行时配合使用
2. 需要提供实现了Driver trait的底层网络驱动
3. 缓冲区大小需要根据设备资源情况合理配置
4. 目前主要支持IPv4，IPv6支持还在开发中

embassy-net为嵌入式设备提供了简单易用的网络功能，特别适合需要轻量级TCP/IP协议栈的物联网应用场景。