智能穿戴手表系统，包含硬件设计、软件架构、传感器集成和用户界面。
一、系统总体设计
1.1 系统架构
┌─────────────────────────────────────────────────────────────┐
│ STM32智能穿戴手表系统架构 │
├─────────────────────────────────────────────────────────────┤
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 主控制器 │ │ 传感器层 │ │ 显示层 │ │
│ │ STM32L4 │ │ │ │ TFT/OLED │ │
│ │ (低功耗) │ │ 心率/血氧 │ │ 触摸屏 │ │
│ │ │ │ 加速度计 │ │ 背光控制 │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
│ ┌──────┴────────────────┴────────────────┴──────┐ │
│ │ 电源管理系统 │ │
│ │ • 锂电池管理 │ │
│ │ • 无线充电 │ │
│ │ • 低功耗模式 │ │
│ └───────────────────────────────────────────────┘ │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 通信模块 │ │ 存储模块 │ │ 外围接口 │ │
│ │ │ │ │ │ │ │
│ │ 蓝牙5.0 │ │ Flash │ │ 振动马达 │ │
│ │ Wi-Fi │ │ SD卡 │ │ 蜂鸣器 │ │
│ │ GPS │ │ EEPROM │ │ LED指示灯 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────┘
1.2 核心功能
| 功能模块 |
具体功能 |
技术指标 |
| 时间功能 |
实时时钟、闹钟、倒计时、秒表 |
精度±2ppm，月误差<1分钟 |
| 健康监测 |
心率、血氧、体温、睡眠监测 |
心率精度±2bpm，血氧±2% |
| 运动监测 |
计步、距离、卡路里、GPS轨迹 |
计步精度>95%，GPS定位精度<10m |
| 环境监测 |
温度、湿度、气压、海拔 |
温度±0.5℃，气压±1hPa |
| 通知功能 |
来电、短信、App推送、久坐提醒 |
支持主流App消息推送 |
| 其他功能 |
音乐控制、拍照控制、NFC支付 |
蓝牙音乐控制，NFC刷卡 |
二、硬件系统设计
2.1 核心元件选型
| 模块 |
推荐型号 |
关键参数 |
接口方式 |
| 主控MCU |
STM32L476RGT6 |
ARM Cortex-M4, 80MHz, 1MB Flash, 128KB RAM, 低功耗 |
- |
| 显示屏 |
GC9A01 1.28"圆形TFT |
240x240分辨率，16位色彩，IPS全视角 |
SPI |
| 触摸屏 |
FT6336U |
电容触摸，支持手势识别 |
I2C |
| 心率血氧 |
MAX30102 |
集成PPG，LED驱动，环境光消除 |
I2C |
| 加速度计 |
BMA423 |
12位分辨率，低功耗，计步算法 |
I2C |
| 陀螺仪 |
MPU6050 |
6轴运动处理，DMP引擎 |
I2C |
| 气压温度 |
BMP280 |
温度±0.5℃，气压±1Pa，海拔±1m |
I2C/SPI |
| GPS模块 |
AT6558 |
支持GPS/GLONASS/北斗，-165dBm灵敏度 |
UART |
| 蓝牙模块 |
DA14531 |
蓝牙5.0，超低功耗，Mesh支持 |
UART |
| Wi-Fi模块 |
ESP32-C3 |
Wi-Fi 6，BLE 5.0，RISC-V内核 |
UART/SPI |
| NFC模块 |
PN532 |
支持ISO14443A/MIFARE，读卡距离5cm |
I2C/UART |
| 电池管理 |
BQ25120 |
300mA线性充电，I2C编程 |
I2C |
| 振动马达 |
0820微型马达 |
3V，10000rpm，响应时间<50ms |
GPIO |
2.2 电源管理系统
/* 电源管理电路设计 */
// 电池：3.7V 200mAh 锂聚合物电池
// 充电：Qi无线充电 + MicroUSB有线充电
// 输出：3.3V（主系统），1.8V（传感器）
// 电源路径管理
#define POWER_SOURCE_BATTERY 0
#define POWER_SOURCE_WIRELESS 1
#define POWER_SOURCE_USB 2
// 电源管理结构体
typedef struct {
uint8_t power_source; // 当前电源
float battery_voltage; // 电池电压
float battery_current; // 电池电流
uint8_t battery_level; // 电量百分比
float temperature; // 电池温度
bool is_charging; // 是否在充电
bool is_full; // 是否充满
} PowerStatus;
// 低功耗模式
typedef enum {
POWER_MODE_ACTIVE, // 全功能模式
POWER_MODE_SLEEP, // 睡眠模式（屏幕关闭）
POWER_MODE_DEEP_SLEEP, // 深度睡眠（仅RTC运行）
POWER_MODE_SHUTDOWN // 关机模式
} PowerMode;
2.3 PCB设计要点
PCB层叠结构（4层板）：
Layer1（顶层）：MCU、传感器、接口
Layer2（内电层）：GND平面
Layer3（内电层）：3.3V/1.8V电源
Layer4（底层）：显示屏、电池、被动元件
布局原则：
1. 模拟/数字分区：传感器在模拟区，数字电路在数字区
2. 射频隔离：蓝牙/Wi-Fi/GPS天线周围净空
3. 热管理：充电IC、显示屏背光注意散热
4. 阻抗控制：射频线50Ω，USB差分线90Ω
三、软件架构设计
3.1 操作系统选择
/* 基于FreeRTOS的多任务系统 */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
// 任务优先级定义
#define TASK_PRIORITY_HIGHEST (configMAX_PRIORITIES - 1)
#define TASK_PRIORITY_DISPLAY 5
#define TASK_PRIORITY_SENSOR 4
#define TASK_PRIORITY_BLUETOOTH 3
#define TASK_PRIORITY_UI 2
#define TASK_PRIORITY_BACKGROUND 1
// 任务堆栈大小
#define STACK_SIZE_DISPLAY 2048
#define STACK_SIZE_SENSOR 1536
#define STACK_SIZE_BLUETOOTH 2048
#define STACK_SIZE_UI 1024
// 系统任务列表
TaskHandle_t xDisplayTask = NULL;
TaskHandle_t xSensorTask = NULL;
TaskHandle_t xBluetoothTask = NULL;
TaskHandle_t xUITask = NULL;
TaskHandle_t xPowerTask = NULL;
3.2 主程序框架
/* 主程序入口 */
int main(void) {
// HAL库初始化
HAL_Init();
// 系统时钟配置
SystemClock_Config();
// 硬件初始化
hardware_init();
// FreeRTOS初始化
xTaskCreate(Display_Task, "Display", STACK_SIZE_DISPLAY, NULL,
TASK_PRIORITY_DISPLAY, &xDisplayTask);
xTaskCreate(Sensor_Task, "Sensor", STACK_SIZE_SENSOR, NULL,
TASK_PRIORITY_SENSOR, &xSensorTask);
xTaskCreate(Bluetooth_Task, "Bluetooth", STACK_SIZE_BLUETOOTH, NULL,
TASK_PRIORITY_BLUETOOTH, &xBluetoothTask);
xTaskCreate(UI_Task, "UI", STACK_SIZE_UI, NULL,
TASK_PRIORITY_UI, &xUITask);
xTaskCreate(Power_Task, "Power", 1024, NULL,
TASK_PRIORITY_BACKGROUND, &xPowerTask);
// 启动调度器
vTaskStartScheduler();
// 不应该执行到这里
while (1) {
// 系统错误处理
system_error_handler();
}
}
/* 硬件初始化 */
void hardware_init(void) {
// GPIO初始化
MX_GPIO_Init();
// 外设时钟使能
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
// 显示屏初始化
display_init();
// 触摸屏初始化
touch_init();
// 传感器初始化
sensor_init_all();
// 蓝牙初始化
bluetooth_init();
// 电源管理初始化
power_management_init();
// 文件系统初始化
filesystem_init();
// 实时时钟初始化
rtc_init();
// 振动马达初始化
vibration_init();
// 蜂鸣器初始化
buzzer_init();
}
四、显示与用户界面
4.1 显示驱动
/* GC9A01 TFT显示屏驱动 */
#include "gc9a01.h"
// 显示屏参数
#define DISPLAY_WIDTH 240
#define DISPLAY_HEIGHT 240
#define DISPLAY_COLORS 65535 // 16位色
#define DISPLAY_SPI SPI1
#define DISPLAY_CS_PIN GPIO_PIN_4
#define DISPLAY_DC_PIN GPIO_PIN_5
#define DISPLAY_RST_PIN GPIO_PIN_6
#define DISPLAY_BL_PIN GPIO_PIN_7
// 显示缓冲区（双缓冲）
uint16_t display_buffer1[DISPLAY_WIDTH * DISPLAY_HEIGHT];
uint16_t display_buffer2[DISPLAY_WIDTH * DISPLAY_HEIGHT];
uint16_t *active_buffer = display_buffer1;
uint16_t *draw_buffer = display_buffer2;
// 显示初始化
void display_init(void) {
// 硬件复位
HAL_GPIO_WritePin(GPIOA, DISPLAY_RST_PIN, GPIO_PIN_RESET);
HAL_Delay(100);
HAL_GPIO_WritePin(GPIOA, DISPLAY_RST_PIN, GPIO_PIN_SET);
HAL_Delay(100);
// 发送初始化序列
display_send_command(0xEF);
display_send_command(0xEB);
display_send_data(0x14);
// 配置显示方向
display_set_rotation(0); // 0度旋转
// 开启显示
display_send_command(0x29);
// 设置背光
display_set_backlight(80); // 80%亮度
}
// 双缓冲交换
void display_swap_buffers(void) {
// 等待DMA传输完成
while (display_dma_transfer_busy());
// 交换缓冲区
uint16_t *temp = active_buffer;
active_buffer = draw_buffer;
draw_buffer = temp;
// 更新显示
display_update(active_buffer);
}
// 图形绘制函数
void display_draw_pixel(int16_t x, int16_t y, uint16_t color) {
if (x < 0 || x >= DISPLAY_WIDTH || y < 0 || y >= DISPLAY_HEIGHT) {
return;
}
draw_buffer[y * DISPLAY_WIDTH + x] = color;
}
void display_draw_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
int16_t dx = abs(x1 - x0);
int16_t dy = abs(y1 - y0);
int16_t sx = (x0 < x1) ? 1 : -1;
int16_t sy = (y0 < y1) ? 1 : -1;
int16_t err = dx - dy;
while (1) {
display_draw_pixel(x0, y0, color);
if (x0 == x1 && y0 == y1) break;
int16_t e2 = 2 * err;
if (e2 > -dy) {
err -= dy;
x0 += sx;
}
if (e2 < dx) {
err += dx;
y0 += sy;
}
}
}
void display_draw_circle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
display_draw_pixel(x0, y0 + r, color);
display_draw_pixel(x0, y0 - r, color);
display_draw_pixel(x0 + r, y0, color);
display_draw_pixel(x0 - r, y0, color);
while (x < y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
display_draw_pixel(x0 + x, y0 + y, color);
display_draw_pixel(x0 - x, y0 + y, color);
display_draw_pixel(x0 + x, y0 - y, color);
display_draw_pixel(x0 - x, y0 - y, color);
display_draw_pixel(x0 + y, y0 + x, color);
display_draw_pixel(x0 - y, y0 + x, color);
display_draw_pixel(x0 + y, y0 - x, color);
display_draw_pixel(x0 - y, y0 - x, color);
}
}
4.2 图形用户界面
/* 基于LVGL的图形界面 */
#include "lvgl.h"
// LVGL初始化
void lvgl_init(void) {
// LVGL初始化
lv_init();
// 显示缓冲区
static lv_disp_draw_buf_t draw_buf;
static lv_color_t buf1[DISPLAY_WIDTH * 20]; // 行缓冲区
static lv_color_t buf2[DISPLAY_WIDTH * 20];
lv_disp_draw_buf_init(&draw_buf, buf1, buf2, DISPLAY_WIDTH * 20);
// 显示驱动
static lv_disp_drv_t disp_drv;
lv_disp_drv_init(&disp_drv);
disp_drv.hor_res = DISPLAY_WIDTH;
disp_drv.ver_res = DISPLAY_HEIGHT;
disp_drv.flush_cb = lvgl_flush_callback;
disp_drv.draw_buf = &draw_buf;
lv_disp_drv_register(&disp_drv);
// 输入设备（触摸屏）
static lv_indev_drv_t indev_drv;
lv_indev_drv_init(&indev_drv);
indev_drv.type = LV_INDEV_TYPE_POINTER;
indev_drv.read_cb = lvgl_touch_read;
lv_indev_drv_register(&indev_drv);
// 创建主题
lv_theme_t *theme = lv_theme_default_init(lv_color_hex(0x003a57),
lv_color_hex(0xffffff),
LV_THEME_DEFAULT_DARK,
&lv_font_montserrat_16);
lv_disp_set_theme(lv_disp_get_default(), theme);
}
// 主界面
void create_main_interface(void) {
// 创建主屏幕
lv_obj_t *main_screen = lv_obj_create(NULL);
// 顶部状态栏
create_status_bar(main_screen);
// 主界面内容
create_watch_face(main_screen);
// 底部导航栏
create_navigation_bar(main_screen);
// 加载屏幕
lv_scr_load(main_screen);
}
// 创建状态栏
void create_status_bar(lv_obj_t *parent) {
lv_obj_t *status_bar = lv_obj_create(parent);
lv_obj_set_size(status_bar, DISPLAY_WIDTH, 30);
lv_obj_set_pos(status_bar, 0, 0);
lv_obj_set_style_bg_color(status_bar, lv_color_hex(0x000000), 0);
lv_obj_set_style_border_width(status_bar, 0, 0);
// 时间显示
lv_obj_t *time_label = lv_label_create(status_bar);
lv_label_set_text(time_label, "12:00");
lv_obj_align(time_label, LV_ALIGN_CENTER, 0, 0);
// 电池图标
lv_obj_t *battery_icon = lv_label_create(status_bar);
lv_label_set_text(battery_icon, LV_SYMBOL_BATTERY_FULL);
lv_obj_align(battery_icon, LV_ALIGN_RIGHT_MID, -10, 0);
// 蓝牙图标
lv_obj_t *bluetooth_icon = lv_label_create(status_bar);
lv_label_set_text(bluetooth_icon, LV_SYMBOL_BLUETOOTH);
lv_obj_align(bluetooth_icon, LV_ALIGN_LEFT_MID, 10, 0);
}
// 创建表盘
void create_watch_face(lv_obj_t *parent) {
lv_obj_t *watch_face = lv_obj_create(parent);
lv_obj_set_size(watch_face, 200, 200);
lv_obj_align(watch_face, LV_ALIGN_CENTER, 0, 0);
lv_obj_set_style_border_width(watch_face, 0, 0);
// 时钟背景
lv_obj_t *clock_bg = lv_obj_create(watch_face);
lv_obj_set_size(clock_bg, 180, 180);
lv_obj_align(clock_bg, LV_ALIGN_CENTER, 0, 0);
lv_obj_set_style_radius(clock_bg, 90, 0);
lv_obj_set_style_bg_color(clock_bg, lv_color_hex(0x1a1a2e), 0);
// 时钟刻度
for (int i = 0; i < 12; i++) {
float angle = i * 30 * 3.14159 / 180;
int16_t x1 = 90 + 70 * sin(angle);
int16_t y1 = 90 - 70 * cos(angle);
int16_t x2 = 90 + 80 * sin(angle);
int16_t y2 = 90 - 80 * cos(angle);
lv_obj_t *scale = lv_line_create(clock_bg);
lv_point_t points[] = {{x1, y1}, {x2, y2}};
lv_line_set_points(scale, points, 2);
lv_obj_set_style_line_width(scale, 2, 0);
lv_obj_set_style_line_color(scale, lv_color_hex(0xffffff), 0);
}
// 时针
lv_obj_t *hour_hand = lv_line_create(clock_bg);
lv_point_t hour_points[] = {{90, 90}, {90, 50}};
lv_line_set_points(hour_hand, hour_points, 2);
lv_obj_set_style_line_width(hour_hand, 6, 0);
lv_obj_set_style_line_color(hour_hand, lv_color_hex(0xff0000), 0);
// 分针
lv_obj_t *minute_hand = lv_line_create(clock_bg);
lv_point_t minute_points[] = {{90, 90}, {90, 30}};
lv_line_set_points(minute_hand, minute_points, 2);
lv_obj_set_style_line_width(minute_hand, 4, 0);
lv_obj_set_style_line_color(minute_hand, lv_color_hex(0x00ff00), 0);
// 秒针
lv_obj_t *second_hand = lv_line_create(clock_bg);
lv_point_t second_points[] = {{90, 90}, {90, 20}};
lv_line_set_points(second_hand, second_points, 2);
lv_obj_set_style_line_width(second_hand, 2, 0);
lv_obj_set_style_line_color(second_hand, lv_color_hex(0x0000ff), 0);
// 中心点
lv_obj_t *center = lv_obj_create(clock_bg);
lv_obj_set_size(center, 10, 10);
lv_obj_align(center, LV_ALIGN_CENTER, 0, 0);
lv_obj_set_style_radius(center, 5, 0);
lv_obj_set_style_bg_color(center, lv_color_hex(0xffffff), 0);
}
五、传感器数据处理
5.1 心率血氧监测
/* MAX30102心率血氧监测算法 */
#include "max30102.h"
#include "algorithm.h"
#define SAMPLE_RATE 100 // 100Hz采样率
#define BUFFER_SIZE 256 // 缓冲区大小
// 数据缓冲区
int32_t red_buffer[BUFFER_SIZE];
int32_t ir_buffer[BUFFER_SIZE];
uint16_t buffer_index = 0;
// 心率血氧计算结果
typedef struct {
uint16_t heart_rate; // 心率（bpm）
uint8_t spO2; // 血氧饱和度（%）
uint8_t confidence; // 置信度（0-100%）
uint32_t timestamp; // 时间戳
} HRSpO2_Result;
// 初始化MAX30102
void max30102_init(void) {
// 复位芯片
max30102_write_register(MAX30102_MODECONFIG, 0x40);
HAL_Delay(10);
// 配置采样率
max30102_write_register(MAX30102_SPO2CONFIG, 0x27); // 100Hz, 411us pulse width
// 配置LED电流
max30102_write_register(MAX30102_LED1_PULSEAMP, 0x24); // IR LED电流
max30102_write_register(MAX30102_LED2_PULSEAMP, 0x24); // Red LED电流
// 开启传感器
max30102_write_register(MAX30102_MODECONFIG, 0x03); // SpO2模式
}
// 心率计算算法
void calculate_heart_rate(void) {
static float heart_rate_filtered = 0;
static float alpha = 0.1; // 低通滤波系数
// 获取PPG信号
int32_t red_value = red_buffer[buffer_index];
int32_t ir_value = ir_buffer[buffer_index];
// 信号质量检测
float signal_quality = evaluate_signal_quality(ir_buffer, BUFFER_SIZE);
if (signal_quality > 0.8) {
// 计算心率
float heart_rate_raw = find_heart_rate(ir_buffer, BUFFER_SIZE, SAMPLE_RATE);
// 滤波处理
heart_rate_filtered = alpha * heart_rate_raw + (1 - alpha) * heart_rate_filtered;
// 心率有效范围限制（30-250bpm）
if (heart_rate_filtered < 30) heart_rate_filtered = 30;
if (heart_rate_filtered > 250) heart_rate_filtered = 250;
// 计算血氧
float R_value = calculate_R_value(red_buffer, ir_buffer, BUFFER_SIZE);
float spO2_raw = 110 - 25 * R_value; // 简化计算公式
// 血氧范围限制
if (spO2_raw < 70) spO2_raw = 70;
if (spO2_raw > 100) spO2_raw = 100;
// 更新结果
HRSpO2_Result result = {
.heart_rate = (uint16_t)heart_rate_filtered,
.spO2 = (uint8_t)spO2_raw,
.confidence = (uint8_t)(signal_quality * 100),
.timestamp = HAL_GetTick()
};
// 存储结果
save_hr_spo2_result(&result);
// 发送到显示
update_hr_display(result.heart_rate, result.spO2);
}
}
// 信号质量评估
float evaluate_signal_quality(int32_t *buffer, uint16_t size) {
// 计算信号均值
int64_t sum = 0;
for (uint16_t i = 0; i < size; i++) {
sum += buffer[i];
}
float mean = (float)sum / size;
// 计算方差
float variance = 0;
for (uint16_t i = 0; i < size; i++) {
float diff = buffer[i] - mean;
variance += diff * diff;
}
variance /= size;
// 计算信噪比
float snr = 20 * log10(mean / sqrt(variance));
// 信号质量评分（0-1）
float quality = 0;
if (snr > 20) quality = 1.0;
else if (snr > 10) quality = 0.8;
else if (snr > 5) quality = 0.5;
else if (snr > 0) quality = 0.2;
return quality;
}
5.2 运动监测算法
/* BMA423计步算法 */
#include "bma423.h"
// 计步数据结构
typedef struct {
uint32_t step_count; // 步数
uint32_t step_timestamp; // 最后一步时间戳
float distance; // 距离（米）
uint16_t calories; // 卡路里
uint8_t activity_level; // 活动等级
} StepData;
// 计步算法初始化
void step_counter_init(void) {
// 初始化BMA423
bma423_init();
// 配置计步参数
bma423_write_register(BMA423_STEP_CNT_CONFIG, 0x15);
bma423_write_register(BMA423_STEP_CNT_CONFIG1, 0x03);
// 开启计步功能
bma423_write_register(BMA423_FEATURE_ENABLE, 0x04);
// 使能中断
bma423_enable_interrupt(BMA423_STEP_CNT_INT);
}
// 计步处理函数
void process_step_data(void) {
static uint32_t last_step_count = 0;
static StepData step_data = {0};
// 读取计步器
uint32_t current_steps = bma423_read_step_counter();
// 检测新步数
if (current_steps > last_step_count) {
uint32_t new_steps = current_steps - last_step_count;
step_data.step_count += new_steps;
step_data.step_timestamp = HAL_GetTick();
// 计算距离（假设步长0.7米）
step_data.distance += new_steps * 0.7f;
// 计算卡路里（假设0.04卡/步）
step_data.calories += (uint16_t)(new_steps * 0.04f);
// 更新活动等级
update_activity_level(&step_data);
// 更新显示
update_step_display(step_data.step_count, step_data.distance, step_data.calories);
last_step_count = current_steps;
}
}
// 睡眠监测
typedef struct {
uint8_t sleep_state; // 睡眠状态
uint32_t sleep_start; // 入睡时间
uint32_t sleep_end; // 醒来时间
uint32_t deep_sleep_time; // 深睡时间
uint32_t light_sleep_time;// 浅睡时间
uint8_t sleep_score; // 睡眠评分
} SleepData;
// 睡眠分析算法
void analyze_sleep(void) {
static SleepData sleep_data = {0};
static uint32_t last_activity_time = 0;
// 读取加速度数据
int16_t accel[3];
bma423_read_acceleration(accel);
// 计算活动强度
float activity = sqrt(accel[0]*accel[0] + accel[1]*accel[1] + accel[2]*accel[2]);
// 睡眠状态检测
uint32_t current_time = HAL_GetTick();
if (activity < 0.1) { // 低活动
if (sleep_data.sleep_state == 0) {
// 开始睡眠
sleep_data.sleep_state = 1;
sleep_data.sleep_start = current_time;
} else {
// 睡眠中
uint32_t sleep_duration = current_time - sleep_data.sleep_start;
// 根据活动变化判断深浅睡眠
if (sleep_duration > 20 * 60 * 1000) { // 20分钟后
static float last_activity = 0;
float activity_change = fabs(activity - last_activity);
if (activity_change < 0.01) {
// 深睡眠
sleep_data.deep_sleep_time += 10; // 10ms采样间隔
} else {
// 浅睡眠
sleep_data.light_sleep_time += 10;
}
last_activity = activity;
}
}
} else {
if (sleep_data.sleep_state == 1) {
// 睡眠结束
sleep_data.sleep_state = 0;
sleep_data.sleep_end = current_time;
// 计算睡眠评分
calculate_sleep_score(&sleep_data);
// 保存睡眠数据
save_sleep_data(&sleep_data);
// 重置数据
memset(&sleep_data, 0, sizeof(SleepData));
}
}
last_activity_time = current_time;
}
参考代码 基于STM32智能穿戴手表设计 www.youwenfan.com/contentcnt/133701.html
六、蓝牙通信协议
6.1 蓝牙协议栈
/* 基于DA14531的蓝牙通信 */
#include "da14531.h"
// 蓝牙服务定义
#define SERVICE_UUID_HEART_RATE 0x180D
#define SERVICE_UUID_BATTERY 0x180F
#define SERVICE_UUID_DEVICE_INFO 0x180A
#define SERVICE_UUID_CUSTOM 0xFFF0
// 特征值定义
typedef struct {
// 心率服务
uint8_t heart_rate_measurement[3]; // 心率测量值
uint8_t body_sensor_location; // 传感器位置
// 电池服务
uint8_t battery_level; // 电池电量
uint8_t battery_state; // 电池状态
// 自定义服务
uint8_t step_count[4]; // 步数
uint8_t temperature[2]; // 温度
uint8_t notification[20]; // 通知
} BluetoothCharacteristics;
// 蓝牙初始化
void bluetooth_init(void) {
// 初始化蓝牙芯片
da14531_init();
// 配置蓝牙参数
bluetooth_configure();
// 创建GATT服务
create_gatt_services();
// 设置设备名称
bluetooth_set_device_name("SmartWatch_V1.0");
// 开始广播
bluetooth_start_advertising();
}
// 创建GATT服务
void create_gatt_services(void) {
// 心率服务
gatt_service_t heart_rate_service = {
.uuid = SERVICE_UUID_HEART_RATE,
.characteristics = {
{.uuid = 0x2A37, .properties = GATT_PROP_NOTIFY}, // 心率测量
{.uuid = 0x2A38, .properties = GATT_PROP_READ} // 传感器位置
},
.characteristic_count = 2
};
gatt_add_service(&heart_rate_service);
// 电池服务
gatt_service_t battery_service = {
.uuid = SERVICE_UUID_BATTERY,
.characteristics = {
{.uuid = 0x2A19, .properties = GATT_PROP_NOTIFY | GATT_PROP_READ}
},
.characteristic_count = 1
};
gatt_add_service(&battery_service);
// 自定义服务
gatt_service_t custom_service = {
.uuid = SERVICE_UUID_CUSTOM,
.characteristics = {
{.uuid = 0xFFF1, .properties = GATT_PROP_NOTIFY | GATT_PROP_READ}, // 步数
{.uuid = 0xFFF2, .properties = GATT_PROP_NOTIFY | GATT_PROP_READ}, // 温度
{.uuid = 0xFFF3, .properties = GATT_PROP_WRITE | GATT_PROP_NOTIFY} // 通知
},
.characteristic_count = 3
};
gatt_add_service(&custom_service);
}
// 蓝牙数据处理
void bluetooth_data_handler(uint8_t *data, uint16_t length) {
// 解析命令
uint8_t command = data[0];
switch (command) {
case 0x01: // 获取时间
send_time_data();
break;
case 0x02: // 获取健康数据
send_health_data();
break;
case 0x03: // 设置闹钟
set_alarm(&data[1]);
break;
case 0x04: // 控制音乐
control_music(data[1]);
break;
case 0x05: // 查找手机
find_phone();
break;
case 0x06: // 相机控制
control_camera(data[1]);
break;
default:
// 未知命令
break;
}
}
// 发送通知到手机
void send_notification(const char *message) {
uint8_t buffer[20] = {0};
// 消息类型
buffer[0] = 0x01; // 文本消息
// 消息内容
uint8_t len = strlen(message);
if (len > 18) len = 18;
memcpy(&buffer[1], message, len);
buffer[len + 1] = '\0';
// 通过蓝牙发送
bluetooth_send_data(SERVICE_UUID_CUSTOM, 0xFFF3, buffer, len + 2);
}
七、电源管理系统
7.1 低功耗管理
/* 电源管理系统 */
#include "stm32l4xx_hal.h"
// 电源状态
typedef enum {
POWER_STATE_ACTIVE, // 全功能运行
POWER_STATE_IDLE, // 空闲状态
POWER_STATE_SLEEP, // 睡眠状态
POWER_STATE_STANDBY, // 待机状态
POWER_STATE_SHUTDOWN // 关机状态
} PowerState;
// 电源管理结构
typedef struct {
PowerState current_state;
PowerState next_state;
uint32_t state_timer;
uint8_t battery_level;
bool is_charging;
float power_consumption;
} PowerManagement;
// 进入低功耗模式
void enter_low_power_mode(PowerState target_state) {
switch (target_state) {
case POWER_STATE_IDLE:
// 关闭外设时钟
__HAL_RCC_GPIOA_CLK_DISABLE();
__HAL_RCC_GPIOB_CLK_DISABLE();
__HAL_RCC_GPIOC_CLK_DISABLE();
__HAL_RCC_GPIOD_CLK_DISABLE();
// 进入Sleep模式
HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
break;
case POWER_STATE_SLEEP:
// 关闭显示屏
display_set_backlight(0);
display_sleep();
// 关闭传感器
sensor_sleep_all();
// 关闭蓝牙
bluetooth_sleep();
// 进入Stop模式
HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
break;
case POWER_STATE_STANDBY:
// 保存状态到备份寄存器
save_system_state();
// 进入Standby模式
HAL_PWR_EnterSTANDBYMode();
break;
case POWER_STATE_SHUTDOWN:
// 完全关机
power_off();
break;
default:
break;
}
}
// 唤醒处理
void wakeup_handler(void) {
// 检测唤醒源
if (__HAL_PWR_GET_FLAG(PWR_FLAG_WU)) {
// 按键唤醒
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
system_wakeup();
} else if (__HAL_RTC_GET_FLAG(RTC_FLAG_ALRAF)) {
// 闹钟唤醒
__HAL_RTC_CLEAR_FLAG(RTC_FLAG_ALRAF);
alarm_handler();
}
}
// 电池管理
void battery_management_task(void) {
static uint32_t last_check_time = 0;
uint32_t current_time = HAL_GetTick();
// 每10秒检查一次电池
if (current_time - last_check_time > 10000) {
last_check_time = current_time;
// 读取电池电压
float voltage = read_battery_voltage();
// 计算电量百分比
uint8_t level = calculate_battery_level(voltage);
// 低电量警告
if (level < 10) {
show_low_battery_warning();
// 进入省电模式
if (level < 5) {
enter_power_saving_mode();
}
}
// 充电状态检测
bool charging = check_charging_status();
// 更新显示
update_battery_display(level, charging);
}
}
八、文件系统与数据存储
8.1 FAT文件系统
/* FATFS文件系统实现 */
#include "fatfs.h"
// 文件系统句柄
FATFS fs;
FIL file;
FRESULT res;
// 文件系统初始化
void filesystem_init(void) {
// 挂载文件系统
res = f_mount(&fs, "0:", 1);
if (res != FR_OK) {
// 格式化文件系统
res = f_mkfs("0:", FM_FAT32, 0, work, sizeof(work));
if (res == FR_OK) {
f_mount(NULL, "0:", 0);
f_mount(&fs, "0:", 1);
}
}
// 创建目录结构
f_mkdir("/Data");
f_mkdir("/Data/Health");
f_mkdir("/Data/Sport");
f_mkdir("/Data/Sleep");
f_mkdir("/Settings");
f_mkdir("/Logs");
}
// 存储健康数据
void save_health_data(HealthData *data) {
char filename[50];
sprintf(filename, "/Data/Health/health_%lu.dat", data->timestamp);
// 打开文件
res = f_open(&file, filename, FA_WRITE | FA_CREATE_ALWAYS);
if (res == FR_OK) {
// 写入数据
UINT bytes_written;
f_write(&file, data, sizeof(HealthData), &bytes_written);
// 关闭文件
f_close(&file);
}
}
// 读取历史数据
void read_history_data(HealthData *buffer, uint32_t start_time, uint32_t end_time) {
DIR dir;
FILINFO fno;
// 打开目录
res = f_opendir(&dir, "/Data/Health");
if (res == FR_OK) {
int index = 0;
while (1) {
res = f_readdir(&dir, &fno);
if (res != FR_OK || fno.fname[0] == 0) break;
// 解析文件名获取时间戳
char *timestamp_str = strstr(fno.fname, "_");
if (timestamp_str) {
timestamp_str++; // 跳过下划线
uint32_t timestamp = atoi(timestamp_str);
// 检查时间范围
if (timestamp >= start_time && timestamp <= end_time) {
char full_path[100];
sprintf(full_path, "/Data/Health/%s", fno.fname);
// 读取文件
FIL file;
if (f_open(&file, full_path, FA_READ) == FR_OK) {
f_read(&file, &buffer[index], sizeof(HealthData), NULL);
f_close(&file);
index++;
}
}
}
}
f_closedir(&dir);
}
}
九、测试与验证
9.1 系统测试程序
/* 系统自检程序 */
void system_self_test(void) {
printf("===== 智能手表自检程序 =====\n");
// 1. 内存测试
printf("1. 内存测试...\n");
if (memory_test() == 0) {
printf(" ✓ RAM测试通过\n");
} else {
printf(" ✗ RAM测试失败\n");
}
// 2. 显示屏测试
printf("2. 显示屏测试...\n");
display_test_pattern();
if (check_display()) {
printf(" ✓ 显示屏测试通过\n");
} else {
printf(" ✗ 显示屏测试失败\n");
}
// 3. 触摸屏测试
printf("3. 触摸屏测试...\n");
if (touch_calibrate()) {
printf(" ✓ 触摸屏校准成功\n");
} else {
printf(" ✗ 触摸屏校准失败\n");
}
// 4. 传感器测试
printf("4. 传感器测试...\n");
test_sensors();
// 5. 蓝牙测试
printf("5. 蓝牙测试...\n");
if (bluetooth_test()) {
printf(" ✓ 蓝牙测试通过\n");
} else {
printf(" ✗ 蓝牙测试失败\n");
}
// 6. 电池测试
printf("6. 电池测试...\n");
test_battery();
// 7. 性能测试
printf("7. 性能测试...\n");
performance_test();
printf("===== 自检完成 =====\n");
}
// 传感器测试
void test_sensors(void) {
// 心率传感器测试
int32_t red, ir;
max30102_read_fifo(&red, &ir);
if (red > 0 && ir > 0) {
printf(" ✓ 心率传感器正常\n");
} else {
printf(" ✗ 心率传感器异常\n");
}
// 加速度计测试
int16_t accel[3];
bma423_read_acceleration(accel);
if (abs(accel[0]) + abs(accel[1]) + abs(accel[2]) > 0) {
printf(" ✓ 加速度计正常\n");
} else {
printf(" ✗ 加速度计异常\n");
}
// 温度传感器测试
float temperature = read_temperature();
if (temperature > 10 && temperature < 50) {
printf(" ✓ 温度传感器正常: %.1f°C\n", temperature);
} else {
printf(" ✗ 温度传感器异常\n");
}
}
十、项目总结
10.1 主要特点
- 高性能处理器：STM32L476提供强大计算能力
- 丰富传感器：集成心率、血氧、运动、环境监测
- 优质显示：圆形TFT IPS显示屏，触摸操作
- 长续航：低功耗设计，支持无线充电
- 智能连接：蓝牙5.0、Wi-Fi、GPS、NFC
- 健康监测：专业级健康数据采集和分析
10.2 技术难点与解决方案
| 技术难点 |
解决方案 |
| 功耗优化 |
多级电源管理，动态频率调整 |
| 传感器精度 |
多传感器融合，软件滤波算法 |
| 小尺寸设计 |
高密度PCB布局，微型元件选型 |
| 防水防尘 |
IP68密封设计，专用接口保护 |
| 算法复杂度 |
优化算法，硬件加速支持 |
10.3 生产成本估算
| 项目 |
成本（元） |
说明 |
| 主控MCU |
25 |
STM32L476RGT6 |
| 显示屏 |
18 |
1.28寸圆形TFT |
| 传感器 |
35 |
心率+加速度+气压+温度 |
| 通信模块 |
25 |
蓝牙+Wi-Fi+GPS+NFC |
| PCB与元件 |
30 |
4层板，各类被动元件 |
| 结构件 |
20 |
外壳、表带、螺丝等 |
| 电池 |
15 |
200mAh锂电池 |
| 组装测试 |
10 |
人工和测试成本 |
| 合计 |
178 |
小批量生产成本 |
10.4 扩展功能建议
- eSIM支持：增加蜂窝网络连接
- 语音助手：集成离线语音识别
- 支付功能：支持银联闪付、交通卡
- 血氧趋势：24小时血氧监测
- 跌倒检测：老人安全监护
- 无线升级：OTA固件升级
- 多语言支持：国际化界面
- 应用商店：第三方应用扩展
浙公网安备 33010602011771号