35d - AI 辅助嵌入式代码生成

┌─────────────────────────────────────────────────────────────────┐
│              嵌入式代码生成 vs 通用代码生成                        │
├──────────────────┬──────────────────┬───────────────────────────┤
│     维度          │   通用代码生成    │   嵌入式代码生成            │
├──────────────────┼──────────────────┼───────────────────────────┤
│ 内存模型          │ 虚拟内存，几乎    │ 物理内存，KB 级，           │
│                  │ 无限制            │ 必须精确控制               │
├──────────────────┼──────────────────┼───────────────────────────┤
│ 动态分配          │ 自由使用          │ 禁止或严格限制             │
│                  │ malloc/new        │ 仅静态分配                │
├──────────────────┼──────────────────┼───────────────────────────┤
│ 错误处理          │ 异常/try-catch    │ 返回码 + 状态机            │
│                  │ 进程可重启        │ 错误可能损坏硬件           │
├──────────────────┼──────────────────┼───────────────────────────┤
│ 并发模型          │ 线程/协程         │ 中断 + RTOS 任务           │
│                  │ 有 OS 调度        │ 优先级抢占，硬实时         │
├──────────────────┼──────────────────┼───────────────────────────┤
│ 硬件依赖          │ 无/抽象化         │ 寄存器级操作               │
│                  │                  │ 时序敏感                   │
├──────────────────┼──────────────────┼───────────────────────────┤
│ 验证方式          │ 单元测试 + CI     │ 硬件在环测试（HIL）         │
│                  │                  │ + 静态分析 + 示波器        │
├──────────────────┼──────────────────┼───────────────────────────┤
│ 安全标准          │ 少数领域          │ MISRA C/C++, IEC 61508    │
│                  │                  │ ISO 26262, DO-178C        │
└──────────────────┴──────────────────┴───────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│  层级 4：应用层                                               │
│  状态机、业务逻辑、数据处理                                     │
│  AI 辅助价值：⭐⭐⭐⭐⭐  风险：⭐⭐                            │
│  → AI 最擅长，与通用代码生成类似                                │
├─────────────────────────────────────────────────────────────┤
│  层级 3：框架层                                               │
│  Arduino API、ESP-IDF 组件、Zephyr 子系统                     │
│  AI 辅助价值：⭐⭐⭐⭐  风险：⭐⭐⭐                            │
│  → AI 有较多训练数据，但需注意版本差异                           │
├─────────────────────────────────────────────────────────────┤
│  层级 2：HAL 层                                               │
│  STM32 HAL/LL、ESP-IDF 驱动、Zephyr 设备模型                  │
│  AI 辅助价值：⭐⭐⭐  风险：⭐⭐⭐⭐                             │
│  → AI 可生成框架代码，但配置参数需人工验证                       │
├─────────────────────────────────────────────────────────────┤
│  层级 1：寄存器层                                              │
│  直接操作 MMIO 寄存器、位域操作、时序控制                        │
│  AI 辅助价值：⭐⭐  风险：⭐⭐⭐⭐⭐                             │
│  → 通用 AI 幻觉率最高，必须用 Embedder 等专用工具               │
└─────────────────────────────────────────────────────────────┘

你是一位嵌入式底层驱动专家，精通 ARM Cortex-M 寄存器级编程。

## 目标芯片
- 型号：[具体型号，如 STM32F407VGT6]
- 内核：[Cortex-M4F]
- 数据手册版本：[版本号/日期]

## 外设需求
- 外设：[如 USART2]
- 功能：[如 115200 8N1 异步通信]
- 引脚：TX=[引脚], RX=[引脚]

## 代码要求
1. 直接操作寄存器，不使用 HAL/LL 库
2. 每个寄存器操作必须注释：
   - 寄存器名称和地址偏移
   - 操作的位域名称和含义
   - 数据手册参考页码（如已知）
3. 使用位域宏定义，不使用魔数
4. 时钟使能必须在外设配置之前
5. 包含初始化函数和基本读写函数

## 输出格式
- 寄存器地址和位域的宏定义头文件
- 初始化函数
- 发送/接收函数
- 每行关键操作的注释

/* stm32f407_uart_reg.h - 寄存器级 UART 驱动 */
#ifndef STM32F407_UART_REG_H
#define STM32F407_UART_REG_H
 
#include <stdint.h>
 
/* ✅ 基地址定义（参考数据手册 Memory Map 章节） */
#define RCC_BASE        0x40023800UL
#define GPIOA_BASE      0x40020000UL
#define USART2_BASE     0x40004400UL
 
/* ✅ RCC 寄存器偏移 */
#define RCC_AHB1ENR     (*(volatile uint32_t *)(RCC_BASE + 0x30))
#define RCC_APB1ENR     (*(volatile uint32_t *)(RCC_BASE + 0x40))
 
/* ✅ GPIO 寄存器偏移 */
#define GPIOA_MODER     (*(volatile uint32_t *)(GPIOA_BASE + 0x00))
#define GPIOA_AFRL      (*(volatile uint32_t *)(GPIOA_BASE + 0x20))
 
/* ✅ USART2 寄存器偏移 */
#define USART2_SR       (*(volatile uint32_t *)(USART2_BASE + 0x00))
#define USART2_DR       (*(volatile uint32_t *)(USART2_BASE + 0x04))
#define USART2_BRR      (*(volatile uint32_t *)(USART2_BASE + 0x08))
#define USART2_CR1      (*(volatile uint32_t *)(USART2_BASE + 0x0C))
 
/* ✅ 位域定义（避免魔数） */
#define USART_SR_TXE    (1U << 7)   /* 发送数据寄存器空 */
#define USART_SR_RXNE   (1U << 5)   /* 接收数据寄存器非空 */
#define USART_SR_TC     (1U << 6)   /* 发送完成 */
#define USART_CR1_UE    (1U << 13)  /* USART 使能 */
#define USART_CR1_TE    (1U << 3)   /* 发送使能 */
#define USART_CR1_RE    (1U << 2)   /* 接收使能 */
 
#endif /* STM32F407_UART_REG_H */

/* stm32f407_uart_reg.c - 寄存器级 UART 实现 */
#include "stm32f407_uart_reg.h"
 
void uart2_init(uint32_t baud_rate)
{
    /* 1. 使能时钟（必须在配置外设之前） */
    RCC_AHB1ENR |= (1U << 0);   /* ✅ GPIOA 时钟使能 */
    RCC_APB1ENR |= (1U << 17);  /* ✅ USART2 时钟使能 */
 
    /* 2. 配置 GPIO 为复用功能 */
    /* PA2 = USART2_TX, PA3 = USART2_RX */
    /* MODER: 10 = 复用功能模式 */
    GPIOA_MODER &= ~((3U << 4) | (3U << 6));  /* 清除 PA2, PA3 */
    GPIOA_MODER |=  ((2U << 4) | (2U << 6));  /* 设置为复用 */
 
    /* AFRL: AF7 = USART1-3 */
    GPIOA_AFRL &= ~((0xFU << 8) | (0xFU << 12));
    GPIOA_AFRL |=  ((7U << 8) | (7U << 12));  /* ✅ AF7 */
 
    /* 3. 配置 USART2 */
    /* ⚠️ 审查点：BRR 计算依赖 APB1 时钟频率 */
    /* 假设 APB1 = 42MHz（SYSCLK=168MHz, AHB/1, APB1/4） */
    /* BRR = f_CK / baud_rate = 42000000 / 115200 ≈ 364.58 */
    /* MANTISSA = 364 = 0x16C, FRACTION = 0.58 * 16 ≈ 9 */
    uint32_t apb1_clk = 42000000UL;  /* ⚠️ 必须与实际时钟配置一致 */
    USART2_BRR = (apb1_clk + baud_rate / 2) / baud_rate;
 
    /* 4. 使能 USART2：发送 + 接收 + USART 使能 */
    USART2_CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_UE;
}
 
void uart2_send_char(char c)
{
    /* ✅ 等待发送缓冲区空 */
    while (!(USART2_SR & USART_SR_TXE))
        ;  /* ⚠️ 审查点：生产代码应加超时 */
    USART2_DR = (uint32_t)c;
}
 
char uart2_recv_char(void)
{
    /* ✅ 等待接收数据就绪 */
    while (!(USART2_SR & USART_SR_RXNE))
        ;  /* ⚠️ 审查点：生产代码应加超时 */
    return (char)(USART2_DR & 0xFF);
}
 
void uart2_send_string(const char *str)
{
    while (*str) {
        uart2_send_char(*str++);
    }
    /* 等待最后一个字节发送完成 */
    while (!(USART2_SR & USART_SR_TC))
        ;
}

你是一位 STM32 HAL 库专家，精通 STM32CubeMX 生成的项目结构。

## 目标
为 [STM32 型号] 生成 [外设] 的 HAL 驱动代码。

## CubeMX 项目信息
- HAL 库版本：[版本号]
- 时钟配置：SYSCLK=[频率]MHz, APB1=[频率]MHz, APB2=[频率]MHz
- 已配置的外设：[列出 CubeMX 中已配置的外设]

## 外设需求
- 外设实例：[如 SPI1, I2C2, TIM3]
- 功能模式：[如 SPI Master, I2C Master, PWM Output]
- 关键参数：[波特率/频率/分辨率等]
- DMA 使用：[是/否，如是指定 DMA 通道]
- 中断使用：[是/否，如是指定中断类型]

## 代码规范
1. 代码放在 CubeMX 的 USER CODE BEGIN/END 标记之间
2. 使用 HAL_StatusTypeDef 返回值
3. 错误处理：失败时调用 Error_Handler() 或返回错误码
4. DMA 缓冲区使用 __attribute__((aligned(4)))
5. 中断回调使用 HAL_xxx_Callback 函数

## 内存约束
- 可用 RAM：[数值] KB
- DMA 缓冲区总大小不超过：[数值] 字节
- 全局变量尽量使用 static 限制作用域

你是一位 ESP-IDF v5.x 驱动开发专家。

## 目标
为 ESP32-[型号] 生成 [外设/传感器] 驱动。

## ESP-IDF 版本要求
- 使用 ESP-IDF v5.3+ 的新版驱动 API
- I2C：使用 i2c_master.h（非旧版 i2c.h）
- SPI：使用 spi_master.h
- GPIO：使用 driver/gpio.h
- ADC：使用 esp_adc/adc_oneshot.h 或 adc_continuous.h

## 驱动接口设计
1. 初始化函数：接受配置结构体，返回句柄
2. 读取函数：返回 esp_err_t，数据通过指针输出
3. 配置函数：运行时修改参数
4. 去初始化函数：释放资源

## 线程安全要求
- 多任务环境下的总线访问保护
- 使用 SemaphoreHandle_t 互斥锁
- 或使用 ESP-IDF 的 i2c_master_bus 内置锁

## 错误处理
- 所有 ESP-IDF API 调用检查返回值
- 通信失败重试（最多 [N] 次）
- 超时使用 pdMS_TO_TICKS() 宏
- 日志使用 ESP_LOGI/W/E 宏

## 代码组织
- 头文件：公共接口 + 配置结构体
- 源文件：实现 + 静态辅助函数
- 寄存器地址和命令用枚举定义

/* bme280_driver.h - BME280 温湿度气压传感器驱动 */
#ifndef BME280_DRIVER_H
#define BME280_DRIVER_H
 
#include "esp_err.h"
#include "driver/i2c_master.h"
 
/* ✅ 配置结构体 */
typedef struct {
    i2c_master_bus_handle_t bus_handle;  /* I2C 总线句柄 */
    uint8_t dev_addr;                    /* 设备地址（0x76 或 0x77） */
    uint8_t oversampling_temp;           /* 温度过采样（1-5） */
    uint8_t oversampling_press;          /* 气压过采样（1-5） */
    uint8_t oversampling_humi;           /* 湿度过采样（1-5） */
} bme280_config_t;
 
/* ✅ 传感器数据结构 */
typedef struct {
    float temperature;  /* 摄氏度 */
    float pressure;     /* hPa */
    float humidity;     /* %RH */
} bme280_data_t;
 
/* ✅ 不透明句柄 */
typedef struct bme280_dev *bme280_handle_t;
 
/* 公共接口 */
esp_err_t bme280_init(const bme280_config_t *config, bme280_handle_t *handle);
esp_err_t bme280_read(bme280_handle_t handle, bme280_data_t *data);
esp_err_t bme280_set_mode(bme280_handle_t handle, uint8_t mode);
esp_err_t bme280_deinit(bme280_handle_t handle);
 
#endif /* BME280_DRIVER_H */

/* bme280_driver.c - BME280 驱动实现 */
#include "bme280_driver.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include <string.h>
 
static const char *TAG = "bme280";
 
/* ✅ 寄存器地址枚举 */
typedef enum {
    BME280_REG_CHIP_ID    = 0xD0,
    BME280_REG_CTRL_HUM   = 0xF2,
    BME280_REG_CTRL_MEAS  = 0xF4,
    BME280_REG_CONFIG      = 0xF5,
    BME280_REG_DATA_START = 0xF7,
    BME280_REG_CALIB_START = 0x88,
} bme280_reg_t;
 
#define BME280_CHIP_ID_VALUE  0x60
#define BME280_DATA_LEN       8
#define BME280_CALIB_LEN      26
#define I2C_TIMEOUT_MS        100
 
/* ✅ 内部结构体（不透明句柄的实现） */
struct bme280_dev {
    i2c_master_dev_handle_t i2c_dev;
    /* 校准数据（从芯片读取，用于补偿计算） */
    uint16_t dig_T1;
    int16_t  dig_T2, dig_T3;
    uint16_t dig_P1;
    int16_t  dig_P2, dig_P3, dig_P4, dig_P5;
    int16_t  dig_P6, dig_P7, dig_P8, dig_P9;
    uint8_t  dig_H1, dig_H3;
    int16_t  dig_H2, dig_H4, dig_H5;
    int8_t   dig_H6;
    int32_t  t_fine;  /* 温度补偿中间值 */
};
 
/* ✅ 静态辅助函数：I2C 寄存器读写 */
static esp_err_t bme280_read_reg(bme280_handle_t dev,
                                  uint8_t reg, uint8_t *data, size_t len)
{
    return i2c_master_transmit_receive(dev->i2c_dev,
                                        &reg, 1,
                                        data, len,
                                        I2C_TIMEOUT_MS);
}
 
static esp_err_t bme280_write_reg(bme280_handle_t dev,
                                   uint8_t reg, uint8_t value)
{
    uint8_t buf[2] = { reg, value };
    return i2c_master_transmit(dev->i2c_dev, buf, 2, I2C_TIMEOUT_MS);
}
 
/* ✅ 读取校准数据 */
static esp_err_t bme280_read_calibration(bme280_handle_t dev)
{
    uint8_t calib[BME280_CALIB_LEN];
    esp_err_t ret = bme280_read_reg(dev, BME280_REG_CALIB_START,
                                     calib, BME280_CALIB_LEN);
    if (ret != ESP_OK) return ret;
 
    /* 解析校准数据（小端序） */
    dev->dig_T1 = (uint16_t)(calib[1] << 8 | calib[0]);
    dev->dig_T2 = (int16_t)(calib[3] << 8 | calib[2]);
    dev->dig_T3 = (int16_t)(calib[5] << 8 | calib[4]);
    dev->dig_P1 = (uint16_t)(calib[7] << 8 | calib[6]);
    dev->dig_P2 = (int16_t)(calib[9] << 8 | calib[8]);
    /* ... 其余校准数据解析省略 ... */
 
    return ESP_OK;
}
 
/* ✅ 初始化 */
esp_err_t bme280_init(const bme280_config_t *config,
                       bme280_handle_t *handle)
{
    /* 参数检查 */
    if (!config || !handle || !config->bus_handle) {
        return ESP_ERR_INVALID_ARG;
    }
 
    /* ✅ 静态分配设备结构体（避免频繁 malloc） */
    static struct bme280_dev dev_instance;
    memset(&dev_instance, 0, sizeof(dev_instance));
 
    /* 添加 I2C 设备 */
    i2c_device_config_t dev_cfg = {
        .dev_addr_length = I2C_ADDR_BIT_LEN_7,
        .device_address = config->dev_addr,
        .scl_speed_hz = 400000,  /* 400kHz Fast Mode */
    };
    esp_err_t ret = i2c_master_bus_add_device(config->bus_handle,
                                               &dev_cfg,
                                               &dev_instance.i2c_dev);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "I2C 设备添加失败: %s", esp_err_to_name(ret));
        return ret;
    }
 
    /* 验证芯片 ID */
    uint8_t chip_id = 0;
    ret = bme280_read_reg(&dev_instance, BME280_REG_CHIP_ID, &chip_id, 1);
    if (ret != ESP_OK || chip_id != BME280_CHIP_ID_VALUE) {
        ESP_LOGE(TAG, "芯片 ID 验证失败: 0x%02X (期望 0x%02X)",
                 chip_id, BME280_CHIP_ID_VALUE);
        return ESP_ERR_NOT_FOUND;
    }
 
    /* 读取校准数据 */
    ret = bme280_read_calibration(&dev_instance);
    if (ret != ESP_OK) return ret;
 
    /* 配置传感器 */
    bme280_write_reg(&dev_instance, BME280_REG_CTRL_HUM,
                     config->oversampling_humi);
    bme280_write_reg(&dev_instance, BME280_REG_CTRL_MEAS,
                     (config->oversampling_temp << 5) |
                     (config->oversampling_press << 2) |
                     0x03);  /* Normal mode */
 
    *handle = &dev_instance;
    ESP_LOGI(TAG, "BME280 初始化成功");
    return ESP_OK;
}
 
/* ✅ 去初始化 */
esp_err_t bme280_deinit(bme280_handle_t handle)
{
    if (!handle) return ESP_ERR_INVALID_ARG;
    /* 设置 Sleep 模式 */
    bme280_write_reg(handle, BME280_REG_CTRL_MEAS, 0x00);
    return i2c_master_bus_rm_device(handle->i2c_dev);
}

你是一位 Arduino 专家。为 [开发板] 生成完整的 Sketch：

## 开发板信息
- 型号：[Arduino Uno/Mega/ESP32 Arduino/Pico]
- 处理器：[ATmega328P/ESP32/RP2040]
- 可用 Flash：[数值] KB
- 可用 RAM：[数值] KB

## 功能需求
[详细描述]

## 硬件连接
[引脚连接表]

## 代码约束
1. 禁止使用 delay()（使用 millis() 非阻塞方式）
2. 禁止使用 String 类（使用 char[] 和 snprintf）
3. 全局变量使用 static 限制作用域
4. 中断处理函数标记 volatile 共享变量
5. 串口波特率：115200
6. 所有常量使用 const 或 #define
7. 内存敏感：避免大数组，使用 PROGMEM 存储常量字符串

## 输出要求
- 单文件 Sketch（.ino）
- 包含详细中文注释
- 包含编译后的预估 Flash/RAM 使用量

你是一位 Zephyr RTOS 专家（v3.7+）。

## 目标板卡
- 板卡标识：[如 nrf52840dk/nrf52840, esp32s3_devkitc]
- 或自定义板卡：[芯片型号 + 板卡描述]

## 应用需求
[详细描述]

## 请生成以下文件
1. prj.conf — Kconfig 配置
2. app.overlay — 设备树覆盖（如需自定义引脚）
3. CMakeLists.txt — 构建配置
4. src/main.c — 主应用代码

## Zephyr 编码规范
1. 日志使用 LOG_MODULE_REGISTER + LOG_INF/WRN/ERR
2. 线程使用 K_THREAD_DEFINE 静态定义
3. 同步使用 k_msgq / k_sem / k_mutex
4. 设备获取使用 DEVICE_DT_GET 宏
5. 配置项通过 Kconfig 而非硬编码
6. 错误检查使用 __ASSERT 或 if + LOG_ERR
7. 内存分配使用 K_MEM_SLAB 或 K_HEAP

## 内存约束
- 总 RAM：[数值] KB
- 线程栈总和不超过：[数值] KB
- 系统堆大小：CONFIG_HEAP_MEM_POOL_SIZE=[数值]

## 内存预算（必须严格遵守）

### RAM 预算
- 总可用 RAM：[数值] KB
- 系统/RTOS 占用：~[数值] KB
- 通信栈占用（Wi-Fi/BLE）：~[数值] KB
- 应用可用 RAM：[数值] KB
- 其中：
  - 全局/静态变量预算：[数值] KB
  - 任务栈总预算：[数值] KB
  - DMA 缓冲区预算：[数值] KB
  - 消息队列/缓冲区预算：[数值] KB

### Flash 预算
- 总 Flash：[数值] MB
- Bootloader：[数值] KB
- OTA 分区（×2）：各 [数值] KB
- NVS/配置：[数值] KB
- 应用可用 Flash：[数值] KB

### 编码规则（基于内存预算）
1. 禁止 malloc/calloc/realloc/free
2. 所有缓冲区使用静态数组，大小在编译时确定
3. 字符串使用固定长度 char[]，禁止 std::string
4. 常量字符串放在 Flash 中（PROGMEM / const / DRAM_ATTR）
5. 结构体使用 __attribute__((packed)) 减少填充
6. 位域用于布尔标志集合
7. 枚举使用 uint8_t 基础类型（如适用）

你是一位嵌入式内存分析专家。分析以下函数的栈使用量：

## 函数代码
[粘贴函数代码]

## 请估算
1. 局部变量占用的栈空间
2. 函数调用链的最大深度
3. 每层调用的栈帧大小
4. 总栈使用量估算（包含安全余量 20%）
5. 推荐的任务栈大小

## 注意事项
- 编译器可能对齐局部变量到 4/8 字节边界
- 中断嵌套会额外消耗栈空间
- printf/sprintf 系列函数通常需要 200-500 字节栈
- TLS 握手可能需要 4-8KB 额外栈空间

你是一位嵌入式内存分析专家。为以下项目生成内存布局图：

## 芯片信息
- 型号：[型号]
- Flash：[大小]，起始地址 0x[地址]
- RAM：[大小]，起始地址 0x[地址]
- 特殊内存区域：[如 PSRAM, CCM RAM, DTCM, ITCM]

## 当前使用情况
- .text（代码段）：[大小] KB
- .rodata（只读数据）：[大小] KB
- .data（已初始化数据）：[大小] KB
- .bss（未初始化数据）：[大小] KB
- 堆：[大小] KB
- 栈：[大小] KB

## 请生成
1. ASCII 内存布局图（Flash 和 RAM 分别展示）
2. 各段的使用率百分比
3. 剩余可用空间分析
4. 优化建议（如果接近上限）

ESP32-S3 内存布局（N16R8 配置）

Flash 布局（16MB）
┌──────────────────────────────────┐ 0x00000000
│  Bootloader (32KB)               │
├──────────────────────────────────┤ 0x00008000
│  Partition Table (4KB)           │
├──────────────────────────────────┤ 0x00009000
│  NVS (24KB)                      │
├──────────────────────────────────┤ 0x0000F000
│  OTA Data (8KB)                  │
├──────────────────────────────────┤ 0x00010000
│  App Partition 0 (ota_0) (3MB)   │
│  ├── .text:    820KB (27%)       │
│  ├── .rodata:  340KB (11%)       │
│  └── 剩余:    1884KB (62%)       │
├──────────────────────────────────┤ 0x00310000
│  App Partition 1 (ota_1) (3MB)   │
├──────────────────────────────────┤ 0x00610000
│  SPIFFS/LittleFS (2MB)           │
├──────────────────────────────────┤ 0x00810000
│  未分配 (8MB)                     │
└──────────────────────────────────┘ 0x01000000

RAM 布局（512KB SRAM + 8MB PSRAM）
┌──────────────────────────────────┐ 0x3FC88000
│  .data (已初始化全局变量) 12KB    │
├──────────────────────────────────┤
│  .bss (未初始化全局变量) 48KB     │
├──────────────────────────────────┤
│  堆 (heap) ~180KB                │
│  ├── Wi-Fi 缓冲区: ~40KB         │
│  ├── MQTT 缓冲区: ~8KB           │
│  ├── 应用缓冲区: ~20KB           │
│  └── 空闲: ~112KB                │
├──────────────────────────────────┤
│  FreeRTOS 任务栈                  │
│  ├── main_task: 4KB              │
│  ├── wifi_task: 4KB              │
│  ├── mqtt_task: 4KB              │
│  ├── sensor_task: 3KB            │
│  └── idle_task: 1KB              │
├──────────────────────────────────┤
│  系统保留 ~260KB                  │
│  (Wi-Fi/BLE 协议栈、FreeRTOS)    │
└──────────────────────────────────┘

PSRAM 布局（8MB）
┌──────────────────────────────────┐
│  大缓冲区（>4KB 的数据）          │
│  ├── 图像缓冲区: 320KB           │
│  ├── 音频缓冲区: 64KB            │
│  └── 空闲: ~7.6MB                │
└──────────────────────────────────┘

使用率摘要：
  Flash: 1.2MB / 3MB (40%) ✅ 充裕
  SRAM:  332KB / 512KB (65%) ⚠️ 注意
  PSRAM: 384KB / 8MB (5%) ✅ 充裕

你是一位 MISRA C:2025 合规编码专家。生成的代码必须遵守以下 MISRA 规则：

## MISRA 合规要求
1. 禁止动态内存分配（Rule 21.3）
2. 所有函数返回值必须检查（Rule 17.7）
3. 指针参数尽可能使用 const（Rule 8.13）
4. 禁止隐式类型转换（Rule 10.3, 10.4）
5. if-else 链必须以 else 结尾（Rule 15.7）
6. switch 必须有 default 分支（Rule 16.4）
7. 循环变量不得在循环体内修改（Rule 14.2）
8. 禁止使用 goto（Rule 15.1）
9. 函数参数不超过 6 个（Advisory）
10. 禁止递归（Rule 17.2）

## 代码风格
- 每个函数不超过 75 行
- 嵌套深度不超过 4 层
- 所有魔数用宏或枚举定义
- 注释标注 MISRA 偏差（如有必要的违规）

## 目标
[描述需要生成的代码]

你是一位嵌入式中断处理专家。生成的中断相关代码必须遵守以下规则：

## ISR 中禁止的操作
1. 禁止 printf/sprintf（非可重入）
2. 禁止 malloc/free（非可重入）
3. 禁止获取互斥锁（可能死锁）
4. 禁止浮点运算（部分平台 ISR 不保存 FPU 上下文）
5. 禁止调用非 FromISR 后缀的 RTOS API
6. 禁止长时间循环或延时

## ISR 中允许的操作
1. 设置 volatile 标志变量
2. 写入无锁环形缓冲区
3. 调用 xTaskNotifyFromISR / xQueueSendFromISR
4. 读写硬件寄存器
5. 清除中断标志

## ISR 与主循环的通信模式
- 模式 1：volatile 标志 + 主循环轮询
- 模式 2：RTOS 任务通知（推荐）
- 模式 3：RTOS 队列（适合传递数据）
- 模式 4：无锁环形缓冲区（适合高频数据流）

## 共享变量规则
- ISR 和主循环共享的变量必须声明为 volatile
- 多字节共享变量的读写必须是原子的，或使用临界区保护
- ARM Cortex-M 上 32 位对齐的读写是原子的

## 请生成
[描述中断处理需求]

/* ring_buffer.h - ISR 安全的无锁环形缓冲区 */
#ifndef RING_BUFFER_H
#define RING_BUFFER_H
 
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
 
/* ✅ 缓冲区大小必须是 2 的幂（用于位掩码取模） */
#define RING_BUF_SIZE  256U
#define RING_BUF_MASK  (RING_BUF_SIZE - 1U)
 
/* 编译时检查大小是 2 的幂 */
_Static_assert((RING_BUF_SIZE & RING_BUF_MASK) == 0U,
               "RING_BUF_SIZE must be power of 2");
 
typedef struct {
    volatile uint32_t head;  /* ✅ volatile：ISR 写，主循环读 */
    volatile uint32_t tail;  /* ✅ volatile：主循环写，ISR 读 */
    uint8_t data[RING_BUF_SIZE];
} ring_buf_t;
 
/* ✅ 静态初始化 */
#define RING_BUF_INIT  { .head = 0U, .tail = 0U, .data = {0} }
 
/* ✅ ISR 中调用：写入一个字节 */
static inline bool ring_buf_put(ring_buf_t *rb, uint8_t byte)
{
    uint32_t next_head = (rb->head + 1U) & RING_BUF_MASK;
    if (next_head == rb->tail) {
        return false;  /* 缓冲区满 */
    }
    rb->data[rb->head] = byte;
    /* ✅ 内存屏障确保数据写入在 head 更新之前完成 */
    __DMB();
    rb->head = next_head;
    return true;
}
 
/* ✅ 主循环中调用：读取一个字节 */
static inline bool ring_buf_get(ring_buf_t *rb, uint8_t *byte)
{
    if (rb->head == rb->tail) {
        return false;  /* 缓冲区空 */
    }
    *byte = rb->data[rb->tail];
    __DMB();
    rb->tail = (rb->tail + 1U) & RING_BUF_MASK;
    return true;
}
 
/* ✅ 查询可用数据量 */
static inline uint32_t ring_buf_count(const ring_buf_t *rb)
{
    return (rb->head - rb->tail) & RING_BUF_MASK;
}
 
#endif /* RING_BUFFER_H */

需要选择语言？
├── RAM < 64KB
│   └── 必须用 C/C++
├── 需要硬实时（<1ms 截止时间）
│   └── 必须用 C/C++
├── 需要安全认证（MISRA/IEC 61508）
│   └── 必须用 C/C++
├── 原型验证 / 教学 / IoT 应用
│   ├── 性能不敏感 → MicroPython
│   └── 性能敏感 → C + MicroPython 混合
├── 生产部署
│   ├── 简单 IoT 节点 → MicroPython 可接受
│   └── 复杂系统 → C/C++ 或 Rust
└── 快速迭代 + 远程更新
    └── MicroPython（脚本可 OTA 更新）

你是一位 MicroPython 嵌入式开发专家。

## 目标平台
- 开发板：[ESP32/Pico/Pico W/STM32 Pyboard]
- MicroPython 版本：[v1.25.x]
- 可用 RAM：[数值] KB（扣除解释器占用）
- 可用 Flash：[数值] KB（用于用户脚本）

## 功能需求
[详细描述]

## MicroPython 编码规范
1. 使用 machine 模块操作硬件（Pin, I2C, SPI, ADC, PWM, Timer）
2. 使用 asyncio（原 uasyncio）实现异步多任务
3. 常量使用 micropython.const() 优化内存
4. 避免频繁创建临时对象（减少 GC 压力）
5. 大数据使用 array 模块而非 list
6. 二进制数据使用 memoryview 避免复制
7. 错误处理使用 try/except，捕获具体异常类型
8. 模块导入使用 from module import name（减少命名空间占用）

## 内存优化要求
- 预估可用堆内存：[数值] KB
- 单个对象不超过 [数值] 字节
- 使用 gc.collect() 在关键点手动触发 GC
- 使用 micropython.mem_info() 监控内存使用

# ❌ 错误：普通变量存储在 RAM 中
LED_PIN = 2
SENSOR_ADDR = 0x76
INTERVAL_MS = 5000
 
# ✅ 正确：const() 将值内联到字节码，不占用 RAM
from micropython import const
 
_LED_PIN = const(2)
_SENSOR_ADDR = const(0x76)
_INTERVAL_MS = const(5000)
 
# 注意：const() 变量名必须以下划线开头（MicroPython 约定）
# const() 只支持整数，不支持浮点数或字符串

# 冻结模块将 .py 文件编译为字节码并存储在 Flash 中
# 而非运行时从 Flash 读取并编译到 RAM
 
# 步骤 1：将模块放入 MicroPython 固件的 modules/ 目录
# 步骤 2：重新编译固件
# 步骤 3：冻结的模块从 Flash 直接执行，节省大量 RAM
 
# 对于不想重编译固件的情况，使用 mpy-cross 预编译：
# $ mpy-cross my_module.py  → 生成 my_module.mpy
# .mpy 文件比 .py 文件加载更快，占用更少 RAM

# ❌ 错误：切片创建新的 bytes 对象，浪费内存
data = bytearray(1024)
chunk = data[100:200]  # 创建了 100 字节的新对象
 
# ✅ 正确：memoryview 创建视图，不复制数据
data = bytearray(1024)
mv = memoryview(data)
chunk = mv[100:200]  # 零拷贝视图，几乎不占额外内存
 
# 实际应用：I2C/SPI 读取大块数据时
buf = bytearray(256)
mv = memoryview(buf)
i2c.readfrom_mem_into(0x76, 0xF7, mv[0:8])  # 只读取 8 字节到缓冲区前 8 位

# ❌ 错误：list 中每个元素都是 Python 对象，内存开销大
# 1000 个 int16 值：list 约占 16KB（每个元素 16 字节）
sensor_data = [0] * 1000
 
# ✅ 正确：array 紧凑存储，内存开销小
# 1000 个 int16 值：array 约占 2KB（每个元素 2 字节）
from array import array
sensor_data = array('h', (0 for _ in range(1000)))  # 'h' = signed short (int16)
 
# 常用类型码：
# 'b' = int8, 'B' = uint8
# 'h' = int16, 'H' = uint16
# 'i' = int32, 'I' = uint32
# 'f' = float32

你是一位 MicroPython asyncio 专家。

## 需求
为 [开发板] 生成异步多任务应用：
1. 任务 1：[描述]，间隔 [时间]
2. 任务 2：[描述]，事件驱动
3. 任务 3：[描述]，间隔 [时间]

## asyncio 编码规范
1. 使用 asyncio（MicroPython v1.19+ 已将 uasyncio 重命名为 asyncio）
2. 所有 I/O 等待使用 await asyncio.sleep_ms() 而非 time.sleep()
3. 任务间通信使用 asyncio.Event 或共享变量
4. 异常处理：每个任务内部 try/except，防止单个任务崩溃影响全局
5. 主函数使用 asyncio.gather() 并发运行所有任务
6. 避免在 async 函数中执行长时间阻塞操作

## 注意事项
- MicroPython 的 asyncio 是协作式调度，不是抢占式
- 长时间计算会阻塞其他任务，需要手动 yield（await asyncio.sleep_ms(0)）
- 中断回调中不能使用 await，使用 micropython.schedule() 延迟处理

# main.py - ESP32 MicroPython 异步 IoT 节点
import asyncio
from machine import Pin, I2C, ADC, reset
from micropython import const
import gc
import json
import time
 
# ✅ 常量定义（const 优化内存）
_LED_PIN = const(2)
_I2C_SDA = const(21)
_I2C_SCL = const(22)
_ADC_PIN = const(34)
_SENSOR_ADDR = const(0x76)
_REPORT_INTERVAL_S = const(30)
_HEARTBEAT_INTERVAL_MS = const(1000)
_WIFI_RETRY_MAX = const(5)
 
# 硬件初始化
led = Pin(_LED_PIN, Pin.OUT)
i2c = I2C(0, sda=Pin(_I2C_SDA), scl=Pin(_I2C_SCL), freq=400000)
adc = ADC(Pin(_ADC_PIN))
adc.atten(ADC.ATTN_11DB)  # 0-3.3V 量程
 
# ✅ 全局状态（使用字典减少全局变量数量）
state = {
    'temp': 0.0,
    'humidity': 0.0,
    'soil': 0,
    'wifi_ok': False,
    'mqtt_ok': False,
    'error_count': 0,
}
 
# ✅ 异步任务 1：传感器采集
async def sensor_task():
    """周期性采集传感器数据"""
    while True:
        try:
            # 读取 I2C 传感器（BME280 简化示例）
            raw = bytearray(8)
            i2c.readfrom_mem(_SENSOR_ADDR, 0xF7, raw)
            # ⚠️ 实际项目需要完整的补偿计算
            state['temp'] = 25.0 + (raw[3] - 128) * 0.1
            state['humidity'] = 50.0 + (raw[6] - 128) * 0.2
 
            # 读取 ADC（土壤湿度）
            state['soil'] = adc.read()
 
        except OSError as e:
            state['error_count'] += 1
            print(f"传感器读取失败: {e}")
 
        # ✅ 手动触发 GC，避免在关键时刻暂停
        gc.collect()
        await asyncio.sleep(_REPORT_INTERVAL_S)
 
# ✅ 异步任务 2：LED 心跳
async def heartbeat_task():
    """LED 心跳指示系统运行状态"""
    while True:
        led.value(1)
        await asyncio.sleep_ms(100)
        led.value(0)
        # 根据状态调整心跳间隔
        if state['error_count'] > 0:
            await asyncio.sleep_ms(200)  # 快闪 = 有错误
        else:
            await asyncio.sleep_ms(_HEARTBEAT_INTERVAL_MS)
 
# ✅ 异步任务 3：MQTT 上报
async def mqtt_task():
    """周期性上报数据到 MQTT Broker"""
    from umqtt.simple import MQTTClient
 
    client = None
    while True:
        try:
            if client is None:
                client = MQTTClient(
                    'esp32_node_001',
                    'broker.example.com',
                    port=1883,
                    keepalive=60
                )
                client.connect()
                state['mqtt_ok'] = True
 
            # ✅ 构建 JSON 消息（使用固定格式减少内存）
            payload = json.dumps({
                't': round(state['temp'], 1),
                'h': round(state['humidity'], 1),
                's': state['soil'],
                'e': state['error_count'],
            })
            client.publish(b'sensor/esp32_001/data', payload)
 
        except Exception as e:
            state['mqtt_ok'] = False
            client = None  # 重连
            print(f"MQTT 错误: {e}")
 
        await asyncio.sleep(_REPORT_INTERVAL_S)
 
# ✅ 异步任务 4：看门狗（软件实现）
async def watchdog_task():
    """监控系统健康状态"""
    from machine import WDT
    wdt = WDT(timeout=60000)  # 60 秒超时
 
    while True:
        wdt.feed()
        # 检查内存使用
        free_mem = gc.mem_free()
        if free_mem < 10000:  # < 10KB 可用
            print(f"⚠️ 内存不足: {free_mem} bytes")
            gc.collect()
        await asyncio.sleep_ms(10000)
 
# Wi-Fi 连接（非异步，启动时执行）
def connect_wifi():
    import network
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
 
    if wlan.isconnected():
        state['wifi_ok'] = True
        return True
 
    wlan.connect('SSID', 'PASSWORD')
    for _ in range(_WIFI_RETRY_MAX):
        if wlan.isconnected():
            state['wifi_ok'] = True
            print(f"Wi-Fi 已连接: {wlan.ifconfig()}")
            return True
        time.sleep(1)
 
    print("Wi-Fi 连接失败")
    return False
 
# ✅ 主函数
async def main():
    # 连接 Wi-Fi
    connect_wifi()
 
    # 并发运行所有任务
    await asyncio.gather(
        sensor_task(),
        heartbeat_task(),
        mqtt_task(),
        watchdog_task(),
    )
 
# 启动
try:
    asyncio.run(main())
except Exception as e:
    print(f"致命错误: {e}")
    time.sleep(5)
    reset()  # 重启设备

你是一位 Rust 嵌入式开发专家，精通 no_std 环境和 Embassy 框架。

## 目标平台
- 芯片：[如 STM32F411, nRF52840, ESP32-C3]
- HAL crate：[如 embassy-stm32, embassy-nrf, esp-hal]
- Embassy 版本：[最新稳定版]

## 项目需求
[详细描述]

## Rust 嵌入式编码规范
1. #![no_std] #![no_main]
2. 使用 defmt 日志（非 println!）
3. 使用 embassy_executor::task 定义异步任务
4. 使用 embassy_time::Timer 替代 busy-wait
5. 外设使用 Peri<'static, T> 所有权模型
6. 错误处理使用 Result<T, E>，避免 unwrap()
7. 中断使用 embassy 的 bind_interrupts! 宏
8. 配置使用 embassy 的 Config 结构体

## 内存约束
- 可用 Flash：[数值] KB
- 可用 RAM：[数值] KB
- 禁止使用 alloc crate（纯静态分配）
- 或允许使用 embedded-alloc（指定堆大小 [数值] KB）

## Cargo.toml 要求
- 列出所有依赖及版本
- 使用 [profile.release] 优化大小（opt-level = 's'）
- 启用 LTO（lto = true）

// ✅ Embassy STM32 异步示例
#![no_std]
#![no_main]
 
use defmt::*;
use embassy_executor::Spawner;
use embassy_stm32::gpio::{AnyPin, Input, Level, Output, Pull, Speed};
use embassy_stm32::Peri;
use embassy_time::Timer;
use {defmt_rtt as _, panic_probe as _};
 
// ✅ 异步任务：LED 闪烁
#[embassy_executor::task]
async fn blink_task(pin: Peri<'static, AnyPin>) {
    let mut led = Output::new(pin, Level::Low, Speed::Low);
 
    loop {
        led.set_high();
        Timer::after_millis(500).await;  // ✅ 非阻塞等待
        led.set_low();
        Timer::after_millis(500).await;
    }
}
 
// ✅ 异步任务：按键检测
#[embassy_executor::task]
async fn button_task(pin: Peri<'static, AnyPin>) {
    let button = Input::new(pin, Pull::Up);
 
    loop {
        // ✅ 等待按键按下（下降沿）
        button.wait_for_falling_edge().await;
        info!("按键按下！");
 
        // 简单去抖动
        Timer::after_millis(50).await;
 
        // 等待按键释放
        button.wait_for_rising_edge().await;
        info!("按键释放");
        Timer::after_millis(50).await;
    }
}
 
// ✅ 主函数也是异步任务
#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());
 
    info!("系统启动");
 
    // ✅ 生成异步任务（所有权转移到任务）
    spawner.spawn(blink_task(p.PA5.into())).unwrap();
    spawner.spawn(button_task(p.PC13.into())).unwrap();
 
    // 主任务可以做其他事情，或者简单等待
    loop {
        Timer::after_secs(60).await;
        info!("系统运行中...");
    }
}

[package]
name = "embassy-stm32-demo"
version = "0.1.0"
edition = "2021"
 
[dependencies]
embassy-executor = { version = "0.7", features = ["arch-cortex-m", "executor-thread"] }
embassy-stm32 = { version = "0.2", features = ["stm32f411ce", "time-driver-any", "memory-x"] }
embassy-time = { version = "0.4" }
defmt = "0.3"
defmt-rtt = "0.4"
panic-probe = { version = "0.3", features = ["print-defmt"] }
cortex-m = { version = "0.7", features = ["critical-section-single-core"] }
cortex-m-rt = "0.7"
 
[profile.release]
opt-level = 's'     # 优化代码体积
lto = true          # 链接时优化
debug = true        # 保留调试信息（defmt 需要）
codegen-units = 1   # 单编译单元（更好的优化）

## Embassy API 参考（请基于以下 API 生成代码）

### GPIO
- Output::new(pin, level, speed) → Output
- Input::new(pin, pull) → Input
- input.wait_for_falling_edge().await
- input.wait_for_rising_edge().await

### I2C
- I2c::new(peri, scl, sda, irq, tx_dma, rx_dma, config) → I2c
- i2c.write(addr, data).await → Result
- i2c.read(addr, buf).await → Result
- i2c.write_read(addr, write, read).await → Result

### SPI
- Spi::new(peri, sck, mosi, miso, tx_dma, rx_dma, config) → Spi
- spi.transfer(read, write).await → Result

### Timer
- Timer::after_millis(ms).await
- Timer::after_secs(s).await
- Timer::after_micros(us).await

请按以下顺序逐步生成代码，每步我会编译验证：

步骤 1：生成 Cargo.toml 和最小 main.rs（仅 LED 闪烁）
步骤 2：添加按键输入任务
步骤 3：添加 I2C 传感器驱动
步骤 4：添加 UART 通信
步骤 5：集成所有功能

每步只生成增量代码，不要重复已验证的部分。

请将以下 ESP-IDF C 代码翻译为 Rust（使用 esp-hal crate）：

## C 代码
[粘贴 C 代码]

## 翻译要求
1. 使用 Rust 惯用写法（不是逐行翻译）
2. 利用 Rust 类型系统替代运行时检查
3. 错误处理使用 Result 而非返回码
4. 资源管理使用 RAII（Drop trait）
5. 共享状态使用 Mutex<RefCell<T>> 或 atomic

## 第一层：硬件约束（不可协商）
- 芯片型号：[型号]
- 物理 RAM：[数值] KB
- 物理 Flash：[数值] KB
- 特殊内存：[PSRAM/CCM/DTCM 等]

## 第二层：系统占用（已确定）
- RTOS 内核：~[数值] KB RAM
- 通信栈（Wi-Fi/BLE/LoRa）：~[数值] KB RAM
- 文件系统：~[数值] KB RAM
- 已有模块占用：~[数值] KB RAM
- 系统总占用：~[数值] KB RAM

## 第三层：应用预算（本次生成的代码必须在此范围内）
- 可用 RAM = 物理 RAM - 系统占用 = [数值] KB
- 本模块 RAM 预算：[数值] KB
  - 全局变量：≤ [数值] KB
  - 任务栈：≤ [数值] KB
  - 缓冲区：≤ [数值] KB
- 本模块 Flash 预算：[数值] KB
  - 代码段：≤ [数值] KB
  - 只读数据：≤ [数值] KB

你是一位嵌入式内存分析专家。请审查以下代码的内存使用：

## 代码
[粘贴代码]

## 请分析
1. 全局/静态变量占用的 RAM（.data + .bss）
2. 每个函数的栈使用量估算
3. 常量数据占用的 Flash（.rodata）
4. 代码段占用的 Flash（.text）估算
5. 总内存使用是否在以下预算内：
   - RAM 预算：[数值] KB
   - Flash 预算：[数值] KB
6. 如果超出预算，提供具体的优化建议

## 编译器信息
- 编译器：[GCC ARM / IAR / LLVM]
- 优化级别：[-Os / -O2 / -Og]
- 目标架构：[Cortex-M0 / M3 / M4 / M7 / RISC-V]

你是一位超低资源嵌入式专家。目标芯片只有 [数值]KB RAM。

## 极端约束
1. 禁止使用任何标准库函数（包括 memcpy, strlen）
2. 禁止使用 RTOS（裸机运行）
3. 全局变量总量不超过 [数值] 字节
4. 函数调用深度不超过 4 层
5. 每个函数的局部变量不超过 [数值] 字节
6. 使用 8 位变量（uint8_t）替代 32 位（节省栈空间）
7. 位域打包布尔标志
8. 查找表替代计算（用 Flash 换 RAM）
9. 状态机使用 switch-case，不使用函数指针数组

## 代码风格
- 内联短函数（减少调用开销）
- 循环展开（如果能减少变量）
- 常量放在 Flash（const / PROGMEM）

┌─────────────────────────────────────────────────────────┐
│  应用层 (Application Layer)                               │
│  业务逻辑、状态机、数据处理                                 │
│  → 只调用 HAL 接口，不直接操作硬件                          │
├─────────────────────────────────────────────────────────┤
│  HAL 接口层 (HAL Interface)                               │
│  统一的 API 定义（头文件/trait）                            │
│  → 定义 init(), read(), write(), deinit() 等接口          │
├─────────────────────────────────────────────────────────┤
│  HAL 实现层 (HAL Implementation)                          │
│  平台特定的实现                                            │
│  → STM32 实现 / ESP32 实现 / nRF52 实现                   │
├─────────────────────────────────────────────────────────┤
│  BSP 层 (Board Support Package)                           │
│  板级配置（引脚映射、时钟、外设实例）                        │
│  → 特定开发板的硬件配置                                    │
├─────────────────────────────────────────────────────────┤
│  硬件 (Hardware)                                          │
│  MCU + 外设 + PCB                                         │
└─────────────────────────────────────────────────────────┘

你是一位嵌入式软件架构师。设计一个可移植的 HAL 层：

## 需要抽象的硬件功能
1. [功能1]：[描述]
2. [功能2]：[描述]
3. [功能3]：[描述]

## 目标平台
- 平台 A：[如 STM32F407 + HAL 库]
- 平台 B：[如 ESP32 + ESP-IDF]
- 平台 C：[如 nRF52840 + Zephyr]（可选）

## HAL 设计要求
1. 头文件定义统一接口（C 语言用函数指针结构体，Rust 用 trait）
2. 每个平台一个实现文件
3. BSP 层配置引脚映射和外设实例
4. 编译时选择平台（通过宏或构建系统）
5. 接口设计遵循"最小公共子集"原则
6. 错误处理使用统一的错误码枚举

## 输出
1. HAL 接口头文件（hal_xxx.h）
2. 平台 A 的实现（hal_xxx_stm32.c）
3. 平台 B 的实现（hal_xxx_esp32.c）
4. BSP 配置示例

/* hal_gpio.h - 可移植 GPIO HAL 接口 */
#ifndef HAL_GPIO_H
#define HAL_GPIO_H
 
#include <stdint.h>
#include <stdbool.h>
 
/* ✅ 统一错误码 */
typedef enum {
    HAL_GPIO_OK = 0,
    HAL_GPIO_ERR_INVALID_PIN,
    HAL_GPIO_ERR_INVALID_MODE,
    HAL_GPIO_ERR_NOT_INITIALIZED,
} hal_gpio_err_t;
 
/* ✅ GPIO 模式枚举 */
typedef enum {
    HAL_GPIO_MODE_INPUT,
    HAL_GPIO_MODE_OUTPUT,
    HAL_GPIO_MODE_INPUT_PULLUP,
    HAL_GPIO_MODE_INPUT_PULLDOWN,
} hal_gpio_mode_t;
 
/* ✅ GPIO 中断触发类型 */
typedef enum {
    HAL_GPIO_INT_RISING,
    HAL_GPIO_INT_FALLING,
    HAL_GPIO_INT_BOTH,
    HAL_GPIO_INT_DISABLE,
} hal_gpio_int_t;
 
/* ✅ 中断回调类型 */
typedef void (*hal_gpio_isr_t)(uint8_t pin, void *arg);
 
/* ✅ 统一接口 */
hal_gpio_err_t hal_gpio_init(uint8_t pin, hal_gpio_mode_t mode);
hal_gpio_err_t hal_gpio_deinit(uint8_t pin);
hal_gpio_err_t hal_gpio_write(uint8_t pin, bool level);
hal_gpio_err_t hal_gpio_read(uint8_t pin, bool *level);
hal_gpio_err_t hal_gpio_toggle(uint8_t pin);
hal_gpio_err_t hal_gpio_set_interrupt(uint8_t pin, hal_gpio_int_t type,
                                       hal_gpio_isr_t callback, void *arg);
 
#endif /* HAL_GPIO_H */

/* hal_gpio_esp32.c - ESP32 平台 GPIO HAL 实现 */
#include "hal_gpio.h"
#include "driver/gpio.h"
#include "esp_log.h"
 
static const char *TAG = "hal_gpio";
 
/* ✅ 回调存储（静态分配） */
#define MAX_GPIO_PINS  40
static hal_gpio_isr_t s_callbacks[MAX_GPIO_PINS];
static void *s_callback_args[MAX_GPIO_PINS];
 
/* ✅ ESP-IDF ISR 到 HAL 回调的适配 */
static void IRAM_ATTR gpio_isr_adapter(void *arg)
{
    uint8_t pin = (uint8_t)(uintptr_t)arg;
    if (pin < MAX_GPIO_PINS && s_callbacks[pin] != NULL) {
        s_callbacks[pin](pin, s_callback_args[pin]);
    }
}
 
hal_gpio_err_t hal_gpio_init(uint8_t pin, hal_gpio_mode_t mode)
{
    gpio_config_t io_conf = {
        .pin_bit_mask = (1ULL << pin),
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = GPIO_INTR_DISABLE,
    };
 
    switch (mode) {
        case HAL_GPIO_MODE_INPUT:
            io_conf.mode = GPIO_MODE_INPUT;
            break;
        case HAL_GPIO_MODE_OUTPUT:
            io_conf.mode = GPIO_MODE_OUTPUT;
            break;
        case HAL_GPIO_MODE_INPUT_PULLUP:
            io_conf.mode = GPIO_MODE_INPUT;
            io_conf.pull_up_en = GPIO_PULLUP_ENABLE;
            break;
        case HAL_GPIO_MODE_INPUT_PULLDOWN:
            io_conf.mode = GPIO_MODE_INPUT;
            io_conf.pull_down_en = GPIO_PULLDOWN_ENABLE;
            break;
        default:
            return HAL_GPIO_ERR_INVALID_MODE;
    }
 
    if (gpio_config(&io_conf) != ESP_OK) {
        return HAL_GPIO_ERR_INVALID_PIN;
    }
    return HAL_GPIO_OK;
}
 
hal_gpio_err_t hal_gpio_write(uint8_t pin, bool level)
{
    if (gpio_set_level((gpio_num_t)pin, level ? 1 : 0) != ESP_OK) {
        return HAL_GPIO_ERR_INVALID_PIN;
    }
    return HAL_GPIO_OK;
}
 
hal_gpio_err_t hal_gpio_read(uint8_t pin, bool *level)
{
    if (level == NULL) {
        return HAL_GPIO_ERR_INVALID_PIN;
    }
    *level = (gpio_get_level((gpio_num_t)pin) != 0);
    return HAL_GPIO_OK;
}
 
hal_gpio_err_t hal_gpio_toggle(uint8_t pin)
{
    bool current;
    hal_gpio_err_t err = hal_gpio_read(pin, &current);
    if (err != HAL_GPIO_OK) return err;
    return hal_gpio_write(pin, !current);
}
 
hal_gpio_err_t hal_gpio_set_interrupt(uint8_t pin, hal_gpio_int_t type,
                                       hal_gpio_isr_t callback, void *arg)
{
    if (pin >= MAX_GPIO_PINS) return HAL_GPIO_ERR_INVALID_PIN;
 
    gpio_int_type_t esp_type;
    switch (type) {
        case HAL_GPIO_INT_RISING:  esp_type = GPIO_INTR_POSEDGE; break;
        case HAL_GPIO_INT_FALLING: esp_type = GPIO_INTR_NEGEDGE; break;
        case HAL_GPIO_INT_BOTH:    esp_type = GPIO_INTR_ANYEDGE; break;
        case HAL_GPIO_INT_DISABLE: esp_type = GPIO_INTR_DISABLE; break;
        default: return HAL_GPIO_ERR_INVALID_MODE;
    }
 
    s_callbacks[pin] = callback;
    s_callback_args[pin] = arg;
 
    gpio_set_intr_type((gpio_num_t)pin, esp_type);
    gpio_install_isr_service(0);
    gpio_isr_handler_add((gpio_num_t)pin, gpio_isr_adapter,
                          (void *)(uintptr_t)pin);
    return HAL_GPIO_OK;
}

AI 生成代码验证工作流：

┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
│ AI 生成   │───→│ 人工审查  │───→│ 静态分析  │───→│ 编译构建  │
│ 代码草稿  │    │ 代码审查  │    │ MISRA/   │    │ 检查警告  │
│          │    │ 清单检查  │    │ cppcheck │    │ map 文件  │
└──────────┘    └──────────┘    └──────────┘    └──────────┘
                                                      │
┌──────────┐    ┌──────────┐    ┌──────────┐          │
│ 生产部署  │←───│ 集成测试  │←───│ 硬件测试  │←─────────┘
│ OTA/烧录  │    │ 系统级   │    │ HIL/实机  │
│          │    │ 验证     │    │ 验证     │
└──────────┘    └──────────┘    └──────────┘

你是一位嵌入式静态分析专家。为以下项目生成 cppcheck 配置：

## 项目信息
- 编译器：[GCC ARM / IAR / Keil]
- 目标平台：[STM32 / ESP32 / nRF52]
- C 标准：[C99 / C11]
- 项目根目录：[路径]
- 源文件目录：[路径列表]
- 头文件目录：[路径列表]

## 请生成
1. cppcheck 命令行参数
2. suppressions.xml（抑制已知误报）
3. MISRA 规则配置文件（如需要）
4. CI/CD 集成脚本（GitHub Actions / GitLab CI）

#!/bin/bash
# run_cppcheck.sh - 嵌入式项目静态分析
 
# ✅ 基本检查
cppcheck \
    --enable=all \
    --std=c99 \
    --platform=arm32-wchar_t2 \
    --suppress=missingIncludeSystem \
    --suppress=unusedFunction \
    --inline-suppr \
    --error-exitcode=1 \
    --xml \
    --xml-version=2 \
    -I include/ \
    -I Drivers/STM32F4xx_HAL_Driver/Inc/ \
    -I Drivers/CMSIS/Include/ \
    -D STM32F407xx \
    -D USE_HAL_DRIVER \
    src/ \
    2> cppcheck_report.xml
 
# ✅ MISRA C:2012 检查（需要 cppcheck premium 或 addon）
cppcheck \
    --addon=misra.json \
    --std=c99 \
    -I include/ \
    src/ \
    2> misra_report.xml
 
echo "静态分析完成，报告已生成"

你是一位嵌入式内存安全专家。审查以下代码的内存安全性：

## 代码
[粘贴代码]

## 审查清单
1. 缓冲区溢出
   - 所有数组访问是否有边界检查？
   - memcpy/memmove 的长度参数是否正确？
   - snprintf 是否使用了正确的缓冲区大小？

2. 栈溢出
   - 函数的局部变量总大小是否超过栈预算？
   - 是否有递归调用？
   - 是否在栈上分配了大数组？

3. 未初始化变量
   - 所有局部变量是否在使用前初始化？
   - 结构体是否完整初始化（memset 或指定初始化器）？

4. 空指针解引用
   - 指针参数是否在使用前检查 NULL？
   - 函数返回的指针是否检查？

5. 整数溢出
   - 算术运算是否可能溢出？
   - 类型转换是否安全（窄化转换）？

6. 对齐问题
   - 结构体是否需要 packed 属性？
   - DMA 缓冲区是否正确对齐？

## 目标平台
- 架构：[ARM Cortex-M / RISC-V / Xtensa]
- 字节序：[小端 / 大端]
- 对齐要求：[4 字节 / 8 字节]

为 STM32F407VGT6 设计传感器数据采集系统的软件架构：
- 4 路 ADC（DMA 循环采集，100Hz）
- 2 路 I2C 传感器（SHT30 + BMP280）
- Modbus RTU 从站（UART2, 9600 8N1）
- SSD1306 OLED 显示（I2C）
- FreeRTOS 多任务

请设计任务架构、优先级分配、通信机制和内存预算。
RAM 预算：192KB 总量，系统占用约 40KB，应用可用约 150KB。

任务架构：
┌─────────────────────────────────────────────────┐
│  看门狗任务 (优先级 7, 栈 512B)                    │
│  → 1s 周期喂狗，监控其他任务心跳                    │
├─────────────────────────────────────────────────┤
│  ADC 采集任务 (优先级 5, 栈 1KB)                   │
│  → DMA 半传输/全传输中断触发                       │
│  → 数据写入消息队列 → 处理任务                     │
├─────────────────────────────────────────────────┤
│  I2C 传感器任务 (优先级 4, 栈 2KB)                 │
│  → 2s 周期采集 SHT30 + BMP280                    │
│  → 数据写入共享结构体（互斥锁保护）                 │
├─────────────────────────────────────────────────┤
│  Modbus 任务 (优先级 3, 栈 2KB)                    │
│  → UART 中断接收 → 帧解析 → 响应                  │
│  → 读取共享数据结构体                              │
├─────────────────────────────────────────────────┤
│  显示任务 (优先级 2, 栈 2KB)                       │
│  → 500ms 周期刷新 OLED                           │
│  → 读取共享数据结构体                              │
└─────────────────────────────────────────────────┘

内存预算：
  任务栈总计：7.5KB
  DMA 缓冲区：4 通道 × 2 × 100 样本 × 2 字节 = 1.6KB
  Modbus 缓冲区：256B × 2（收发）= 512B
  OLED 帧缓冲：128 × 64 / 8 = 1KB
  消息队列：100 × sizeof(adc_data_t) ≈ 2KB
  共享数据结构体：~200B
  总计：~13KB（远在 150KB 预算内）

# 运行 cppcheck
cppcheck --enable=all --std=c99 -I Inc/ Src/ 2> report.xml
 
# 检查编译后的内存使用
arm-none-eabi-size build/firmware.elf
# 输出：
#    text    data     bss     dec     hex filename
#   45632    1024    8192   54848    d640 build/firmware.elf
# Flash: 45KB + 1KB = 46KB (11% of 512KB) ✅
# RAM: 1KB + 8KB = 9KB (5% of 192KB) ✅ （不含 FreeRTOS 堆）

为 ESP32 MicroPython 智能花盆项目生成代码结构：
- 土壤湿度传感器（ADC，GP34）
- DHT22 温湿度（GP4）
- 水泵继电器（GP5）
- LED 状态指示（GP2）
- Wi-Fi + MQTT（每 30 分钟上报）
- Deep Sleep（采集+上报后休眠）
- 电池电压监测（ADC，GP35）

内存约束：ESP32 MicroPython 可用堆约 100KB。
使用 asyncio 异步编程。
所有常量使用 const() 优化。

smart_pot/
├── main.py          # 入口，Deep Sleep 管理
├── config.py        # 配置常量（Wi-Fi, MQTT, 阈值）
├── sensors.py       # 传感器读取模块
├── actuators.py     # 执行器控制模块
├── network_mgr.py   # Wi-Fi + MQTT 管理
└── utils.py         # 工具函数（电池电压、日志）

# sensors.py - 传感器模块
from machine import Pin, ADC
from micropython import const
import dht
import time
 
# ✅ 常量定义
_SOIL_PIN = const(34)
_DHT_PIN = const(4)
_BATTERY_PIN = const(35)
_SOIL_DRY = const(3500)    # ADC 值：干燥阈值
_SOIL_WET = const(1500)    # ADC 值：湿润阈值
_ADC_SAMPLES = const(10)   # 多次采样取平均
 
# 硬件初始化
_soil_adc = ADC(Pin(_SOIL_PIN))
_soil_adc.atten(ADC.ATTN_11DB)
_soil_adc.width(ADC.WIDTH_12BIT)
 
_batt_adc = ADC(Pin(_BATTERY_PIN))
_batt_adc.atten(ADC.ATTN_11DB)
 
_dht_sensor = dht.DHT22(Pin(_DHT_PIN))
 
def read_soil_moisture():
    """读取土壤湿度（0-100%），多次采样取平均"""
    total = 0
    for _ in range(_ADC_SAMPLES):
        total += _soil_adc.read()
        time.sleep_ms(10)
    avg = total // _ADC_SAMPLES
 
    # ✅ 线性映射到 0-100%
    if avg >= _SOIL_DRY:
        return 0
    elif avg <= _SOIL_WET:
        return 100
    else:
        return ((_SOIL_DRY - avg) * 100) // (_SOIL_DRY - _SOIL_WET)
 
def read_dht22():
    """读取 DHT22 温湿度，返回 (温度, 湿度) 或 (None, None)"""
    try:
        _dht_sensor.measure()
        return _dht_sensor.temperature(), _dht_sensor.humidity()
    except OSError:
        return None, None
 
def read_battery_voltage():
    """读取电池电压（V），假设分压比 2:1"""
    raw = _batt_adc.read()
    voltage = (raw / 4095.0) * 3.3 * 2.0  # 分压比补偿
    return round(voltage, 2)
 
def needs_watering(soil_pct, threshold=30):
    """判断是否需要浇水"""
    return soil_pct < threshold

# 内存使用检查
import gc
gc.collect()
print(f"可用内存: {gc.mem_free()} bytes")
# 输出：可用内存: 89432 bytes（约 87KB，在 100KB 预算内）
 
# Deep Sleep 功耗测试
# 活跃期：~80mA，持续约 5 秒
# Deep Sleep：~10μA
# 每 30 分钟唤醒一次
# 电池续航估算：2000mAh / (80mA × 5s/1800s + 0.01mA) ≈ 8000 小时 ≈ 333 天

为 STM32F411CEU6（WeAct Black Pill）生成 Embassy Rust 项目：
- I2C1 读取 TMP102 温度传感器（PB6=SCL, PB7=SDA, 地址 0x48）
- USART2 串口输出温度值（PA2=TX, 115200 baud）
- PA0 LED 温度告警（>30°C 闪烁）
- PC13 按键（板载按键）

请提供完整的 Cargo.toml、memory.x、build.rs 和 src/main.rs。
使用 Embassy 最新稳定版 API。
使用 defmt 日志。

#![no_std]
#![no_main]
 
use defmt::*;
use embassy_executor::Spawner;
use embassy_stm32::i2c::I2c;
use embassy_stm32::usart::{Config as UartConfig, UartTx};
use embassy_stm32::gpio::{AnyPin, Input, Level, Output, Pull, Speed};
use embassy_stm32::time::Hertz;
use embassy_stm32::Peri;
use embassy_time::Timer;
use core::fmt::Write;
use heapless::String;
use {defmt_rtt as _, panic_probe as _};
 
const TMP102_ADDR: u8 = 0x48;
const TEMP_THRESHOLD: f32 = 30.0;
 
// ✅ 温度读取任务
#[embassy_executor::task]
async fn temp_task(
    i2c: I2c<'static>,
    mut uart: UartTx<'static>,
    led: Peri<'static, AnyPin>,
) {
    let mut led = Output::new(led, Level::Low, Speed::Low);
    let mut buf = [0u8; 2];
 
    loop {
        // 读取 TMP102 温度寄存器
        match i2c.read(TMP102_ADDR, &mut buf).await {
            Ok(()) => {
                // TMP102: 12 位分辨率，0.0625°C/LSB
                let raw = ((buf[0] as i16) << 4) | ((buf[1] as i16) >> 4);
                let temp = raw as f32 * 0.0625;
 
                info!("温度: {:.1}°C", temp);
 
                // UART 输出
                let mut s: String<32> = String::new();
                let _ = write!(s, "Temp: {:.1}C\r\n", temp);
                let _ = uart.write(s.as_bytes()).await;
 
                // 温度告警
                if temp > TEMP_THRESHOLD {
                    led.set_high();
                    Timer::after_millis(100).await;
                    led.set_low();
                } else {
                    led.set_low();
                }
            }
            Err(e) => {
                error!("I2C 读取失败: {:?}", e);
            }
        }
 
        Timer::after_secs(2).await;
    }
}
 
// ✅ 按键任务
#[embassy_executor::task]
async fn button_task(pin: Peri<'static, AnyPin>) {
    let button = Input::new(pin, Pull::Up);
 
    loop {
        button.wait_for_falling_edge().await;
        info!("按键按下 - 切换模式");
        Timer::after_millis(50).await; // 去抖动
    }
}
 
#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());
 
    // I2C 初始化
    let i2c = I2c::new(
        p.I2C1,
        p.PB6, // SCL
        p.PB7, // SDA
        Hertz(100_000),
        Default::default(),
    );
 
    // UART 初始化
    let mut uart_config = UartConfig::default();
    uart_config.baudrate = 115200;
    let uart_tx = UartTx::new(p.USART2, p.PA2, NoDma, uart_config).unwrap();
 
    info!("系统启动");
 
    spawner.spawn(temp_task(i2c, uart_tx, p.PA0.into())).unwrap();
    spawner.spawn(button_task(p.PC13.into())).unwrap();
}