35b - AI 辅助固件开发

你是一位 ESP-IDF v5.x 专家。为 ESP32-[型号] 生成 GPIO 配置代码：

## 需求
- 输出引脚：GPIO [引脚号]，推挽输出，用于控制 [设备]
- 输入引脚：GPIO [引脚号]，上拉输入，用于检测 [信号]
- 中断引脚：GPIO [引脚号]，下降沿触发，用于 [用途]

## 要求
1. 使用 gpio_config_t 结构体批量配置
2. 中断使用 gpio_isr_handler_add 注册
3. ISR 中只发送通知（xTaskNotifyFromISR），不做业务逻辑
4. 包含去抖动处理（软件去抖，[时间] ms）
5. 所有引脚号使用宏定义

/* gpio_config_example.c - ESP-IDF GPIO 配置示例 */
#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
 
// ✅ 引脚定义使用宏，便于修改
#define LED_PIN         GPIO_NUM_2
#define BUTTON_PIN      GPIO_NUM_0
#define SENSOR_INT_PIN  GPIO_NUM_4
 
// ✅ 去抖动时间定义
#define DEBOUNCE_TIME_MS  50
 
static TaskHandle_t s_gpio_task_handle = NULL;
static volatile uint32_t s_last_isr_time = 0;  // ✅ volatile 修饰
 
// ✅ ISR 尽可能短，只发送通知
static void IRAM_ATTR gpio_isr_handler(void *arg)
{
    uint32_t now = xTaskGetTickCountFromISR();
    // ✅ 软件去抖动
    if ((now - s_last_isr_time) > pdMS_TO_TICKS(DEBOUNCE_TIME_MS)) {
        s_last_isr_time = now;
        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
        // ✅ 使用 FromISR 版本的 API
        vTaskNotifyGiveFromISR(s_gpio_task_handle, 
                               &xHigherPriorityTaskWoken);
        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
    }
}
 
esp_err_t gpio_init(void)
{
    // 输出引脚配置
    gpio_config_t io_conf_output = {
        .pin_bit_mask = (1ULL << LED_PIN),
        .mode = GPIO_MODE_OUTPUT,
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = GPIO_INTR_DISABLE,
    };
    ESP_ERROR_CHECK(gpio_config(&io_conf_output));  // ✅ 错误检查
 
    // 输入引脚配置（带中断）
    gpio_config_t io_conf_input = {
        .pin_bit_mask = (1ULL << BUTTON_PIN) | (1ULL << SENSOR_INT_PIN),
        .mode = GPIO_MODE_INPUT,
        .pull_up_en = GPIO_PULLUP_ENABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = GPIO_INTR_NEGEDGE,  // 下降沿触发
    };
    ESP_ERROR_CHECK(gpio_config(&io_conf_input));
 
    // 安装 GPIO ISR 服务
    ESP_ERROR_CHECK(gpio_install_isr_service(0));
    ESP_ERROR_CHECK(gpio_isr_handler_add(BUTTON_PIN, 
                                          gpio_isr_handler, NULL));
    return ESP_OK;
}

你是一位 ESP-IDF v5.x 专家。为 ESP32 生成 [传感器型号] 的 I2C 驱动：

## 硬件连接
- I2C 总线：I2C_NUM_[0/1]
- SDA：GPIO [引脚号]
- SCL：GPIO [引脚号]
- 设备地址：0x[地址]
- 时钟频率：[100/400] kHz

## 功能需求
1. 初始化函数：配置 I2C 主机，验证设备 ID
2. 读取函数：读取 [数据类型]，返回工程单位值
3. 配置函数：设置 [采样率/量程/模式]
4. 错误处理：I2C 通信超时重试（最多 3 次）

## 代码规范
- 使用 ESP-IDF 的新版 I2C 驱动（i2c_master.h，非旧版 i2c.h）
- 所有寄存器地址用枚举定义
- 返回 esp_err_t，不使用断言
- 线程安全：使用互斥锁保护 I2C 总线访问

你是一位 ESP-IDF v5.x 专家。为 ESP32 生成 [外设型号] 的 SPI 驱动：

## 硬件连接
- SPI 总线：SPI[2/3]_HOST
- MOSI：GPIO [引脚号]
- MISO：GPIO [引脚号]
- SCLK：GPIO [引脚号]
- CS：GPIO [引脚号]
- 时钟频率：[频率] MHz
- SPI 模式：Mode [0/1/2/3]

## 功能需求
1. SPI 总线初始化和设备添加
2. 寄存器读写函数（单字节和多字节）
3. DMA 传输支持（数据量 > [阈值] 字节时使用 DMA）
4. 片选信号管理

## 约束
- 使用 spi_device_transmit（同步）或 spi_device_queue_trans（异步）
- DMA 缓冲区必须使用 DMA 可访问的内存（heap_caps_malloc）
- 最大传输大小：[数值] 字节

你是一位 ESP-IDF v5.x 专家。

## ADC 需求
- 通道：ADC1_CHANNEL_[编号]（GPIO [引脚号]）
- 分辨率：12 位
- 衰减：[0dB/2.5dB/6dB/11dB]（对应量程）
- 采样模式：[单次/连续]
- 如果连续采样：采样率 [数值] Hz，使用 DMA

## PWM 需求（LEDC）
- 通道：LEDC_CHANNEL_[编号]
- GPIO：[引脚号]
- 频率：[数值] Hz
- 分辨率：[数值] 位
- 用途：[LED 调光/电机控制/蜂鸣器]

## 要求
1. ADC 使用 ESP-IDF v5.x 新版 API（adc_oneshot / adc_continuous）
2. ADC 校准使用 esp_adc_cal（如芯片支持）
3. PWM 渐变使用 ledc_set_fade_with_time
4. 包含原始值到工程单位的转换函数

你是一位 ESP-IDF + FreeRTOS 专家。为以下系统设计多任务架构：

## 系统功能
[描述系统需要完成的所有功能]

## 任务列表
1. [任务名]：[功能描述]，周期 [时间]
2. [任务名]：[功能描述]，事件驱动
3. ...

## 资源约束
- 可用 RAM：[数值] KB（扣除系统和 Wi-Fi/BLE 栈占用）
- 所有任务栈总和不超过 [数值] KB
- CPU 核心：[单核/双核]

## 请设计
1. 任务优先级分配方案（说明理由）
2. 每个任务的栈大小估算（说明依据）
3. 任务间通信机制（队列/信号量/事件组/任务通知）
4. 共享资源保护策略
5. 看门狗集成方案
6. 核心亲和性分配（双核时）

## 输出格式
- 任务架构图（ASCII）
- 每个任务的 xTaskCreate 参数
- 通信机制的创建和使用代码

你是一位 ESP-IDF Wi-Fi 专家。生成 Wi-Fi STA 模式连接代码：

## 需求
1. 从 NVS 读取 SSID 和密码
2. 支持自动重连（最大重试 [次数] 次，间隔递增）
3. 连接成功后通过事件通知应用层
4. 支持 WPA2/WPA3
5. 获取 IP 后启动 SNTP 时间同步
6. 包含信号强度（RSSI）查询接口

## 错误处理
- 认证失败：通知应用层，不重试
- 连接丢失：自动重连，指数退避（1s, 2s, 4s, 8s, 最大 60s）
- DHCP 超时：重新连接

## 功耗优化
- 使用 DTIM [数值] 省电模式
- 空闲时降低 Wi-Fi 发射功率

你是一位 ESP32 低功耗专家。设计 Deep Sleep 电源管理方案：

## 工作模式
- 活跃期：[描述活跃期任务]，持续约 [时间]
- 睡眠期：Deep Sleep，持续 [时间]
- 唤醒源：[定时器/GPIO/ULP/触摸]

## 唤醒后需要保持的状态
- RTC 内存中保存：[列出需要跨睡眠保持的变量]
- GPIO 状态保持：[列出需要保持电平的引脚]

## 功耗目标
- 活跃期电流：< [数值] mA
- Deep Sleep 电流：< [数值] μA
- 目标续航：[时间]（[电池容量] mAh）

## 请生成
1. Deep Sleep 进入前的准备代码（关闭外设、保存状态）
2. 唤醒源配置
3. 唤醒后的恢复代码（判断唤醒原因、恢复外设）
4. RTC_DATA_ATTR 变量声明
5. 功耗预算计算

/* power_manager.c - ESP32 Deep Sleep 管理 */
#include "esp_sleep.h"
#include "esp_log.h"
#include "driver/gpio.h"
#include "driver/rtc_io.h"
 
static const char *TAG = "power";
 
// ✅ RTC 内存中保存跨睡眠数据
RTC_DATA_ATTR static uint32_t s_boot_count = 0;
RTC_DATA_ATTR static float s_last_temperature = 0.0f;
 
// ⚠️ 审查点：确认唤醒引脚支持 RTC 功能
#define WAKEUP_PIN  GPIO_NUM_33  // 必须是 RTC GPIO
 
void enter_deep_sleep(uint64_t sleep_time_us)
{
    ESP_LOGI(TAG, "进入 Deep Sleep，时长 %llu 秒", 
             sleep_time_us / 1000000);
 
    // 1. 关闭不需要的外设
    // ⚠️ 审查点：确保所有 SPI/I2C 设备已正确释放
    // i2c_driver_delete(I2C_NUM_0);
    // spi_bus_remove_device(spi_handle);
 
    // 2. 配置 GPIO 保持状态
    // ✅ 保持 LED 关闭状态
    gpio_set_level(LED_PIN, 0);
    rtc_gpio_isolate(LED_PIN);  // 隔离非 RTC GPIO 降低漏电
 
    // 3. 配置唤醒源
    // 定时器唤醒
    esp_sleep_enable_timer_wakeup(sleep_time_us);
    
    // GPIO 唤醒（可选）
    esp_sleep_enable_ext0_wakeup(WAKEUP_PIN, 0);  // 低电平唤醒
    rtc_gpio_pullup_en(WAKEUP_PIN);
 
    // 4. 进入 Deep Sleep
    esp_deep_sleep_start();
    // ✅ 此行之后的代码不会执行
}
 
void check_wakeup_reason(void)
{
    s_boot_count++;
    esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
    
    switch (cause) {
        case ESP_SLEEP_WAKEUP_TIMER:
            ESP_LOGI(TAG, "定时器唤醒，第 %lu 次启动", s_boot_count);
            break;
        case ESP_SLEEP_WAKEUP_EXT0:
            ESP_LOGI(TAG, "GPIO 唤醒，第 %lu 次启动", s_boot_count);
            break;
        case ESP_SLEEP_WAKEUP_UNDEFINED:
            ESP_LOGI(TAG, "首次上电启动");
            break;
        default:
            ESP_LOGW(TAG, "未知唤醒原因: %d", cause);
            break;
    }
}

你是一位 STM32 固件专家，精通 CubeMX 配置。

## 项目需求
- 芯片：[STM32 具体型号，如 STM32F407VGT6]
- 需要的外设：
  1. [外设1]：[具体需求]
  2. [外设2]：[具体需求]
  3. [外设3]：[具体需求]

## 请提供 CubeMX 配置建议
1. 时钟树配置（HSE 频率、PLL 倍频、各总线时钟）
2. 引脚分配方案（避免冲突，考虑 PCB 布局）
3. DMA 通道分配（避免冲突）
4. 中断优先级分配（NVIC 分组方案）
5. 每个外设的关键配置参数

## 约束
- 开发板：[型号，如 STM32F407 Discovery]
- 已占用引脚：[列出已使用的引脚]
- 功耗要求：[如有]

你是一位 STM32 HAL 库专家。生成多通道 ADC + DMA 采集代码：

## 硬件配置
- 芯片：[STM32 型号]
- ADC：ADC1
- 通道：[列出通道和对应 GPIO]
- 采样率：[数值] Hz
- 分辨率：12 位

## 需求
1. DMA 循环模式连续采集
2. 半传输和全传输中断处理（双缓冲）
3. 采样值滤波（移动平均，窗口大小 [数值]）
4. 原始值到电压/温度的转换函数
5. 过压/欠压告警回调

## 代码规范
- 使用 HAL 库 API
- DMA 缓冲区对齐到 4 字节
- 中断回调中只设置标志，主循环处理数据
- 兼容 CubeMX 生成的项目结构（代码放在 USER CODE 区域）

你是一位 STM32 定时器专家。

## 需求 1：PWM 输出
- 定时器：TIM[编号]
- 通道：CH[编号]，GPIO [引脚]
- 频率：[数值] Hz
- 分辨率：[数值] 位
- 用途：[电机控制/LED 调光/蜂鸣器]
- 需要互补输出和死区时间：[是/否]

## 需求 2：编码器接口
- 定时器：TIM[编号]
- A 相：GPIO [引脚]
- B 相：GPIO [引脚]
- 编码器类型：[AB 相正交/单相计数]
- 计数模式：[双边沿/单边沿]
- 溢出处理：[需要/不需要]

## 请生成
1. 定时器初始化代码（HAL_TIM_PWM_Init / HAL_TIM_Encoder_Init）
2. PWM 占空比动态调整函数
3. 编码器位置和速度读取函数
4. 溢出中断处理（如需要）

你是一位 STM32 中断管理专家。为以下系统设计中断优先级方案：

## 系统中断列表
1. [中断源1]：[用途]，响应时间要求 [时间]
2. [中断源2]：[用途]，响应时间要求 [时间]
3. ...

## NVIC 配置
- 优先级分组：[0-4]（抢占优先级位数 / 子优先级位数）
- 是否使用 FreeRTOS：[是/否]
  - 如果是：configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY = [值]

## 请设计
1. 每个中断的抢占优先级和子优先级
2. 优先级分配理由
3. 中断嵌套场景分析
4. FreeRTOS 兼容性检查（如适用）
5. 中断服务程序的最大执行时间估算

你是一位 STM32 固件专家。我的项目使用 HAL 库，但以下模块需要更高性能。
请将这些模块从 HAL 重写为 LL 库实现，保持接口不变：

## 需要优化的模块
1. [模块名]：当前 HAL 实现的性能瓶颈是 [描述]
2. [模块名]：需要在 ISR 中调用，HAL 开销太大

## 要求
- 保持与 HAL 项目的兼容性（不影响其他 HAL 模块）
- LL 函数使用内联（__STATIC_INLINE）
- 保留 HAL 的错误处理风格（返回 HAL_StatusTypeDef）
- 注释中标注对应的 HAL API 名称，便于对照

你是一位 Arduino 专家。为 [开发板型号] 生成 Sketch：

## 开发板
- 型号：[Arduino Uno/Mega/Nano/ESP32 Arduino]
- 处理器：[ATmega328P/ATmega2560/ESP32]

## 功能需求
[详细描述需要实现的功能]

## 硬件连接
- [传感器/模块1]：[引脚连接]
- [传感器/模块2]：[引脚连接]
- ...

## 需要的库
- [库名1]：[用途]
- [库名2]：[用途]

## 代码要求
1. setup() 中完成所有初始化
2. loop() 中使用非阻塞方式（millis() 而非 delay()）
3. 串口输出调试信息（波特率 115200）
4. 包含错误处理（传感器读取失败时的处理）
5. 变量命名清晰，添加中文注释

/* 多传感器非阻塞采集示例 */
// ✅ 使用 millis() 实现非阻塞多任务
 
// 任务间隔定义
const unsigned long TEMP_INTERVAL = 2000;   // 温度采集间隔 2s
const unsigned long DISPLAY_INTERVAL = 500; // 显示刷新间隔 500ms
const unsigned long LED_INTERVAL = 1000;    // LED 闪烁间隔 1s
 
// 上次执行时间
unsigned long lastTempTime = 0;
unsigned long lastDisplayTime = 0;
unsigned long lastLedTime = 0;
 
// 状态变量
float currentTemp = 0.0;
bool ledState = false;
 
void setup() {
    Serial.begin(115200);
    pinMode(LED_BUILTIN, OUTPUT);
    // 传感器初始化...
    Serial.println("系统初始化完成");
}
 
void loop() {
    unsigned long now = millis();
    
    // ✅ 任务 1：温度采集（非阻塞）
    if (now - lastTempTime >= TEMP_INTERVAL) {
        lastTempTime = now;
        currentTemp = readTemperature();
        // ⚠️ 审查点：检查传感器返回值有效性
        if (isnan(currentTemp)) {
            Serial.println("温度读取失败！");
            return;  // 跳过本次循环
        }
    }
    
    // ✅ 任务 2：显示刷新（非阻塞）
    if (now - lastDisplayTime >= DISPLAY_INTERVAL) {
        lastDisplayTime = now;
        updateDisplay(currentTemp);
    }
    
    // ✅ 任务 3：LED 心跳（非阻塞）
    if (now - lastLedTime >= LED_INTERVAL) {
        lastLedTime = now;
        ledState = !ledState;
        digitalWrite(LED_BUILTIN, ledState);
    }
}

你是一位 Arduino 库管理专家。

## 项目需求
我需要在 [开发板] 上实现以下功能：
1. [功能1]
2. [功能2]
3. [功能3]

## 请推荐
1. 每个功能推荐 2-3 个候选库
2. 对比表：维护状态、Star 数、兼容板卡、内存占用、许可证
3. 库之间的兼容性分析（是否有引脚/定时器/中断冲突）
4. 总内存占用估算（Flash + RAM）
5. 是否超出目标板卡的资源限制

## 约束
- Flash 可用：[数值] KB
- RAM 可用：[数值] KB
- 已使用的库：[列出]
- 已占用的定时器/中断：[列出]

你是一位同时精通 Arduino 和 ESP-IDF 的嵌入式专家。

## 迁移背景
我有一个运行在 ESP32 上的 Arduino 项目，需要迁移到 ESP-IDF，原因：
- [性能不足/功耗过高/需要更精细的控制/生产部署需要]

## 当前 Arduino 代码
[粘贴或描述当前代码结构]

## 使用的 Arduino 库
1. [库名]：[用途]
2. [库名]：[用途]

## 请提供
1. Arduino API → ESP-IDF API 的映射表
2. 每个 Arduino 库的 ESP-IDF 替代方案
3. 迁移步骤和优先级
4. 需要重写的模块和可以直接移植的模块
5. 迁移后的预期改进（性能/功耗/代码体积）

## Arduino → ESP-IDF 常见 API 映射
| Arduino | ESP-IDF | 说明 |
|---------|---------|------|
| digitalWrite() | gpio_set_level() | GPIO 输出 |
| digitalRead() | gpio_get_level() | GPIO 输入 |
| analogRead() | adc_oneshot_read() | ADC 读取 |
| Serial.print() | ESP_LOGI() | 日志输出 |
| delay() | vTaskDelay() | 延时（RTOS 友好） |
| millis() | esp_timer_get_time()/1000 | 时间戳 |
| attachInterrupt() | gpio_isr_handler_add() | 中断注册 |
| Wire.begin() | i2c_master_bus_new() | I2C 初始化 |
| SPI.begin() | spi_bus_initialize() | SPI 初始化 |

你是一位 Raspberry Pi Pico MicroPython 专家。

## 开发板
- 型号：[Pico / Pico W / Pico 2]
- MicroPython 版本：[最新稳定版]

## 功能需求
[描述需要实现的功能]

## 硬件连接
- [传感器/模块]：[引脚连接]

## 代码要求
1. 使用 machine 模块操作硬件（Pin, I2C, SPI, ADC, PWM）
2. 使用 uasyncio 实现异步多任务（非阻塞）
3. 错误处理使用 try/except
4. 内存优化：使用 const() 定义常量，避免大字符串
5. 如果是 Pico W：使用 network 模块连接 Wi-Fi

## MicroPython 特殊注意事项
- 避免频繁创建对象（GC 压力）
- 大数组使用 array 模块而非 list
- 文件操作注意 Flash 写入寿命
- 中断处理函数必须简短（micropython.schedule 延迟处理）

# main.py - Pico W 异步多任务示例
import uasyncio as asyncio
from machine import Pin, I2C, ADC
import network
import time
 
# 硬件初始化
led = Pin("LED", Pin.OUT)  # Pico W 板载 LED
adc = ADC(Pin(26))         # ADC0 - GP26
i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000)
 
# ✅ 异步任务 1：LED 心跳
async def heartbeat():
    while True:
        led.toggle()
        await asyncio.sleep_ms(500)
 
# ✅ 异步任务 2：传感器采集
async def read_sensors():
    while True:
        raw = adc.read_u16()
        voltage = raw * 3.3 / 65535
        print(f"ADC: {voltage:.2f}V")
        await asyncio.sleep_ms(2000)
 
# ✅ 异步任务 3：Wi-Fi 连接（Pico W）
async def connect_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(ssid, password)
    
    max_wait = 10
    while max_wait > 0:
        if wlan.status() >= 3:  # 已连接
            break
        max_wait -= 1
        print("等待 Wi-Fi 连接...")
        await asyncio.sleep(1)
    
    if wlan.isconnected():
        print(f"Wi-Fi 已连接: {wlan.ifconfig()}")
    else:
        print("Wi-Fi 连接失败")
 
# 主函数
async def main():
    await connect_wifi("SSID", "PASSWORD")
    
    # ✅ 并发运行多个任务
    await asyncio.gather(
        heartbeat(),
        read_sensors(),
    )
 
# 启动
asyncio.run(main())

你是一位 Raspberry Pi Pico C SDK 专家。

## 开发板
- 型号：[Pico / Pico W / Pico 2]
- SDK 版本：[2.1.x]

## 功能需求
[描述需要实现的功能]

## 代码要求
1. 使用 Pico SDK 的硬件抽象层（hardware_gpio, hardware_i2c 等）
2. 多核使用：[是否使用双核，如何分配任务]
3. DMA 使用：[是否需要 DMA 传输]
4. 中断处理：[列出需要的中断]
5. CMakeLists.txt 配置

## Pico SDK 特殊注意事项
- RP2040 双核：core0 默认运行 main()，core1 通过 multicore_launch_core1() 启动
- PIO（可编程 I/O）：适合自定义协议和精确时序
- Flash 编程：运行时写 Flash 需要注意 XIP 缓存

你是一位 Raspberry Pi Linux 嵌入式开发专家。

## 开发板
- 型号：Raspberry Pi [4/5]
- 操作系统：Raspberry Pi OS [Bookworm/Bullseye]

## 功能需求
[描述需要实现的功能]

## GPIO 访问方式
- Pi 5 推荐：libgpiod（gpiod 库，支持新的 GPIO 字符设备接口）
- Pi 4 及更早：RPi.GPIO（Python）或 pigpio（C/Python）
- ⚠️ Pi 5 不再支持 /dev/mem 直接访问，必须使用 libgpiod

## 编程语言
- [Python / C / C++ / Rust]

## 代码要求
1. 使用 [libgpiod/RPi.GPIO/pigpio] 访问 GPIO
2. SPI/I2C 通过 /dev/spidev 和 /dev/i2c 设备文件
3. 实时性要求：[如有，考虑 PREEMPT_RT 内核补丁]
4. 开机自启动：systemd 服务配置

你是一位 FreeRTOS 架构专家。为以下嵌入式系统设计完整的任务架构：

## 系统描述
[描述系统功能和硬件平台]

## 功能模块
1. [模块名]：[功能]，执行频率 [Hz/事件驱动]，实时性 [硬/软/无]
2. [模块名]：[功能]，执行频率 [Hz/事件驱动]，实时性 [硬/软/无]
3. ...

## 共享资源
- [资源1]：被 [任务列表] 访问
- [资源2]：被 [任务列表] 访问

## 请设计
1. **任务列表**：每个任务的名称、优先级、栈大小、核心亲和性
2. **通信机制**：
   - 任务间数据传递：队列（xQueueSend/Receive）
   - 事件通知：事件组（xEventGroupSetBits/WaitBits）
   - 二值信号：任务通知（xTaskNotifyGive/ulTaskNotifyTake）
3. **同步机制**：
   - 互斥锁：保护共享资源
   - 计数信号量：限制并发访问
4. **优先级反转防护**：使用优先级继承互斥锁
5. **看门狗策略**：每个任务的喂狗方式
6. **错误恢复**：任务异常时的处理策略

## 输出格式
- ASCII 任务架构图
- 每个任务的创建代码
- 通信/同步对象的创建代码
- 关键路径分析

/* FreeRTOS 生产者-消费者模式 */
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
 
// 数据结构
typedef struct {
    float temperature;
    float humidity;
    uint32_t timestamp;
} sensor_data_t;
 
// ✅ 队列句柄
static QueueHandle_t s_data_queue = NULL;
// ✅ 互斥锁保护共享硬件（I2C 总线）
static SemaphoreHandle_t s_i2c_mutex = NULL;
 
// 生产者任务：传感器采集
void sensor_task(void *pvParameters)
{
    sensor_data_t data;
    TickType_t last_wake = xTaskGetTickCount();
    
    while (1) {
        // ✅ 使用互斥锁保护 I2C 总线
        if (xSemaphoreTake(s_i2c_mutex, pdMS_TO_TICKS(100)) == pdTRUE) {
            data.temperature = read_temperature();
            data.humidity = read_humidity();
            data.timestamp = xTaskGetTickCount();
            xSemaphoreGive(s_i2c_mutex);
            
            // ✅ 发送到队列（非阻塞，队列满则丢弃最旧数据）
            if (xQueueSend(s_data_queue, &data, 0) != pdTRUE) {
                // 队列满，可选：覆盖最旧数据
                sensor_data_t dummy;
                xQueueReceive(s_data_queue, &dummy, 0);
                xQueueSend(s_data_queue, &data, 0);
            }
        }
        
        // ✅ 精确周期执行
        vTaskDelayUntil(&last_wake, pdMS_TO_TICKS(1000));
    }
}
 
// 消费者任务：数据处理和上报
void upload_task(void *pvParameters)
{
    sensor_data_t data;
    
    while (1) {
        // ✅ 阻塞等待数据
        if (xQueueReceive(s_data_queue, &data, portMAX_DELAY) == pdTRUE) {
            // 处理和上报数据
            mqtt_publish_sensor_data(&data);
        }
    }
}
 
void app_main(void)
{
    // 创建队列（缓冲 10 条数据）
    s_data_queue = xQueueCreate(10, sizeof(sensor_data_t));
    // 创建互斥锁
    s_i2c_mutex = xSemaphoreCreateMutex();
    
    // ✅ 创建任务，指定优先级和栈大小
    xTaskCreate(sensor_task, "sensor", 3072, NULL, 5, NULL);
    xTaskCreate(upload_task, "upload", 4096, NULL, 3, NULL);
}

你是一位 Zephyr RTOS 专家。为以下项目生成配置：

## 目标硬件
- 开发板：[板卡名称，如 nrf52840dk_nrf52840]
- 或自定义板卡：[芯片型号]

## 功能需求
1. [功能1]
2. [功能2]
3. ...

## 请生成
1. prj.conf（Kconfig 配置）
2. 设备树 overlay（如需自定义引脚）
3. CMakeLists.txt
4. 主要源文件框架

## Zephyr 特殊要求
- 使用 Zephyr 的日志系统（LOG_MODULE_REGISTER）
- 使用 Zephyr 的设备驱动模型（device_get_binding / DEVICE_DT_GET）
- 线程使用 K_THREAD_DEFINE 静态定义
- 配置项使用 Kconfig 而非硬编码

/* Zephyr RTOS 多线程示例 */
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
 
LOG_MODULE_REGISTER(main, LOG_LEVEL_INF);
 
// ✅ 消息队列定义
K_MSGQ_DEFINE(sensor_msgq, sizeof(struct sensor_value), 10, 4);
 
// ✅ 静态线程定义
#define SENSOR_STACK_SIZE 1024
#define SENSOR_PRIORITY   5
#define PROCESS_STACK_SIZE 2048
#define PROCESS_PRIORITY   7
 
// 传感器采集线程
void sensor_thread(void *p1, void *p2, void *p3)
{
    const struct device *dev = DEVICE_DT_GET_ANY(bosch_bme280);
    
    if (!device_is_ready(dev)) {
        LOG_ERR("传感器设备未就绪");
        return;
    }
    
    while (1) {
        struct sensor_value temp;
        
        if (sensor_sample_fetch(dev) == 0) {
            sensor_channel_get(dev, SENSOR_CHAN_AMBIENT_TEMP, &temp);
            // ✅ 发送到消息队列
            k_msgq_put(&sensor_msgq, &temp, K_NO_WAIT);
            LOG_INF("温度: %d.%06d °C", temp.val1, temp.val2);
        }
        
        k_sleep(K_SECONDS(2));
    }
}
 
// 数据处理线程
void process_thread(void *p1, void *p2, void *p3)
{
    struct sensor_value data;
    
    while (1) {
        // ✅ 阻塞等待数据
        if (k_msgq_get(&sensor_msgq, &data, K_FOREVER) == 0) {
            // 处理数据...
            LOG_INF("处理数据: %d.%06d", data.val1, data.val2);
        }
    }
}
 
// ✅ 静态创建线程
K_THREAD_DEFINE(sensor_tid, SENSOR_STACK_SIZE,
                sensor_thread, NULL, NULL, NULL,
                SENSOR_PRIORITY, 0, 0);
 
K_THREAD_DEFINE(process_tid, PROCESS_STACK_SIZE,
                process_thread, NULL, NULL, NULL,
                PROCESS_PRIORITY, 0, 0);

你是一位 RT-Thread 专家。请注意 RT-Thread 的 API 与 FreeRTOS 不同：
- 线程创建：rt_thread_create() / RT_THREAD_DEFINE
- 消息队列：rt_mq_create() / rt_mq_send() / rt_mq_recv()
- 互斥锁：rt_mutex_create() / rt_mutex_take() / rt_mutex_release()
- 信号量：rt_sem_create() / rt_sem_take() / rt_sem_release()
- 定时器：rt_timer_create()
- 日志：rt_kprintf() / LOG_D() / LOG_I() / LOG_W() / LOG_E()

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

## 请使用 RT-Thread API 生成代码

你是一位 RTOS 系统设计专家。分析以下任务系统并优化配置：

## 当前任务配置
| 任务名 | 优先级 | 栈大小 | 周期/触发 | 功能 |
|--------|--------|--------|----------|------|
| [任务1] | [值] | [值]KB | [周期/事件] | [描述] |
| [任务2] | [值] | [值]KB | [周期/事件] | [描述] |
| ... | ... | ... | ... | ... |

## 观察到的问题
[描述观察到的问题：任务饿死、栈溢出、响应延迟等]

## 请分析
1. 优先级分配是否合理？是否存在优先级反转风险？
2. 栈大小是否合适？（基于任务调用深度和局部变量估算）
3. 是否存在死锁风险？
4. CPU 利用率估算
5. 优化建议和修改后的配置表

## RTOS 信息
- RTOS：[FreeRTOS/Zephyr/RT-Thread]
- 调度策略：[抢占式/时间片/混合]
- 时钟节拍：[数值] Hz
- 总可用 RAM：[数值] KB

你是一位嵌入式通信协议专家。为 [平台] 生成 [协议] 驱动：

## 通信参数
### UART
- 波特率：[数值]
- 数据位：[7/8]
- 停止位：[1/2]
- 校验：[无/奇/偶]
- 流控：[无/RTS-CTS/XON-XOFF]
- 接收方式：[轮询/中断/DMA]

### SPI
- 模式：Mode [0/1/2/3]（CPOL/CPHA）
- 频率：[数值] MHz
- 位序：[MSB/LSB] First
- 数据宽度：[8/16] 位
- CS 管理：[硬件/软件]

### I2C
- 速率：[100/400/1000] kHz
- 地址模式：[7/10] 位
- 设备地址：0x[地址]
- 是否支持时钟拉伸：[是/否]

## 功能需求
1. 初始化函数
2. 发送函数（阻塞/非阻塞）
3. 接收函数（阻塞/非阻塞）
4. 错误处理和超时
5. [如需要] DMA 传输支持

你是一位 Modbus 协议专家。为 [平台] 实现 Modbus RTU 从站：

## 通信参数
- UART：[端口]
- 波特率：[9600/19200/115200]
- 从站地址：[1-247]
- 数据格式：8N1 / 8E1

## 寄存器映射
| 寄存器类型 | 起始地址 | 数量 | 描述 |
|-----------|---------|------|------|
| 保持寄存器 (4x) | 40001 | [数量] | [描述] |
| 输入寄存器 (3x) | 30001 | [数量] | [描述] |
| 线圈 (0x) | 00001 | [数量] | [描述] |
| 离散输入 (1x) | 10001 | [数量] | [描述] |

## 支持的功能码
- 0x01：读线圈
- 0x02：读离散输入
- 0x03：读保持寄存器
- 0x04：读输入寄存器
- 0x05：写单个线圈
- 0x06：写单个寄存器
- 0x0F：写多个线圈
- 0x10：写多个寄存器

## 要求
1. CRC-16 校验（Modbus 标准）
2. 帧间超时检测（3.5 字符时间）
3. 异常响应处理
4. 寄存器读写回调函数（应用层实现）
5. 线程安全（如使用 RTOS）

你是一位 CAN 总线专家。为 [平台] 实现 CAN 通信：

## CAN 配置
- CAN 控制器：[内置/外部 MCP2515]
- 波特率：[125/250/500/1000] kbps
- 模式：[标准帧 11 位 / 扩展帧 29 位]

## 消息定义
| 消息 ID | 方向 | DLC | 数据定义 | 周期 |
|---------|------|-----|---------|------|
| 0x[ID] | TX | [1-8] | [字节定义] | [ms] |
| 0x[ID] | RX | [1-8] | [字节定义] | [ms] |

## 需求
1. CAN 初始化（波特率、过滤器配置）
2. 发送函数（标准帧/扩展帧）
3. 接收处理（中断驱动 + 消息队列）
4. 过滤器配置（只接收指定 ID）
5. 错误处理（总线关闭恢复）
6. [如需要] CANopen 或 J1939 协议层

你是一位 BLE 协议专家。为 [ESP32/nRF52/STM32WB] 设计 BLE GATT 服务：

## 服务定义
### 自定义服务：[服务名称]
- 服务 UUID：[自定义 128 位 UUID]

### 特征值列表
| 特征值名称 | UUID | 属性 | 数据类型 | 长度 | 描述 |
|-----------|------|------|---------|------|------|
| [名称] | [UUID] | Read/Notify | [类型] | [字节] | [描述] |
| [名称] | [UUID] | Write | [类型] | [字节] | [描述] |
| [名称] | [UUID] | Read/Write | [类型] | [字节] | [描述] |

## 广播配置
- 设备名称：[名称]
- 广播间隔：[ms]
- 连接参数：min [ms] / max [ms] / latency [次] / timeout [ms]

## 需求
1. GATT 服务和特征值注册
2. 读/写回调函数
3. Notify 推送函数
4. 连接/断开事件处理
5. 配对和绑定（如需要）
6. MTU 协商

## 平台
- [ESP32: 使用 esp_gatts_api / NimBLE]
- [nRF52: 使用 Zephyr BLE 子系统]
- [STM32WB: 使用 STM32 BLE 栈]

你是一位 ESP-IDF + FreeRTOS 架构师。为 ESP32-S3 智能门锁设计系统架构：

功能：指纹识别（UART）、BLE 开锁、Wi-Fi MQTT 远程管理、
电池供电 Deep Sleep、NVS 存储开锁记录、OTA 更新。

请设计：
1. FreeRTOS 任务架构（任务列表、优先级、栈大小）
2. 状态机设计（待机→唤醒→认证→开锁→记录→睡眠）
3. 电源管理策略（何时进入 Deep Sleep，唤醒源）
4. 安全设计（指纹数据加密、BLE 配对、MQTT TLS）

┌─────────────────────────────────────────────────────┐
│              智能门锁 FreeRTOS 任务架构                │
├─────────────────────────────────────────────────────┤
│                                                     │
│  [优先级 10] 指纹任务                                │
│  ├── UART 通信（R503 协议）                          │
│  ├── 指纹录入/匹配/删除                              │
│  └── 匹配成功 → 发送事件到门锁控制任务                 │
│                                                     │
│  [优先级 8] BLE 任务                                 │
│  ├── GATT 服务（开锁特征值、状态特征值）               │
│  ├── 配对和绑定管理                                   │
│  └── 开锁命令 → 发送事件到门锁控制任务                 │
│                                                     │
│  [优先级 12] 门锁控制任务（最高优先级）                 │
│  ├── 等待开锁事件（指纹/BLE/远程）                    │
│  ├── 驱动电机开锁                                    │
│  ├── 记录开锁日志到 NVS                              │
│  └── 超时自动上锁                                    │
│                                                     │
│  [优先级 5] Wi-Fi/MQTT 任务                          │
│  ├── 定期唤醒连接 Wi-Fi                              │
│  ├── 上报开锁记录                                    │
│  ├── 接收远程开锁命令                                 │
│  └── 检查 OTA 更新                                   │
│                                                     │
│  [优先级 3] 电源管理任务                              │
│  ├── 电池电量监测（ADC）                              │
│  ├── 空闲超时检测                                    │
│  └── 进入 Deep Sleep                                │
│                                                     │
│  [优先级 15] 看门狗任务                               │
│  └── 监控所有任务，喂狗                               │
│                                                     │
└─────────────────────────────────────────────────────┘

分析智能门锁的功耗预算：
- 电池：2 节 CR123A（3V，1500mAh × 2 = 3000mAh）
- 目标续航：6 个月

工作模式分析：
- Deep Sleep（99.9% 时间）：10μA
- 指纹唤醒+匹配（每天 10 次，每次 3 秒）：80mA
- BLE 广播（持续）：需要评估是否可行
- Wi-Fi 连接（每天 2 次，每次 10 秒）：150mA

请计算：
1. 每日平均功耗
2. 预计续航时间
3. 优化建议（BLE 广播策略、Wi-Fi 连接频率）

为 STM32F407VGT6 配置 Modbus RTU/TCP 网关的 CubeMX 参数：

需要的外设：
1. USART2：RS485 Modbus RTU（9600-115200 可配置，DMA 接收）
2. SPI1：W5500 以太网模块
3. TIM6：Modbus RTU 帧间超时检测（3.5 字符时间）
4. GPIO：RS485 方向控制（DE/RE）
5. IWDG：独立看门狗

请提供：
1. 时钟树配置（168MHz SYSCLK）
2. 引脚分配（避免冲突）
3. DMA 通道分配
4. 中断优先级（FreeRTOS 兼容）
5. NVIC 分组方案

为 STM32F407 生成 Modbus RTU 主站代码，功能：
1. 扫描 RS485 总线上的从站（地址 1-32）
2. 定期轮询每个在线从站的寄存器
3. 轮询策略：高优先级从站 1 秒，低优先级 5 秒
4. 通信失败重试 3 次，连续失败标记从站离线
5. 使用 DMA 接收，TIM6 检测帧间间隔

平台：STM32 HAL + FreeRTOS

为 STM32F407 + W5500 生成 Modbus TCP 服务端代码：
1. 监听端口 502
2. 支持最多 4 个并发 TCP 连接
3. 将 TCP 请求转发到 RTU 总线
4. 响应超时处理（RTU 从站无响应时返回异常码）
5. 数据缓存：最近一次成功读取的数据可直接返回（可配置）

使用 W5500 的 Socket API（非 lwIP）