C语言-装饰器模式详解与实践 - LED控制系统

C语言装饰器模式详解与实践 - LED控制系统

1. 什么是装饰器模式？

装饰器模式允许我们动态地向对象添加新的功能，而不改变其原有结构。在LED控制系统中，我们可以通过装饰器模式实现不同的LED效果叠加。

2. 为什么需要装饰器模式？

• 动态添加LED效果
• 效果可以自由组合
• 不修改原有代码
• 符合开闭原则
• 代码复用性高

3. 实际应用场景

• LED状态指示
• 设备运行状态显示
• 警告信号显示
• 用户界面反馈
• 调试信息显示

4. 代码实现

LedController

+set_state()

+update()

+destroy()

BasicLed

-pin

-state

LedDecorator

-wrapped

BlinkLed

-interval

-counter

-state

BreathLed

-period

-counter

SosLed

-counter

-pattern_pos

-pattern

-pattern_length

4.1 头文件 (led_decorator.h)

#ifndef LED_DECORATOR_H
#define LED_DECORATOR_H

#include 
#include 

// LED控制接口
typedef struct {
    void (*set_brightness)(void* self, uint8_t level);
    void (*update)(void* self);
    void (*destroy)(void* self);
} LedController;

// 基础LED控制器
typedef struct {
    LedController base;
    uint8_t pin;         // LED引脚
    uint8_t brightness;  // 当前亮度
} BasicLed;

// LED装饰器基类
typedef struct {
    LedController base;
    LedController* wrapped;
} LedDecorator;

// 创建基础LED控制器
LedController* create_basic_led(uint8_t pin);

// 创建闪烁装饰器
LedController* create_blink_led(LedController* wrapped, uint16_t interval_ms);

// 创建呼吸灯装饰器
LedController* create_breath_led(LedController* wrapped, uint16_t period_ms);

// 创建渐变装饰器
LedController* create_fade_led(LedController* wrapped, uint16_t fade_time_ms);

// 销毁LED控制器
void destroy_led_controller(LedController* controller);

#endif // LED_DECORATOR_H

4.2 实现文件 (led_decorator.c)

#include "led_decorator.h"
#include 
#include 

// 模拟硬件操作
static void hw_set_pin(uint8_t pin, uint8_t level) {
    printf("设置引脚 %d 亮度为 %d\n", pin, level);
}

// 基础LED控制器实现
static void basic_set_brightness(void* self, uint8_t level) {
    BasicLed* led = (BasicLed*)self;
    led->brightness = level;
    hw_set_pin(led->pin, level);
}

static void basic_update(void* self) {
    // 基础LED不需要更新
}

static void basic_destroy(void* self) {
    free(self);
}

// 闪烁装饰器实现
typedef struct {
    LedDecorator base;
    uint16_t interval;
    uint16_t counter;
    bool state;
} BlinkLed;

static void blink_set_brightness(void* self, uint8_t level) {
    BlinkLed* led = (BlinkLed*)self;
    led->base.wrapped->set_brightness(led->base.wrapped, level);
}

static void blink_update(void* self) {
    BlinkLed* led = (BlinkLed*)self;
    led->counter++;
    
    if (led->counter >= led->interval) {
        led->counter = 0;
        led->state = !led->state;
        led->base.wrapped->set_brightness(led->base.wrapped, 
                                        led->state ? 255 : 0);
    }
}

static void blink_destroy(void* self) {
    BlinkLed* led = (BlinkLed*)self;
    destroy_led_controller(led->base.wrapped);
    free(led);
}

// 呼吸灯装饰器实现
typedef struct {
    LedDecorator base;
    uint16_t period;
    uint16_t counter;
} BreathLed;

static void breath_set_brightness(void* self, uint8_t level) {
    BreathLed* led = (BreathLed*)self;
    led->base.wrapped->set_brightness(led->base.wrapped, level);
}

static void breath_update(void* self) {
    BreathLed* led = (BreathLed*)self;
    led->counter++;
    
    if (led->counter >= led->period) {
        led->counter = 0;
    }
    
    // 使用正弦波实现呼吸效果
    float phase = (float)led->counter / led->period * 3.14159f * 2;
    uint8_t brightness = (uint8_t)((sinf(phase) + 1.0f) * 127.5f);
    led->base.wrapped->set_brightness(led->base.wrapped, brightness);
}

static void breath_destroy(void* self) {
    BreathLed* led = (BreathLed*)self;
    destroy_led_controller(led->base.wrapped);
    free(led);
}

// 创建函数实现
LedController* create_basic_led(uint8_t pin) {
    BasicLed* led = (BasicLed*)malloc(sizeof(BasicLed));
    led->base.set_brightness = basic_set_brightness;
    led->base.update = basic_update;
    led->base.destroy = basic_destroy;
    led->pin = pin;
    led->brightness = 0;
    return (LedController*)led;
}

LedController* create_blink_led(LedController* wrapped, uint16_t interval_ms) {
    BlinkLed* led = (BlinkLed*)malloc(sizeof(BlinkLed));
    led->base.base.set_brightness = blink_set_brightness;
    led->base.base.update = blink_update;
    led->base.base.destroy = blink_destroy;
    led->base.wrapped = wrapped;
    led->interval = interval_ms;
    led->counter = 0;
    led->state = false;
    return (LedController*)led;
}

LedController* create_breath_led(LedController* wrapped, uint16_t period_ms) {
    BreathLed* led = (BreathLed*)malloc(sizeof(BreathLed));
    led->base.base.set_brightness = breath_set_brightness;
    led->base.base.update = breath_update;
    led->base.base.destroy = breath_destroy;
    led->base.wrapped = wrapped;
    led->period = period_ms;
    led->counter = 0;
    return (LedController*)led;
}

void destroy_led_controller(LedController* controller) {
    if (controller && controller->destroy) {
        controller->destroy(controller);
    }
}

4.3 使用示例 (main.c)

#include "led_decorator.h"
#include 
#include   // 用于Sleep函数

void simulate_time(LedController* led, int ms) {
    printf("\n模拟运行 %d ms:\n", ms);
    for (int i = 0; i < ms; i += 100) {
        led->update(led);
        Sleep(100);  // 模拟时间流逝
    }
}

int main() {
    // 创建基础LED（使用引脚13）
    LedController* led = create_basic_led(13);
    
    printf("=== 测试基础LED ===\n");
    led->set_brightness(led, 128);  // 设置50%亮度
    
    printf("\n=== 测试闪烁LED ===\n");
    led = create_blink_led(led, 500);  // 500ms闪烁间隔
    simulate_time(led, 2000);  // 运行2秒
    
    printf("\n=== 测试呼吸LED ===\n");
    led = create_breath_led(led, 2000);  // 2000ms呼吸周期
    simulate_time(led, 3000);  // 运行3秒
    
    // 清理资源
    destroy_led_controller(led);
    
    return 0;
}

5. 代码分析

5.1 关键设计点

1. LED控制接口统一
2. 装饰器链式组合
3. 时间管理机制
4. 资源管理完善

5.2 实现特点

1. 函数指针实现多态
2. 模块化设计
3. 效果可组合
4. 代码复用性高

6. 编译和运行

gcc -c led_decorator.c -o led_decorator.o
gcc -c main.c -o main.o
gcc led_decorator.o main.o -o led_demo

7. 注意事项

1. 时序控制精度
2. 内存管理
3. 硬件接口抽象
4. 中断处理

8. 改进建议

1. 添加PWM控制
2. 实现更多效果
3. 优化时间管理
4. 添加错误处理

9. 总结

装饰器模式在LED控制系统中的应用，使得我们可以灵活地组合不同的LED效果，同时保持代码的清晰和可维护性。这种模式特别适合需要动态组合多种LED效果的场景。

参考资料

1. 《嵌入式系统设计》
2. 《设计模式》
3. 《单片机编程实践》