嵌入式软件架构设计原则：从零构建可维护的系统¶

学习目标¶

完成本教程后，你将能够：

理解软件架构的核心概念和重要性
掌握分层架构的设计方法和实现技巧
学会模块化设计和接口定义
理解并实现硬件抽象层（HAL）
掌握解耦合的策略和实现方法
应用常见的嵌入式架构模式
能够重构现有代码以改善架构
设计可测试、可移植的嵌入式系统

前置要求¶

在开始学习前，建议你具备：

知识要求： - 熟悉C语言基础（结构体、指针、函数指针） - 了解基本的GPIO和外设操作 - 理解编译和链接过程 - 掌握基本的调试技能

技能要求： - 能够使用开发环境编写和调试代码 - 会使用基本的版本控制工具 - 了解如何阅读数据手册

开发环境： - 任何支持C语言的嵌入式开发板 - 开发IDE（Arduino IDE、STM32CubeIDE、PlatformIO等） - 基本的硬件（LED、按键、传感器）

为什么需要良好的软件架构¶

真实场景：架构缺失的代价¶

让我们从一个真实的例子开始。假设你正在开发一个温度监控系统：

版本1：快速原型（无架构）

// main.c - 所有代码都在一个文件中
#include <Arduino.h>

#define TEMP_SENSOR_PIN A0
#define LED_PIN 13
#define BUZZER_PIN 12

void setup() {
    Serial.begin(9600);
    pinMode(LED_PIN, OUTPUT);
    pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
    // 直接读取传感器
    int raw = analogRead(TEMP_SENSOR_PIN);
    float voltage = raw * (5.0 / 1023.0);
    float temperature = (voltage - 0.5) * 100.0;

    // 直接显示
    Serial.print("Temperature: ");
    Serial.println(temperature);

    // 直接控制输出
    if (temperature > 30.0) {
        digitalWrite(LED_PIN, HIGH);
        digitalWrite(BUZZER_PIN, HIGH);
    } else {
        digitalWrite(LED_PIN, LOW);
        digitalWrite(BUZZER_PIN, LOW);
    }

    delay(1000);
}

看起来很简单？现在需求变化了：

更换传感器型号（不同的转换公式）
添加LCD显示
支持多个温度阈值
添加数据记录功能
移植到不同的MCU平台

问题出现了： - 修改传感器需要改动多处代码 - 添加新功能导致代码越来越长 - 难以测试单个功能 - 移植需要重写大量代码 - 团队协作困难

这就是缺乏良好架构的代价！

软件架构的核心价值¶

良好的软件架构能够带来：

价值	说明	实际收益
可维护性	代码结构清晰，易于理解和修改	减少50%+的维护时间
可扩展性	方便添加新功能而不影响现有代码	新功能开发速度提升3倍
可测试性	各模块独立，便于单元测试	缺陷率降低70%
可移植性	更换硬件平台只需修改底层	移植时间从数周缩短到数天
可复用性	模块可在不同项目中复用	减少重复开发工作
团队协作	清晰的模块划分便于多人开发	团队效率提升2倍

嵌入式系统的特殊挑战¶

嵌入式系统的架构设计需要考虑特殊约束：

┌─────────────────────────────────────────────┐
│  嵌入式系统的特殊性                          │
├─────────────────────────────────────────────┤
│                                             │
│  ⚡ 资源受限                                │
│     • RAM: 几KB到几MB                       │
│     • Flash: 几十KB到几MB                   │
│     • CPU: 几MHz到几百MHz                   │
│                                             │
│  ⏱️ 实时性要求                              │
│     • 中断响应时间                          │
│     • 任务调度延迟                          │
│     • 确定性行为                            │
│                                             │
│  🔌 硬件依赖                                │
│     • 特定外设接口                          │
│     • 寄存器直接操作                        │
│     • 时序要求严格                          │
│                                             │
│  🔋 功耗限制                                │
│     • 电池供电                              │
│     • 低功耗模式                            │
│     • 功耗预算管理                          │
│                                             │
│  🛡️ 可靠性要求                              │
│     • 长时间稳定运行                        │
│     • 错误恢复机制                          │
│     • 看门狗保护                            │
│                                             │
└─────────────────────────────────────────────┘

架构设计必须平衡这些约束！

准备工作¶

硬件准备¶

名称	数量	说明	参考型号
开发板	1	任意MCU开发板	Arduino Uno, ESP32, STM32
LED灯	3	红、绿、蓝各一个	5mm LED
温度传感器	1	模拟或数字温度传感器	LM35, DS18B20
LCD显示屏	1	I2C接口LCD	1602 LCD
按键	2	轻触开关	6x6mm
电阻	若干	220Ω, 10kΩ	¼W
面包板	1	用于搭建电路	-
杜邦线	若干	连接线	-

软件准备¶

开发环境： - Arduino IDE 2.0+ 或 - PlatformIO 或 - STM32CubeIDE

推荐的项目结构：

temperature_monitor/
├── src/
│   ├── main.c
│   ├── hal/              # 硬件抽象层
│   ├── drivers/          # 驱动层
│   ├── services/         # 服务层
│   └── app/              # 应用层
├── include/
│   ├── hal/
│   ├── drivers/
│   ├── services/
│   └── app/
└── test/                 # 测试代码

电路连接¶

基础连接图：

Arduino/MCU          外设连接
┌─────────┐
│         │
│  Pin 9  ├──────┬─── 220Ω ───┬─── LED红 ───┬─── GND
│         │      │             │             │
│  Pin 10 ├──────┼─── 220Ω ───┼─── LED绿 ───┤
│         │      │             │             │
│  Pin 11 ├──────┴─── 220Ω ───┴─── LED蓝 ───┘
│         │
│  A0     ├────── 温度传感器 ────── GND/VCC
│         │
│  SDA    ├────── LCD SDA
│  SCL    ├────── LCD SCL
│         │
│  Pin 2  ├────── 按键1 ────── GND
│  Pin 3  ├────── 按键2 ────── GND
│         │
│   GND   ├──────────────────── 公共地
│   5V    ├──────────────────── 电源
│         │
└─────────┘

步骤1：理解分层架构¶

1.1 分层架构的基本概念¶

分层架构是嵌入式系统最常用的架构模式。它将系统划分为多个层次，每层只与相邻层交互。

典型的四层架构：

┌─────────────────────────────────────────────┐
│           应用层 (Application Layer)         │
│  • 业务逻辑                                  │
│  • 用户交互                                  │
│  • 状态管理                                  │
├─────────────────────────────────────────────┤
│           服务层 (Service Layer)             │
│  • 通用服务                                  │
│  • 算法实现                                  │
│  • 数据处理                                  │
├─────────────────────────────────────────────┤
│           驱动层 (Driver Layer)              │
│  • 硬件抽象                                  │
│  • 设备驱动                                  │
│  • 外设接口                                  │
├─────────────────────────────────────────────┤
│           硬件层 (Hardware Layer)            │
│  • 物理硬件                                  │
│  • 寄存器操作                                │
│  • 中断处理                                  │
└─────────────────────────────────────────────┘

层间交互规则： - ✅ 上层可以调用下层接口 - ❌ 下层不能直接调用上层（使用回调） - ❌ 不能跨层调用（必须通过相邻层） - ✅ 同层之间可以相互调用

1.2 实战：重构无架构代码¶

让我们将开头的温度监控系统重构为分层架构。

第一步：识别职责并分层

// 原始代码的职责分析：
// 1. 硬件操作：analogRead, digitalWrite
// 2. 数据转换：raw -> voltage -> temperature
// 3. 业务逻辑：温度阈值判断
// 4. 输出控制：LED和蜂鸣器

// 分层方案：
// - 硬件层：GPIO和ADC寄存器操作
// - 驱动层：温度传感器驱动、LED驱动
// - 服务层：温度数据处理
// - 应用层：监控逻辑

第二步：实现硬件抽象层（HAL）

// hal/gpio_hal.h - GPIO硬件抽象层
#ifndef GPIO_HAL_H
#define GPIO_HAL_H

#include <stdint.h>

// GPIO引脚定义
typedef enum {
    GPIO_PIN_0 = 0,
    GPIO_PIN_1,
    GPIO_PIN_2,
    // ... 更多引脚
    GPIO_PIN_13 = 13
} GPIO_Pin_t;

// GPIO模式
typedef enum {
    GPIO_MODE_INPUT,
    GPIO_MODE_OUTPUT,
    GPIO_MODE_INPUT_PULLUP
} GPIO_Mode_t;

// GPIO状态
typedef enum {
    GPIO_LOW = 0,
    GPIO_HIGH = 1
} GPIO_State_t;

// HAL接口函数
void HAL_GPIO_Init(GPIO_Pin_t pin, GPIO_Mode_t mode);
void HAL_GPIO_Write(GPIO_Pin_t pin, GPIO_State_t state);
GPIO_State_t HAL_GPIO_Read(GPIO_Pin_t pin);
void HAL_GPIO_Toggle(GPIO_Pin_t pin);

#endif // GPIO_HAL_H

// hal/gpio_hal.c - Arduino平台实现
#include "gpio_hal.h"
#include <Arduino.h>

void HAL_GPIO_Init(GPIO_Pin_t pin, GPIO_Mode_t mode) {
    switch (mode) {
        case GPIO_MODE_INPUT:
            pinMode(pin, INPUT);
            break;
        case GPIO_MODE_OUTPUT:
            pinMode(pin, OUTPUT);
            break;
        case GPIO_MODE_INPUT_PULLUP:
            pinMode(pin, INPUT_PULLUP);
            break;
    }
}

void HAL_GPIO_Write(GPIO_Pin_t pin, GPIO_State_t state) {
    digitalWrite(pin, state);
}

GPIO_State_t HAL_GPIO_Read(GPIO_Pin_t pin) {
    return (GPIO_State_t)digitalRead(pin);
}

void HAL_GPIO_Toggle(GPIO_Pin_t pin) {
    GPIO_State_t current = HAL_GPIO_Read(pin);
    HAL_GPIO_Write(pin, current == GPIO_HIGH ? GPIO_LOW : GPIO_HIGH);
}

HAL层的优势： - ✅ 隔离硬件平台差异 - ✅ 更换MCU只需修改HAL实现 - ✅ 上层代码完全不变 - ✅ 便于单元测试（可以mock HAL）

第三步：实现ADC硬件抽象层

// hal/adc_hal.h
#ifndef ADC_HAL_H
#define ADC_HAL_H

#include <stdint.h>

// ADC通道定义
typedef enum {
    ADC_CHANNEL_0 = 0,
    ADC_CHANNEL_1,
    ADC_CHANNEL_2,
    ADC_CHANNEL_3,
    ADC_CHANNEL_4,
    ADC_CHANNEL_5
} ADC_Channel_t;

// ADC参考电压
typedef enum {
    ADC_REF_DEFAULT,    // 默认参考电压（通常是VCC）
    ADC_REF_INTERNAL,   // 内部参考电压
    ADC_REF_EXTERNAL    // 外部参考电压
} ADC_Reference_t;

// HAL接口
void HAL_ADC_Init(ADC_Reference_t ref);
uint16_t HAL_ADC_Read(ADC_Channel_t channel);
float HAL_ADC_ReadVoltage(ADC_Channel_t channel);

#endif // ADC_HAL_H

// hal/adc_hal.c - Arduino平台实现
#include "adc_hal.h"
#include <Arduino.h>

static float reference_voltage = 5.0;  // 默认5V参考电压

void HAL_ADC_Init(ADC_Reference_t ref) {
    switch (ref) {
        case ADC_REF_DEFAULT:
            analogReference(DEFAULT);
            reference_voltage = 5.0;
            break;
        case ADC_REF_INTERNAL:
            analogReference(INTERNAL);
            reference_voltage = 1.1;  // Arduino Uno内部参考电压
            break;
        case ADC_REF_EXTERNAL:
            analogReference(EXTERNAL);
            reference_voltage = 5.0;  // 需要根据实际外部参考电压设置
            break;
    }
}

uint16_t HAL_ADC_Read(ADC_Channel_t channel) {
    return analogRead(channel);
}

float HAL_ADC_ReadVoltage(ADC_Channel_t channel) {
    uint16_t raw = HAL_ADC_Read(channel);
    return (raw * reference_voltage) / 1023.0;
}

第四步：实现驱动层

// drivers/temp_sensor_driver.h - 温度传感器驱动
#ifndef TEMP_SENSOR_DRIVER_H
#define TEMP_SENSOR_DRIVER_H

#include <stdint.h>
#include <stdbool.h>

// 传感器配置
typedef struct {
    uint8_t adc_channel;      // ADC通道
    float offset;             // 偏移量（V）
    float scale;              // 缩放系数（°C/V）
} TempSensor_Config_t;

// 传感器句柄
typedef struct {
    TempSensor_Config_t config;
    bool initialized;
    float last_temperature;
} TempSensor_Handle_t;

// 驱动接口
bool TempSensor_Init(TempSensor_Handle_t* handle, const TempSensor_Config_t* config);
bool TempSensor_Read(TempSensor_Handle_t* handle, float* temperature);
float TempSensor_GetLastReading(const TempSensor_Handle_t* handle);

#endif // TEMP_SENSOR_DRIVER_H

// drivers/temp_sensor_driver.c
#include "temp_sensor_driver.h"
#include "hal/adc_hal.h"
#include <string.h>

bool TempSensor_Init(TempSensor_Handle_t* handle, const TempSensor_Config_t* config) {
    if (handle == NULL || config == NULL) {
        return false;
    }

    // 复制配置
    memcpy(&handle->config, config, sizeof(TempSensor_Config_t));

    // 初始化ADC
    HAL_ADC_Init(ADC_REF_DEFAULT);

    handle->initialized = true;
    handle->last_temperature = 0.0;

    return true;
}

bool TempSensor_Read(TempSensor_Handle_t* handle, float* temperature) {
    if (handle == NULL || !handle->initialized || temperature == NULL) {
        return false;
    }

    // 读取电压
    float voltage = HAL_ADC_ReadVoltage(handle->config.adc_channel);

    // 转换为温度：temperature = (voltage - offset) * scale
    // 对于LM35: offset = 0.5V, scale = 100°C/V
    *temperature = (voltage - handle->config.offset) * handle->config.scale;

    // 保存最后读数
    handle->last_temperature = *temperature;

    return true;
}

float TempSensor_GetLastReading(const TempSensor_Handle_t* handle) {
    if (handle == NULL || !handle->initialized) {
        return 0.0;
    }

    return handle->last_temperature;
}

驱动层的特点： - ✅ 封装硬件细节 - ✅ 提供设备级抽象 - ✅ 处理设备特定的转换和配置 - ✅ 使用句柄管理设备实例

第五步：实现LED驱动

// drivers/led_driver.h
#ifndef LED_DRIVER_H
#define LED_DRIVER_H

#include <stdint.h>
#include <stdbool.h>

// LED状态
typedef enum {
    LED_STATE_OFF = 0,
    LED_STATE_ON = 1
} LED_State_t;

// LED配置
typedef struct {
    uint8_t pin;
    bool active_high;  // true: 高电平点亮, false: 低电平点亮
} LED_Config_t;

// LED句柄
typedef struct {
    LED_Config_t config;
    LED_State_t state;
    bool initialized;
} LED_Handle_t;

// 驱动接口
bool LED_Init(LED_Handle_t* handle, const LED_Config_t* config);
void LED_On(LED_Handle_t* handle);
void LED_Off(LED_Handle_t* handle);
void LED_Toggle(LED_Handle_t* handle);
void LED_SetState(LED_Handle_t* handle, LED_State_t state);
LED_State_t LED_GetState(const LED_Handle_t* handle);

#endif // LED_DRIVER_H

// drivers/led_driver.c
#include "led_driver.h"
#include "hal/gpio_hal.h"
#include <string.h>

bool LED_Init(LED_Handle_t* handle, const LED_Config_t* config) {
    if (handle == NULL || config == NULL) {
        return false;
    }

    // 复制配置
    memcpy(&handle->config, config, sizeof(LED_Config_t));

    // 初始化GPIO
    HAL_GPIO_Init(handle->config.pin, GPIO_MODE_OUTPUT);

    // 初始状态为关闭
    handle->state = LED_STATE_OFF;
    LED_Off(handle);

    handle->initialized = true;

    return true;
}

void LED_On(LED_Handle_t* handle) {
    if (handle == NULL || !handle->initialized) {
        return;
    }

    GPIO_State_t gpio_state = handle->config.active_high ? GPIO_HIGH : GPIO_LOW;
    HAL_GPIO_Write(handle->config.pin, gpio_state);
    handle->state = LED_STATE_ON;
}

void LED_Off(LED_Handle_t* handle) {
    if (handle == NULL || !handle->initialized) {
        return;
    }

    GPIO_State_t gpio_state = handle->config.active_high ? GPIO_LOW : GPIO_HIGH;
    HAL_GPIO_Write(handle->config.pin, gpio_state);
    handle->state = LED_STATE_OFF;
}

void LED_Toggle(LED_Handle_t* handle) {
    if (handle == NULL || !handle->initialized) {
        return;
    }

    if (handle->state == LED_STATE_ON) {
        LED_Off(handle);
    } else {
        LED_On(handle);
    }
}

void LED_SetState(LED_Handle_t* handle, LED_State_t state) {
    if (state == LED_STATE_ON) {
        LED_On(handle);
    } else {
        LED_Off(handle);
    }
}

LED_State_t LED_GetState(const LED_Handle_t* handle) {
    if (handle == NULL || !handle->initialized) {
        return LED_STATE_OFF;
    }

    return handle->state;
}

第六步：实现应用层

// app/temp_monitor_app.h
#ifndef TEMP_MONITOR_APP_H
#define TEMP_MONITOR_APP_H

#include <stdint.h>
#include <stdbool.h>

// 应用配置
typedef struct {
    float temp_threshold_high;   // 高温阈值
    float temp_threshold_low;    // 低温阈值
    uint32_t sample_interval_ms; // 采样间隔（毫秒）
} TempMonitor_Config_t;

// 应用接口
bool TempMonitor_Init(const TempMonitor_Config_t* config);
void TempMonitor_Run(void);
void TempMonitor_SetThreshold(float high, float low);
float TempMonitor_GetCurrentTemp(void);

#endif // TEMP_MONITOR_APP_H

// app/temp_monitor_app.c
#include "temp_monitor_app.h"
#include "drivers/temp_sensor_driver.h"
#include "drivers/led_driver.h"
#include <stdio.h>

// 应用状态
typedef struct {
    TempMonitor_Config_t config;
    TempSensor_Handle_t temp_sensor;
    LED_Handle_t led_alarm;
    LED_Handle_t led_status;
    float current_temperature;
    uint32_t last_sample_time;
    bool initialized;
} TempMonitor_State_t;

static TempMonitor_State_t app_state = {0};

bool TempMonitor_Init(const TempMonitor_Config_t* config) {
    if (config == NULL) {
        return false;
    }

    // 保存配置
    app_state.config = *config;

    // 初始化温度传感器
    TempSensor_Config_t sensor_config = {
        .adc_channel = 0,  // A0
        .offset = 0.5,     // LM35偏移
        .scale = 100.0     // LM35缩放系数
    };

    if (!TempSensor_Init(&app_state.temp_sensor, &sensor_config)) {
        return false;
    }

    // 初始化报警LED（红色）
    LED_Config_t led_alarm_config = {
        .pin = 9,
        .active_high = true
    };

    if (!LED_Init(&app_state.led_alarm, &led_alarm_config)) {
        return false;
    }

    // 初始化状态LED（绿色）
    LED_Config_t led_status_config = {
        .pin = 10,
        .active_high = true
    };

    if (!LED_Init(&app_state.led_status, &led_status_config)) {
        return false;
    }

    app_state.initialized = true;
    app_state.last_sample_time = 0;

    // 点亮状态LED表示系统正常
    LED_On(&app_state.led_status);

    printf("Temperature Monitor initialized\n");
    printf("High threshold: %.1f°C\n", config->temp_threshold_high);
    printf("Low threshold: %.1f°C\n", config->temp_threshold_low);

    return true;
}

void TempMonitor_Run(void) {
    if (!app_state.initialized) {
        return;
    }

    // 检查是否到达采样时间
    uint32_t current_time = millis();
    if (current_time - app_state.last_sample_time < app_state.config.sample_interval_ms) {
        return;
    }

    app_state.last_sample_time = current_time;

    // 读取温度
    float temperature;
    if (!TempSensor_Read(&app_state.temp_sensor, &temperature)) {
        printf("Error: Failed to read temperature\n");
        return;
    }

    app_state.current_temperature = temperature;

    // 打印温度
    printf("[%lu ms] Temperature: %.2f°C\n", current_time, temperature);

    // 检查阈值并控制报警
    if (temperature > app_state.config.temp_threshold_high) {
        LED_On(&app_state.led_alarm);
        printf("WARNING: Temperature too high!\n");
    } else if (temperature < app_state.config.temp_threshold_low) {
        LED_On(&app_state.led_alarm);
        printf("WARNING: Temperature too low!\n");
    } else {
        LED_Off(&app_state.led_alarm);
    }
}

void TempMonitor_SetThreshold(float high, float low) {
    if (!app_state.initialized) {
        return;
    }

    app_state.config.temp_threshold_high = high;
    app_state.config.temp_threshold_low = low;

    printf("Threshold updated: High=%.1f°C, Low=%.1f°C\n", high, low);
}

float TempMonitor_GetCurrentTemp(void) {
    return app_state.current_temperature;
}

第七步：主程序

// main.c
#include "app/temp_monitor_app.h"

void setup() {
    Serial.begin(115200);

    // 配置应用
    TempMonitor_Config_t config = {
        .temp_threshold_high = 30.0,  // 30°C
        .temp_threshold_low = 15.0,   // 15°C
        .sample_interval_ms = 1000    // 1秒采样一次
    };

    // 初始化应用
    if (!TempMonitor_Init(&config)) {
        Serial.println("Failed to initialize temperature monitor!");
        while (1);  // 停止运行
    }
}

void loop() {
    // 运行应用
    TempMonitor_Run();
}

1.3 分层架构的优势总结¶

对比原始代码和分层架构：

方面	原始代码	分层架构
代码行数	~30行	~400行
文件数量	1个	8个
可维护性	⭐	⭐⭐⭐⭐⭐
可测试性	⭐	⭐⭐⭐⭐⭐
可移植性	⭐	⭐⭐⭐⭐⭐
可扩展性	⭐	⭐⭐⭐⭐⭐
初期开发时间	快	慢
长期维护成本	高	低

看起来代码变多了，值得吗？

✅ 绝对值得！ 因为：

更换传感器：只需修改驱动层，其他代码不变
添加LCD显示：只需在应用层添加显示逻辑
移植到STM32：只需重写HAL层
单元测试：可以独立测试每一层
团队协作：不同人可以并行开发不同层

设计原则2：模块化设计¶

模块化是将系统分解为独立、可重用的模块，每个模块负责特定功能。

模块化的关键要素¶

高内聚：模块内部功能紧密相关
低耦合：模块之间依赖最小化
单一职责：每个模块只负责一个功能
明确接口：模块通过定义良好的接口交互

实践示例：温度监控系统的模块划分¶

// ========== 温度传感器模块 (temperature_sensor.h) ==========
#ifndef TEMPERATURE_SENSOR_H
#define TEMPERATURE_SENSOR_H

#include <stdint.h>

// 初始化温度传感器
void TempSensor_Init(void);

// 读取温度值（单位：0.1°C）
int16_t TempSensor_Read(void);

// 检查传感器是否正常
uint8_t TempSensor_IsReady(void);

#endif

// ========== 温度传感器模块实现 (temperature_sensor.c) ==========
#include "temperature_sensor.h"
#include "i2c_driver.h"  // 依赖I2C驱动

#define TEMP_SENSOR_ADDR  0x48
#define TEMP_REG_ADDR     0x00

void TempSensor_Init(void) {
    // 初始化I2C接口
    I2C_Init();
    // 配置传感器
    // ...
}

int16_t TempSensor_Read(void) {
    uint8_t data[2];
    // 通过I2C读取温度数据
    I2C_ReadBytes(TEMP_SENSOR_ADDR, TEMP_REG_ADDR, data, 2);
    // 转换为温度值
    int16_t temp = (data[0] << 8) | data[1];
    return temp / 16;  // 转换为0.1°C单位
}

uint8_t TempSensor_IsReady(void) {
    // 检查传感器是否响应
    return I2C_DeviceReady(TEMP_SENSOR_ADDR);
}

// ========== 显示模块 (display.h) ==========
#ifndef DISPLAY_H
#define DISPLAY_H

#include <stdint.h>

// 初始化显示器
void Display_Init(void);

// 显示温度值
void Display_ShowTemperature(int16_t temp);

// 显示警告信息
void Display_ShowWarning(const char* message);

#endif

// ========== 应用主控模块 (app_main.c) ==========
#include "temperature_sensor.h"
#include "display.h"

#define TEMP_THRESHOLD_HIGH  300  // 30.0°C
#define TEMP_THRESHOLD_LOW   100  // 10.0°C

void App_Init(void) {
    TempSensor_Init();
    Display_Init();
}

void App_Run(void) {
    // 读取温度
    int16_t temperature = TempSensor_Read();

    // 显示温度
    Display_ShowTemperature(temperature);

    // 检查温度范围
    if (temperature > TEMP_THRESHOLD_HIGH) {
        Display_ShowWarning("温度过高!");
    } else if (temperature < TEMP_THRESHOLD_LOW) {
        Display_ShowWarning("温度过低!");
    }
}

模块化优势： - 每个模块职责单一，易于理解和维护 - 模块可以独立开发和测试 - 更换传感器型号只需修改温度传感器模块 - 更换显示器只需修改显示模块 - 应用主控模块不关心底层实现细节

设计原则3：接口抽象与解耦合¶

接口抽象是通过定义标准接口来隔离实现细节，实现模块间的解耦合。

为什么需要解耦合¶

紧耦合的问题： - 修改一个模块可能影响其他模块 - 难以进行单元测试 - 代码复用困难 - 移植性差

实践示例：存储接口抽象¶

// ========== 存储接口定义 (storage_interface.h) ==========
#ifndef STORAGE_INTERFACE_H
#define STORAGE_INTERFACE_H

#include <stdint.h>

// 存储接口结构体
typedef struct {
    // 初始化存储设备
    void (*Init)(void);

    // 写入数据
    uint8_t (*Write)(uint32_t addr, const uint8_t* data, uint32_t len);

    // 读取数据
    uint8_t (*Read)(uint32_t addr, uint8_t* data, uint32_t len);

    // 擦除扇区
    uint8_t (*Erase)(uint32_t addr);

} Storage_Interface_t;

#endif

// ========== Flash存储实现 (flash_storage.c) ==========
#include "storage_interface.h"
#include "flash_driver.h"

static void Flash_Init(void) {
    Flash_Driver_Init();
}

static uint8_t Flash_Write(uint32_t addr, const uint8_t* data, uint32_t len) {
    return Flash_Driver_Program(addr, data, len);
}

static uint8_t Flash_Read(uint32_t addr, uint8_t* data, uint32_t len) {
    return Flash_Driver_Read(addr, data, len);
}

static uint8_t Flash_Erase(uint32_t addr) {
    return Flash_Driver_EraseSector(addr);
}

// Flash存储接口实例
const Storage_Interface_t FlashStorage = {
    .Init = Flash_Init,
    .Write = Flash_Write,
    .Read = Flash_Read,
    .Erase = Flash_Erase
};

// ========== EEPROM存储实现 (eeprom_storage.c) ==========
#include "storage_interface.h"
#include "eeprom_driver.h"

static void EEPROM_Init(void) {
    EEPROM_Driver_Init();
}

static uint8_t EEPROM_Write(uint32_t addr, const uint8_t* data, uint32_t len) {
    return EEPROM_Driver_Write(addr, data, len);
}

static uint8_t EEPROM_Read(uint32_t addr, uint8_t* data, uint32_t len) {
    return EEPROM_Driver_Read(addr, data, len);
}

static uint8_t EEPROM_Erase(uint32_t addr) {
    // EEPROM不需要擦除操作
    return 1;
}

// EEPROM存储接口实例
const Storage_Interface_t EEPROMStorage = {
    .Init = EEPROM_Init,
    .Write = EEPROM_Write,
    .Read = EEPROM_Read,
    .Erase = EEPROM_Erase
};

// ========== 配置管理模块 (config_manager.c) ==========
#include "storage_interface.h"

// 使用存储接口指针，实现解耦合
static const Storage_Interface_t* storage = NULL;

void Config_Init(const Storage_Interface_t* storage_impl) {
    // 注入存储接口实现
    storage = storage_impl;
    storage->Init();
}

uint8_t Config_Save(uint32_t addr, const uint8_t* data, uint32_t len) {
    if (storage == NULL) return 0;
    return storage->Write(addr, data, len);
}

uint8_t Config_Load(uint32_t addr, uint8_t* data, uint32_t len) {
    if (storage == NULL) return 0;
    return storage->Read(addr, data, len);
}

// ========== 应用层使用 (main.c) ==========
#include "config_manager.h"
#include "flash_storage.h"
#include "eeprom_storage.h"

int main(void) {
    // 可以灵活选择使用Flash或EEPROM
    #ifdef USE_FLASH
        Config_Init(&FlashStorage);
    #else
        Config_Init(&EEPROMStorage);
    #endif

    // 应用代码不需要关心底层使用的是哪种存储
    uint8_t config_data[16];
    Config_Load(0x1000, config_data, 16);

    return 0;
}

解耦合的优势： - 配置管理模块不依赖具体的存储实现 - 可以轻松切换存储介质（Flash、EEPROM、SD卡等） - 便于单元测试（可以注入模拟的存储接口） - 提高代码复用性

设计原则4：常见架构模式¶

模式1：事件驱动架构¶

事件驱动架构通过事件和事件处理器来组织系统，适合处理异步事件。

// ========== 事件系统 (event_system.h) ==========
#ifndef EVENT_SYSTEM_H
#define EVENT_SYSTEM_H

#include <stdint.h>

// 事件类型定义
typedef enum {
    EVENT_BUTTON_PRESSED,
    EVENT_BUTTON_RELEASED,
    EVENT_TIMER_EXPIRED,
    EVENT_DATA_RECEIVED,
    EVENT_MAX
} Event_Type_t;

// 事件结构
typedef struct {
    Event_Type_t type;
    void* data;
} Event_t;

// 事件处理器函数类型
typedef void (*Event_Handler_t)(Event_t* event);

// 注册事件处理器
void Event_RegisterHandler(Event_Type_t type, Event_Handler_t handler);

// 发送事件
void Event_Post(Event_Type_t type, void* data);

// 事件循环
void Event_Loop(void);

#endif

// ========== 事件系统实现 (event_system.c) ==========
#include "event_system.h"

#define EVENT_QUEUE_SIZE 16

static Event_t event_queue[EVENT_QUEUE_SIZE];
static uint8_t queue_head = 0;
static uint8_t queue_tail = 0;

static Event_Handler_t handlers[EVENT_MAX] = {NULL};

void Event_RegisterHandler(Event_Type_t type, Event_Handler_t handler) {
    if (type < EVENT_MAX) {
        handlers[type] = handler;
    }
}

void Event_Post(Event_Type_t type, void* data) {
    uint8_t next = (queue_tail + 1) % EVENT_QUEUE_SIZE;
    if (next != queue_head) {  // 队列未满
        event_queue[queue_tail].type = type;
        event_queue[queue_tail].data = data;
        queue_tail = next;
    }
}

void Event_Loop(void) {
    while (queue_head != queue_tail) {
        Event_t* event = &event_queue[queue_head];

        // 调用对应的事件处理器
        if (handlers[event->type] != NULL) {
            handlers[event->type](event);
        }

        queue_head = (queue_head + 1) % EVENT_QUEUE_SIZE;
    }
}

// ========== 应用层使用事件系统 ==========
#include "event_system.h"

// 按钮按下事件处理器
void OnButtonPressed(Event_t* event) {
    uint8_t button_id = *(uint8_t*)event->data;
    printf("按钮 %d 被按下\n", button_id);
    // 执行相应操作
}

// 定时器超时事件处理器
void OnTimerExpired(Event_t* event) {
    printf("定时器超时\n");
    // 执行定时任务
}

int main(void) {
    // 注册事件处理器
    Event_RegisterHandler(EVENT_BUTTON_PRESSED, OnButtonPressed);
    Event_RegisterHandler(EVENT_TIMER_EXPIRED, OnTimerExpired);

    // 主循环
    while (1) {
        // 处理所有待处理事件
        Event_Loop();

        // 其他任务
        // ...
    }

    return 0;
}

// 在中断或其他地方发送事件
void EXTI_IRQHandler(void) {
    uint8_t button_id = 1;
    Event_Post(EVENT_BUTTON_PRESSED, &button_id);
}

事件驱动架构的优势： - 解耦事件产生者和消费者 - 易于添加新的事件类型和处理器 - 适合处理异步和并发事件 - 提高系统的响应性

模式2：状态机模式¶

状态机模式用于管理具有多个状态的系统，在嵌入式系统中非常常见。

// ========== 简单的LED状态机示例 ==========
typedef enum {
    LED_STATE_OFF,
    LED_STATE_ON,
    LED_STATE_BLINK_SLOW,
    LED_STATE_BLINK_FAST
} LED_State_t;

typedef struct {
    LED_State_t current_state;
    uint32_t blink_counter;
} LED_StateMachine_t;

static LED_StateMachine_t led_sm = {LED_STATE_OFF, 0};

void LED_StateMachine_Update(void) {
    switch (led_sm.current_state) {
        case LED_STATE_OFF:
            LED_SetState(LED_OFF);
            break;

        case LED_STATE_ON:
            LED_SetState(LED_ON);
            break;

        case LED_STATE_BLINK_SLOW:
            led_sm.blink_counter++;
            if (led_sm.blink_counter >= 1000) {  // 1秒切换
                LED_Toggle();
                led_sm.blink_counter = 0;
            }
            break;

        case LED_STATE_BLINK_FAST:
            led_sm.blink_counter++;
            if (led_sm.blink_counter >= 200) {  // 200ms切换
                LED_Toggle();
                led_sm.blink_counter = 0;
            }
            break;
    }
}

void LED_SetMode(LED_State_t new_state) {
    led_sm.current_state = new_state;
    led_sm.blink_counter = 0;
}

深入理解¶

架构设计的权衡¶

在实际项目中，架构设计需要在多个因素之间权衡：

1. 性能 vs 可维护性¶

过度抽象的问题： - 每增加一层抽象都会带来性能开销（函数调用、间接访问） - 在资源受限的嵌入式系统中，过度抽象可能影响性能

权衡策略： - 在性能关键路径上减少抽象层次 - 使用内联函数减少函数调用开销 - 在非关键路径上优先考虑可维护性

// 性能关键代码：直接操作
static inline void FastGPIO_Set(void) {
    GPIOA->BSRR = GPIO_PIN_5;  // 直接寄存器操作
}

// 非关键代码：使用抽象接口
void SlowOperation(void) {
    LED_SetState(LED_ON);  // 通过抽象接口
}

2. 灵活性 vs 简单性¶

过度设计的问题： - 为了未来可能的需求增加复杂性 - 代码难以理解和维护

权衡策略： - 遵循YAGNI原则（You Aren't Gonna Need It） - 只为当前需求设计，但保持扩展性 - 使用重构来应对需求变化

3. 可移植性 vs 性能优化¶

硬件抽象的代价： - 完全的硬件抽象可能无法充分利用硬件特性 - 某些优化需要直接访问硬件

权衡策略： - 在HAL层提供硬件抽象 - 在性能关键部分允许直接硬件访问 - 使用条件编译隔离平台相关代码

// 通用实现（可移植）
void Generic_Delay(uint32_t ms) {
    for (uint32_t i = 0; i < ms * 1000; i++) {
        __NOP();
    }
}

// 平台优化实现
#ifdef USE_HARDWARE_TIMER
void Optimized_Delay(uint32_t ms) {
    // 使用硬件定时器实现精确延时
    TIM_Start(ms);
    while (!TIM_IsExpired());
}
#endif

架构演进策略¶

软件架构不是一成不变的，应该随着项目发展逐步演进。

阶段1：原型阶段¶

快速实现功能验证
可以接受较低的代码质量
重点是验证可行性

阶段2：重构阶段¶

识别重复代码和紧耦合
引入模块化和分层
建立清晰的接口

阶段3：优化阶段¶

性能优化
资源优化
稳定性提升

阶段4：维护阶段¶

持续重构
添加新功能
修复bug

最佳实践¶

1. 文件组织¶

project/
├── src/
│   ├── app/              # 应用层
│   │   ├── app_main.c
│   │   └── app_config.c
│   ├── service/          # 服务层
│   │   ├── event_system.c
│   │   └── state_machine.c
│   ├── driver/           # 驱动层
│   │   ├── led_driver.c
│   │   └── sensor_driver.c
│   └── hal/              # 硬件抽象层
│       └── gpio_hal.c
├── inc/                  # 头文件
│   ├── app/
│   ├── service/
│   ├── driver/
│   └── hal/
└── test/                 # 测试代码
    └── unit_tests/

2. 命名规范¶

// 模块前缀 + 功能描述
void LED_Init(void);           // LED模块的初始化函数
void LED_SetState(uint8_t state);  // LED模块的设置状态函数

// 类型定义使用_t后缀
typedef struct {
    uint8_t state;
    uint32_t counter;
} LED_Context_t;

// 枚举使用大写
typedef enum {
    LED_STATE_OFF,
    LED_STATE_ON
} LED_State_t;

3. 接口设计原则¶

最小化接口：只暴露必要的函数
一致性：相似功能使用相似的接口
完整性：提供完整的功能集合
文档化：清晰的注释说明

/**
 * @brief  初始化LED驱动
 * @param  None
 * @retval None
 * @note   必须在使用其他LED函数前调用
 */
void LED_Init(void);

/**
 * @brief  设置LED状态
 * @param  state: LED状态 (LED_OFF 或 LED_ON)
 * @retval 0: 成功, 1: 失败
 */
uint8_t LED_SetState(LED_State_t state);

常见问题¶

Q1: 什么时候应该使用分层架构？¶

A: 分层架构适用于大多数嵌入式项目，特别是： - 项目规模较大（超过5000行代码） - 需要支持多个硬件平台 - 团队有多人协作开发 - 项目需要长期维护

对于非常简单的项目（如简单的LED闪烁），可以使用更简单的结构。但即使是小项目，养成良好的架构习惯也是有益的。

Q2: 如何平衡抽象和性能？¶

A: 遵循以下原则： 1. 先正确，后优化：首先确保代码正确和可维护 2. 测量后优化：使用性能分析工具找出真正的瓶颈 3. 局部优化：只在性能关键路径上减少抽象 4. 使用内联：对于简单的抽象函数使用inline关键字

// 使用内联函数保持抽象的同时减少开销
static inline void GPIO_SetHigh(GPIO_TypeDef* port, uint16_t pin) {
    port->BSRR = pin;
}

Q3: 模块之间应该如何通信？¶

A: 常见的模块间通信方式：

直接函数调用：适用于同步、简单的交互
回调函数：适用于异步通知
事件系统：适用于多对多的通信
消息队列：适用于RTOS环境下的任务间通信

选择哪种方式取决于具体需求： - 简单的控制流：直接函数调用 - 需要解耦：回调函数或事件系统 - 实时系统：消息队列

Q4: 如何处理硬件依赖？¶

A: 使用硬件抽象层（HAL）：

// 定义硬件抽象接口
typedef struct {
    void (*Init)(void);
    void (*Write)(uint8_t data);
    uint8_t (*Read)(void);
} UART_HAL_t;

// 不同平台实现相同接口
#ifdef STM32
    extern const UART_HAL_t STM32_UART_HAL;
    #define UART_HAL STM32_UART_HAL
#elif defined(ESP32)
    extern const UART_HAL_t ESP32_UART_HAL;
    #define UART_HAL ESP32_UART_HAL
#endif

// 应用层使用统一接口
void App_SendData(uint8_t data) {
    UART_HAL.Write(data);
}

Q5: 什么是"过度设计"？如何避免？¶

A: 过度设计是指为了未来可能的需求而增加不必要的复杂性。

避免过度设计的方法： 1. YAGNI原则：只实现当前需要的功能 2. 迭代开发：从简单开始，逐步重构 3. 代码审查：团队讨论设计的必要性 4. 保持简单：优先选择简单的解决方案

判断标准： - 如果一个抽象层只有一个实现，可能是过度设计 - 如果代码比解决的问题还复杂，可能是过度设计 - 如果团队成员难以理解，可能是过度设计

总结¶

本文介绍了嵌入式软件架构设计的核心原则：

分层架构：将系统划分为多个层次，每层专注于特定功能，提高可维护性和可移植性
模块化设计：将系统分解为独立模块，实现高内聚低耦合，提高代码复用性
接口抽象：通过定义标准接口隔离实现细节，实现模块间解耦合
架构模式：事件驱动和状态机等模式帮助组织复杂的系统逻辑

关键要点： - 良好的架构设计需要在性能、灵活性和简单性之间权衡 - 架构应该随项目发展逐步演进，避免过度设计 - 遵循命名规范和接口设计原则，提高代码可读性 - 使用硬件抽象层处理硬件依赖，提高可移植性

实践建议： 1. 从简单开始，逐步重构和优化 2. 优先考虑可维护性，在性能关键处优化 3. 保持接口简单清晰，文档完整 4. 定期代码审查，持续改进架构

延伸阅读¶

推荐进一步学习的资源：

状态机设计与应用 - 深入学习状态机模式
命令行接口框架开发 - 学习CLI架构设计
日志系统架构设计 - 了解日志系统的架构
完整应用框架设计 - 学习完整的应用框架

推荐书籍： - 《嵌入式C语言自我修养》- 深入理解嵌入式C编程 - 《设计模式：可复用面向对象软件的基础》- 经典设计模式 - 《代码整洁之道》- 编写高质量代码的原则

在线资源： - Embedded Artistry - 嵌入式软件工程最佳实践 - Interrupt Blog - 嵌入式系统技术博客

参考资料¶

Martin, Robert C. "Clean Architecture: A Craftsman's Guide to Software Structure and Design"
Gamma, Erich, et al. "Design Patterns: Elements of Reusable Object-Oriented Software"
Douglass, Bruce Powel. "Real-Time Design Patterns: Robust Scalable Architecture for Real-Time Systems"
Embedded Artistry. "Embedded Software Architecture Best Practices"

练习题：

设计一个温湿度监控系统的分层架构，包括传感器层、数据处理层和显示层，画出架构图并说明各层职责。

将以下紧耦合的代码重构为使用接口抽象的设计：

void App_SaveConfig(void) {
    Flash_Write(0x1000, config_data, 16);  // 直接调用Flash函数
}

设计一个简单的事件系统，支持按钮事件、定时器事件和串口接收事件，实现事件注册和分发机制。
分析你当前项目的架构，识别出紧耦合的部分，提出改进方案。

下一步：建议学习状态机设计与应用，深入了解如何使用状态机模式管理复杂的系统状态。