嵌入式分层架构：底层调用上层的3种方法

Shylock_Mister

1969人浏览 · 2025-10-30 08:30:00

Shylock_Mister · 2025-10-30 08:30:00 发布

嵌入式分层架构：底层调用上层的方法与实践

核心问题：为何需要反向调用

在嵌入式分层架构中，底层不应该直接依赖上层，但底层硬件事件和中断需要通知上层应用。根据GeeksforGeeks (2019)关于分层架构中回调的讲解，这种设计需求来自于避免循环依赖的原则。传统的直接调用会导致：[1]

// 错误设计：形成循环依赖
// 上层包含下层头文件
#include "lowerlayer.h"

// 下层也包含上层头文件
#include "upperlayer.h"  // 循环依赖！编译器无法处理

解决方案是通过反向依赖（Dependency Inversion Principle, DIP）——两个层都依赖于抽象接口而不是彼此的具体实现。

方法一：回调函数（Callback Function）——最通用方案

回调函数是嵌入式系统中底层调用上层最常用的方法。根据**Beningo, J. (2017)**的《Embedded Basics – Callback Functions》研究，回调是"一个指向可执行代码的引用，作为参数传递给其他代码，允许较低级的软件层调用函数"。[2]

基础回调实现

最简单的回调机制如下：[1]

// lowerlayer.h - 底层头文件
typedef void (*notify_callback_t)(void);  // 回调函数指针类型

void register_callback(notify_callback_t callback);
void lowerlayer_process(void);

// lowerlayer.c - 底层实现
static notify_callback_t g_callback = NULL;

void register_callback(notify_callback_t callback) {
    g_callback = callback;  // 注册回调
}

void lowerlayer_process(void) {
    // 底层处理逻辑
    if (g_callback != NULL) {
        g_callback();  // 底层调用上层的回调函数
    }
}

// upperlayer.c - 上层应用
#include "lowerlayer.h"

void upper_layer_handler(void) {
    printf("Upper layer notified!\n");
}

int main(void) {
    register_callback(upper_layer_handler);  // 注册上层函数
    lowerlayer_process();                     // 触发回调
    return 0;
}

工作流程：[1]

上层在初始化时将其函数地址注册到底层
底层将函数指针存储在全局变量中
底层事件发生时，通过指针调用上层函数
避免了循环依赖——下层头文件中不出现上层符号

带数据的回调机制

实际应用中，回调需要传递事件相关数据：[1]

// lowerlayer.h
typedef void (*event_callback_t)(int event_code, void *data);

void register_event_callback(event_callback_t callback);

// lowerlayer.c
static event_callback_t g_event_callback = NULL;

void register_event_callback(event_callback_t callback) {
    g_event_callback = callback;
}

void sensor_interrupt_handler(void) {
    int sensor_data = read_sensor();
    if (g_event_callback != NULL) {
        g_event_callback(EVENT_SENSOR_DATA, &sensor_data);
    }
}

// upperlayer.c
void process_sensor_event(int event_code, void *data) {
    if (event_code == EVENT_SENSOR_DATA) {
        int *value = (int *)data;
        printf("Sensor reading: %d\n", *value);
    }
}

int main(void) {
    register_event_callback(process_sensor_event);
    // ...
}

方法二：依赖注入与硬件抽象层（HAL）

依赖注入（Dependency Injection）是解决分层问题的更优雅方案。根据Beningo, J. (2023)关于硬件抽象层的研究，这种方法使用结构体包含函数指针来定义接口。[3]

接口定义

// dio_interface.h - 硬件抽象接口
#ifndef DIO_INTERFACE_H
#define DIO_INTERFACE_H

#include <stdint.h>

typedef enum {
    DIO_LOW = 0,
    DIO_HIGH = 1
} dio_state_t;

typedef enum {
    DIO_PORT_A = 0,
    DIO_PORT_B = 1
} dio_port_t;

typedef enum {
    DIO_PIN_0 = 0,
    DIO_PIN_1 = 1,
    DIO_PIN_2 = 2
} dio_pin_t;

// 接口：函数指针结构体
typedef struct {
    void (*init)(void);
    void (*write)(dio_port_t port, dio_pin_t pin, dio_state_t state);
    dio_state_t (*read)(dio_port_t port, dio_pin_t pin);
} dio_interface_t;

#endif

硬件实现

// stm32_dio.c - STM32微控制器实现
#include "dio_interface.h"

void STM32_DIO_Init(void) {
    // STM32特定的GPIO初始化代码
}

void STM32_DIO_Write(dio_port_t port, dio_pin_t pin, dio_state_t state) {
    // STM32特定的GPIO写入代码
}

dio_state_t STM32_DIO_Read(dio_port_t port, dio_pin_t pin) {
    // STM32特定的GPIO读取代码
    return DIO_LOW;
}

// 实例化接口
const dio_interface_t stm32_dio = {
    .init = STM32_DIO_Init,
    .write = STM32_DIO_Write,
    .read = STM32_DIO_Read
};

上层应用（与硬件无关）

// led_driver.h
#include "dio_interface.h"

typedef struct {
    const dio_interface_t *dio;  // 依赖注入
    dio_port_t port;
    dio_pin_t pin;
} led_t;

void led_init(led_t *led, const dio_interface_t *dio_interface,
              dio_port_t port, dio_pin_t pin);
void led_toggle(led_t *led);

// led_driver.c
#include "led_driver.h"

static led_t *g_led = NULL;

void led_init(led_t *led, const dio_interface_t *dio_interface,
              dio_port_t port, dio_pin_t pin) {
    g_led = led;
    g_led->dio = dio_interface;  // 注入依赖
    g_led->port = port;
    g_led->pin = pin;
    
    g_led->dio->init();  // 调用硬件初始化
}

void led_toggle(led_t *led) {
    dio_state_t state = led->dio->read(led->port, led->pin);
    dio_state_t new_state = (state == DIO_LOW) ? DIO_HIGH : DIO_LOW;
    led->dio->write(led->port, led->pin, new_state);
}

// main.c - 应用程序
int main(void) {
    led_t my_led;
    led_init(&my_led, &stm32_dio, DIO_PORT_A, DIO_PIN_0);
    
    led_toggle(&my_led);
    
    return 0;
}

关键优势：[3]

LED驱动完全独立于硬件
可以在不同硬件上复用（只需传入不同的接口实现）
便于单元测试（可传入mock实现）
符合依赖倒置原则

方法三：观察者模式（Observer Pattern）

观察者模式是一种发布-订阅机制，特别适合多个上层模块监听同一个底层事件的场景。根据**Embedded Artistry (2023)**的观察者模式讲解，该模式的核心是Subject（被观察者）维护一个Observers列表。[4]

完整实现

// observer.h
#ifndef OBSERVER_H
#define OBSERVER_H

typedef struct observer observer_t;

// 观察者接口：更新函数
typedef void (*observer_update_t)(observer_t *self, void *data);

struct observer {
    observer_update_t update;
    void *context;  // 观察者的上下文数据
};

#endif

// subject.h - 被观察者（底层模块）
#ifndef SUBJECT_H
#define SUBJECT_H

#include "observer.h"

#define MAX_OBSERVERS 10

typedef struct {
    observer_t *observers[MAX_OBSERVERS];
    int observer_count;
} subject_t;

void subject_init(subject_t *subject);
void subject_attach(subject_t *subject, observer_t *observer);
void subject_detach(subject_t *subject, observer_t *observer);
void subject_notify(subject_t *subject, void *data);

#endif

// subject.c
#include "subject.h"
#include <string.h>

void subject_init(subject_t *subject) {
    subject->observer_count = 0;
    memset(subject->observers, 0, sizeof(subject->observers));
}

void subject_attach(subject_t *subject, observer_t *observer) {
    if (subject->observer_count < MAX_OBSERVERS) {
        subject->observers[subject->observer_count] = observer;
        subject->observer_count++;
    }
}

void subject_detach(subject_t *subject, observer_t *observer) {
    for (int i = 0; i < subject->observer_count; i++) {
        if (subject->observers[i] == observer) {
            for (int j = i; j < subject->observer_count - 1; j++) {
                subject->observers[j] = subject->observers[j + 1];
            }
            subject->observer_count--;
            break;
        }
    }
}

void subject_notify(subject_t *subject, void *data) {
    for (int i = 0; i < subject->observer_count; i++) {
        if (subject->observers[i] != NULL) {
            subject->observers[i]->update(subject->observers[i], data);
        }
    }
}

// sensor.h - 底层传感器（Subject）
#ifndef SENSOR_H
#define SENSOR_H

#include "subject.h"

typedef struct {
    subject_t subject;
    int sensor_value;
} sensor_t;

void sensor_init(sensor_t *sensor);
void sensor_read(sensor_t *sensor);

#endif

// sensor.c - 底层传感器实现
#include "sensor.h"

sensor_t g_sensor;

void sensor_init(sensor_t *sensor) {
    subject_init(&sensor->subject);
    sensor->sensor_value = 0;
}

void sensor_read(sensor_t *sensor) {
    // 模拟读取硬件传感器
    sensor->sensor_value++;
    
    // 通知所有观察者
    subject_notify(&sensor->subject, &sensor->sensor_value);
}

// application.c - 上层应用
#include "sensor.h"
#include <stdio.h>

typedef struct {
    const char *name;
} display_context_t;

// 观察者1：显示模块
void display_update(observer_t *self, void *data) {
    display_context_t *ctx = (display_context_t *)self->context;
    int *value = (int *)data;
    printf("[%s] Sensor value: %d\n", ctx->name, *value);
}

// 观察者2：日志模块
void logger_update(observer_t *self, void *data) {
    int *value = (int *)data;
    printf("[Logger] Recorded value: %d\n", *value);
}

int main(void) {
    sensor_t sensor;
    sensor_init(&sensor);
    
    // 创建观察者
    display_context_t display_ctx = {.name = "DisplayModule"};
    observer_t display_observer = {
        .update = display_update,
        .context = &display_ctx
    };
    
    observer_t logger_observer = {
        .update = logger_update,
        .context = NULL
    };
    
    // 注册观察者
    subject_attach(&sensor.subject, &display_observer);
    subject_attach(&sensor.subject, &logger_observer);
    
    // 传感器触发事件
    sensor_read(&sensor);  // 输出：Display和Logger都收到通知
    sensor_read(&sensor);
    
    // 取消注册
    subject_detach(&sensor.subject, &logger_observer);
    sensor_read(&sensor);  // 只有Display收到通知
    
    return 0;
}

方法四：事件驱动系统与消息队列

在RTOS中，消息队列是底层与上层通信的标准方法。根据**High Integrity Systems (2025)**关于RTOS任务通知的研究，现代RTOS提供轻量级的任务通知机制。[5]

FreeRTOS示例

// sensor_task.c - 底层传感器任务
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

extern QueueHandle_t sensor_event_queue;

void sensor_interrupt_handler(void) {
    // 中断处理程序
    int sensor_reading = read_hardware_sensor();
    
    // 将事件发送到队列（底层通知上层）
    xQueueSendFromISR(sensor_event_queue, &sensor_reading, NULL);
}

void sensor_task(void *pvParameters) {
    while (1) {
        int reading = read_hardware_sensor();
        xQueueSend(sensor_event_queue, &reading, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

// application_task.c - 上层应用任务
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

QueueHandle_t sensor_event_queue;

void display_task(void *pvParameters) {
    int sensor_value;
    
    while (1) {
        // 上层监听底层事件（非阻塞等待）
        if (xQueueReceive(sensor_event_queue, &sensor_value, pdMS_TO_TICKS(100)) == pdTRUE) {
            printf("Sensor value: %d\n", sensor_value);
            update_display(sensor_value);
        }
    }
}

int main(void) {
    // 创建消息队列
    sensor_event_queue = xQueueCreate(10, sizeof(int));
    
    // 创建底层任务
    xTaskCreate(sensor_task, "SensorTask", 256, NULL, 2, NULL);
    
    // 创建上层任务
    xTaskCreate(display_task, "DisplayTask", 256, NULL, 1, NULL);
    
    vTaskStartScheduler();
    return 0;
}

优势：[6]

线程安全的通信
上下层任务可以异步执行
自动处理优先级和调度
支持多个上层监听同一事件

方法五：状态机模式

状态机是嵌入式系统中组织复杂状态转移的经典方法。根据Wolff Electronic Design (2025)的分析，状态机提供了清晰的层次结构和易于维护的设计。[7]

简化的状态机实现

// state_machine.h
typedef enum {
    STATE_IDLE,
    STATE_ACTIVE,
    STATE_ERROR
} system_state_t;

typedef enum {
    EVENT_START,
    EVENT_STOP,
    EVENT_FAULT,
    EVENT_RESET
} system_event_t;

typedef struct {
    system_state_t current_state;
    // 事件处理函数指针（底层调用上层）
    void (*on_state_changed)(system_state_t new_state);
} state_machine_t;

void sm_init(state_machine_t *sm);
void sm_process_event(state_machine_t *sm, system_event_t event);

// state_machine.c
void sm_init(state_machine_t *sm) {
    sm->current_state = STATE_IDLE;
}

void sm_process_event(state_machine_t *sm, system_event_t event) {
    system_state_t next_state = sm->current_state;
    
    switch (sm->current_state) {
        case STATE_IDLE:
            if (event == EVENT_START) {
                next_state = STATE_ACTIVE;
            }
            break;
            
        case STATE_ACTIVE:
            if (event == EVENT_STOP) {
                next_state = STATE_IDLE;
            } else if (event == EVENT_FAULT) {
                next_state = STATE_ERROR;
            }
            break;
            
        case STATE_ERROR:
            if (event == EVENT_RESET) {
                next_state = STATE_IDLE;
            }
            break;
    }
    
    if (next_state != sm->current_state) {
        sm->current_state = next_state;
        // 底层通知上层状态变化
        if (sm->on_state_changed != NULL) {
            sm->on_state_changed(next_state);
        }
    }
}

// application.c - 上层应用
void application_state_handler(system_state_t state) {
    switch (state) {
        case STATE_IDLE:
            printf("System idle\n");
            break;
        case STATE_ACTIVE:
            printf("System active\n");
            break;
        case STATE_ERROR:
            printf("System error\n");
            break;
    }
}

int main(void) {
    state_machine_t sm;
    sm_init(&sm);
    sm.on_state_changed = application_state_handler;  // 注册回调
    
    sm_process_event(&sm, EVENT_START);   // 触发状态转移
    sm_process_event(&sm, EVENT_STOP);
    
    return 0;
}

方法对比总结

方法	复杂度	内存开销	适用场景	性能
回调函数	低	最低	单一事件通知	最快
依赖注入	中	中等	硬件抽象层	快
观察者模式	中	中等	多观察者事件	快
消息队列	高	高	RTOS系统	中等
状态机	中	低	复杂状态转移	快

实际嵌入式项目案例：完整传感器驱动架构

// 底层：硬件驱动（lowerlayer）
// lowerlayer.h
typedef void (*sensor_event_callback_t)(int event, void *data);

void sensor_init(sensor_event_callback_t callback);
void sensor_start(void);

// 中间层：驱动抽象（middleware）
// sensor_driver.h
#include "lowerlayer.h"

void sensor_driver_init(void);
void sensor_driver_start(void);

// 上层：应用程序（application）
// app.h
void app_init(void);
void app_sensor_handler(int event, void *data);

// 集成示例
int main(void) {
    // 1. 上层注册回调到底层
    sensor_init(app_sensor_handler);
    
    // 2. 初始化中间层
    sensor_driver_init();
    
    // 3. 启动系统
    sensor_driver_start();
    
    // 4. 主循环/RTOS调度
    while (1) {
        // 底层中断发生时，自动调用app_sensor_handler
    }
}