┌─────────────────────────────────────────────────────────────┐
│                         应用层                               │
│    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    │
│    │  业务逻辑   │    │  用户界面   │    │  通信协议   │    │
│    └─────────────┘    └─────────────┘    └─────────────┘    │
├─────────────────────────────────────────────────────────────┤
│                       中间件层                               │
│    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    │
│    │  文件系统   │    │  网络协议栈 │    │  USB协议栈  │    │
│    └─────────────┘    └─────────────┘    └─────────────┘    │
├─────────────────────────────────────────────────────────────┤
│                        系统层                                │
│    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    │
│    │  Bootloader │    │    RTOS     │    │    HAL      │    │
│    └─────────────┘    └─────────────┘    └─────────────┘    │
├─────────────────────────────────────────────────────────────┤
│                        硬件层                                │
│    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    │
│    │  MCU核心    │    │    外设     │    │   存储器    │    │
│    │ Cortex-M    │    │ GPIO/UART   │    │ Flash/RAM   │    │
│    └─────────────┘    └─────────────┘    └─────────────┘    │
└─────────────────────────────────────────────────────────────┘

┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐
│ 需求分析 │ ──▶ │ 架构设计 │ ──▶ │ 代码编写 │ ──▶ │ 编译构建 │
└──────────┘     └──────────┘     └──────────┘     └──────────┘
                                                           │
┌──────────┐     ┌──────────┐     ┌──────────┐            │
│ 发布交付 │ ◀── │ 测试验证 │ ◀── │ 烧录调试 │ ◀───────────┘
└──────────┘     └──────────┘     └──────────┘
                      │
                      ▼
                 ┌──────────┐
                 │  通过?   │──否──▶ 返回代码编写
                 └──────────┘
                      │
                     是

        ┌─────────────────┐
        │    开始任务     │
        └────────┬────────┘
                 │
                 ▼
        ┌─────────────────┐
        │   任务类型判断   │
        └────────┬────────┘
                 │
     ┌───────────┼───────────┐
     │           │           │
     ▼           ▼           ▼
┌────────┐  ┌────────┐  ┌────────┐
│ Craft  │  │  Plan  │  │  Ask   │
│ 实干   │  │ 规划   │  │ 问答   │
└───┬────┘  └───┬────┘  └───┬────┘
    │           │           │
    ▼           ▼           ▼
┌────────┐  ┌────────┐  ┌────────┐
│直接执行│  │输出方案│  │提供建议│
│交付结果│  │确认后执行│  │纯文字  │
└────────┘  └────────┘  └────────┘

/**
 * @file gpio_init.c
 * @brief STM32F103 GPIO 初始化
 * @date 2026-06-06
 */

#include "stm32f10x.h"

/**
 * @brief GPIO 初始化函数
 * @note  PA0 - 推挽输出 (LED/控制信号)
 *        PA1 - 浮空输入 (按键/传感器)
 */
void GPIO_Init(void)
{
    // 1. 使能 GPIOA 时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
    // 2. 定义 GPIO 配置结构体
    GPIO_InitTypeDef GPIO_InitStruct;
    
    // 3. 配置 PA0 - 推挽输出
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;      // 推挽输出
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;     // 输出速度 50MHz
    GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    // 4. 配置 PA1 - 浮空输入
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING; // 浮空输入
    GPIO_Init(GPIOA, &GPIO_InitStruct);
}

/**
 * @brief 设置 PA0 输出电平
 * @param level 0=低电平, 1=高电平
 */
void PA0_SetLevel(uint8_t level)
{
    if (level)
        GPIO_SetBits(GPIOA, GPIO_Pin_0);
    else
        GPIO_ResetBits(GPIOA, GPIO_Pin_0);
}

/**
 * @brief 读取 PA1 输入状态
 * @return 0=低电平, 1=高电平
 */
uint8_t PA1_GetStatus(void)
{
    return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1);
}

#include "FreeRTOS.h"
#include "task.h"

/* 任务句柄 */
TaskHandle_t xLedTaskHandle = NULL;
TaskHandle_t xKeyTaskHandle = NULL;
TaskHandle_t xDataTaskHandle = NULL;

/**
 * @brief LED 闪烁任务
 * @param pvParameters 任务参数
 */
void vTaskLedBlink(void *pvParameters)
{
    (void)pvParameters;
    
    for (;;)
    {
        // LED 亮
        LED_On();
        vTaskDelay(pdMS_TO_TICKS(250));
        
        // LED 灭
        LED_Off();
        vTaskDelay(pdMS_TO_TICKS(250));
    }
}

/**
 * @brief 按键扫描任务
 * @param pvParameters 任务参数
 */
void vTaskKeyScan(void *pvParameters)
{
    (void)pvParameters;
    
    for (;;)
    {
        // 扫描按键状态
        Key_Scan();
        vTaskDelay(pdMS_TO_TICKS(50));
    }
}

/**
 * @brief 数据采集任务
 * @param pvParameters 任务参数
 */
void vTaskDataCollect(void *pvParameters)
{
    (void)pvParameters;
    
    for (;;)
    {
        // 采集传感器数据
        Sensor_Read();
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

/**
 * @brief 创建所有任务
 */
void CreateTasks(void)
{
    /* 创建 LED 任务 - 优先级 2 */
    xTaskCreate(vTaskLedBlink, "LED", 128, NULL, 2, &xLedTaskHandle);
    
    /* 创建按键任务 - 优先级 3 */
    xTaskCreate(vTaskKeyScan, "KEY", 128, NULL, 3, &xKeyTaskHandle);
    
    /* 创建数据采集任务 - 优先级 1 */
    xTaskCreate(vTaskDataCollect, "DATA", 256, NULL, 1, &xDataTaskHandle);
}

UART_Init(115200);  // 初始化 UART，波特率 115200

void delay_ms(int ms) {
    for(int i=0; i<ms; i++)
        for(int j=0; j<1000; j++);
}

// 方案 1：使用 HAL 库
void delay_ms(uint32_t ms) {
    HAL_Delay(ms);
}

// 方案 2：使用 FreeRTOS
void delay_ms(uint32_t ms) {
    vTaskDelay(pdMS_TO_TICKS(ms));
}

┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│ 阅读数据手册 │───▶│ 理解寄存器   │───▶│ 生成宏定义   │
└──────────────┘    └──────────────┘    └──────────────┘
                                                 │
┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│ 输出文档     │◀───│ 代码审查     │◀───│ 编写初始化   │
└──────────────┘    └──────────────┘    └──────────────┘

基于上传的 ADXL345 数据手册，提取关键寄存器定义，
生成 C 语言头文件，包含寄存器地址、位掩码定义。

#ifndef __ADXL345_REG_H__
#define __ADXL345_REG_H__

/* Device ID */
#define ADXL345_REG_DEVID           0x00
#define ADXL345_DEVID_VALUE         0xE5

/* Threshold Registers */
#define ADXL345_REG_THRESH_TAP      0x1D
#define ADXL345_REG_OFSX            0x1E
#define ADXL345_REG_OFSY            0x1F
#define ADXL345_REG_OFSZ            0x20

/* Tap Duration */
#define ADXL345_REG_DUR             0x21

/* Power Control */
#define ADXL345_REG_POWER_CTL       0x2D
#define ADXL345_BIT_LINK            (1 << 5)
#define ADXL345_BIT_AUTO_SLEEP      (1 << 4)
#define ADXL345_BIT_MEASURE         (1 << 3)
#define ADXL345_BIT_SLEEP           (1 << 2)

/* Data Format */
#define ADXL345_REG_DATA_FORMAT     0x31
#define ADXL345_BIT_SELF_TEST       (1 << 7)
#define ADXL345_BIT_SPI             (1 << 6)
#define ADXL345_BIT_INT_INVERT      (1 << 5)
#define ADXL345_BIT_FULL_RES        (1 << 3)
#define ADXL345_BIT_JUSTIFY         (1 << 2)

/* Data Registers */
#define ADXL345_REG_DATAX0          0x32
#define ADXL345_REG_DATAX1          0x33
#define ADXL345_REG_DATAY0          0x34
#define ADXL345_REG_DATAY1          0x35
#define ADXL345_REG_DATAZ0          0x36
#define ADXL345_REG_DATAZ1          0x37

#endif /* __ADXL345_REG_H__ */

基于生成的寄存器头文件，编写 ADXL345 的初始化函数和
数据读取函数，包含 I2C 通信接口。

/**
 * @file adxl345.c
 * @brief ADXL345 加速度传感器驱动
 */

#include "adxl345_reg.h"
#include "i2c_driver.h"

#define ADXL345_ADDR    0x53  // I2C 地址

/**
 * @brief ADXL345 初始化
 * @return 0=成功, -1=失败
 */
int ADXL345_Init(void)
{
    uint8_t id;
    
    // 读取设备 ID，验证通信
    if (I2C_ReadReg(ADXL345_ADDR, ADXL345_REG_DEVID, &id, 1) != 0)
        return -1;
    
    if (id != ADXL345_DEVID_VALUE)
        return -1;
    
    // 配置测量范围 ±2g
    I2C_WriteReg(ADXL345_ADDR, ADXL345_REG_DATA_FORMAT, 0x00);
    
    // 使能测量模式
    I2C_WriteReg(ADXL345_ADDR, ADXL345_REG_POWER_CTL, ADXL345_BIT_MEASURE);
    
    return 0;
}

/**
 * @brief 读取加速度数据
 * @param x X轴加速度 (单位: mg)
 * @param y Y轴加速度 (单位: mg)
 * @param z Z轴加速度 (单位: mg)
 * @return 0=成功, -1=失败
 */
int ADXL345_ReadAccel(int16_t *x, int16_t *y, int16_t *z)
{
    uint8_t buf[6];
    
    // 读取 6 字节数据 (X0, X1, Y0, Y1, Z0, Z1)
    if (I2C_ReadReg(ADXL345_ADDR, ADXL345_REG_DATAX0, buf, 6) != 0)
        return -1;
    
    // 组合数据 (小端模式)
    *x = (int16_t)(buf[0] | (buf[1] << 8));
    *y = (int16_t)(buf[2] | (buf[3] << 8));
    *z = (int16_t)(buf[4] | (buf[5] << 8));
    
    // 转换为 mg (分辨率约 3.9 mg/LSB)
    *x = (*x * 39) / 10;
    *y = (*y * 39) / 10;
    *z = (*z * 39) / 10;
    
    return 0;
}

生成 Modbus RTU 从机协议的代码框架，包含：
1. 帧解析函数
2. 功能码 0x03 (读保持寄存器) 处理
3. 功能码 0x06 (写单个寄存器) 处理
4. CRC 校验计算

/**
 * @brief Modbus RTU 从机协议处理
 */

#include <stdint.h>
#include <string.h>

#define MODBUS_SLAVE_ADDR       0x01
#define MODBUS_FUNC_READ        0x03
#define MODBUS_FUNC_WRITE       0x06
#define MODBUS_MAX_REG_COUNT    125

/* 保持寄存器 */
static uint16_t holding_regs[MODBUS_MAX_REG_COUNT];

/**
 * @brief CRC16 计算 (Modbus)
 */
uint16_t Modbus_CRC16(uint8_t *data, uint16_t len)
{
    uint16_t crc = 0xFFFF;
    
    for (uint16_t i = 0; i < len; i++)
    {
        crc ^= data[i];
        for (uint8_t j = 0; j < 8; j++)
        {
            if (crc & 0x0001)
                crc = (crc >> 1) ^ 0xA001;
            else
                crc >>= 1;
        }
    }
    
    return crc;
}

/**
 * @brief 处理 Modbus 请求
 * @param rx_buf 接收缓冲区
 * @param rx_len 接收长度
 * @param tx_buf 发送缓冲区
 * @return 响应长度
 */
uint16_t Modbus_Process(uint8_t *rx_buf, uint16_t rx_len, uint8_t *tx_buf)
{
    // 验证地址
    if (rx_buf[0] != MODBUS_SLAVE_ADDR)
        return 0;
    
    // 验证 CRC
    uint16_t rx_crc = (rx_buf[rx_len - 1] << 8) | rx_buf[rx_len - 2];
    uint16_t calc_crc = Modbus_CRC16(rx_buf, rx_len - 2);
    if (rx_crc != calc_crc)
        return 0;
    
    uint8_t func = rx_buf[1];
    uint16_t tx_len = 0;
    
    switch (func)
    {
        case MODBUS_FUNC_READ:
            tx_len = Modbus_ReadHoldingRegs(rx_buf, tx_buf);
            break;
            
        case MODBUS_FUNC_WRITE:
            tx_len = Modbus_WriteSingleReg(rx_buf, tx_buf);
            break;
            
        default:
            // 非法功能码
            tx_buf[0] = MODBUS_SLAVE_ADDR;
            tx_buf[1] = func | 0x80;
            tx_buf[2] = 0x01;  // 非法功能码异常
            tx_len = 3;
            break;
    }
    
    // 添加 CRC
    if (tx_len > 0)
    {
        uint16_t crc = Modbus_CRC16(tx_buf, tx_len);
        tx_buf[tx_len++] = crc & 0xFF;
        tx_buf[tx_len++] = (crc >> 8) & 0xFF;
    }
    
    return tx_len;
}

我的 STM32 程序运行时进入 HardFault，
LR = 0xFFFFFFF9， stacked PC 指向 0x08001234
CFSR = 0x00000400
请分析可能的原因。

void HardFault_Handler(void)
{
    __asm volatile(
        "TST LR, #4\n"
        "ITE EQ\n"
        "MRSEQ R0, MSP\n"
        "MRSNE R0, PSP\n"
        "B HardFault_Handler_C\n"
    );
}

void HardFault_Handler_C(uint32_t *stack)
{
    uint32_t r0 = stack[0];
    uint32_t r1 = stack[1];
    uint32_t r2 = stack[2];
    uint32_t r3 = stack[3];
    uint32_t r12 = stack[4];
    uint32_t lr = stack[5];
    uint32_t pc = stack[6];
    uint32_t psr = stack[7];
    
    // 在此处设置断点，查看寄存器值
    while(1);
}

[粘贴标准库代码]

设置定时任务：每天晚上 8 点，扫描项目目录下的 C 文件，
进行代码风格检查，生成审查报告并发到邮箱。

"帮我查一下 STM32F4 的 GPIO 速度配置"
"生成一个 UART 初始化代码发给我"

┌─────────────────────────────────────────┐
│           项目：智能温控系统              │
├─────────────┬─────────────┬────────────┤
│   Agent 1   │   Agent 2   │   Agent 3  │
│  传感器驱动  │   控制算法  │   通信协议  │
│   开发     │    开发     │    开发    │
└─────────────┴─────────────┴────────────┘
              │
              ▼
       ┌────────────┐
       │   主 Agent  │
       │  集成协调   │
       └────────────┘

为 [芯片型号] 生成 [外设名称] 的初始化代码，
配置 [具体参数]，使用 [库类型]。

审查以下代码，找出潜在问题并提出优化建议：
[粘贴代码]

基于以下代码，生成 API 文档，包含函数说明、
参数、返回值和使用示例：
[粘贴代码]

程序出现 [现象描述]，错误信息如下：
[错误信息]
请分析可能的原因和解决方案。

将以下 [源平台] 代码迁移到 [目标平台]，
保持功能一致：
[粘贴代码]