系统架构设计¶

// 网关主要模块
struct gateway_system {
    // 协议栈管理
    struct protocol_manager {
        struct zigbee_coordinator *zigbee;
        struct thread_border_router *thread;
        struct ble_central *ble;
        struct wifi_station *wifi;
    } protocols;

    // 设备管理
    struct device_manager {
        struct device_list devices;
        struct pairing_service pairing;
        struct device_discovery discovery;
    } devices;

    // 自动化引擎
    struct automation_engine {
        struct scene_list scenes;
        struct rule_engine rules;
        struct scheduler scheduler;
    } automation;

    // 云端连接
    struct cloud_connector {
        struct mqtt_client *mqtt;
        struct https_client *https;
        struct ota_manager *ota;
    } cloud;
};

// 传感器节点 OTA 配置
CONFIG_BOOTLOADER_MCUBOOT=y
CONFIG_IMG_MANAGER=y
CONFIG_MCUBOOT_IMG_MANAGER=y
CONFIG_IMG_ERASE_PROGRESSIVELY=y

// OTA 升级流程
void ota_upgrade_handler(void) {
    // 1. 接收固件包
    while (receiving_firmware) {
        uint8_t *chunk = zigbee_receive_chunk();
        img_mgmt_impl_write_image_data(offset, chunk, chunk_size);
        offset += chunk_size;
    }

    // 2. 验证固件
    if (img_mgmt_impl_verify_image() == 0) {
        // 3. 标记为待测试
        boot_set_pending(1);

        // 4. 重启到新固件
        sys_reboot(SYS_REBOOT_WARM);
    }
}

// 基于证书的设备认证
struct device_identity {
    uint8_t device_id[16];           // 唯一设备 ID
    uint8_t manufacturer_cert[256];  // 制造商证书
    uint8_t device_cert[256];        // 设备证书
    uint8_t private_key[32];         // 设备私钥
};

// 设备配对流程
int device_pairing(struct device_identity *id) {
    // 1. 交换证书
    exchange_certificates(id->device_cert, id->manufacturer_cert);

    // 2. 验证证书链
    if (!verify_certificate_chain()) {
        return -EAUTH;
    }

    // 3. 生成会话密钥
    uint8_t session_key[32];
    ecdh_generate_shared_secret(id->private_key, peer_public_key, session_key);

    // 4. 保存配对信息
    save_pairing_info(id->device_id, session_key);

    return 0;
}

// AES-128 加密通信
struct encrypted_message {
    uint8_t iv[16];           // 初始化向量
    uint8_t payload[256];     // 加密数据
    uint8_t mac[16];          // 消息认证码
};

int send_encrypted_message(const uint8_t *data, size_t len) {
    struct encrypted_message msg;

    // 1. 生成随机 IV
    sys_csrand_get(msg.iv, sizeof(msg.iv));

    // 2. AES-128-CBC 加密
    aes_encrypt_cbc(session_key, msg.iv, data, len, msg.payload);

    // 3. 计算 HMAC-SHA256
    hmac_sha256(session_key, msg.payload, len, msg.mac);

    // 4. 发送加密消息
    return zigbee_send(&msg, sizeof(msg));
}

// 主应用线程
void gateway_main_thread(void) {
    // 初始化各协议栈
    zigbee_coordinator_init();
    thread_border_router_init();
    ble_central_init();
    wifi_station_init();

    // 启动设备管理服务
    device_manager_start();

    // 启动自动化引擎
    automation_engine_start();

    // 连接云端
    mqtt_connect("mqtt.example.com", 8883);

    // 主循环
    while (1) {
        // 处理协议栈事件
        process_protocol_events();

        // 处理自动化规则
        process_automation_rules();

        // 同步云端状态
        sync_cloud_state();

        k_sleep(K_MSEC(100));
    }
}

// 设备发现和配对
void device_discovery_thread(void) {
    while (1) {
        // 扫描 Zigbee 设备
        struct zigbee_device *zb_dev = zigbee_scan_devices();
        if (zb_dev) {
            device_manager_add(zb_dev, PROTOCOL_ZIGBEE);
        }

        // 扫描 BLE 设备
        struct ble_device *ble_dev = ble_scan_devices();
        if (ble_dev) {
            device_manager_add(ble_dev, PROTOCOL_BLE);
        }

        k_sleep(K_SECONDS(5));
    }
}

// 场景自动化示例
void scene_automation_example(void) {
    // 定义"回家模式"场景
    struct scene home_scene = {
        .name = "回家模式",
        .triggers = {
            {.type = TRIGGER_DOOR_UNLOCK, .device_id = "lock_001"},
            {.type = TRIGGER_TIME, .time = "18:00"},
        },
        .actions = {
            {.type = ACTION_LIGHT_ON, .device_id = "light_001"},
            {.type = ACTION_LIGHT_ON, .device_id = "light_002"},
            {.type = ACTION_THERMOSTAT_SET, .device_id = "thermo_001", .value = 24},
        },
    };

    automation_engine_add_scene(&home_scene);
}

// 使用 Zephyr 的抢占式调度实现确定性
#define PRIORITY_CRITICAL    0   // 最高优先级：安全监控
#define PRIORITY_HIGH        5   // 高优先级：数据采集
#define PRIORITY_NORMAL      10  // 普通优先级：数据处理
#define PRIORITY_LOW         15  // 低优先级：日志记录

// 关键任务：安全监控（1ms 周期）
void safety_monitor_thread(void) {
    while (1) {
        // 检查安全参数
        if (check_temperature() > TEMP_THRESHOLD ||
            check_pressure() > PRESSURE_THRESHOLD) {
            // 立即触发紧急停机
            emergency_shutdown();
        }

        k_sleep(K_USEC(1000));  // 1ms 周期
    }
}
K_THREAD_DEFINE(safety_tid, 2048, safety_monitor_thread, NULL, NULL, NULL,
                PRIORITY_CRITICAL, 0, 0);

// 高优先级任务：数据采集（10ms 周期）
void data_acquisition_thread(void) {
    while (1) {
        // 采集传感器数据
        float temp = read_temperature_sensor();
        float vibration = read_vibration_sensor();
        float pressure = read_pressure_sensor();

        // 存入缓冲区
        data_buffer_push(temp, vibration, pressure);

        k_sleep(K_MSEC(10));  // 10ms 周期
    }
}
K_THREAD_DEFINE(acq_tid, 4096, data_acquisition_thread, NULL, NULL, NULL,
                PRIORITY_HIGH, 0, 0);

// PTP 时间同步配置
CONFIG_NET_GPTP=y
CONFIG_NET_GPTP_VLAN=y

// 时间同步初始化
void time_sync_init(void) {
    struct gptp_domain *domain;

    // 配置 PTP 域
    domain = gptp_get_domain();
    gptp_set_priority1(domain, 128);
    gptp_set_priority2(domain, 128);

    // 启动 PTP 协议
    gptp_start();

    printk("PTP time synchronization started\n");
}

// 获取同步时间戳
uint64_t get_synchronized_timestamp(void) {
    struct net_ptp_time ts;

    gptp_get_time(&ts);

    return (uint64_t)ts.second * 1000000000ULL + ts.nanosecond;
}

// 主备切换机制
enum gateway_role {
    ROLE_PRIMARY,
    ROLE_BACKUP,
};

struct gateway_ha {
    enum gateway_role role;
    const struct device *peer_comm;  // 与对端通信
    k_timer_t heartbeat_timer;
    uint32_t peer_heartbeat_count;
};

void ha_heartbeat_handler(struct k_timer *timer) {
    struct gateway_ha *ha = CONTAINER_OF(timer, struct gateway_ha, heartbeat_timer);

    if (ha->role == ROLE_PRIMARY) {
        // 主设备发送心跳
        send_heartbeat(ha->peer_comm);
    } else {
        // 备设备检查心跳
        if (ha->peer_heartbeat_count == 0) {
            // 主设备失联，切换为主
            LOG_WRN("Primary gateway failed, taking over");
            ha->role = ROLE_PRIMARY;
            activate_gateway_services();
        }
        ha->peer_heartbeat_count = 0;
    }
}

// 传感器融合数据结构
struct sensor_fusion_data {
    uint64_t timestamp;
    float temperature;
    float vibration_x;
    float vibration_y;
    float vibration_z;
    float pressure;
    float current;
};

// 同步采集多个传感器
void synchronized_acquisition(struct sensor_fusion_data *data) {
    // 获取同步时间戳
    data->timestamp = get_synchronized_timestamp();

    // 同时触发所有传感器采样
    trigger_all_sensors();

    // 等待采样完成
    k_sleep(K_USEC(100));

    // 读取所有传感器数据
    data->temperature = read_temperature();
    data->vibration_x = read_vibration_x();
    data->vibration_y = read_vibration_y();
    data->vibration_z = read_vibration_z();
    data->pressure = read_pressure();
    data->current = read_current();
}

// 使用 DMA 实现高速 ADC 采集
#define SAMPLE_RATE     10000  // 10kHz
#define BUFFER_SIZE     1024

static uint16_t adc_buffer[BUFFER_SIZE];
static struct k_sem adc_sem;

void adc_dma_callback(const struct device *dev, void *user_data,
                      uint32_t channel, int status) {
    if (status == 0) {
        k_sem_give(&adc_sem);
    }
}

void high_speed_acquisition_thread(void) {
    const struct device *adc = DEVICE_DT_GET(DT_NODELABEL(adc0));

    // 配置 ADC DMA 模式
    struct adc_sequence sequence = {
        .buffer = adc_buffer,
        .buffer_size = sizeof(adc_buffer),
        .resolution = 12,
        .oversampling = 0,
        .channels = BIT(0),
    };

    while (1) {
        // 启动 DMA 采集
        adc_read_async(adc, &sequence, &adc_sem);

        // 等待采集完成
        k_sem_take(&adc_sem, K_FOREVER);

        // 处理采集数据
        process_adc_data(adc_buffer, BUFFER_SIZE);
    }
}

// FFT 频谱分析（用于振动监测）
#include <zephyr/dsp/dsp.h>

void vibration_analysis(float *samples, size_t count) {
    // 执行 FFT
    float fft_output[FFT_SIZE];
    arm_rfft_fast_f32(&fft_instance, samples, fft_output, 0);

    // 计算功率谱
    float power_spectrum[FFT_SIZE / 2];
    for (int i = 0; i < FFT_SIZE / 2; i++) {
        float real = fft_output[2 * i];
        float imag = fft_output[2 * i + 1];
        power_spectrum[i] = sqrtf(real * real + imag * imag);
    }

    // 检测异常频率
    for (int i = 0; i < FFT_SIZE / 2; i++) {
        float freq = (float)i * SAMPLE_RATE / FFT_SIZE;
        if (power_spectrum[i] > THRESHOLD && 
            freq > FAULT_FREQ_MIN && freq < FAULT_FREQ_MAX) {
            LOG_WRN("Abnormal vibration detected at %.1f Hz", freq);
            trigger_alarm(ALARM_VIBRATION_ABNORMAL);
        }
    }
}

// 简单的趋势分析
struct trend_analyzer {
    float history[HISTORY_SIZE];
    size_t index;
    float slope;
};

void update_trend(struct trend_analyzer *ta, float value) {
    ta->history[ta->index] = value;
    ta->index = (ta->index + 1) % HISTORY_SIZE;

    // 计算线性回归斜率
    ta->slope = calculate_linear_regression_slope(ta->history, HISTORY_SIZE);

    // 预测未来值
    float predicted = value + ta->slope * PREDICTION_STEPS;

    if (predicted > FAILURE_THRESHOLD) {
        LOG_WRN("Predicted failure in %d steps", PREDICTION_STEPS);
        schedule_maintenance();
    }
}

// 主监控系统
struct monitoring_system {
    // 数据采集
    struct {
        struct k_thread thread;
        struct k_msgq data_queue;
    } acquisition;

    // 数据分析
    struct {
        struct k_thread thread;
        struct trend_analyzer analyzers[10];
    } analysis;

    // 数据存储
    struct {
        struct k_thread thread;
        struct ring_buffer *buffer;
    } storage;

    // 云端同步
    struct {
        struct k_thread thread;
        struct mqtt_client *client;
    } cloud;
};

// 初始化监控系统
void monitoring_system_init(struct monitoring_system *sys) {
    // 创建数据采集线程
    k_thread_create(&sys->acquisition.thread, acq_stack, STACK_SIZE,
                    acquisition_thread_entry, sys, NULL, NULL,
                    PRIORITY_HIGH, 0, K_NO_WAIT);

    // 创建数据分析线程
    k_thread_create(&sys->analysis.thread, analysis_stack, STACK_SIZE,
                    analysis_thread_entry, sys, NULL, NULL,
                    PRIORITY_NORMAL, 0, K_NO_WAIT);

    // 创建数据存储线程
    k_thread_create(&sys->storage.thread, storage_stack, STACK_SIZE,
                    storage_thread_entry, sys, NULL, NULL,
                    PRIORITY_LOW, 0, K_NO_WAIT);

    // 创建云端同步线程
    k_thread_create(&sys->cloud.thread, cloud_stack, STACK_SIZE,
                    cloud_thread_entry, sys, NULL, NULL,
                    PRIORITY_LOW, 0, K_NO_WAIT);
}

// 功耗状态定义
enum power_state {
    POWER_ACTIVE,       // 活跃状态：所有功能开启
    POWER_IDLE,         // 空闲状态：显示关闭，传感器低频采样
    POWER_SLEEP,        // 睡眠状态：仅保持时钟和加速度计
    POWER_DEEP_SLEEP,   // 深度睡眠：仅 RTC 运行
};

struct power_manager {
    enum power_state current_state;
    uint32_t idle_timeout;
    uint32_t sleep_timeout;
    struct k_timer idle_timer;
    struct k_timer sleep_timer;
};

// 功耗状态机
void power_state_transition(struct power_manager *pm, enum power_state new_state) {
    if (pm->current_state == new_state) {
        return;
    }

    switch (new_state) {
    case POWER_ACTIVE:
        // 唤醒所有外设
        display_on();
        enable_all_sensors();
        set_cpu_freq(64000000);  // 64MHz
        break;

    case POWER_IDLE:
        // 关闭显示，降低采样率
        display_off();
        reduce_sensor_sampling_rate();
        set_cpu_freq(32000000);  // 32MHz
        k_timer_start(&pm->sleep_timer, K_SECONDS(pm->sleep_timeout), K_NO_WAIT);
        break;

    case POWER_SLEEP:
        // 仅保持必要传感器
        disable_non_essential_sensors();
        enable_motion_detection();  // 运动检测唤醒
        set_cpu_freq(16000000);  // 16MHz
        break;

    case POWER_DEEP_SLEEP:
        // 进入深度睡眠
        disable_all_sensors();
        pm_device_action_run(PM_DEVICE_ACTION_SUSPEND);
        break;
    }

    pm->current_state = new_state;
    LOG_INF("Power state: %d", new_state);
}

// 用户活动检测
void user_activity_handler(void) {
    // 检测到用户活动，切换到活跃状态
    power_state_transition(&pm, POWER_ACTIVE);

    // 重启空闲定时器
    k_timer_start(&pm.idle_timer, K_SECONDS(pm.idle_timeout), K_NO_WAIT);
}

// 心率传感器智能采样
struct hr_sensor_config {
    bool continuous_mode;  // 连续模式 vs 按需模式
    uint32_t sample_interval;
    uint32_t active_duration;
};

void hr_sensor_smart_sampling(struct hr_sensor_config *cfg) {
    if (cfg->continuous_mode) {
        // 运动时：连续采样
        hr_sensor_set_mode(HR_MODE_CONTINUOUS);
        hr_sensor_set_rate(HR_RATE_HIGH);  // 1Hz
    } else {
        // 静止时：间歇采样
        hr_sensor_set_mode(HR_MODE_SINGLE_SHOT);

        // 每 5 分钟采样一次
        while (1) {
            hr_sensor_trigger_measurement();
            k_sleep(K_MSEC(cfg->active_duration));  // 采样 10 秒
            hr_sensor_power_down();
            k_sleep(K_MINUTES(5));
        }
    }
}

// 姿态估计（使用互补滤波器）
struct attitude_estimator {
    float roll;
    float pitch;
    float yaw;
    float alpha;  // 滤波系数
};

void update_attitude(struct attitude_estimator *est,
                     float acc_x, float acc_y, float acc_z,
                     float gyro_x, float gyro_y, float gyro_z,
                     float dt) {
    // 从加速度计计算倾角
    float acc_roll = atan2f(acc_y, acc_z);
    float acc_pitch = atan2f(-acc_x, sqrtf(acc_y * acc_y + acc_z * acc_z));

    // 从陀螺仪积分角度
    float gyro_roll = est->roll + gyro_x * dt;
    float gyro_pitch = est->pitch + gyro_y * dt;
    float gyro_yaw = est->yaw + gyro_z * dt;

    // 互补滤波融合
    est->roll = est->alpha * gyro_roll + (1 - est->alpha) * acc_roll;
    est->pitch = est->alpha * gyro_pitch + (1 - est->alpha) * acc_pitch;
    est->yaw = gyro_yaw;  // 偏航角仅依赖陀螺仪
}

// 步数检测算法
struct step_detector {
    float acc_magnitude_history[WINDOW_SIZE];
    size_t history_index;
    uint32_t step_count;
    uint64_t last_step_time;
};

void detect_steps(struct step_detector *sd, float acc_x, float acc_y, float acc_z) {
    // 计算加速度幅值
    float magnitude = sqrtf(acc_x * acc_x + acc_y * acc_y + acc_z * acc_z);

    // 更新历史数据
    sd->acc_magnitude_history[sd->history_index] = magnitude;
    sd->history_index = (sd->history_index + 1) % WINDOW_SIZE;

    // 计算平均值和标准差
    float mean = calculate_mean(sd->acc_magnitude_history, WINDOW_SIZE);
    float std_dev = calculate_std_dev(sd->acc_magnitude_history, WINDOW_SIZE);

    // 峰值检测
    if (magnitude > mean + THRESHOLD * std_dev) {
        uint64_t current_time = k_uptime_get();

        // 防止重复计数（最小步频限制）
        if (current_time - sd->last_step_time > MIN_STEP_INTERVAL) {
            sd->step_count++;
            sd->last_step_time = current_time;
            LOG_DBG("Step detected, total: %u", sd->step_count);
        }
    }
}

// 触摸事件处理
enum touch_gesture {
    GESTURE_TAP,
    GESTURE_DOUBLE_TAP,
    GESTURE_LONG_PRESS,
    GESTURE_SWIPE_UP,
    GESTURE_SWIPE_DOWN,
    GESTURE_SWIPE_LEFT,
    GESTURE_SWIPE_RIGHT,
};

struct touch_handler {
    uint32_t touch_start_time;
    int16_t touch_start_x;
    int16_t touch_start_y;
    bool touch_active;
};

enum touch_gesture detect_gesture(struct touch_handler *th,
                                   int16_t x, int16_t y, bool pressed) {
    if (pressed && !th->touch_active) {
        // 触摸开始
        th->touch_start_time = k_uptime_get_32();
        th->touch_start_x = x;
        th->touch_start_y = y;
        th->touch_active = true;
        return GESTURE_NONE;
    }

    if (!pressed && th->touch_active) {
        // 触摸结束
        th->touch_active = false;
        uint32_t duration = k_uptime_get_32() - th->touch_start_time;
        int16_t dx = x - th->touch_start_x;
        int16_t dy = y - th->touch_start_y;

        // 判断手势
        if (duration < TAP_DURATION && abs(dx) < TAP_THRESHOLD && abs(dy) < TAP_THRESHOLD) {
            return GESTURE_TAP;
        } else if (duration > LONG_PRESS_DURATION) {
            return GESTURE_LONG_PRESS;
        } else if (abs(dx) > SWIPE_THRESHOLD) {
            return dx > 0 ? GESTURE_SWIPE_RIGHT : GESTURE_SWIPE_LEFT;
        } else if (abs(dy) > SWIPE_THRESHOLD) {
            return dy > 0 ? GESTURE_SWIPE_DOWN : GESTURE_SWIPE_UP;
        }
    }

    return GESTURE_NONE;
}

// 振动马达控制
void haptic_feedback(enum haptic_pattern pattern) {
    const struct device *motor = DEVICE_DT_GET(DT_NODELABEL(vibration_motor));

    switch (pattern) {
    case HAPTIC_SHORT:
        // 短振动：按键反馈
        pwm_set_pulse_dt(motor, PWM_USEC(50));
        k_sleep(K_MSEC(50));
        pwm_set_pulse_dt(motor, 0);
        break;

    case HAPTIC_LONG:
        // 长振动：通知提醒
        pwm_set_pulse_dt(motor, PWM_USEC(100));
        k_sleep(K_MSEC(200));
        pwm_set_pulse_dt(motor, 0);
        break;

    case HAPTIC_DOUBLE:
        // 双振动：重要提醒
        for (int i = 0; i < 2; i++) {
            pwm_set_pulse_dt(motor, PWM_USEC(80));
            k_sleep(K_MSEC(100));
            pwm_set_pulse_dt(motor, 0);
            k_sleep(K_MSEC(100));
        }
        break;
    }
}

// BLE 数据同步服务
struct sync_service {
    struct bt_conn *conn;
    struct k_msgq sync_queue;
    bool sync_in_progress;
};

// 同步数据包
struct sync_packet {
    uint8_t type;  // 数据类型：步数、心率、睡眠等
    uint64_t timestamp;
    uint8_t data[256];
    size_t data_len;
};

// 数据同步线程
void data_sync_thread(void *arg) {
    struct sync_service *svc = arg;
    struct sync_packet packet;

    while (1) {
        // 等待连接
        if (!svc->conn) {
            k_sleep(K_SECONDS(1));
            continue;
        }

        // 从队列获取待同步数据
        if (k_msgq_get(&svc->sync_queue, &packet, K_NO_WAIT) == 0) {
            // 发送数据包
            bt_gatt_notify(svc->conn, &sync_attr, &packet, sizeof(packet));

            // 等待确认
            k_sleep(K_MSEC(100));
        } else {
            k_sleep(K_MSEC(500));
        }
    }
}

// 添加数据到同步队列
void queue_data_for_sync(uint8_t type, const void *data, size_t len) {
    struct sync_packet packet = {
        .type = type,
        .timestamp = k_uptime_get(),
        .data_len = MIN(len, sizeof(packet.data)),
    };

    memcpy(packet.data, data, packet.data_len);
    k_msgq_put(&sync_svc.sync_queue, &packet, K_NO_WAIT);
}

// 智能手环主系统
struct smartband_system {
    // 传感器管理
    struct {
        struct sensor_device *imu;
        struct sensor_device *hr;
        struct sensor_device *env;
    } sensors;

    // 数据处理
    struct {
        struct step_detector step_det;
        struct hr_monitor hr_mon;
        struct sleep_analyzer sleep_ana;
    } analytics;

    // 用户界面
    struct {
        struct display_device *display;
        struct touch_handler touch;
        enum ui_screen current_screen;
    } ui;

    // 通信
    struct {
        struct bt_conn *conn;
        struct sync_service sync;
        struct notification_service notify;
    } comm;

    // 功耗管理
    struct power_manager pm;
};

// 主循环
void smartband_main(void) {
    struct smartband_system sys;

    // 初始化系统
    smartband_init(&sys);

    while (1) {
        // 更新传感器数据
        update_sensors(&sys);

        // 数据分析
        analyze_data(&sys);

        // 更新 UI
        update_ui(&sys);

        // 处理通信
        handle_communication(&sys);

        // 功耗管理
        manage_power(&sys);

        k_sleep(K_MSEC(100));
    }
}

// 2oo3 表决系统
struct voting_system {
    float (*read_sensor_a)(void);
    float (*read_sensor_b)(void);
    float (*read_sensor_c)(void);
};

float read_with_voting(struct voting_system *vs) {
    float value_a = vs->read_sensor_a();
    float value_b = vs->read_sensor_b();
    float value_c = vs->read_sensor_c();

    // 2oo3 表决逻辑
    if (fabs(value_a - value_b) < TOLERANCE) {
        return (value_a + value_b) / 2.0f;
    } else if (fabs(value_a - value_c) < TOLERANCE) {
        return (value_a + value_c) / 2.0f;
    } else if (fabs(value_b - value_c) < TOLERANCE) {
        return (value_b + value_c) / 2.0f;
    } else {
        // 三个值都不一致，触发告警
        LOG_ERR("Voting failed: A=%.2f, B=%.2f, C=%.2f", value_a, value_b, value_c);
        trigger_alarm(ALARM_SENSOR_DISAGREEMENT);
        return value_a;  // 返回主传感器值
    }
}

// 软件多版本执行
struct software_redundancy {
    int (*algorithm_v1)(int input);
    int (*algorithm_v2)(int input);
    int (*algorithm_v3)(int input);
};

int execute_with_redundancy(struct software_redundancy *sr, int input) {
    int result_v1 = sr->algorithm_v1(input);
    int result_v2 = sr->algorithm_v2(input);
    int result_v3 = sr->algorithm_v3(input);

    // 多数表决
    if (result_v1 == result_v2) {
        return result_v1;
    } else if (result_v1 == result_v3) {
        return result_v1;
    } else if (result_v2 == result_v3) {
        return result_v2;
    } else {
        LOG_ERR("Software voting failed");
        return result_v1;
    }
}

// 多级 Watchdog 系统
struct watchdog_system {
    const struct device *wdt_hw;      // 硬件 Watchdog
    struct k_timer wdt_sw_timer;      // 软件 Watchdog
    uint32_t task_heartbeats[MAX_TASKS];
    uint32_t last_feed_time;
};

// 任务心跳
void task_heartbeat(int task_id) {
    wdt_sys.task_heartbeats[task_id] = k_uptime_get_32();
}

// 软件 Watchdog 检查
void software_watchdog_check(struct k_timer *timer) {
    uint32_t current_time = k_uptime_get_32();

    // 检查所有任务心跳
    for (int i = 0; i < MAX_TASKS; i++) {
        if (current_time - wdt_sys.task_heartbeats[i] > TASK_TIMEOUT) {
            LOG_ERR("Task %d timeout", i);
            // 尝试恢复任务
            restart_task(i);
        }
    }

    // 喂硬件 Watchdog
    wdt_feed(wdt_sys.wdt_hw, 0);
    wdt_sys.last_feed_time = current_time;
}

// 系统健康检查
struct health_monitor {
    uint32_t cpu_usage;
    uint32_t memory_usage;
    uint32_t task_count;
    uint32_t error_count;
};

void system_health_check(struct health_monitor *hm) {
    // CPU 使用率检查
    hm->cpu_usage = get_cpu_usage();
    if (hm->cpu_usage > CPU_USAGE_THRESHOLD) {
        LOG_WRN("High CPU usage: %u%%", hm->cpu_usage);
    }

    // 内存使用率检查
    hm->memory_usage = get_memory_usage();
    if (hm->memory_usage > MEMORY_USAGE_THRESHOLD) {
        LOG_WRN("High memory usage: %u%%", hm->memory_usage);
    }

    // 任务数量检查
    hm->task_count = get_task_count();
    if (hm->task_count > MAX_TASK_COUNT) {
        LOG_ERR("Too many tasks: %u", hm->task_count);
    }

    // 错误计数检查
    if (hm->error_count > ERROR_COUNT_THRESHOLD) {
        LOG_ERR("Too many errors: %u", hm->error_count);
        trigger_system_recovery();
    }
}

// 异常捕获和记录
void exception_handler(void) {
    // 保存异常上下文
    struct exception_context ctx;
    save_exception_context(&ctx);

    // 记录异常信息
    LOG_ERR("Exception occurred:");
    LOG_ERR("  PC: 0x%08x", ctx.pc);
    LOG_ERR("  LR: 0x%08x", ctx.lr);
    LOG_ERR("  SP: 0x%08x", ctx.sp);
    LOG_ERR("  Exception type: %u", ctx.exception_type);

    // 保存到非易失性存储
    save_crash_dump(&ctx);

    // 尝试恢复或重启
    if (can_recover()) {
        recover_from_exception();
    } else {
        sys_reboot(SYS_REBOOT_WARM);
    }
}