设计模式在嵌入式系统中的应用完全指南#

设计模式是软件工程中经过验证的解决方案，是前辈们智慧的结晶。在嵌入式开发中，合理运用设计模式可以提高代码的可维护性、可扩展性和可测试性。本文将带你深入理解设计模式，并掌握在嵌入式领域应用它们的正确姿势。

一、设计模式概述#

1.1 什么是设计模式#

mindmap root((设计模式)) 定义经验的总结问题的通用解决方案可复用的最佳实践目的提高代码复用提高可维护性提高可扩展性降低耦合度分类创建型结构型行为型

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类编目的代码设计经验总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

1.2 设计模式分类#

graph TB A[设计模式] --> B[创建型<br/>5种] A --> C[结构型<br/>7种] A --> D[行为型<br/>11种] B --> B1[单例模式] B --> B2[工厂方法] B --> B3[抽象工厂] B --> B4[建造者模式] B --> B5[原型模式] C --> C1[适配器模式] C --> C2[桥接模式] C --> C3[组合模式] C --> C4[装饰器模式] C --> C5[外观模式] C --> C6[享元模式] C --> C7[代理模式] D --> D1[责任链模式] D --> D2[命令模式] D --> D3[迭代器模式] D --> D4[中介者模式] D --> D5[备忘录模式] D --> D6[观察者模式] D --> D7[状态模式] D --> D8[策略模式] D --> D9[模板方法] D --> D10[访问者模式] D --> D11[解释器模式]

二、创建型模式#

创建型模式主要关注对象的创建过程，帮助我们更优雅地创建对象。

2.1 单例模式 (Singleton)#

核心思想#

确保一个类只有一个实例，并提供一个全局访问点。

graph LR A[客户端] --> B[单例类] B --> C[唯一实例] B --> D[静态获取方法] style C fill:#e8f5e9 style D fill:#e3f2fd

嵌入式应用场景#

硬件抽象层 (HAL) 管理
系统配置管理器
串口/USB 等外设的唯一访问点

代码示例#

1
// 单例模式 - 线程安全 (适用于 RTOS)
2
#include <stdint.h>
3
#include <stdbool.h>
4

5
typedef struct {
6
    uint32_t baudrate;
7
    uint8_t parity;
8
    uint8_t stop_bits;
9
    // 其他串口配置...
10
} UART_Config;
11

12
typedef struct {
13
    UART_Config config;
14
    bool initialized;
15
    // 私有数据
16
} UART_Manager;
17

18
static UART_Manager* instance = NULL;
19
static uint8_t mutex_locked = 0;
20

21
// 双检查锁定 (Double-Checked Locking)
22
UART_Manager* UART_Manager_GetInstance(void) {
23
    if (instance == NULL) {
24
        // 第一次检查
25
        if (mutex_locked == 0) {
26
            mutex_locked = 1;
27
            // 临界区
28
            if (instance == NULL) {
29
                // 第二次检查
30
                static UART_Manager uart = {0};
31
                instance = &uart;
32
            }
33
            mutex_locked = 0;
34
        }
35
    }
36
    return instance;
37
}
38

39
// 简单版本 (裸机环境)
40
#define UART_MANAGER_GET() \
41
    do { \
42
        static UART_Manager *inst = NULL; \
43
        if (inst == NULL) { \
44
            static UART_Manager uart = {.initialized = false}; \
45
            inst = &uart; \
46
        } \
47
        return inst; \
48
    } while(0)

1
// 实际应用：系统配置管理器
2
typedef struct {
3
    System_Config data;
4
    bool dirty;
5
} Config_Manager;
6

7
static Config_Manager *Config_Get(void) {
8
    static Config_Manager mgr = {
9
        .data = {
10
            .clock_freq = 72000000,
11
            .tick_rate = 1000,
12
            .power_mode = POWER_NORMAL,
13
        },
14
        .dirty = false,
15
    };
16
    return &mgr;
17
}
18

19
void Config_SetClock(uint32_t freq) {
20
    Config_Manager *cfg = Config_Get();
21
    cfg->data.clock_freq = freq;
22
    cfg->dirty = true;
23
}

2.2 工厂方法模式 (Factory Method)#

核心思想#

定义一个创建对象的接口，但让子类决定实例化哪个类。

flowchart TD A[抽象创建者] --> B[具体创建者A] A --> C[具体创建者B] B --> D[具体产品A] C --> E[具体产品B] style A fill:#fff3e0 style D fill:#e8f5e9 style E fill:#e8f5e9

嵌入式应用场景#

传感器驱动的统一管理
通信协议的不同实现
设备驱动的动态加载

代码示例#

1
// 传感器驱动工厂
2
#include <stdint.h>
3
#include <stdbool.h>
4

5
// 传感器抽象接口
6
typedef struct Sensor Sensor;
7

8
struct Sensor {
9
    const char *name;
10
    int (*init)(void);
11
    int (*read)(float *value);
12
    int (*deinit)(void);
13
};
14

15
// 抽象工厂接口
16
typedef struct {
17
    Sensor* (*create)(uint8_t id);
18
    void (*destroy)(Sensor *sensor);
19
} Sensor_Factory;
20

21
// 温度传感器
22
typedef struct {
23
    Sensor base;
24
    float calibration;
25
} Temp_Sensor;
26

27
static int temp_init(void) {
28
    // 初始化温度传感器
29
    return 0;
30
}
31

32
static int temp_read(float *value) {
33
    *value = 25.0f + (float)(rand() % 100) / 100.0f;
34
    return 0;
35
}
36

37
static Sensor temp_sensor = {
38
    .name = "Temperature",
39
    .init = temp_init,
40
    .read = temp_read,
41
};
42

43
// 湿度传感器
44
typedef struct {
45
    Sensor base;
46
    uint8_t mode;
47
} Humidity_Sensor;
48

49
static int humidity_read(float *value) {
50
    *value = 60.0f + (float)(rand() % 300) / 10.0f;
51
    return 0;
52
}
53

54
// 工厂实现
55
static Sensor* sensor_factory_create(uint8_t type) {
56
    switch(type) {
57
        case 0:  // 温度传感器
58
            return &temp_sensor;
59
        case 1:  // 湿度传感器
60
            // 返回湿度传感器实例
61
            break;
62
        default:
63
            return NULL;
64
    }
65
    return NULL;
66
}
67

68
static Sensor_Factory factory = {
69
    .create = sensor_factory_create,
70
    .destroy = NULL,
71
};
72

73
// 使用示例
74
void sensor_demo(void) {
75
    Sensor *temp = factory.create(0);
76
    if (temp) {
77
        temp->init();
78
        float value;
79
        temp->read(&value);
80
        printf("Temperature: %.2f\n", value);
81
    }
82
}

2.3 抽象工厂模式 (Abstract Factory)#

核心思想#

提供一个创建一系列相关对象的接口，而无需指定它们具体的类。

classDiagram class AbstractFactory { <<interface>> +createSensor() Sensor +createActuator() Actuator } class ConcreteFactory1 { +createSensor() Sensor +createActuator() Actuator } class ConcreteFactory2 { +createSensor() Sensor +createActuator() Actuator } AbstractFactory <|-- ConcreteFactory1 AbstractFactory <|-- ConcreteFactory2

嵌入式应用场景#

不同平台 (STM32/ESP32) 的统一抽象
不同产品线的硬件抽象

1
// 抽象工厂 - 跨平台硬件抽象
2
typedef struct {
3
    void (*gpio_init)(uint8_t pin, uint8_t mode);
4
    void (*gpio_write)(uint8_t pin, uint8_t value);
5
    int (*gpio_read)(uint8_t pin);
6
    void (*delay_ms)(uint32_t ms);
7
    int (*uart_send)(uint8_t ch);
8
    int (*uart_recv)(uint8_t *ch);
9
} HAL_Interface;
10

11
static HAL_Interface *hal = NULL;
12

13
void HAL_SetImplementation(HAL_Interface *impl) {
14
    hal = impl;
15
}
16

17
// STM32 实现
18
static HAL_Interface stm32_hal = {
19
    .gpio_init = stm32_gpio_init,
20
    .gpio_write = stm32_gpio_write,
21
    .gpio_read = stm32_gpio_read,
22
    .delay_ms = HAL_Delay,
23
    .uart_send = UART_Send,
24
    .uart_recv = UART_Recv,
25
};
26

27
// ESP32 实现
28
static HAL_Interface esp32_hal = {
29
    .gpio_init = esp32_gpio_init,
30
    .gpio_write = esp32_gpio_write,
31
    .gpio_read = esp32_gpio_read,
32
    .delay_ms = vTaskDelay,
33
    .uart_send = uart_write_bytes,
34
    .uart_recv = uart_read_bytes,
35
};
36

37
// 平台选择
38
void Platform_Init(bool is_stm32) {
39
    HAL_SetImplementation(is_stm32 ? &stm32_hal : &esp32_hal);
40
}

2.4 建造者模式 (Builder)#

核心思想#

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

嵌入式应用场景#

复杂配置的构建
通信协议的组装
数据帧的构造

1
// 建造者模式 - CAN 报文构建
2
typedef struct {
3
    uint32_t id;
4
    uint8_t dlc;
5
    uint8_t data[8];
6
    bool ext_id;
7
    bool rtr;
8
} CAN_Message;
9

10
typedef struct {
11
    CAN_Message *msg;
12
} CAN_MessageBuilder;
13

14
CAN_MessageBuilder CAN_Builder_Init(void) {
15
    static CAN_Message msg = {0};
16
    CAN_MessageBuilder builder = { .msg = &msg };
17
    return builder;
18
}
19

20
CAN_MessageBuilder CAN_Builder_Id(CAN_MessageBuilder self, uint32_t id) {
21
    self.msg->id = id;
22
    return self;
23
}
24

25
CAN_MessageBuilder CAN_Builder_Data(CAN_MessageBuilder self,
26
                                     uint8_t *data, uint8_t len) {
27
    for (uint8_t i = 0; i < len && i < 8; i++) {
28
        self.msg->data[i] = data[i];
29
    }
30
    self.msg->dlc = len;
31
    return self;
32
}
33

34
CAN_MessageBuilder CAN_Builder_ExtId(CAN_MessageBuilder self) {
35
    self.msg->ext_id = true;
36
    return self;
37
}
38

39
CAN_Message CAN_Builder_Build(CAN_MessageBuilder self) {
40
    return *self.msg;
41
}
42

43
// 使用示例
44
void can_send_example(void) {
45
    CAN_Message msg = CAN_Builder_Init()
46
        .Id(0x123)
47
        .ExtId()
48
        .Data((uint8_t[]){0x01, 0x02, 0x03}, 3)
49
        .Build();
50

51
    CAN_Send(&msg);
52
}

2.5 原型模式 (Prototype)#

核心思想#

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

嵌入式应用场景#

配置模板的复制
协议数据包的批量生成

1
// 原型模式 - 配置模板
2
typedef struct {
3
    char name[32];
4
    uint32_t period;
5
    uint8_t priority;
6
    void (*callback)(void*);
7
} Task_Config;
8

9
typedef struct Task_Config {
10
    struct Task_Config *next;
11
    Task_Config proto;
12
} Task_Prototype;
13

14
static Task_Config sensor_task_proto = {
15
    .name = "Sensor",
16
    .period = 100,
17
    .priority = 5,
18
    .callback = NULL,
19
};
20

21
static Task_Config comm_task_proto = {
22
    .name = "Comm",
23
    .period = 50,
24
    .priority = 3,
25
    .callback = NULL,
26
};
27

28
Task_Config* Task_Clone(Task_Config *proto) {
29
    Task_Config *new_task = malloc(sizeof(Task_Config));
30
    if (new_task) {
31
        memcpy(new_task, proto, sizeof(Task_Config));
32
    }
33
    return new_task;
34
}
35

36
// 使用
37
Task_Config *task1 = Task_Clone(&sensor_task_proto);
38
strcpy(task1->name, "TempSensor");
39
task1->period = 200;

三、结构型模式#

结构型模式关注如何组合类和对象以获得更大的结构。

3.1 适配器模式 (Adapter)#

核心思想#

将一个类的接口转换成客户希望的另外一个接口。

flowchart LR A[客户端] --> B[适配器] B --> C[被适配者] style B fill:#fff3e0 style C fill:#e3f2fd

嵌入式应用场景#

不同传感器的统一接口
旧驱动在新系统上的适配
第三方库的整合

1
// 适配器模式 - 统一传感器接口
2
#include <stdint.h>
3

4
// 目标接口 (嵌入式通用传感器接口)
5
typedef struct {
6
    int (*read_raw)(void *buffer, uint16_t size);
7
    int (*read_float)(float *value);
8
    int (*init)(void);
9
    int (*deinit)(void);
10
} Sensor_Interface;
11

12
// 旧版温度传感器驱动 (遗留代码)
13
typedef struct {
14
    uint16_t raw_value;
15
    float temperature;
16
} Legacy_TempSensor;
17

18
int legacy_temp_read(uint16_t *raw) {
19
    // 旧驱动实现
20
    *raw = 2500;
21
    return 0;
22
}
23

24
float legacy_temp_convert(uint16_t raw) {
25
    return (float)raw / 100.0f - 273.15f;
26
}
27

28
// 适配器 - 将旧驱动适配到新接口
29
static int adapter_read_raw(void *buffer, uint16_t size) {
30
    if (size < sizeof(uint16_t)) return -1;
31
    Legacy_TempSensor *sensor = (Legacy_TempSensor*)buffer;
32
    return legacy_temp_read(&sensor->raw_value);
33
}
34

35
static int adapter_read_float(float *value) {
36
    uint16_t raw;
37
    legacy_temp_read(&raw);
38
    *value = legacy_temp_convert(raw);
39
    return 0;
40
}
41

42
static int adapter_init(void) {
43
    // 初始化旧驱动
44
    return 0;
45
}
46

47
static int adapter_deinit(void) {
48
    return 0;
49
}
50

51
static Sensor_Interface temp_sensor_adapter = {
52
    .read_raw = adapter_read_raw,
53
    .read_float = adapter_read_float,
54
    .init = adapter_init,
55
    .deinit = adapter_deinit,
56
};

3.2 桥接模式 (Bridge)#

核心思想#

将抽象部分与实现部分分离，使它们可以独立变化。

graph TB A[抽象] --> B[实现接口] A --> C[具体抽象] B --> D[具体实现A] B --> E[具体实现B] style A fill:#f3e5f5 style B fill:#e1f5fe

嵌入式应用场景#

平台无关的驱动架构
通信协议与传输层分离

1
// 桥接模式 - 通信协议抽象
2
#include <stdint.h>
3

4
// 实现接口 (传输层)
5
typedef struct Transport_ops {
6
    int (*open)(void *ctx);
7
    int (*send)(void *ctx, const uint8_t *data, uint16_t len);
8
    int (*recv)(void *ctx, uint8_t *data, uint16_t len);
9
    int (*close)(void *ctx);
10
} Transport_ops;
11

12
// 抽象协议层
13
typedef struct {
14
    Transport_ops *transport;
15
    void *transport_ctx;
16
} Protocol;
17

18
// UART 传输实现
19
typedef struct {
20
    uint8_t uart_id;
21
} UART_Context;
22

23
static int uart_open(void *ctx) { return 0; }
24
static int uart_send(void *ctx, const uint8_t *data, uint16_t len) {
25
    UART_Context *c = (UART_Context*)ctx;
26
    // 发送数据...
27
    return len;
28
}
29
static int uart_recv(void *ctx, uint8_t *data, uint16_t len) {
30
    return 0;
31
}
32
static int uart_close(void *ctx) { return 0; }
33

34
static Transport_ops uart_transport = {
35
    .open = uart_open,
36
    .send = uart_send,
37
    .recv = uart_recv,
38
    .close = uart_close,
39
};
40

41
// SPI 传输实现
42
static Transport_ops spi_transport = {
43
    .open = spi_open,
44
    .send = spi_send,
45
    .recv = spi_recv,
46
    .close = spi_close,
47
};
48

49
// 协议使用
50
void Protocol_Init(Protocol *proto, Transport_ops *trans) {
51
    proto->transport = trans;
52
}
53

54
void Protocol_Send(Protocol *proto, uint8_t *data, uint16_t len) {
55
    proto->transport->send(proto->transport_ctx, data, len);
56
}

3.3 组合模式 (Composite)#

核心思想#

将对象组合成树形结构以表示”部分-整体”的层次结构。

graph TD A[组件] --> B[叶子] A --> C[容器] C --> D[叶子1] C --> E[叶子2] C --> F[容器2] F --> G[叶子3]

嵌入式应用场景#

设备树的表示
菜单系统
文件系统

1
// 组合模式 - 设备管理
2
#include <stdint.h>
3
#include <stdbool.h>
4

5
typedef struct Device Device;
6

7
typedef struct {
8
    int (*init)(Device *dev);
9
    int (*start)(Device *dev);
10
    int (*stop)(Device *dev);
11
    int (*ioctl)(Device *dev, uint32_t cmd, void *arg);
12
} Device_Ops;
13

14
struct Device {
15
    const char *name;
16
    Device_Ops *ops;
17
    Device *parent;
18
    Device *children;
19
    Device *next;
20
    bool enabled;
21
};
22

23
int Device_Init(Device *dev) {
24
    if (dev && dev->ops && dev->ops->init) {
25
        return dev->ops->init(dev);
26
    }
27
    return -1;
28
}
29

30
int Device_Start(Device *dev) {
31
    int ret = 0;
32
    if (dev && dev->ops && dev->ops->start) {
33
        ret = dev->ops->start(dev);
34
    }
35
    // 启动所有子设备
36
    for (Device *child = dev->children; child != NULL; child = child->next) {
37
        ret |= Device_Start(child);
38
    }
39
    dev->enabled = true;
40
    return ret;
41
}
42

43
int Device_Stop(Device *dev) {
44
    int ret = 0;
45
    // 停止所有子设备
46
    for (Device *child = dev->children; child != NULL; child = child->next) {
47
        ret |= Device_Stop(child);
48
    }
49
    if (dev && dev->ops && dev->ops->stop) {
50
        ret |= dev->ops->stop(dev);
51
    }
52
    dev->enabled = false;
53
    return ret;
54
}
55

56
// 添加子设备
57
void Device_AddChild(Device *parent, Device *child) {
58
    child->parent = parent;
59
    child->next = parent->children;
60
    parent->children = child;
61
}

3.4 装饰器模式 (Decorator)#

核心思想#

动态地给一个对象添加一些额外的职责。

graph LR A[组件] --> B[具体组件] A --> C[装饰器] C --> D[具体装饰器A] C --> E[具体装饰器B] style A fill:#fce4ec style C fill:#fff9c4

嵌入式应用场景#

传感器数据的预处理
通信数据的加密/压缩
日志记录增强

1
// 装饰器模式 - 数据处理流水线
2
#include <stdint.h>
3
#include <string.h>
4

5
typedef struct DataProcessor DataProcessor;
6

7
typedef int (*ProcessFunc)(DataProcessor *proc, uint8_t *data, uint16_t len);
8

9
struct DataProcessor {
10
    ProcessFunc process;
11
    DataProcessor *next;  // 链式装饰
12
    void *context;
13
};
14

15
// 基础处理器
16
int base_process(DataProcessor *proc, uint8_t *data, uint16_t len) {
17
    return len;
18
}
19

20
// 装饰器 - 校验和
21
typedef struct {
22
    DataProcessor base;
23
} Checksum_Decorator;
24

25
int checksum_process(DataProcessor *proc, uint8_t *data, uint16_t len) {
26
    uint8_t sum = 0;
27
    for (uint16_t i = 0; i < len; i++) {
28
        sum += data[i];
29
    }
30
    data[len] = sum;
31
    // 调用下一个处理器
32
    if (proc->next) {
33
        return proc->next->process(proc->next, data, len + 1);
34
    }
35
    return len + 1;
36
}
37

38
// 装饰器 - 加密
39
typedef struct {
40
    DataProcessor base;
41
    uint8_t key[16];
42
} Encrypt_Decorator;
43

44
int encrypt_process(DataProcessor *proc, uint8_t *data, uint16_t len) {
45
    Encrypt_Decorator *enc = (Encrypt_Decorator*)proc;
46
    // XOR 加密
47
    for (uint16_t i = 0; i < len; i++) {
48
        data[i] ^= enc->key[i % 16];
49
    }
50
    if (proc->next) {
51
        return proc->next->process(proc->next, data, len);
52
    }
53
    return len;
54
}
55

56
// 使用示例
57
void data_pipeline_demo(void) {
58
    // 创建处理器链
59
    static Checksum_Decorator cs = {0};
60
    cs.base.process = checksum_process;
61

62
    static Encrypt_Decorator enc = {0};
63
    enc.base.process = encrypt_process;
64
    memset(enc.key, 0x5A, 16);
65

66
    // 链式连接: 加密 -> 校验和 -> 基础
67
    enc.base.next = &cs.base;
68
    cs.base.next = NULL;
69

70
    uint8_t data[] = "Hello Embedded";
71
    int len = sizeof(data) - 1;
72

73
    // 处理数据
74
    len = enc.base.process(&enc.base, data, len);
75
}

3.5 外观模式 (Facade)#

核心思想#

为复杂的子系统提供一个统一的接口。

graph TD A[客户端] --> F[外观] F --> S1[子系统1] F --> S2[子系统2] F --> S3[子系统3] style F fill:#e8f5e9

嵌入式应用场景#

硬件抽象层 (HAL)
统一 API 接口
初始化系统

1
// 外观模式 - 统一的硬件初始化接口
2
#include <stdint.h>
3

4
typedef struct {
5
    int (*gpio_init)(void);
6
    int (*uart_init)(void);
7
    int (*spi_init)(void);
8
    int (*i2c_init)(void);
9
    int (*adc_init)(void);
10
    int (*timer_init)(void);
11
} HAL_Facade;
12

13
static int GPIO_Init(void) { /* 实现 */ return 0; }
14
static int UART_Init(void) { /* 实现 */ return 0; }
15
static int SPI_Init(void) { /* 实现 */ return 0; }
16
static int I2C_Init(void) { /* 实现 */ return 0; }
17
static int ADC_Init(void) { /* 实现 */ return 0; }
18
static int Timer_Init(void) { /* 实现 */ return 0; }
19

20
static HAL_Facade hal = {
21
    .gpio_init = GPIO_Init,
22
    .uart_init = UART_Init,
23
    .spi_init = SPI_Init,
24
    .i2c_init = I2C_Init,
25
    .adc_init = ADC_Init,
26
    .timer_init = Timer_Init,
27
};
28

29
// 统一初始化
30
int System_InitAll(void) {
31
    int ret = 0;
32
    ret |= hal.gpio_init();
33
    ret |= hal.uart_init();
34
    ret |= hal.spi_init();
35
    ret |= hal.i2c_init();
36
    ret |= hal.adc_init();
37
    ret |= hal.timer_init();
38
    return ret;
39
}

3.6 享元模式 (Flyweight)#

核心思想#

运用共享技术有效地支持大量细粒度对象。

嵌入式应用场景#

状态机的高效实现
大量相似对象
固件资源受限环境

1
// 享元模式 - 事件处理
2
#include <stdint.h>
3
#include <stdbool.h>
4

5
typedef struct EventType EventType;
6
typedef struct Event Event;
7

8
// 享元 - 事件类型 (共享)
9
struct EventType {
10
    uint8_t id;
11
    const char *name;
12
    void (*handler)(Event *event);
13
    EventType *next;
14
};
15

16
// 具体享元对象
17
struct Event {
18
    EventType *type;
19
    uint32_t timestamp;
20
    void *data;
21
    uint16_t data_len;
22
};
23

24
// 享元工厂
25
static EventType event_types[16];
26
static uint8_t event_type_count = 0;
27

28
EventType* EventType_Register(uint8_t id, const char *name,
29
                               void (*handler)(Event*)) {
30
    // 查找是否已存在
31
    for (uint8_t i = 0; i < event_type_count; i++) {
32
        if (event_types[i].id == id) {
33
            return &event_types[i];
34
        }
35
    }
36
    // 创建新的享元
37
    if (event_type_count < 16) {
38
        EventType *et = &event_types[event_type_count++];
39
        et->id = id;
40
        et->name = name;
41
        et->handler = handler;
42
        return et;
43
    }
44
    return NULL;
45
}
46

47
// 使用享元创建事件
48
Event* Event_Create(uint8_t type_id, void *data, uint16_t len) {
49
    static Event pool[32];  // 事件对象池
50
    static uint8_t pool_idx = 0;
51

52
    Event *event = &pool[pool_idx++ % 32];
53
    event->type = EventType_Register(type_id, NULL, NULL);
54
    event->data = data;
55
    event->data_len = len;
56
    event->timestamp = HAL_GetTick();
57
    return event;
58
}

3.7 代理模式 (Proxy)#

核心思想#

为其他对象提供一种代理以控制对这个对象的访问。

flowchart LR C[客户端] --> P[代理] P --> R[真实对象] style P fill:#e1f5fe style R fill:#fce4ec

嵌入式应用场景#

硬件访问控制
资源懒加载
访问权限控制

1
// 代理模式 - 硬件资源访问控制
2
#include <stdint.h>
3
#include <stdbool.h>
4

5
typedef struct HW_Device HW_Device;
6
typedef struct HW_Proxy HW_Proxy;
7

8
typedef int (*ReadFunc)(HW_Device *dev, uint8_t *buf, uint16_t len);
9
typedef int (*WriteFunc)(HW_Device *dev, const uint8_t *buf, uint16_t len);
10

11
struct HW_Device {
12
    ReadFunc read;
13
    WriteFunc write;
14
    void *base_addr;
15
    bool initialized;
16
};
17

18
struct HW_Proxy {
19
    HW_Device *real_device;
20
    bool access_granted;
21
    uint32_t access_count;
22
};
23

24
// 权限检查代理
25
int proxy_read(HW_Device *dev, uint8_t *buf, uint16_t len) {
26
    HW_Proxy *proxy = (HW_Proxy*)dev;
27
    if (!proxy->access_granted) {
28
        return -1;  // 无权限
29
    }
30
    proxy->access_count++;
31
    return proxy->real_device->read(proxy->real_device, buf, len);
32
}
33

34
int proxy_write(HW_Device *dev, const uint8_t *buf, uint16_t len) {
35
    HW_Proxy *proxy = (HW_Proxy*)dev;
36
    if (!proxy->access_granted) {
37
        return -1;
38
    }
39
    return proxy->real_device->write(proxy->real_device, buf, len);
40
}
41

42
void HW_Proxy_Init(HW_Proxy *proxy, HW_Device *real) {
43
    proxy->real_device = real;
44
    proxy->access_granted = false;
45
    proxy->access_count = 0;
46
}

四、行为型模式#

行为型模式关注对象之间的通信和职责分配。

4.1 观察者模式 (Observer)#

核心思想#

定义对象间的一对多依赖关系，当一个对象改变状态时，所有依赖它的对象都会得到通知。

嵌入式应用场景#

事件驱动系统
传感器数据更新通知
UI 更新机制

1
// 观察者模式 - 传感器数据发布/订阅
2
#include <stdint.h>
3
#include <stdbool.h>
4
#include <stdlib.h>
5

6
#define MAX_OBSERVERS 8
7

8
typedef struct Observer Observer;
9
typedef struct Subject Subject;
10

11
struct Observer {
12
    void (*update)(void *data);
13
    const char *name;
14
};
15

16
struct Subject {
17
    Observer *observers[MAX_OBSERVERS];
18
    uint8_t observer_count;
19
    void *data;
20
};
21

22
void Subject_Init(Subject *subject) {
23
    subject->observer_count = 0;
24
    subject->data = NULL;
25
}
26

27
bool Subject_Attach(Subject *subject, Observer *observer) {
28
    if (subject->observer_count >= MAX_OBSERVERS) {
29
        return false;
30
    }
31
    subject->observers[subject->observer_count++] = observer;
32
    return true;
33
}
34

35
bool Subject_Detach(Subject *subject, Observer *observer) {
36
    for (uint8_t i = 0; i < subject->observer_count; i++) {
37
        if (subject->observers[i] == observer) {
38
            for (uint8_t j = i; j < subject->observer_count - 1; j++) {
39
                subject->observers[j] = subject->observers[j + 1];
40
            }
41
            subject->observer_count--;
42
            return true;
43
        }
44
    }
45
    return false;
46
}
47

48
void Subject_Notify(Subject *subject) {
49
    for (uint8_t i = 0; i < subject->observer_count; i++) {
50
        subject->observers[i]->update(subject->data);
51
    }
52
}
53

54
// 使用示例 - 温度传感器监控
55
static Subject temp_subject;
56

57
void display_update(void *data) {
58
    float temp = *(float*)data;
59
    printf("Display: %.1f°C\n", temp);
60
}
61

62
void alarm_update(void *data) {
63
    float temp = *(float*)data;
64
    if (temp > 30.0f) {
65
        printf("ALARM: High temperature!\n");
66
    }
67
}
68

69
void log_update(void *data) {
70
    printf("Log: Temperature updated\n");
71
}
72

73
void sensor_demo(void) {
74
    Subject_Init(&temp_subject);
75

76
    static Observer observers[3] = {
77
        {.update = display_update, .name = "Display"},
78
        {.update = alarm_update, .name = "Alarm"},
79
        {.update = log_update, .name = "Log"},
80
    };
81

82
    Subject_Attach(&temp_subject, &observers[0]);
83
    Subject_Attach(&temp_subject, &observers[1]);
84
    Subject_Attach(&temp_subject, &observers[2]);
85

86
    // 温度变化，通知所有观察者
87
    float temp = 25.5f;
88
    temp_subject.data = &temp;
89
    Subject_Notify(&temp_subject);
90
}

4.2 状态模式 (State)#

核心思想#

允许对象在内部状态改变时改变它的行为。

stateDiagram-v2 [*] --> IDLE IDLE --> RUNNING: start RUNNING --> PAUSED: pause PAUSED --> RUNNING: resume RUNNING --> STOPPED: stop STOPPED --> IDLE: reset PAUSED --> STOPPED: stop

嵌入式应用场景#

状态机实现
协议状态管理
设备运行状态控制

1
// 状态模式 - 状态机
2
#include <stdint.h>
3
#include <stdbool.h>
4

5
typedef struct State State;
6
typedef struct StateMachine StateMachine;
7

8
struct State {
9
    const char *name;
10
    int (*enter)(StateMachine *sm);
11
    int (*exit)(StateMachine *sm);
12
    int (*handle)(StateMachine *sm, uint32_t event);
13
};
14

15
struct StateMachine {
16
    State *current_state;
17
    State *states;
18
    uint8_t state_count;
19
    void *context;
20
};
21

22
int StateMachine_Transition(StateMachine *sm, uint8_t new_state) {
23
    if (new_state >= sm->state_count) {
24
        return -1;
25
    }
26
    if (sm->current_state && sm->current_state->exit) {
27
        sm->current_state->exit(sm);
28
    }
29
    sm->current_state = &sm->states[new_state];
30
    if (sm->current_state->enter) {
31
        sm->current_state->enter(sm);
32
    }
33
    return 0;
34
}
35

36
int StateMachine_Handle(StateMachine *sm, uint32_t event) {
37
    if (sm->current_state && sm->current_state->handle) {
38
        return sm->current_state->handle(sm, event);
39
    }
40
    return -1;
41
}
42

43
// LED 状态机示例
44
typedef enum {
45
    LED_OFF,
46
    LED_ON,
47
    LED_BLINK,
48
    LED_STATE_COUNT
49
} LED_State;
50

51
static int led_on_enter(StateMachine *sm) {
52
    HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_SET);
53
    return 0;
54
}
55

56
static int led_off_enter(StateMachine *sm) {
57
    HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_RESET);
58
    return 0;
59
}
60

61
static int led_handle(StateMachine *sm, uint32_t event) {
62
    switch (event) {
63
        case 0:  // 开启
64
            StateMachine_Transition(sm, LED_ON);
65
            break;
66
        case 1:  // 关闭
67
            StateMachine_Transition(sm, LED_OFF);
68
            break;
69
        case 2:  // 切换
70
            if (sm->current_state->enter == led_on_enter) {
71
                StateMachine_Transition(sm, LED_OFF);
72
            } else {
73
                StateMachine_Transition(sm, LED_ON);
74
            }
75
            break;
76
    }
77
    return 0;
78
}
79

80
static State led_states[LED_STATE_COUNT] = {
81
    [LED_OFF] = {.name = "OFF", .enter = led_off_enter, .handle = led_handle},
82
    [LED_ON]  = {.name = "ON",  .enter = led_on_enter, .handle = led_handle},
83
};

4.3 策略模式 (Strategy)#

核心思想#

定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。

graph TD C[Context] --> S[Strategy] S --> S1[策略A] S --> S2[策略B] S --> S3[策略C] style C fill:#e1f5fe style S fill:#fff3e0

嵌入式应用场景#

不同算法切换
通信协议选择
数据压缩方式选择

1
// 策略模式 - 通信协议选择
2
#include <stdint.h>
3

4
typedef struct ProtocolStrategy ProtocolStrategy;
5

6
typedef int (*EncodeFunc)(const uint8_t *in, uint16_t in_len,
7
                          uint8_t *out, uint16_t *out_len);
8
typedef int (*DecodeFunc)(const uint8_t *in, uint16_t in_len,
9
                          uint8_t *out, uint16_t *out_len);
10

11
struct ProtocolStrategy {
12
    const char *name;
13
    EncodeFunc encode;
14
    DecodeFunc decode;
15
};
16

17
// JSON 策略
18
static int json_encode(const uint8_t *in, uint16_t in_len,
19
                       uint8_t *out, uint16_t *out_len) {
20
    // JSON 编码实现
21
    return 0;
22
}
23

24
// 二进制协议策略
25
static int binary_encode(const uint8_t *in, uint16_t in_len,
26
                        uint8_t *out, uint16_t *out_len) {
27
    // 二进制编码实现
28
    return 0;
29
}
30

31
// Protobuf 风格策略
32
static int protobuf_encode(const uint8_t *in, uint16_t in_len,
33
                          uint8_t *out, uint16_t *out_len) {
34
    // Protobuf 编码实现
35
    return 0;
36
}
37

38
static ProtocolStrategy strategies[] = {
39
    {.name = "JSON", .encode = json_encode},
40
    {.name = "Binary", .encode = binary_encode},
41
    {.name = "Protobuf", .encode = protobuf_encode},
42
};
43

44
// 使用
45
typedef struct {
46
    ProtocolStrategy *strategy;
47
    uint8_t strategy_id;
48
} Comm_Context;
49

50
void Comm_SetProtocol(Comm_Context *ctx, uint8_t id) {
51
    if (id < 3) {
52
        ctx->strategy = &strategies[id];
53
        ctx->strategy_id = id;
54
    }
55
}
56

57
int Comm_Send(Comm_Context *ctx, const uint8_t *data, uint16_t len) {
58
    uint8_t buffer[256];
59
    uint16_t out_len;
60
    return ctx->strategy->encode(data, len, buffer, &out_len);
61
}

4.4 命令模式 (Command)#

核心思想#

将请求封装成对象，从而允许你参数化不同请求。

graph TD I[Invoker] --> C[Command] C --> R[Receiver] C --> C1[ConcreteCommand] style I fill:#e8f5e9 style C fill:#fff3e0 style C1 fill:#fce4ec

嵌入式应用场景#

命令队列
撤销/重做功能
任务调度

1
// 命令模式 - 命令队列与执行
2
#include <stdint.h>
3
#include <stdbool.h>
4

5
typedef struct Command Command;
6

7
typedef int (*ExecuteFunc)(Command *cmd);
8
typedef int (*UndoFunc)(Command *cmd);
9

10
struct Command {
11
    ExecuteFunc execute;
12
    UndoFunc undo;
13
    void *data;
14
    const char *name;
15
};
16

17
typedef struct {
18
    Command *queue[32];
19
    uint8_t head;
20
    uint8_t tail;
21
    uint8_t count;
22
} CommandQueue;
23

24
int CommandQueue_Init(CommandQueue *q) {
25
    q->head = 0;
26
    q->tail = 0;
27
    q->count = 0;
28
    return 0;
29
}
30

31
bool CommandQueue_IsEmpty(CommandQueue *q) {
32
    return q->count == 0;
33
}
34

35
bool CommandQueue_IsFull(CommandQueue *q) {
36
    return q->count >= 32;
37
}
38

39
int CommandQueue_Push(CommandQueue *q, Command *cmd) {
40
    if (CommandQueue_IsFull(q)) {
41
        return -1;
42
    }
43
    q->queue[q->tail] = cmd;
44
    q->tail = (q->tail + 1) % 32;
45
    q->count++;
46
    return 0;
47
}
48

49
Command* CommandQueue_Pop(CommandQueue *q) {
50
    if (CommandQueue_IsEmpty(q)) {
51
        return NULL;
52
    }
53
    Command *cmd = q->queue[q->head];
54
    q->head = (q->head + 1) % 32;
55
    q->count--;
56
    return cmd;
57
}
58

59
// 具体命令 - LED 控制
60
typedef struct {
61
    Command base;
62
    uint8_t pin;
63
    uint8_t action;  // 0: off, 1: on, 2: toggle
64
} LED_Command;
65

66
static int led_execute(Command *cmd) {
67
    LED_Command *led = (LED_Command*)cmd;
68
    switch (led->action) {
69
        case 0: HAL_GPIO_WritePin(GPIOA, led->pin, 0); break;
70
        case 1: HAL_GPIO_WritePin(GPIOA, led->pin, 1); break;
71
        case 2: HAL_GPIO_TogglePin(GPIOA, led->pin); break;
72
    }
73
    return 0;
74
}
75

76
static int led_undo(Command *cmd) {
77
    LED_Command *led = (LED_Command*)cmd;
78
    led->action = (led->action == 1) ? 0 : 1;
79
    return led_execute(cmd);
80
}
81

82
LED_Command led_on_cmd = {
83
    .base = {.execute = led_execute, .undo = led_undo},
84
    .pin = LED_PIN,
85
    .action = 1,
86
};
87

88
// 使用示例
89
void command_demo(void) {
90
    CommandQueue queue;
91
    CommandQueue_Init(&queue);
92

93
    CommandQueue_Push(&queue, (Command*)&led_on_cmd);
94
    // ... 添加更多命令
95

96
    while (!CommandQueue_IsEmpty(&queue)) {
97
        Command *cmd = CommandQueue_Pop(&queue);
98
        cmd->execute(cmd);
99
    }
100
}

4.5 模板方法模式 (Template Method)#

核心思想#

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

flowchart TD A[模板方法] --> B[步骤1] A --> C[步骤2] A --> D[步骤3] B --> E[具体实现1] C --> F[具体实现2] D --> G[具体实现3] style A fill:#e1f5fe

嵌入式应用场景#

驱动框架
初始化流程
协议处理

1
// 模板方法 - 驱动初始化框架
2
#include <stdint.h>
3

4
typedef struct Driver Driver;
5

6
typedef int (*InitFunc)(Driver *drv);
7
typedef int (*ReadFunc)(Driver *drv, void *buf, uint16_t len);
8
typedef int (*WriteFunc)(Driver *drv, const void *buf, uint16_t len);
9
typedef int (*DeinitFunc)(Driver *drv);
10

11
struct Driver {
12
    InitFunc init;
13
    ReadFunc read;
14
    WriteFunc write;
15
    DeinitFunc deinit;
16
    void *context;
17
    bool initialized;
18
};
19

20
// 模板方法 - 标准驱动生命周期
21
int Driver_StandardLifecycle(Driver *drv) {
22
    int ret;
23

24
    // 步骤1: 检查参数
25
    if (!drv || !drv->init || !drv->read || !drv->write) {
26
        return -1;
27
    }
28

29
    // 步骤2: 初始化 (子类实现)
30
    ret = drv->init(drv);
31
    if (ret != 0) {
32
        return ret;
33
    }
34
    drv->initialized = true;
35

36
    // 步骤3: 等待就绪
37
    // (可由子类重写的钩子)
38

39
    return 0;
40
}
41

42
// 模板方法 - 读写操作
43
int Driver_Read(Driver *drv, void *buf, uint16_t len) {
44
    if (!drv || !drv->initialized) {
45
        return -1;
46
    }
47
    return drv->read(drv, buf, len);
48
}
49

50
int Driver_Write(Driver *drv, const void *buf, uint16_t len) {
51
    if (!drv || !drv->initialized) {
52
        return -1;
53
    }
54
    return drv->write(drv, buf, len);
55
}
56

57
// 具体驱动 - UART 实现
58
static int uart_driver_init(Driver *drv) {
59
    // UART 特定初始化
60
    return 0;
61
}
62

63
static int uart_driver_read(Driver *drv, void *buf, uint16_t len) {
64
    // UART 读取实现
65
    return 0;
66
}
67

68
static Driver uart_driver = {
69
    .init = uart_driver_init,
70
    .read = uart_driver_read,
71
    .write = NULL,
72
    .deinit = NULL,
73
};

4.6 责任链模式 (Chain of Responsibility)#

核心思想#

将请求的发送者和接收者解耦，让多个对象都有机会处理请求。

嵌入式应用场景#

事件处理
权限检查
消息过滤

1
// 责任链模式 - 消息处理
2
#include <stdint.h>
3
#include <stdbool.h>
4

5
typedef struct Handler Handler;
6
typedef struct Message Message;
7

8
typedef int (*HandlerFunc)(Handler *handler, Message *msg);
9

10
struct Message {
11
    uint32_t type;
12
    uint32_t priority;
13
    void *payload;
14
    uint16_t payload_len;
15
    bool handled;
16
};
17

18
struct Handler {
19
    HandlerFunc handle;
20
    Handler *next;
21
    const char *name;
22
};
23

24
int Handler_Handle(Handler *handler, Message *msg) {
25
    if (!handler) {
26
        return -1;
27
    }
28

29
    int result = handler->handle(handler, msg);
30

31
    // 如果当前处理器无法处理，传递给下一个
32
    if (result != 0 && handler->next) {
33
        return Handler_Handle(handler->next, msg);
34
    }
35

36
    return result;
37
}
38

39
// 具体处理器 - 消息验证
40
static int validator_handle(Handler *h, Message *msg) {
41
    if (msg->payload_len == 0 || msg->payload == NULL) {
42
        printf("[Validator] Invalid message\n");
43
        return -1;
44
    }
45
    printf("[Validator] Message validated\n");
46
    return 0;  // 验证通过，继续传递
47
}
48

49
// 具体处理器 - 权限检查
50
static int auth_handle(Handler *h, Message *msg) {
51
    // 简化: 检查 priority
52
    if (msg->priority > 10) {
53
        printf("[Auth] Permission denied\n");
54
        return -1;
55
    }
56
    printf("[Auth] Authorized\n");
57
    return 0;
58
}
59

60
// 具体处理器 - 消息处理
61
static int processor_handle(Handler *h, Message *msg) {
62
    printf("[Processor] Processing message type: %lu\n", msg->type);
63
    msg->handled = true;
64
    return 0;
65
}
66

67
// 链式组装
68
static Handler validator = {.handle = validator_handle, .name = "Validator"};
69
static Handler auth = {.handle = auth_handle, .name = "Auth"};
70
static Handler processor = {.handle = processor_handle, .name = "Processor"};
71

72
void HandlerChain_Init(void) {
73
    validator.next = &auth;
74
    auth.next = &processor;
75
    processor.next = NULL;
76
}
77

78
// 使用
79
void message_demo(void) {
80
    HandlerChain_Init();
81

82
    Message msg = {
83
        .type = 1,
84
        .priority = 5,
85
        .payload = "Hello",
86
        .payload_len = 5,
87
        .handled = false,
88
    };
89

90
    Handler_Handle(&validator, &msg);
91
}

4.7 迭代器模式 (Iterator)#

核心思想#

提供一种方法顺序访问集合对象中的各个元素，而不需暴露该对象的内部表示。

嵌入式应用场景#

遍历传感器列表
遍历设备树
遍历数据缓冲

1
// 迭代器模式 - 设备遍历
2
#include <stdint.h>
3

4
typedef struct Device Device;
5
typedef struct Iterator Iterator;
6

7
typedef Device* (*NextFunc)(Iterator *it);
8
typedef bool (*HasNextFunc)(Iterator *it);
9
typedef void (*ResetFunc)(Iterator *it);
10

11
struct Iterator {
12
    NextFunc next;
13
    HasNextFunc hasNext;
14
    ResetFunc reset;
15
    void *context;
16
    uint8_t index;
17
};
18

19
struct Device {
20
    const char *name;
21
    uint8_t type;
22
    Device *next;
23
};
24

25
static Device *devices = NULL;
26

27
void Device_Add(Device *dev) {
28
    dev->next = devices;
29
    devices = dev;
30
}
31

32
// 迭代器实现
33
static Device* device_next(Iterator *it) {
34
    Device **list = (Device**)it->context;
35
    Device *dev = list[it->index++];
36
    return dev;
37
}
38

39
static bool device_has_next(Iterator *it) {
40
    Device **list = (Device**)it->context;
41
    return list[it->index] != NULL;
42
}
43

44
static void device_reset(Iterator *it) {
45
    it->index = 0;
46
}
47

48
void DeviceIterator_Init(Iterator *it) {
49
    static Device *device_list[16];
50

51
    // 收集设备到数组
52
    uint8_t count = 0;
53
    for (Device *d = devices; d && count < 16; d = d->next) {
54
        device_list[count++] = d;
55
    }
56
    device_list[count] = NULL;
57

58
    it->context = device_list;
59
    it->next = device_next;
60
    it->hasNext = device_has_next;
61
    it->reset = device_reset;
62
    it->index = 0;
63
}
64

65
// 使用
66
void iterator_demo(void) {
67
    static Device dev1 = {.name = "UART1", .type = 1};
68
    static Device dev2 = {.name = "SPI1", .type = 2};
69
    static Device dev3 = {.name = "I2C1", .type = 3};
70

71
    Device_Add(&dev1);
72
    Device_Add(&dev2);
73
    Device_Add(&dev3);
74

75
    Iterator it;
76
    DeviceIterator_Init(&it);
77

78
    while (it.hasNext(&it)) {
79
        Device *d = it.next(&it);
80
        printf("Device: %s\n", d->name);
81
    }
82
}

4.8 中介者模式 (Mediator)#

核心思想#

用一个中介对象来封装一系列的对象交互。

graph TD C1[组件1] --> M[中介者] C2[组件2] --> M C3[组件3] --> M M --> C1 M --> C2 M --> C3 style M fill:#e8f5e9

嵌入式应用场景#

GUI 事件处理
多模块协调
总线通信

1
// 中介者模式 - 多模块协调
2
#include <stdint.h>
3

4
typedef struct Mediator Mediator;
5
typedef struct Component Component;
6

7
typedef void (*NotifyFunc)(Component *comp, Mediator *med, uint32_t event);
8

9
struct Component {
10
    NotifyFunc on_notify;
11
    const char *name;
12
    Mediator *mediator;
13
};
14

15
struct Mediator {
16
    Component **components;
17
    uint8_t component_count;
18
};
19

20
void Mediator_Register(Mediator *med, Component *comp) {
21
    if (med->component_count < 16) {
22
        comp->mediator = med;
23
        med->components[med->component_count++] = comp;
24
    }
25
}
26

27
void Mediator_Notify(Mediator *med, Component *sender, uint32_t event) {
28
    // 广播给其他组件
29
    for (uint8_t i = 0; i < med->component_count; i++) {
30
        Component *comp = med->components[i];
31
        if (comp != sender && comp->on_notify) {
32
            comp->on_notify(comp, med, event);
33
        }
34
    }
35
}
36

37
// 具体组件
38
static Mediator system_mediator;
39

40
static void sensor_on_notify(Component *comp, Mediator *med, uint32_t event) {
41
    printf("[%s] Received event: %lu\n", comp->name, event);
42
}
43

44
static void display_on_notify(Component *comp, Mediator *med, uint32_t event) {
45
    printf("[%s] Received event: %lu\n", comp->name, event);
46
}
47

48
static Component sensor = {.name = "Sensor", .on_notify = sensor_on_notify};
49
static Component display = {.name = "Display", .on_notify = display_on_notify};
50
static Component button = {.name = "Button", .on_notify = NULL};
51

52
void mediator_demo(void) {
53
    Mediator_Register(&system_mediator, &sensor);
54
    Mediator_Register(&system_mediator, &display);
55
    Mediator_Register(&system_mediator, &button);
56

57
    // 按钮按下，通知传感器和显示器
58
    Mediator_Notify(&system_mediator, &button, 0x01);
59
}

4.9 备忘录模式 (Memento)#

核心思想#

在不破坏封装性的前提下捕获对象的内部状态。

嵌入式应用场景#

配置保存与恢复
系统状态快照
错误恢复

1
// 备忘录模式 - 配置保存/恢复
2
#include <stdint.h>
3
#include <string.h>
4

5
typedef struct {
6
    uint32_t clock;
7
    uint8_t power_mode;
8
    uint8_t baudrate;
9
    bool debug_enabled;
10
} SystemConfig;
11

12
typedef struct {
13
    SystemConfig state;
14
    uint32_t timestamp;
15
} ConfigMemento;
16

17
typedef struct {
18
    SystemConfig current;
19
    ConfigMemento backup;
20
    bool has_backup;
21
} ConfigManager;
22

23
void Config_Save(ConfigManager *mgr) {
24
    mgr->backup.state = mgr->current;
25
    mgr->backup.timestamp = HAL_GetTick();
26
    mgr->has_backup = true;
27
}
28

29
void Config_Restore(ConfigManager *mgr) {
30
    if (mgr->has_backup) {
31
        mgr->current = mgr->backup.state;
32
    }
33
}
34

35
void Config_Update(ConfigManager *mgr, uint32_t clock, uint8_t mode) {
36
    mgr->current.clock = clock;
37
    mgr->current.power_mode = mode;
38
}

4.10 访问者模式 (Visitor)#

核心思想#

表示一个作用于某对象结构中的各元素的操作。

嵌入式应用场景#

设备树遍历
AST 处理
报表生成

1
// 访问者模式 - 设备树操作
2
#include <stdint.h>
3

4
typedef struct Node Node;
5
typedef struct Visitor Visitor;
6

7
typedef void (*VisitFunc)(Visitor *vis, Node *node);
8

9
struct Visitor {
10
    VisitFunc visit_device;
11
    VisitFunc visit_sensor;
12
    VisitFunc visit_actuator;
13
};
14

15
struct Node {
16
    const char *name;
17
    uint8_t type;  // 0: device, 1: sensor, 2: actuator
18
    Node *children;
19
    Node *next;
20
};
21

22
void Visitor_Visit(Visitor *vis, Node *node) {
23
    if (!node) return;
24

25
    switch (node->type) {
26
        case 0: if (vis->visit_device) vis->visit_device(vis, node); break;
27
        case 1: if (vis->visit_sensor) vis->visit_sensor(vis, node); break;
28
        case 2: if (vis->visit_actuator) vis->visit_actuator(vis, node); break;
29
    }
30

31
    // 访问子节点
32
    for (Node *child = node->children; child; child = child->next) {
33
        Visitor_Visit(vis, child);
34
    }
35
}
36

37
// 具体访问者 - 统计设备数量
38
static uint32_t sensor_count = 0;
39
static uint32_t actuator_count = 0;
40

41
static void count_sensor(Visitor *vis, Node *node) {
42
    sensor_count++;
43
    printf("Sensor: %s\n", node->name);
44
}
45

46
static void count_actuator(Visitor *vis, Node *node) {
47
    actuator_count++;
48
    printf("Actuator: %s\n", node->name);
49
}
50

51
static Visitor counter = {
52
    .visit_sensor = count_sensor,
53
    .visit_actuator = count_actuator,
54
};

4.11 解释器模式 (Interpreter)#

核心思想#

给定一个语言，定义它的文法的一种表示。

嵌入式应用场景#

命令解析
配置脚本
简单协议解析

1
// 解释器模式 - 简单命令解析
2
#include <stdint.h>
3
#include <stdbool.h>
4

5
typedef struct Expression Expression;
6

7
typedef bool (*InterpretFunc)(Expression *exp, const char *context);
8

9
struct Expression {
10
    InterpretFunc interpret;
11
};
12

13
// 终结符表达式
14
typedef struct {
15
    Expression base;
16
    char keyword[16];
17
} TerminalExpression;
18

19
bool terminal_interpret(Expression *exp, const char *cmd) {
20
    TerminalExpression *term = (TerminalExpression*)exp;
21
    return strncmp(cmd, term->keyword, strlen(term->keyword)) == 0;
22
}
23

24
// 非终结符表达式 - And
25
typedef struct {
26
    Expression base;
27
    Expression *left;
28
    Expression *right;
29
} AndExpression;
30

31
bool and_interpret(Expression *exp, const char *cmd) {
32
    AndExpression *ae = (AndExpression*)exp;
33
    return ae->left->interpret(ae->left, cmd) &&
34
           ae->right->interpret(ae->right, cmd);
35
}
36

37
// 使用示例
38
void interpreter_demo(void) {
39
    // 构建语法树: "SET" AND "LED" AND "ON"
40
    static TerminalExpression set_exp = {
41
        .base = {.interpret = terminal_interpret},
42
        .keyword = "SET"
43
    };
44
    static TerminalExpression led_exp = {
45
        .base = {.interpret = terminal_interpret},
46
        .keyword = "LED"
47
    };
48
    static TerminalExpression on_exp = {
49
        .base = {.interpret = terminal_interpret},
50
        .keyword = "ON"
51
    };
52

53
    static AndExpression and1 = {
54
        .base = {.interpret = and_interpret},
55
        .left = &set_exp.base,
56
        .right = &led_exp.base
57
    };
58

59
    static AndExpression and2 = {
60
        .base = {.interpret = and_interpret},
61
        .left = &and1.base,
62
        .right = &on_exp.base
63
    };
64

65
    bool result = and2.base.interpret(&and2.base, "SET LED ON");
66
    printf("Result: %s\n", result ? "OK" : "FAIL");
67
}

五、嵌入式设计模式使用建议#

5.1 模式选择指南#

graph TD A[开始] --> B{资源限制?} B -->|是| C[轻量级模式] B -->|否| D[标准模式] C --> C1{需要单例?} C1 -->|是| C2[单例模式] C1 -->|否| C3[工厂方法] C3 --> C4{需要状态机?} C4 -->|是| C5[状态模式] C4 -->|否| C6[观察者模式] D --> D1{复杂度高?} D1 -->|是| D2[使用多个模式] D1 -->|否| D3[简单架构] style C2 fill:#e8f5e9 style C5 fill:#e8f5e9 style C6 fill:#e8f5e9

5.2 嵌入式推荐模式#

模式	推荐程度	适用场景	资源开销
单例模式	⭐⭐⭐⭐⭐	硬件管理	低
工厂方法	⭐⭐⭐⭐⭐	驱动注册	低
观察者模式	⭐⭐⭐⭐⭐	事件系统	中
状态模式	⭐⭐⭐⭐	协议状态机	中
策略模式	⭐⭐⭐⭐	算法切换	低
命令模式	⭐⭐⭐⭐	任务队列	中
模板方法	⭐⭐⭐⭐	驱动框架	低
适配器模式	⭐⭐⭐⭐	驱动兼容	低
责任链模式	⭐⭐⭐	消息处理	中
外观模式	⭐⭐⭐	HAL 封装	低

5.3 注意事项#

1. 避免过度设计#

1
// ❌ 过度设计
2
class AbstractFactoryBuilderAdapter<template<T>::Strategy> {};
3

4
// ✅ 适度设计
5
typedef struct {
6
    void (*init)(void);
7
    void (*deinit)(void);
8
} Driver;

2. 考虑资源限制#

1
// ❌ 动态内存 (嵌入式禁忌)
2
void *malloc(size_t size);
3

4
// ✅ 静态分配
5
static uint8_t buffer[256];

3. 优先级#

pie title 设计优先级 "代码可读性" : 35 "运行效率" : 30 "内存占用" : 20 "扩展性" : 15

六、总结#

mindmap root((设计模式)) 创建型单例 - 硬件管理工厂 - 驱动注册抽象工厂 - 跨平台建造者 - 复杂配置原型 - 模板复制结构型适配器 - 接口兼容桥接 - 分离实现组合 - 树形结构装饰器 - 增强功能外观 - 统一接口享元 - 资源共享代理 - 访问控制行为型观察者 - 事件通知状态 - 状态机策略 - 算法切换命令 - 请求封装模板 - 流程框架责任链 - 链式处理迭代器 - 遍历中介者 - 模块协调备忘录 - 状态保存访问者 - 操作分离解释器 - 解析规则

设计模式不是银弹，在嵌入式开发中需要根据实际场景和资源限制灵活运用。记住：简单的代码比聪明的代码更可靠。

参考资料：

《Design Patterns: Elements of Reusable Object-Oriented Software》
《Patterns of Enterprise Application Architecture》
《Embedded Systems Architecture》

JJZBQA

设计模式在嵌入式系统中的应用完全指南#

一、设计模式概述#

1.1 什么是设计模式#

1.2 设计模式分类#

二、创建型模式#

2.1 单例模式 (Singleton)#

核心思想#

嵌入式应用场景#

代码示例#

2.2 工厂方法模式 (Factory Method)#

核心思想#

嵌入式应用场景#

代码示例#

2.3 抽象工厂模式 (Abstract Factory)#

核心思想#

嵌入式应用场景#

2.4 建造者模式 (Builder)#

核心思想#

嵌入式应用场景#

2.5 原型模式 (Prototype)#

核心思想#

嵌入式应用场景#

三、结构型模式#

3.1 适配器模式 (Adapter)#

核心思想#

嵌入式应用场景#

3.2 桥接模式 (Bridge)#

核心思想#

嵌入式应用场景#

3.3 组合模式 (Composite)#

核心思想#

嵌入式应用场景#

3.4 装饰器模式 (Decorator)#

核心思想#

嵌入式应用场景#

3.5 外观模式 (Facade)#

核心思想#

嵌入式应用场景#

3.6 享元模式 (Flyweight)#

核心思想#

嵌入式应用场景#

3.7 代理模式 (Proxy)#

核心思想#

嵌入式应用场景#

四、行为型模式#

4.1 观察者模式 (Observer)#

核心思想#

嵌入式应用场景#

4.2 状态模式 (State)#

核心思想#

嵌入式应用场景#

4.3 策略模式 (Strategy)#

核心思想#

嵌入式应用场景#

4.4 命令模式 (Command)#

核心思想#

嵌入式应用场景#

4.5 模板方法模式 (Template Method)#

核心思想#

嵌入式应用场景#

4.6 责任链模式 (Chain of Responsibility)#

核心思想#

嵌入式应用场景#

4.7 迭代器模式 (Iterator)#

核心思想#

嵌入式应用场景#

4.8 中介者模式 (Mediator)#

核心思想#

嵌入式应用场景#

4.9 备忘录模式 (Memento)#

核心思想#

嵌入式应用场景#

4.10 访问者模式 (Visitor)#

核心思想#

嵌入式应用场景#

4.11 解释器模式 (Interpreter)#

核心思想#

嵌入式应用场景#

五、嵌入式设计模式使用建议#