第 11 章：Embassy 生态与视野拓展

┌─────────────────────────────────────────────────────────────┐
│                      应用层 (Application)                     │
├─────────────────────────────────────────────────────────────┤
│  协议栈层                                                    │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────┐  │
│  │embassy-  │ │embassy-  │ │ trouble  │ │ 第三方驱动     │  │
│  │  net     │ │  usb     │ │  (BLE)   │ │ (embedded-hal)│  │
│  └────┬─────┘ └────┬─────┘ └────┬─────┘ └──────┬────────┘  │
├───────┼─────────────┼────────────┼──────────────┼───────────┤
│  框架核心层                                                  │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────┐  │
│  │embassy-  │ │embassy-  │ │embassy-  │ │embassy-       │  │
│  │ executor │ │  time    │ │  sync    │ │ embedded-hal  │  │
│  └────┬─────┘ └────┬─────┘ └────┬─────┘ └──────┬────────┘  │
├───────┼─────────────┼────────────┼──────────────┼───────────┤
│  HAL 层                                                      │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────┐  │
│  │embassy-  │ │embassy-  │ │embassy-  │ │  esp-hal      │  │
│  │  stm32   │ │  nrf     │ │  rp      │ │  (乐鑫官方)    │  │
│  └────┬─────┘ └────┬─────┘ └────┬─────┘ └──────┬────────┘  │
├───────┼─────────────┼────────────┼──────────────┼───────────┤
│  硬件层                                                      │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────┐  │
│  │  STM32   │ │  nRF52/  │ │ RP2040/  │ │  ESP32 系列   │  │
│  │  系列    │ │  53/54   │ │ RP2350   │ │               │  │
│  └──────────┘ └──────────┘ └──────────┘ └───────────────┘  │
└─────────────────────────────────────────────────────────────┘

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_stm32::usb::{Driver, Instance};
use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
use embassy_usb::UsbDevice;
use {defmt_rtt as _, panic_probe as _};

// USB 设备描述符配置
static CONFIG_DESCRIPTOR: [u8; 256] = [0; 256];
static BOS_DESCRIPTOR: [u8; 256] = [0; 256];
static CONTROL_BUF: [u8; 64] = [0; 64];

// CDC 类的状态缓冲区
static mut STATE: State = State::new();

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());

    // 创建 USB 驱动（使用 PA11/PA12，即 USB DM/DP）
    let driver = Driver::new(p.USB, p.PA12, p.PA11);

    // 配置 USB 设备
    let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
    config.manufacturer = Some("Embassy");
    config.product = Some("CDC-ACM Example");
    config.serial_number = Some("12345678");

    // 构建 USB 设备
    let mut builder = embassy_usb::Builder::new(
        driver,
        config,
        &mut CONFIG_DESCRIPTOR,
        &mut BOS_DESCRIPTOR,
        &mut [], // msos_descriptor
        &mut CONTROL_BUF,
    );

    // 创建 CDC-ACM 类实例
    let state = unsafe { &mut STATE };
    let mut class = CdcAcmClass::new(&mut builder, state, 64);

    let mut usb = builder.build();

    // 启动 USB 设备（在独立任务中运行）
    spawner.spawn(usb_task(usb)).unwrap();

    // 主循环：回显数据
    let mut buf = [0u8; 64];
    loop {
        // 异步等待接收数据
        match class.read_packet(&mut buf).await {
            Ok(n) => {
                defmt::info!("Received {} bytes", n);
                // 将收到的数据原样发回
                class.write_packet(&buf[..n]).await.unwrap();
            }
            Err(e) => {
                defmt::warn!("USB read error: {:?}", e);
            }
        }
    }
}

// USB 设备运行任务
#[embassy_executor::task]
async fn usb_task(mut device: UsbDevice<'static, Driver<'static, embassy_stm32::peripherals::USB>>) {
    device.run().await;
}

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_net::tcp::TcpSocket;
use embassy_net::{Config, StackResources};
use embassy_stm32::eth::{Ethernet, PacketQueue};
use embassy_stm32::peripherals::ETH;
use embassy_stm32::rng::Rng;
use embassy_stm32::{bind_interrupts, eth, peripherals, rng};
use static_cell::StaticCell;
use {defmt_rtt as _, panic_probe as _};

bind_interrupts!(struct Irqs {
    ETH => eth::InterruptHandler;
    RNG => rng::InterruptHandler<peripherals::RNG>;
});

// 静态分配网络资源（零堆分配）
static PACKETS: StaticCell<PacketQueue<4, 4>> = StaticCell::new();
static RESOURCES: StaticCell<StackResources<3>> = StaticCell::new();

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());

    // 初始化以太网 MAC + PHY
    let mac_addr = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF];
    let device = Ethernet::new(
        PACKETS.init(PacketQueue::<4, 4>::new()),
        p.ETH,
        Irqs,
        p.PA1, p.PA2, p.PC1, p.PA7, p.PC4, p.PC5,
        p.PG13, p.PB13, p.PG11,
        // PHY 地址，根据硬件原理图确定
        0,
        mac_addr,
    );

    // 配置网络：使用 DHCP
    let config = Config::dhcpv4(Default::default());

    // 初始化网络栈
    let seed = 1234; // 实际应用中应使用真随机数
    let stack = &*embassy_net::new(
        device,
        config,
        RESOURCES.init(StackResources::<3>::new()),
        seed,
    );

    // 等待 DHCP 获取 IP
    defmt::info!("Waiting for DHCP...");
    stack.wait_config_up().await;
    defmt::info!("Network up! IP: {:?}", stack.config_v4());

    // 启动 TCP echo 任务
    spawner.spawn(net_task(stack)).unwrap();
}

#[embassy_executor::task]
async fn net_task(stack: &'static embassy_net::Stack<Ethernet<'static>>) {
    stack.run().await;
}

// 在实际应用中，TCP echo 会在另一个任务中：
// #[embassy_executor::task]
// async fn echo_task(stack: &'static embassy_net::Stack<...>) {
//     let mut rx_buf = [0u8; 1024];
//     let mut tx_buf = [0u8; 1024];
//     let mut socket = TcpSocket::new(stack, &mut rx_buf, &mut tx_buf);
//
//     loop {
//         // 监听端口 1234
//         socket.set_timeout(Some(embassy_time::Duration::from_secs(10)));
//         if let Err(e) = socket.accept(1234).await {
//             defmt::warn!("Accept error: {:?}", e);
//             continue;
//         }
//         defmt::info!("Client connected!");
//
//         // 回显循环
//         let mut buf = [0u8; 256];
//         loop {
//             match socket.read(&mut buf).await {
//                 Ok(0) => break,  // 连接关闭
//                 Ok(n) => {
//                     socket.write_all(&buf[..n]).await.unwrap();
//                 }
//                 Err(_) => break,
//             }
//         }
//         defmt::info!("Client disconnected");
//     }
// }

use embassy_boot_stm32::{AlignedBuffer, FirmwareUpdater, FirmwareUpdaterConfig};
use embassy_stm32::flash::Flash;

// 在应用中接收新固件并写入
async fn perform_ota_update(flash: Flash<'_>, firmware_data: &[u8]) {
    let config = FirmwareUpdaterConfig::from_linkerfile_blocking(
        flash, // 用于写入 DFU 区域
        flash, // 用于操作状态分区
    );

    let mut magic = AlignedBuffer([0; 4]);
    let mut updater = FirmwareUpdater::new(config, &mut magic.0);

    // 分块写入新固件
    let mut offset = 0;
    for chunk in firmware_data.chunks(4096) {
        updater.write_firmware(offset, chunk).await.unwrap();
        offset += chunk.len();
    }

    // 标记更新完成，下次重启时 Bootloader 会应用更新
    updater.mark_updated().await.unwrap();

    defmt::info!("OTA update staged, rebooting...");
    // 触发系统复位
    cortex_m::peripheral::SCB::sys_reset();
}

// 概念性示例，展示 trouble 的 API 风格
use trouble::gatt::{GattServer, ServiceBuilder};
use trouble::host::{BleHost, BleHostResources};
use trouble::types::{Address, Uuid};

// 创建一个自定义 GATT 服务
// 包含一个可读可写的特征值（Characteristic）
async fn ble_gatt_server_example() {
    // 初始化 BLE Controller（平台相关）
    // let controller = ...;

    // 创建 Host 资源
    // let mut resources = BleHostResources::new();

    // 构建 GATT 服务表
    // let mut server = GattServer::new(&mut resources);
    // let mut service = ServiceBuilder::new(Uuid::new_long([
    //     0x00, 0x00, 0x12, 0x34, // 自定义 UUID
    //     0x00, 0x00, 0x10, 0x00,
    //     0x80, 0x00, 0x00, 0x80,
    //     0x5F, 0x9B, 0x34, 0xFB,
    // ]));
    //
    // let my_char = service.add_characteristic(
    //     Uuid::new_short(0x2A00),
    //     CharacteristicProps::READ | CharacteristicProps::WRITE,
    //     [0u8; 20],  // 初始值
    // );
    //
    // server.add_service(service);

    // 开始广播
    // host.advertise(&Default::default(), Advertisement::ConnectableScannableUndirected {
    //     adv_data: &[...],
    //     scan_data: &[...],
    // }).await;

    // 等待连接并处理 GATT 请求
    // let mut conn = host.next_connection().await;
    // loop {
    //     match server.next_event(&mut conn).await {
    //         GattEvent::Read(handle) => { /* 返回特征值 */ }
    //         GattEvent::Write(handle, data) => { /* 处理写入 */ }
    //     }
    // }
}

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_time::{Duration, Timer};
use esp_hal::gpio::{Io, Level, Output};
use esp_hal::timer::timg::TimerGroup;
use {defmt_rtt as _, panic_probe as _};

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    // 初始化 ESP32-C3 外设
    let peripherals = esp_hal::init(esp_hal::Config::default());

    // 配置 GPIO8 为输出（ESP32-C3-DevKitM-1 的板载 LED）
    let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
    let mut led = Output::new(io.pins.gpio8, Level::Low);

    // 配置 Embassy 时间驱动
    let timg0 = TimerGroup::new(peripherals.TIMG0);
    esp_hal_embassy::init(timg0.timer0);

    // 闪烁循环
    loop {
        led.toggle();
        Timer::after(Duration::from_millis(500)).await;
    }
}

第 1 阶段：巩固基础（1-2 周）
├── 完成 Embassy 官方 examples 中的 blinky、button、uart
├── 理解 async/await 在嵌入式中的行为
└── 熟练使用 defmt 日志

第 2 阶段：外设与通信（2-4 周）
├── I2C/SPI 传感器驱动
├── DMA + UART 高速通信
├── 多任务协作（Channel + Mutex）
└── 定时器与 PWM 控制

第 3 阶段：协议栈（4-8 周）
├── USB CDC（调试 + 通信）
├── 以太网/WiFi + TCP/UDP
├── BLE（GATT Server）
└── OTA 更新（embassy-boot）

第 4 阶段：产品化（持续）
├── 低功耗设计
├── 错误处理与看门狗
├── 生产测试方案
└── 安全启动与签名

Part 2：Embassy 核心编程
│
├── 第 7 章：思想与代价
│   ├── async/await 范式
│   ├── 零开销异步
│   └── 协作式 vs 抢占式
│
├── 第 8 章：第一个工程
│   ├── 工程结构与依赖
│   ├── HAL 使用（GPIO/UART/SPI/I2C）
│   ├── DMA 与异步传输
│   └── embassy-time 定时器
│
├── 第 9 章：运行时
│   ├── Future 与 Waker
│   ├── Executor 架构
│   ├── 协作式调度
│   └── 抢占式调度（InterruptExecutor）
│
├── 第 10 章：任务间通信
│   ├── Signal / Watch
│   ├── Channel / PriorityChannel
│   ├── PubSubChannel
│   ├── Mutex
│   └── 死锁与饥饿规避
│
└── 第 11 章：生态与视野（本章）
    ├── embassy-usb（USB 设备栈）
    ├── embassy-net（网络协议栈）
    ├── embassy-boot（安全 Bootloader）
    ├── trouble / nrf-softdevice（BLE）
    ├── esp-rs（ESP32 生态）
    └── 社区与学习路径