基于FreeRTOS的嵌入式智能可穿戴设备系统设计#

1
// 传感器数据消息队列
2
QueueHandle_t sensor_data_queue;
3
sensor_data_queue = xQueueCreate(10, sizeof(SensorData_t));
4

5
// GUI更新消息队列
6
QueueHandle_t gui_update_queue;
7
gui_update_queue = xQueueCreate(5, sizeof(GUI_Update_t));

1
// SPI总线互斥锁
2
SemaphoreHandle_t spi_mutex;
3
spi_mutex = xSemaphoreCreateMutex();
4

5
// 数据就绪信号量
6
SemaphoreHandle_t data_ready_sem;
7
data_ready_sem = xSemaphoreCreateBinary();

1
// 系统事件标志组
2
EventGroupHandle_t system_events;
3
system_events = xEventGroupCreate();
4

5
// 事件定义
6
#define SENSOR_DATA_READY_BIT (1 << 0)
7
#define GUI_REFRESH_BIT (1 << 1)
8
#define LOW_BATTERY_BIT (1 << 2)

1
// PPG信号滤波处理
2
typedef struct {
3
    float raw_signal;
4
    float filtered_signal;
5
    float dc_component;
6
    float ac_component;
7
} PPG_Signal_t;
8

9
// 自适应带通滤波器设计
10
void adaptive_bandpass_filter(PPG_Signal_t* signal, float heart_rate) {
11
    // 根据心率动态调整截止频率
12
    float low_cutoff = heart_rate * 0.8 / 60.0;  // Hz
13
    float high_cutoff = heart_rate * 1.2 / 60.0; // Hz
14

15
    // 实现二阶Butterworth滤波器
16
    // ...
17
}

1
float calculate_heart_rate(float* ppg_signal, int sample_count, float sample_rate) {
2
    float max_correlation = 0;
3
    int best_lag = 0;
4

5
    // 计算自相关函数
6
    for (int lag = MIN_LAG; lag <= MAX_LAG; lag++) {
7
        float correlation = 0;
8
        for (int i = 0; i < sample_count - lag; i++) {
9
            correlation += ppg_signal[i] * ppg_signal[i + lag];
10
        }
11

12
        if (correlation > max_correlation) {
13
            max_correlation = correlation;
14
            best_lag = lag;
15
        }
16
    }
17

18
    // 计算心率（次/分钟）
19
    return 60.0 * sample_rate / best_lag;
20
}

1
// 计算SDNN（正常窦性心搏间期的标准差）
2
float calculate_sdnn(float* rr_intervals, int count) {
3
    float mean = 0;
4
    for (int i = 0; i < count; i++) {
5
        mean += rr_intervals[i];
6
    }
7
    mean /= count;
8

9
    float variance = 0;
10
    for (int i = 0; i < count; i++) {
11
        variance += (rr_intervals[i] - mean) * (rr_intervals[i] - mean);
12
    }
13

14
    return sqrt(variance / count);
15
}

1
// 三轴加速度合成与重力去除
2
typedef struct {
3
    float x, y, z;
4
    float magnitude;
5
    float filtered;
6
} Acceleration_t;
7

8
void process_acceleration(Acceleration_t* accel) {
9
    // 计算合加速度
10
    accel->magnitude = sqrt(accel->x * accel->x +
11
                           accel->y * accel->y +
12
                           accel->z * accel->z);
13

14
    // 去除重力分量（高通滤波）
15
    static float gravity = 9.81;
16
    accel->filtered = accel->magnitude - gravity;
17
}

1
// 步数检测状态机
2
typedef enum {
3
    STEP_IDLE,
4
    STEP_POSITIVE_SLOPE,
5
    STEP_PEAK_DETECTED,
6
    STEP_NEGATIVE_SLOPE,
7
    STEP_VALLEY_DETECTED
8
} Step_State_t;
9

10
int detect_steps(float* acceleration, int sample_count, float threshold) {
11
    int step_count = 0;
12
    Step_State_t state = STEP_IDLE;
13
    float prev_value = acceleration[0];
14

15
    for (int i = 1; i < sample_count; i++) {
16
        float current = acceleration[i];
17

18
        switch (state) {
19
            case STEP_IDLE:
20
                if (current > threshold && prev_value <= threshold) {
21
                    state = STEP_POSITIVE_SLOPE;
22
                }
23
                break;
24

25
            case STEP_POSITIVE_SLOPE:
26
                if (current < prev_value) {
27
                    state = STEP_PEAK_DETECTED;
28
                }
29
                break;
30

31
            case STEP_PEAK_DETECTED:
32
                step_count++;
33
                state = STEP_NEGATIVE_SLOPE;
34
                break;
35

36
            case STEP_NEGATIVE_SLOPE:
37
                if (current > threshold) {
38
                    state = STEP_POSITIVE_SLOPE;
39
                } else if (current < -threshold) {
40
                    state = STEP_VALLEY_DETECTED;
41
                }
42
                break;
43

44
            case STEP_VALLEY_DETECTED:
45
                if (current > -threshold) {
46
                    state = STEP_IDLE;
47
                }
48
                break;
49
        }
50

51
        prev_value = current;
52
    }
53

54
    return step_count;
55
}

1
typedef struct {
2
    float activity_level;      // 活动水平
3
    float body_movement;       // 身体移动强度
4
    float position_changes;    // 体位变化次数
5
    float sleep_score;         // 睡眠评分
6
} Sleep_Analysis_t;
7

8
void analyze_sleep_pattern(Acceleration_t* accel_data, int sample_count,
9
                          Sleep_Analysis_t* analysis) {
10
    float total_activity = 0;
11
    int movement_count = 0;
12

13
    for (int i = 0; i < sample_count; i++) {
14
        // 计算活动水平
15
        float activity = fabs(accel_data[i].filtered);
16
        total_activity += activity;
17

18
        // 检测显著运动
19
        if (activity > MOVEMENT_THRESHOLD) {
20
            movement_count++;
21
        }
22
    }
23

24
    analysis->activity_level = total_activity / sample_count;
25
    analysis->body_movement = movement_count;
26
    analysis->position_changes = detect_position_changes(accel_data, sample_count);
27
    analysis->sleep_score = calculate_sleep_score(analysis);
28
}

1
typedef enum {
2
    SLEEP_AWAKE,
3
    SLEEP_REM,
4
    SLEEP_LIGHT,
5
    SLEEP_DEEP
6
} Sleep_Stage_t;
7

8
Sleep_Stage_t classify_sleep_stage(float activity_level, float heart_rate_variability,
9
                                  float time_since_sleep_start) {
10
    if (activity_level > 0.5) {
11
        return SLEEP_AWAKE;
12
    }
13

14
    if (time_since_sleep_start < 60) {  // 入睡初期
15
        if (heart_rate_variability < 30) {
16
            return SLEEP_LIGHT;
17
        } else {
18
            return SLEEP_REM;
19
        }
20
    } else {  // 深度睡眠期
21
        if (heart_rate_variability < 20 && activity_level < 0.1) {
22
            return SLEEP_DEEP;
23
        } else if (heart_rate_variability > 40) {
24
            return SLEEP_REM;
25
        } else {
26
            return SLEEP_LIGHT;
27
        }
28
    }
29
}

1
// 显示缓冲配置
2
static lv_disp_draw_buf_t draw_buf;
3
static lv_color_t buf_1[DISP_HOR_RES * 20];  // 行缓冲
4
static lv_color_t buf_2[DISP_HOR_RES * 20];  // 双缓冲
5

6
// 显示驱动初始化
7
void lvgl_display_init(void) {
8
    lv_init();
9

10
    // 初始化显示缓冲
11
    lv_disp_draw_buf_init(&draw_buf, buf_1, buf_2, DISP_HOR_RES * 20);
12

13
    // 配置显示驱动
14
    static lv_disp_drv_t disp_drv;
15
    lv_disp_drv_init(&disp_drv);
16
    disp_drv.hor_res = DISP_HOR_RES;
17
    disp_drv.ver_res = DISP_VER_RES;
18
    disp_drv.draw_buf = &draw_buf;
19
    disp_drv.flush_cb = my_disp_flush;
20
    disp_drv.user_data = &spi_handle;
21

22
    lv_disp_drv_register(&disp_drv);
23
}