在嵌入式系统开发中，一个常见的核心挑战是如何将不同接口、不同协议的硬件设备与软件组件整合到一个统一、协调的系统中。这就像需要让多种不同规格的插头都能插入同一个插座一样。而适配器模式 (Adapter Pattern) 作为一种经典的结构型设计模式，恰好通过提供一个中间转换层，优雅地解决了接口不兼容的问题，使得新旧组件能够和谐共处。
适配器模式的核心概念
适配器模式的核心思想是充当两个不兼容接口之间的桥梁。它通过包装一个已有的类（被适配者），提供一个与客户端代码期望的接口（目标接口）兼容的新接口。这与现实生活中的电源适配器工作原理完全相同，无论插头标准如何，经过适配器转换后，都能为设备提供稳定的电力。
嵌入式系统中的适配器模式应用场景
嵌入式开发中，适配器模式的应用非常广泛，主要体现在以下几个场景。
1. 统一不同传感器接口
在物联网或环境监测设备中，我们经常需要集成来自不同厂商、采用不同通信协议（如I2C、SPI、单总线）的传感器。如果没有统一的接口，上层应用逻辑将变得极其复杂和难以维护。
// 传感器接口类型定义
typedef enum {
SENSOR_INTERFACE_I2C,
SENSOR_INTERFACE_SPI,
SENSOR_INTERFACE_UART,
SENSOR_INTERFACE_ANALOG,
SENSOR_INTERFACE_ONE_WIRE
} sensor_interface_t;
// 传感器数据精度枚举
typedef enum {
PRECISION_LOW,
PRECISION_MEDIUM,
PRECISION_HIGH,
PRECISION_ULTRA
} sensor_precision_t;
2. 协议转换
嵌入式设备通常需要与多种通信协议交互，例如将HTTP请求转换为MQTT消息，或将自定义二进制协议解析为JSON格式。适配器可以在协议层进行透明转换，对业务逻辑隐藏底层细节。
// 通信协议转换类型
typedef enum {
PROTOCOL_HTTP_TO_MQTT,
PROTOCOL_COAP_TO_HTTP,
PROTOCOL_CUSTOM_TO_JSON,
PROTOCOL_BINARY_TO_TEXT
} protocol_conversion_t;
3. 兼容新旧驱动版本
在系统升级或硬件迭代过程中，新驱动可能与旧版API不兼容。使用适配器模式包装新驱动，使其暴露与旧驱动一致的接口，可以完美实现向后兼容，降低系统升级的风险和成本。
// 驱动版本枚举
typedef enum {
DRIVER_V1_LEGACY,
DRIVER_V2_STANDARD,
DRIVER_V3_ENHANCED
} driver_version_t;
传感器适配器：统一多源数据的典范
下面我们通过构建一个完整的传感器适配器系统，来具体展示适配器模式在嵌入式开发中的强大威力。我们将为BME280（I2C接口）和DHT11（单总线接口）这两款特性迥异的传感器，创建一个统一的访问接口。
第一步：定义统一的传感器接口
所有适配器的目标都是实现这个统一的接口。它定义了传感器应该具备的基本信息、操作函数和高级功能。
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
// 统一的传感器数据结构
typedef struct {
float temperature; // 温度，单位：摄氏度
float humidity; // 湿度，单位：百分比
float pressure; // 气压，单位：百帕
float altitude; // 海拔，单位：米
uint32_t timestamp; // 时间戳，毫秒
uint8_t sensor_id; // 传感器标识
bool data_valid; // 数据有效性标志
} sensor_data_t;
// 传感器配置参数结构
typedef struct {
sensor_precision_t precision;
uint16_t sample_rate; // 采样频率，Hz
uint8_t averaging_samples; // 平均采样数
bool calibration_enabled; // 校准使能
float calibration_offset; // 校准偏移
} sensor_config_t;
// 统一的传感器适配器接口（目标接口）
typedef struct sensor_adapter {
// 基础信息
const char *sensor_name;
sensor_interface_t interface_type;
uint8_t sensor_address;
// 核心数据读取接口（适配的目标方法）
int32_t (*read_temperature)(void);
int32_t (*read_humidity)(void);
int32_t (*read_pressure)(void);
int32_t (*read_altitude)(void);
// 高级功能接口
bool (*initialize)(void);
bool (*configure)(const sensor_config_t *config);
bool (*self_test)(void);
bool (*sleep)(void);
bool (*wakeup)(void);
// 数据获取接口
bool (*read_all_data)(sensor_data_t *data);
bool (*read_single_measurement)(sensor_data_t *data, uint8_t measurement_type);
// 错误处理
uint16_t (*get_last_error)(void);
bool (*reset)(void);
// 适配器私有上下文（通常包含原生驱动句柄）
void *adapter_context;
} sensor_adapter_t;
这种通过结构体定义函数指针接口的方式，是C语言实现多态和接口抽象的常见技巧，也是很多设计模式在嵌入式领域的落地形式。
第二步：实现BME280传感器适配器
BME280是一款高精度、支持I2C/SPI的数字温湿度气压传感器。我们的适配器需要将其原生驱动接口“转换”到统一的sensor_adapter_t接口。
#include "bme280.h"
#include "i2c_driver.h"
// BME280适配器私有上下文
typedef struct {
struct bme280_dev device; // BME280原生设备结构体
struct bme280_data comp_data; // 补偿后的数据
sensor_config_t config;
bool initialized;
uint16_t error_code;
} bme280_adapter_context_t;
static bme280_adapter_context_t bme280_context = {0};
// 温度读取适配函数：调用原生驱动，并转换数据格式和精度
static int32_t bme280_read_temperature(void)
{
if (!bme280_context.initialized) {
return INT32_MIN; // 返回错误值
}
int8_t result = bme280_get_sensor_data(BME280_TEMP, &bme280_context.comp_data,
&bme280_context.device);
if (result != BME280_OK) {
bme280_context.error_code = 0x1000 | (uint16_t)(-result);
return INT32_MIN;
}
// 将浮点数温度转换为固定精度（0.01°C）的整型返回
return (int32_t)(bme280_context.comp_data.temperature * 100);
}
// 湿度读取适配函数
static int32_t bme280_read_humidity(void)
{
if (!bme280_context.initialized) {
return INT32_MIN;
}
int8_t result = bme280_get_sensor_data(BME280_HUM, &bme280_context.comp_data,
&bme280_context.device);
if (result != BME280_OK) {
bme280_context.error_code = 0x1001 | (uint16_t)(-result);
return INT32_MIN;
}
// 转换为0.01%精度
return (int32_t)(bme280_context.comp_data.humidity * 100);
}
// 气压读取适配函数（转换为百帕单位）
static int32_t bme280_read_pressure(void)
{
if (!bme280_context.initialized) {
return INT32_MIN;
}
int8_t result = bme280_get_sensor_data(BME280_PRESS, &bme280_context.comp_data,
&bme280_context.device);
if (result != BME280_OK) {
bme280_context.error_code = 0x1002 | (uint16_t)(-result);
return INT32_MIN;
}
// 原生驱动返回帕斯卡(Pa)，转换为百帕(hPa)，精度0.01百帕
return (int32_t)(bme280_context.comp_data.pressure / 100.0f * 100);
}
// 海拔计算适配函数（基于气压公式计算）
static int32_t bme280_read_altitude(void)
{
int32_t pressure = bme280_read_pressure();
if (pressure == INT32_MIN) {
return INT32_MIN;
}
// 使用标准气压公式计算海拔
float pressure_hpa = pressure / 100.0f;
float altitude = 44330.0f * (1.0f - powf(pressure_hpa / 1013.25f, 1.0f / 5.255f));
return (int32_t)(altitude * 100); // 精度0.01米
}
// 初始化适配：设置BME280原生驱动参数
static bool bme280_initialize(void)
{
if (bme280_context.initialized) {
return true;
}
// 初始化BME280设备结构体
bme280_context.device.dev_id = BME280_I2C_ADDR_PRIM;
bme280_context.device.intf = BME280_I2C_INTF;
bme280_context.device.read = user_i2c_read;
bme280_context.device.write = user_i2c_write;
bme280_context.device.delay_ms = user_delay_ms;
int8_t result = bme280_init(&bme280_context.device);
if (result != BME280_OK) {
bme280_context.error_code = 0x2000 | (uint16_t)(-result);
return false;
}
// 配置传感器采样和滤波参数
bme280_context.device.settings.osr_h = BME280_OVERSAMPLING_1X;
bme280_context.device.settings.osr_p = BME280_OVERSAMPLING_16X;
bme280_context.device.settings.osr_t = BME280_OVERSAMPLING_2X;
bme280_context.device.settings.filter = BME280_FILTER_COEFF_16;
uint8_t settings_sel = BME280_OSR_PRESS_SEL | BME280_OSR_TEMP_SEL |
BME280_OSR_HUM_SEL | BME280_FILTER_SEL;
result = bme280_set_sensor_settings(settings_sel, &bme280_context.device);
if (result != BME280_OK) {
bme280_context.error_code = 0x2001 | (uint16_t)(-result);
return false;
}
bme280_context.initialized = true;
return true;
}
// 配置适配：根据统一配置设置具体传感器参数
static bool bme280_configure(const sensor_config_t *config)
{
if (!bme280_context.initialized) {
return false;
}
// 根据配置的精度枚举，映射到BME280的具体过采样设置
uint8_t osr_setting;
switch (config->precision) {
case PRECISION_LOW:
osr_setting = BME280_OVERSAMPLING_1X;
break;
case PRECISION_MEDIUM:
osr_setting = BME280_OVERSAMPLING_2X;
break;
case PRECISION_HIGH:
osr_setting = BME280_OVERSAMPLING_4X;
break;
case PRECISION_ULTRA:
osr_setting = BME280_OVERSAMPLING_16X;
break;
default:
osr_setting = BME280_OVERSAMPLING_2X;
}
bme280_context.device.settings.osr_h = osr_setting;
bme280_context.device.settings.osr_p = osr_setting;
bme280_context.device.settings.osr_t = osr_setting;
// 应用新的过采样设置
uint8_t settings_sel = BME280_OSR_PRESS_SEL | BME280_OSR_TEMP_SEL |
BME280_OSR_HUM_SEL;
int8_t result = bme280_set_sensor_settings(settings_sel, &bme280_context.device);
if (result != BME280_OK) {
bme280_context.error_code = 0x2002 | (uint16_t)(-result);
return false;
}
// 保存配置到上下文
memcpy(&bme280_context.config, config, sizeof(sensor_config_t));
return true;
}
// 读取所有数据并填充到统一结构体中
static bool bme280_read_all_data(sensor_data_t *data)
{
if (!bme280_context.initialized || data == NULL) {
return false;
}
// 设置为强制测量模式，触发一次数据采集
int8_t result = bme280_set_sensor_mode(BME280_FORCED_MODE, &bme280_context.device);
if (result != BME280_OK) {
bme280_context.error_code = 0x3000 | (uint16_t)(-result);
return false;
}
// 等待测量完成（具体时间取决于配置）
user_delay_ms(10);
// 读取所有传感器数据
result = bme280_get_sensor_data(BME280_ALL, &bme280_context.comp_data,
&bme280_context.device);
if (result != BME280_OK) {
bme280_context.error_code = 0x3001 | (uint16_t)(-result);
return false;
}
// 填充统一的传感器数据结构
data->temperature = bme280_context.comp_data.temperature;
data->humidity = bme280_context.comp_data.humidity;
data->pressure = bme280_context.comp_data.pressure / 100.0f; // 转换为百帕
data->timestamp = get_system_timestamp();
data->sensor_id = 0x01;
data->data_valid = true;
// 基于气压计算海拔
data->altitude = 44330.0f * (1.0f - powf(data->pressure / 1013.25f, 1.0f / 5.255f));
return true;
}
// 其他适配函数：自检、错误获取、复位等（略）
static bool bme280_self_test(void) { /* ... */ }
static uint16_t bme280_get_last_error(void) { /* ... */ }
static bool bme280_reset(void) { /* ... */ }
// BME280适配器实例（全局对象）
sensor_adapter_t bme280_adapter = {
.sensor_name = "BME280",
.interface_type = SENSOR_INTERFACE_I2C,
.sensor_address = BME280_I2C_ADDR_PRIM,
.read_temperature = bme280_read_temperature,
.read_humidity = bme280_read_humidity,
.read_pressure = bme280_read_pressure,
.read_altitude = bme280_read_altitude,
.initialize = bme280_initialize,
.configure = bme280_configure,
.self_test = bme280_self_test,
.sleep = NULL, // BME280不支持单独休眠
.wakeup = NULL,
.read_all_data = bme280_read_all_data,
.read_single_measurement = NULL, // 使用统一读取接口即可
.get_last_error = bme280_get_last_error,
.reset = bme280_reset,
.adapter_context = &bme280_context
};
第三步：实现DHT11传感器适配器
DHT11是一款低成本、单总线数字温湿度传感器，功能比BME280简单很多（不支持气压测量）。适配器需要处理这些功能差异，例如在不支持的功能上返回错误或默认值。
#include "dht11.h"
#include "gpio_driver.h"
// DHT11适配器私有上下文
typedef struct {
dht11_sensor_t sensor; // DHT11原生传感器结构体
sensor_config_t config;
bool initialized;
uint16_t error_code;
} dht11_adapter_context_t;
static dht11_adapter_context_t dht11_context = {0};
// DHT11温度读取适配
static int32_t dht11_read_temperature(void)
{
if (!dht11_context.initialized) {
return INT32_MIN;
}
dht11_data_t data;
if (!dht11_read(&dht11_context.sensor, &data)) {
dht11_context.error_code = 0x4000;
return INT32_MIN;
}
// DHT11返回整数温度，转换为0.01°C精度
return data.temperature * 100;
}
// DHT11湿度读取适配
static int32_t dht11_read_humidity(void)
{
if (!dht11_context.initialized) {
return INT32_MIN;
}
dht11_data_t data;
if (!dht11_read(&dht11_context.sensor, &data)) {
dht11_context.error_code = 0x4001;
return INT32_MIN;
}
// DHT11返回整数湿度，转换为0.01%精度
return data.humidity * 100;
}
// DHT11不支持气压和海拔，返回错误值
static int32_t dht11_read_pressure(void)
{
dht11_context.error_code = 0x4002; // 功能不支持错误码
return INT32_MIN;
}
static int32_t dht11_read_altitude(void)
{
dht11_context.error_code = 0x4003; // 功能不支持错误码
return INT32_MIN;
}
// DHT11初始化适配（主要是GPIO引脚初始化）
static bool dht11_initialize(void)
{
if (dht11_context.initialized) {
return true;
}
dht11_context.sensor.gpio_pin = GPIO_DHT11_PIN;
dht11_context.sensor.gpio_port = GPIO_DHT11_PORT;
if (!dht11_init(&dht11_context.sensor)) {
dht11_context.error_code = 0x5000;
return false;
}
dht11_context.initialized = true;
return true;
}
// DHT11配置适配（DHT11配置选项非常有限，主要保存配置）
static bool dht11_configure(const sensor_config_t *config)
{
if (!dht11_context.initialized) {
return false;
}
memcpy(&dht11_context.config, config, sizeof(sensor_config_t));
return true;
}
// DHT11读取所有数据（填充不支持的数据字段为0）
static bool dht11_read_all_data(sensor_data_t *data)
{
if (!dht11_context.initialized || data == NULL) {
return false;
}
dht11_data_t dht_data;
if (!dht11_read(&dht11_context.sensor, &dht_data)) {
dht11_context.error_code = 0x6000;
return false;
}
// 填充统一数据结构，不支持的字段设为0
data->temperature = (float)dht_data.temperature;
data->humidity = (float)dht_data.humidity;
data->pressure = 0.0f; // DHT11不支持气压
data->altitude = 0.0f; // DHT11不支持海拔
data->timestamp = get_system_timestamp();
data->sensor_id = 0x02;
data->data_valid = (dht_data.temperature != 0 || dht_data.humidity != 0);
return true;
}
// DHT11适配器实例
sensor_adapter_t dht11_adapter = {
.sensor_name = "DHT11",
.interface_type = SENSOR_INTERFACE_ONE_WIRE,
.sensor_address = 0,
.read_temperature = dht11_read_temperature,
.read_humidity = dht11_read_humidity,
.read_pressure = dht11_read_pressure, // 虽然不支持，但接口必须存在
.read_altitude = dht11_read_altitude, // 同上
.initialize = dht11_initialize,
.configure = dht11_configure,
.self_test = dht11_self_test,
.sleep = NULL,
.wakeup = NULL,
.read_all_data = dht11_read_all_data,
.read_single_measurement = NULL,
.get_last_error = dht11_get_last_error,
.reset = dht11_reset,
.adapter_context = &dht11_context
};
第四步：创建传感器管理器
有了统一的适配器接口后，我们可以创建一个管理器来方便地注册、查找和操作这些传感器，实现解耦和集中管理。
// 传感器管理器
typedef struct {
sensor_adapter_t *adapters[MAX_SENSORS];
uint8_t adapter_count;
bool initialized;
} sensor_manager_t;
static sensor_manager_t sensor_manager = {0};
// 初始化传感器管理器
bool sensor_manager_init(void)
{
if (sensor_manager.initialized) {
return true;
}
sensor_manager.adapter_count = 0;
sensor_manager.initialized = true;
printf("Sensor Manager: Initialized\n");
return true;
}
// 注册传感器适配器
bool sensor_manager_register_adapter(sensor_adapter_t *adapter)
{
if (!sensor_manager.initialized ||
sensor_manager.adapter_count >= MAX_SENSORS ||
adapter == NULL) {
return false;
}
// 注册时自动初始化适配器
if (adapter->initialize != NULL && !adapter->initialize()) {
printf("Failed to initialize adapter: %s\n", adapter->sensor_name);
return false;
}
sensor_manager.adapters[sensor_manager.adapter_count++] = adapter;
printf("Registered sensor adapter: %s\n", adapter->sensor_name);
return true;
}
// 通过索引读取指定传感器数据
bool sensor_manager_read_data(uint8_t sensor_index, sensor_data_t *data)
{
if (!sensor_manager.initialized ||
sensor_index >= sensor_manager.adapter_count ||
data == NULL) {
return false;
}
sensor_adapter_t *adapter = sensor_manager.adapters[sensor_index];
if (adapter->read_all_data == NULL) {
return false;
}
return adapter->read_all_data(data);
}
// 批量读取所有已注册传感器的数据
uint8_t sensor_manager_read_all_sensors(sensor_data_t *data_array, uint8_t max_sensors)
{
if (!sensor_manager.initialized || data_array == NULL) {
return 0;
}
uint8_t successful_reads = 0;
for (uint8_t i = 0; i < sensor_manager.adapter_count && successful_reads < max_sensors; i++) {
if (sensor_manager_read_data(i, &data_array[successful_reads])) {
successful_reads++;
}
}
return successful_reads;
}
// 按名称查找传感器适配器
sensor_adapter_t *sensor_manager_find_adapter(const char *sensor_name)
{
if (!sensor_manager.initialized || sensor_name == NULL) {
return NULL;
}
for (uint8_t i = 0; i < sensor_manager.adapter_count; i++) {
if (strcmp(sensor_manager.adapters[i]->sensor_name, sensor_name) == 0) {
return sensor_manager.adapters[i];
}
}
return NULL;
}
第五步：应用示例
现在，上层应用可以完全不用关心底层是BME280还是DHT11，统一通过sensor_adapter_t接口和传感器管理器进行操作，实现了内存管理和硬件访问的抽象化。
int main(void) {
// 1. 初始化管理器
sensor_manager_init();
// 2. 注册所有可用的传感器适配器
sensor_manager_register_adapter(&bme280_adapter);
sensor_manager_register_adapter(&dht11_adapter);
// 3. 配置传感器（例如，设置为高精度模式）
sensor_config_t high_precision_config = {
.precision = PRECISION_HIGH,
.sample_rate = 1,
.averaging_samples = 4,
.calibration_enabled = true,
.calibration_offset = 0.0f
};
sensor_adapter_t *bme280 = sensor_manager_find_adapter("BME280");
if (bme280 && bme280->configure) {
bme280->configure(&high_precision_config);
}
// 4. 读取数据 - 方式一：直接通过适配器接口
if (bme280) {
int32_t temp = bme280->read_temperature();
if (temp != INT32_MIN) {
printf("BME280 Temperature: %.2f C\n", temp / 100.0f);
}
}
// 5. 读取数据 - 方式二：通过管理器批量读取
sensor_data_t sensor_data[2];
uint8_t count = sensor_manager_read_all_sensors(sensor_data, 2);
for (int i = 0; i < count; i++) {
printf("Sensor[%d]: T=%.1fC, H=%.1f%%, P=%.1fhPa\n",
sensor_data[i].sensor_id,
sensor_data[i].temperature,
sensor_data[i].humidity,
sensor_data[i].pressure);
}
return 0;
}
总结与优势分析
通过以上完整的实战示例，我们可以看到适配器模式在嵌入式系统中带来的显著优势：
- 接口统一，降低复杂度：上层应用只需面对一套统一的API，无需关心底层是I2C、SPI还是单总线通信。
- 硬件解耦，提高可维护性：当需要更换传感器（例如从DHT11升级到BME280）时，只需提供新的适配器，业务逻辑代码几乎无需改动。
- 向后兼容，平滑升级：可以轻松兼容旧版驱动或硬件，为新旧组件共存提供可能。
- 功能适配与填补：适配器可以处理类似DHT11不支持气压的功能缺失情况，返回合理错误或默认值，保证接口行为的一致性。
- 便于测试与模拟：可以创建“模拟传感器适配器”用于单元测试，无需连接真实硬件。
无论是应对多样的传感器接口、复杂的协议转换，还是驱动兼容性挑战，适配器模式都提供了一种结构清晰、扩展性强的解决方案。掌握这种设计思想，对于构建稳定、可维护的嵌入式系统至关重要。
如果你对嵌入式系统设计模式或底层开发有更多兴趣，欢迎在云栈社区与其他开发者交流探讨。
发表于 前天 06:11
|
查看: 6|
回复: 0
