基于 RT-Thread+ADS1115+GD32F305 的高精度电机测试工装开发全解析（下）

6.3 按键驱动

系统设计了一个校准按键，用于进入 / 退出校准模式和确认操作。以下是按键驱动的实现：

按键驱动代码key.c

#include "key.h"
#include "rtthread.h"
#include "rtdevice.h"

// 按键引脚定义
#define KEY_PIN GET_PIN(C, 13)

// 按键状态枚举
typedef enum
{
KEY_STATE_RELEASED = 0, // 释放
KEY_STATE_PRESSED, // 按下
KEY_STATE_LONG_PRESSED // 长按
} key_state_t;

// 按键事件枚举
typedef enum
{
KEY_EVENT_NONE = 0, // 无事件
KEY_EVENT_PRESS, // 短按事件
KEY_EVENT_LONG_PRESS // 长按事件
} key_event_t;

// 按键配置参数
#define KEY_LONG_PRESS_TIME 2000 // 长按判断时间(ms)
#define KEY_SCAN_INTERVAL 50 // 扫描间隔(ms)
#define KEY_DEBOUNCE_TIME 50 // 消抖时间(ms)

// 按键状态变量
static struct
{
key_state_t state; // 当前状态
uint32_t press_start_time; // 按下开始时间
uint32_t last_state_change; // 最后一次状态变化时间
uint8_t raw_state; // 原始状态
key_event_t event; // 按键事件
} key_info = {
.state = KEY_STATE_RELEASED,
.press_start_time = 0,
.last_state_change = 0,
.raw_state = 1, // 初始为释放状态(上拉)
.event = KEY_EVENT_NONE
};

// 按键事件消息队列
static struct rt_messagequeue key_mq;
static uint8_t mq_buffer[32]; // 消息队列缓冲区

/**
* @brief 按键扫描函数
* @return 按键事件
*/
static key_event_t key_scan(void)
{
uint8_t current_raw_state;
uint32_t current_time = rt_tick_get_millisecond();
key_event_t current_event = KEY_EVENT_NONE;

// 读取原始引脚状态(按键按下为低电平)
current_raw_state = rt_pin_read(KEY_PIN);

// 检查状态是否变化，且超过消抖时间
if (current_raw_state != key_info.raw_state &&
(current_time - key_info.last_state_change) > KEY_DEBOUNCE_TIME)
{
// 更新原始状态和时间
key_info.raw_state = current_raw_state;
key_info.last_state_change = current_time;

// 状态变化处理
if (current_raw_state == 0) // 按键按下
{
key_info.state = KEY_STATE_PRESSED;
key_info.press_start_time = current_time;
}
else // 按键释放
{
// 判断是短按还是长按
if (key_info.state == KEY_STATE_LONG_PRESSED)
{
current_event = KEY_EVENT_LONG_PRESS;
}
else if (key_info.state == KEY_STATE_PRESSED)
{
current_event = KEY_EVENT_PRESS;
}

key_info.state = KEY_STATE_RELEASED;
}
}
else
{
// 状态未变化，检查长按
if (key_info.state == KEY_STATE_PRESSED &&
(current_time - key_info.press_start_time) > KEY_LONG_PRESS_TIME)
{
key_info.state = KEY_STATE_LONG_PRESSED;
}
}

return current_event;
}

/**
* @brief 按键处理线程
* @param parameter 线程参数
*/
static void key_thread(void *parameter)
{
key_event_t event;

while (1)
{
// 扫描按键
event = key_scan();

// 如果有事件，发送到消息队列
if (event != KEY_EVENT_NONE)
{
rt_mq_send(&key_mq, &event, sizeof(event));
}

// 延时扫描间隔
rt_thread_mdelay(KEY_SCAN_INTERVAL);
}
}

/**
* @brief 初始化按键
* @return 0: 成功, -1: 失败
*/
int key_init(void)
{
rt_err_t ret;

// 配置按键引脚为输入模式(上拉)
rt_pin_mode(KEY_PIN, PIN_MODE_INPUT_PULLUP);

// 初始化消息队列
ret = rt_mq_init(&key_mq, "key_mq",
mq_buffer, sizeof(key_event_t),
sizeof(mq_buffer), RT_IPC_FLAG_FIFO);
if (ret != RT_EOK)
{
rt_kprintf("Failed to initialize key message queue\n");
return -1;
}

// 创建按键处理线程
rt_thread_t thread = rt_thread_create("key",
key_thread,
RT_NULL,
512,
5,
10);
if (thread != RT_NULL)
{
rt_thread_startup(thread);
}
else
{
rt_kprintf("Failed to create key thread\n");
rt_mq_detach(&key_mq);
return -1;
}

rt_kprintf("Key driver initialized successfully\n");
return 0;
}

/**
* @brief 获取按键事件
* @param event 存储事件的指针
* @param timeout 超时时间(ms)
* @return 0: 成功获取事件, -1: 超时或失败
*/
int key_get_event(key_event_t *event, int32_t timeout)
{
if (event == RT_NULL)
return -1;

return rt_mq_recv(&key_mq, event, sizeof(key_event_t), timeout);
}

// 导出初始化函数
INIT_DEVICE_EXPORT(key_init);

按键驱动头文件

#ifndef __KEY_H
#define __KEY_H

#include <rtthread.h>

// 按键事件枚举
typedef enum
{
KEY_EVENT_NONE = 0, // 无事件
KEY_EVENT_PRESS, // 短按事件
KEY_EVENT_LONG_PRESS // 长按事件
} key_event_t;

/**
* @brief 初始化按键
* @return 0: 成功, -1: 失败
*/
int key_init(void);

/**
* @brief 获取按键事件
* @param event 存储事件的指针
* @param timeout 超时时间(ms)
* @return 0: 成功获取事件, -1: 超时或失败
*/
int key_get_event(key_event_t *event, int32_t timeout);

#endif /* __KEY_H */

7. 应用程序设计

7.1 应用程序总体设计

应用程序是基于前面开发的各个驱动模块，实现电机测试工装的核心功能。主要包括：

实时采集电机参数（电压、电流、转速、圈数）
在 OLED 屏上以数码管风格显示这些参数
支持参数校准功能
支持设备 ID 显示
保存校准参数到 Flash

应用程序采用 RT-Thread 的多任务机制，将不同功能划分为独立的任务，通过消息队列和共享内存进行通信。

7.2 数据结构设计

定义以下数据结构来存储系统运行时的数据：

应用程序数据结构

#ifndef __APP_DATA_H
#define __APP_DATA_H

#include <rtthread.h>

// 电机参数结构体
struct motor_params
{
float voltage; // 母线电压(V)
float current; // 工作电流(A)
uint32_t speed; // 转速(RPM)
float revolutions; // 转动圈数
float calib_revolutions; // 校准总圈数
uint8_t device_id; // 设备ID
};

// 校准参数结构体
struct calibration_params
{
float voltage_offset; // 电压偏移量(V)
float voltage_scale; // 电压比例系数
float current_offset; // 电流偏移量(A)
float current_scale; // 电流比例系数
uint8_t device_id; // 设备ID
uint32_t encoder_ppr; // 编码器每圈脉冲数
};

// 系统状态结构体
struct system_state
{
uint8_t in_calibration; // 是否在校准模式(0=正常, 1=校准)
uint8_t calib_item; // 当前校准项目(0=电压, 1=电流, 2=编码器)
uint8_t updated; // 数据更新标志
rt_mutex_t data_mutex; // 数据访问互斥锁
};

// 初始化电机参数
void motor_params_init(struct motor_params *params);

// 初始化校准参数为默认值
void calibration_params_init(struct calibration_params *calib);

// 初始化系统状态
int system_state_init(struct system_state *state);

#endif /* __APP_DATA_H */

应用程序数据结构实现

#include "app_data.h"

/**
* @brief 初始化电机参数
* @param params 电机参数结构体指针
*/
void motor_params_init(struct motor_params *params)
{
if (params != RT_NULL)
{
params->voltage = 0.0f;
params->current = 0.0f;
params->speed = 0;
params->revolutions = 0.0f;
params->calib_revolutions = 0.0f;
params->device_id = 0;
}
}

/**
* @brief 初始化校准参数为默认值
* @param calib 校准参数结构体指针
*/
void calibration_params_init(struct calibration_params *calib)
{
if (calib != RT_NULL)
{
calib->voltage_offset = 0.0f;
calib->voltage_scale = 1.0f;
calib->current_offset = 0.0f;
calib->current_scale = 1.0f;
calib->device_id = 1; // 默认设备ID为1
calib->encoder_ppr = 1000; // 默认每圈1000脉冲
}
}

/**
* @brief 初始化系统状态
* @param state 系统状态结构体指针
* @return 0: 成功, -1: 失败
*/
int system_state_init(struct system_state *state)
{
if (state == RT_NULL)
return -1;

state->in_calibration = 0;
state->calib_item = 0;
state->updated = 0;

// 初始化互斥锁
state->data_mutex = rt_mutex_create("data_mutex", RT_IPC_FLAG_FIFO);
if (state->data_mutex == RT_NULL)
{
rt_kprintf("Failed to create data mutex\n");
return -1;
}

return 0;
}

7.3 任务设计与实现

7.3.1 参数采集任务

参数采集任务负责周期性地从传感器采集电机参数，并更新到共享内存中。

参数采集任务

#include "data_collector.h"
#include "voltage_current.h"
#include "encoder.h"
#include "app_data.h"
#include "rtthread.h"

// 任务配置
#define COLLECTOR_TASK_PRIORITY 8
#define COLLECTOR_TASK_STACK_SIZE 1024
#define COLLECTOR_TASK_TIMESLICE 10
#define COLLECT_INTERVAL 100 // 采集间隔(ms)

// 全局数据指针
static struct motor_params *motor_params = RT_NULL;
static struct system_state *system_state = RT_NULL;

/**
* @brief 参数采集任务入口
* @param parameter 任务参数
*/
static void collector_task_entry(void *parameter)
{
rt_err_t ret;

while (1)
{
// 检查是否有数据指针
if (motor_params == RT_NULL || system_state == RT_NULL)
{
rt_thread_mdelay(COLLECT_INTERVAL);
continue;
}

// 上锁保护数据访问
ret = rt_mutex_take(system_state->data_mutex, RT_WAITING_FOREVER);
if (ret == RT_EOK)
{
// 采集电压
read_motor_voltage(&motor_params->voltage);

// 采集电流
read_motor_current(&motor_params->current);

// 采集转速
encoder_get_speed(&motor_params->speed);

// 采集圈数
encoder_get_revolutions(&motor_params->revolutions);

// 设置数据更新标志
system_state->updated = 1;

// 解锁
rt_mutex_release(system_state->data_mutex);
}

// 延时等待下一次采集
rt_thread_mdelay(COLLECT_INTERVAL);
}
}

/**
* @brief 初始化参数采集任务
* @param params 电机参数结构体指针
* @param state 系统状态结构体指针
* @return 0: 成功, -1: 失败
*/
int data_collector_init(struct motor_params *params, struct system_state *state)
{
if (params == RT_NULL || state == RT_NULL)
{
rt_kprintf("Invalid parameters for data collector initialization\n");
return -1;
}

// 保存数据指针
motor_params = params;
system_state = state;

// 创建采集任务
rt_thread_t thread = rt_thread_create("collector",
collector_task_entry,
RT_NULL,
COLLECTOR_TASK_STACK_SIZE,
COLLECTOR_TASK_PRIORITY,
COLLECTOR_TASK_TIMESLICE);
if (thread != RT_NULL)
{
rt_thread_startup(thread);
rt_kprintf("Data collector task initialized successfully\n");
return 0;
}
else
{
rt_kprintf("Failed to create data collector task\n");
return -1;
}
}

参数采集任务头文件

#ifndef __DATA_COLLECTOR_H
#define __DATA_COLLECTOR_H

#include "app_data.h"

#endif /* __DATA_COLLECTOR_H */

7.3.2 显示更新任务

显示更新任务负责从共享内存中读取电机参数，并在 OLED 屏上以数码管风格显示。

显示更新任务

#include "display_task.h"
#include "u8g2.h"
#include "u8g2_init.h"
#include "digit_display.h"
#include "app_data.h"
#include "rtthread.h"

// 任务配置
#define DISPLAY_TASK_PRIORITY 6
#define DISPLAY_TASK_STACK_SIZE 2048
#define DISPLAY_TASK_TIMESLICE 10
#define DISPLAY_UPDATE_INTERVAL 200 // 显示更新间隔(ms)

// 全局数据指针
static struct motor_params *motor_params = RT_NULL;
static struct system_state *system_state = RT_NULL;
static struct calibration_params *calib_params = RT_NULL;

// 显示区域定义
#define AREA_VOLTAGE_X 0
#define AREA_VOLTAGE_Y 30
#define AREA_CURRENT_X 0
#define AREA_CURRENT_Y 60
#define AREA_SPEED_X 70
#define AREA_SPEED_Y 30
#define AREA_REVOLUTIONS_X 70
#define AREA_REVOLUTIONS_Y 60
#define AREA_ID_X 100
#define AREA_ID_Y 12

/**
* @brief 绘制正常模式界面
*/
static void draw_normal_screen(void)
{
u8g2_t *u8g2 = u8g2_get_instance();
rt_err_t ret;
struct motor_params local_params;

// 上锁读取数据
ret = rt_mutex_take(system_state->data_mutex, RT_WAITING_FOREVER);
if (ret == RT_EOK)
{
// 复制数据到本地
local_params = *motor_params;

// 清除更新标志
system_state->updated = 0;

// 解锁
rt_mutex_release(system_state->data_mutex);
}
else
{
return;
}

// 清屏
u8g2_ClearBuffer(u8g2);

// 绘制标题和单位
u8g2_SetFont(u8g2, u8g2_font_ncenB10_tr);
u8g2_DrawStr(u8g2, 0, 12, "V:");
u8g2_DrawStr(u8g2, 0, 42, "A:");
u8g2_DrawStr(u8g2, 70, 12, "RPM:");
u8g2_DrawStr(u8g2, 70, 42, "圈数:");
u8g2_DrawStr(u8g2, 80, 12, "ID:");

// 绘制设备ID
draw_integer(AREA_ID_X, AREA_ID_Y, local_params.device_id, 2, 0);

// 绘制电压(2位整数, 1位小数)
draw_number_with_decimal(AREA_VOLTAGE_X + 15, AREA_VOLTAGE_Y,
local_params.voltage, 2, 1, 1);

// 绘制电流(1位整数, 2位小数)
draw_number_with_decimal(AREA_CURRENT_X + 15, AREA_CURRENT_Y,
local_params.current, 1, 2, 1);

// 绘制转速(4位整数)
draw_integer(AREA_SPEED_X + 35, AREA_SPEED_Y, local_params.speed, 4, 1);

// 绘制圈数(4位整数, 1位小数)
draw_number_with_decimal(AREA_REVOLUTIONS_X + 35, AREA_REVOLUTIONS_Y,
local_params.revolutions, 4, 1, 1);

// 刷新显示
u8g2_SendBuffer(u8g2);
}

/**
* @brief 绘制校准模式界面
*/
static void draw_calibration_screen(void)
{
u8g2_t *u8g2 = u8g2_get_instance();
rt_err_t ret;
struct motor_params local_params;

// 上锁读取数据
ret = rt_mutex_take(system_state->data_mutex, RT_WAITING_FOREVER);
if (ret == RT_EOK)
{
// 复制数据到本地
local_params = *motor_params;

// 清除更新标志
system_state->updated = 0;

// 解锁
rt_mutex_release(system_state->data_mutex);
}
else
{
return;
}

// 清屏
u8g2_ClearBuffer(u8g2);

// 绘制校准模式标题
u8g2_SetFont(u8g2, u8g2_font_ncenB10_tr);
u8g2_DrawStr(u8g2, 0, 12, "校准模式");

// 根据当前校准项目绘制不同内容
switch (system_state->calib_item)
{
case 0: // 电压校准
u8g2_DrawStr(u8g2, 0, 30, "电压校准:");
draw_number_with_decimal(50, 30, local_params.voltage, 2, 1, 1);
u8g2_DrawStr(u8g2, 100, 30, "V");
u8g2_DrawStr(u8g2, 0, 50, "短按:校准长按:退出");
break;

case 1: // 电流校准
u8g2_DrawStr(u8g2, 0, 30, "电流校准:");
draw_number_with_decimal(50, 30, local_params.current, 1, 2, 1);
u8g2_DrawStr(u8g2, 100, 30, "A");
u8g2_DrawStr(u8g2, 0, 50, "短按:校准长按:退出");
break;

case 2: // 编码器校准
u8g2_DrawStr(u8g2, 0, 30, "编码器校准:");
draw_integer(70, 30, calib_params->encoder_ppr, 4, 1);
u8g2_DrawStr(u8g2, 0, 50, "短按:重置长按:退出");
break;

case 3: // 设备ID设置
u8g2_DrawStr(u8g2, 0, 30, "设备ID:");
draw_integer(50, 30, local_params.device_id, 2, 1);
u8g2_DrawStr(u8g2, 0, 50, "短按:增加长按:退出");
break;
}

// 刷新显示
u8g2_SendBuffer(u8g2);
}

/**
* @brief 显示更新任务入口
* @param parameter 任务参数
*/
static void display_task_entry(void *parameter)
{
while (1)
{
// 检查是否有数据指针
if (motor_params == RT_NULL || system_state == RT_NULL || calib_params == RT_NULL)
{
rt_thread_mdelay(DISPLAY_UPDATE_INTERVAL);
continue;
}

// 根据系统状态绘制不同界面
if (system_state->in_calibration)
{
draw_calibration_screen();
}
else
{
draw_normal_screen();
}

// 延时等待下一次更新
rt_thread_mdelay(DISPLAY_UPDATE_INTERVAL);
}
}

/**
* @brief 初始化显示更新任务
* @param params 电机参数结构体指针
* @param state 系统状态结构体指针
* @param calib 校准参数结构体指针
* @return 0: 成功, -1: 失败
*/
int display_task_init(struct motor_params *params, struct system_state *state,
struct calibration_params *calib)
{
if (params == RT_NULL || state == RT_NULL || calib == RT_NULL)
{
rt_kprintf("Invalid parameters for display task initialization\n");
return -1;
}

// 保存数据指针
motor_params = params;
system_state = state;
calib_params = calib;

// 创建显示任务
rt_thread_t thread = rt_thread_create("display",
display_task_entry,
RT_NULL,
DISPLAY_TASK_STACK_SIZE,
DISPLAY_TASK_PRIORITY,
DISPLAY_TASK_TIMESLICE);
if (thread != RT_NULL)
{
rt_thread_startup(thread);
rt_kprintf("Display task initialized successfully\n");
return 0;
}
else
{
rt_kprintf("Failed to create display task\n");
return -1;
}
}

显示更新任务头文件

#ifndef __DISPLAY_TASK_H
#define __DISPLAY_TASK_H

#include "app_data.h"

#endif /* __DISPLAY_TASK_H */

7.3.3 校准管理任务

校准管理任务负责处理校准逻辑，响应校准命令，更新校准参数。

校准管理任务

#include "calibration_task.h"
#include "voltage_current.h"
#include "encoder.h"
#include "key.h"
#include "app_data.h"
#include "data_storage.h"
#include "rtthread.h"

// 任务配置
#define CALIB_TASK_PRIORITY 7
#define CALIB_TASK_STACK_SIZE 1024
#define CALIB_TASK_TIMESLICE 10

// 全局数据指针
static struct motor_params *motor_params = RT_NULL;
static struct system_state *system_state = RT_NULL;
static struct calibration_params *calib_params = RT_NULL;

/**
* @brief 执行电压校准
*/
static void calibrate_voltage(void)
{
float current_voltage;

// 读取当前电压（应连接已知参考电压）
read_motor_voltage(&current_voltage);

// 假设此时实际电压为0V（短接输入），计算偏移量
calib_params->voltage_offset = current_voltage;

// 保存校准参数
data_storage_save_calibration(calib_params);

// 更新电压校准参数
set_voltage_calibration(calib_params->voltage_offset, calib_params->voltage_scale);

rt_kprintf("Voltage calibration completed: offset=%.3f\n", calib_params->voltage_offset);
}

/**
* @brief 执行电流校准
*/
static void calibrate_current(void)
{
float current_current;

// 读取当前电流（应确保电机未工作，电流为0）
read_motor_current(&current_current);

// 计算偏移量（此时实际电流应为0A）
calib_params->current_offset = current_current;

// 保存校准参数
data_storage_save_calibration(calib_params);

// 更新电流校准参数
set_current_calibration(calib_params->current_offset, calib_params->current_scale);

rt_kprintf("Current calibration completed: offset=%.3f\n", calib_params->current_offset);
}

/**
* @brief 执行编码器校准
*/
static void calibrate_encoder(void)
{
// 重置编码器计数
encoder_reset_count();

// 更新电机参数中的圈数
if (motor_params != RT_NULL)
{
motor_params->revolutions = 0.0f;
}

rt_kprintf("Encoder calibration completed: count reset\n");
}

/**
* @brief 增加设备ID
*/
static void increment_device_id(void)
{
if (motor_params != NULL && calib_params != NULL)
{
// 设备ID范围1-255
calib_params->device_id++;
if (calib_params->device_id == 0)
calib_params->device_id = 1;

motor_params->device_id = calib_params->device_id;

// 保存校准参数
data_storage_save_calibration(calib_params);

rt_kprintf("Device ID updated to: %d\n", calib_params->device_id);
}
}

/**
* @brief 校准管理任务入口
* @param parameter 任务参数
*/
static void calibration_task_entry(void *parameter)
{
key_event_t event;
int ret;

while (1)
{
// 检查是否有数据指针
if (motor_params == RT_NULL || system_state == RT_NULL || calib_params == RT_NULL)
{
rt_thread_mdelay(50);
continue;
}

// 如果不在校准模式，等待长按事件进入校准模式
if (!system_state->in_calibration)
{
ret = key_get_event(&event, RT_WAITING_FOREVER);
if (ret == RT_EOK && event == KEY_EVENT_LONG_PRESS)
{
rt_kprintf("Entering calibration mode\n");
system_state->in_calibration = 1;
system_state->calib_item = 0; // 默认从电压校准开始
}
}
else
{
// 在校准模式下，处理按键事件
ret = key_get_event(&event, RT_WAITING_FOREVER);
if (ret == RT_EOK)
{
switch (event)
{
case KEY_EVENT_PRESS:
// 短按：执行当前项目校准或切换项目
rt_kprintf("Calibration item %d pressed\n", system_state->calib_item);

switch (system_state->calib_item)
{
case 0: // 电压校准
calibrate_voltage();
// 切换到下一个校准项目
system_state->calib_item = 1;
break;

case 1: // 电流校准
calibrate_current();
// 切换到下一个校准项目
system_state->calib_item = 2;
break;

case 2: // 编码器校准
calibrate_encoder();
// 切换到下一个校准项目
system_state->calib_item = 3;
break;

case 3: // 设备ID设置
increment_device_id();
// 循环回到第一个校准项目
system_state->calib_item = 0;
break;

default:
system_state->calib_item = 0;
break;
}
break;

case KEY_EVENT_LONG_PRESS:
// 长按：退出校准模式
rt_kprintf("Exiting calibration mode\n");
system_state->in_calibration = 0;
break;

default:
break;
}
}
}
}
}

/**
* @brief 初始化校准管理任务
* @param params 电机参数结构体指针
* @param state 系统状态结构体指针
* @param calib 校准参数结构体指针
* @return 0: 成功, -1: 失败
*/
int calibration_task_init(struct motor_params *params, struct system_state *state,
struct calibration_params *calib)
{
if (params == RT_NULL || state == RT_NULL || calib == RT_NULL)
{
rt_kprintf("Invalid parameters for calibration task initialization\n");
return -1;
}

// 保存数据指针
motor_params = params;
system_state = state;
calib_params = calib;

// 创建校准任务
rt_thread_t thread = rt_thread_create("calibration",
calibration_task_entry,
RT_NULL,
CALIB_TASK_STACK_SIZE,
CALIB_TASK_PRIORITY,
CALIB_TASK_TIMESLICE);
if (thread != RT_NULL)
{
rt_thread_startup(thread);
rt_kprintf("Calibration task initialized successfully\n");
return 0;
}
else
{
rt_kprintf("Failed to create calibration task\n");
return -1;
}
}

校准管理任务头文件

#ifndef __CALIBRATION_TASK_H
#define __CALIBRATION_TASK_H

#include "app_data.h"

#endif /* __CALIBRATION_TASK_H */

7.4 数据存储模块

数据存储模块负责将校准参数保存到 Flash 中，以便系统重启后仍能使用之前的校准参数。

数据存储模块data_storage.c

#include "data_storage.h"
#include "app_data.h"
#include "rtthread.h"
#include "gd32f30x.h"
#include <string.h>

// Flash存储配置
#define FLASH_PAGE_SIZE 1024 // 每页大小(字节)
#define CALIB_DATA_PAGE 63 // 存储校准数据的页(最后一页)
#define FLASH_BASE_ADDR 0x08000000 // Flash基地址
#define CALIB_DATA_ADDR (FLASH_BASE_ADDR + CALIB_DATA_PAGE * FLASH_PAGE_SIZE)

// 数据校验结构体
typedef struct
{
struct calibration_params data;
uint32_t checksum; // 校验和
} calib_data_with_checksum;

/**
* @brief 计算校验和
* @param data 数据指针
* @param len 数据长度
* @return 校验和
*/
static uint32_t calculate_checksum(const void *data, uint32_t len)
{
const uint8_t *bytes = (const uint8_t *)data;
uint32_t checksum = 0;
uint32_t i;

for (i = 0; i < len; i++)
{
checksum += bytes[i];
}

return checksum;
}

/**
* @brief 擦除Flash页
* @param page 页号
* @return 0: 成功, -1: 失败
*/
static int flash_erase_page(uint32_t page)
{
// 解锁Flash
fmc_unlock();

// 擦除指定页
fmc_page_erase(FLASH_BASE_ADDR + page * FLASH_PAGE_SIZE);

// 检查是否有错误
if (fmc_flag_get(FMC_FLAG_END | FMC_FLAG_WPERR | FMC_FLAG_PGERR) != RESET)
{
// 清除标志
fmc_flag_clear(FMC_FLAG_END | FMC_FLAG_WPERR | FMC_FLAG_PGERR);
fmc_lock();
return -1;
}

// 锁定Flash
fmc_lock();
return 0;
}

/**
* @brief 写入数据到Flash
* @param addr 地址
* @param data 数据指针
* @param len 数据长度
* @return 0: 成功, -1: 失败
*/
static int flash_write_data(uint32_t addr, const void *data, uint32_t len)
{
const uint16_t *half_words = (const uint16_t *)data;
uint32_t i;
uint32_t words = (len + 1) / 2; // 转换为半字数量

// 解锁Flash
fmc_unlock();

// 写入数据
for (i = 0; i < words; i++)
{
fmc_halfword_program(addr + i * 2, half_words[i]);

// 检查是否有错误
if (fmc_flag_get(FMC_FLAG_END | FMC_FLAG_WPERR | FMC_FLAG_PGERR) != RESET)
{
// 清除标志
fmc_flag_clear(FMC_FLAG_END | FMC_FLAG_WPERR | FMC_FLAG_PGERR);
fmc_lock();
return -1;
}
}

// 锁定Flash
fmc_lock();
return 0;
}

/**
* @brief 从Flash读取数据
* @param addr 地址
* @param data 数据指针
* @param len 数据长度
*/
static void flash_read_data(uint32_t addr, void *data, uint32_t len)
{
memcpy(data, (const void *)addr, len);
}

/**
* @brief 保存校准参数到Flash
* @param calib 校准参数结构体指针
* @return 0: 成功, -1: 失败
*/
int data_storage_save_calibration(const struct calibration_params *calib)
{
calib_data_with_checksum data;
int ret;

if (calib == RT_NULL)
return -1;

// 复制数据
data.data = *calib;

// 计算校验和
data.checksum = calculate_checksum(&data.data, sizeof(struct calibration_params));

// 擦除Flash页
ret = flash_erase_page(CALIB_DATA_PAGE);
if (ret != 0)
{
rt_kprintf("Failed to erase flash page\n");
return -1;
}

// 写入数据
ret = flash_write_data(CALIB_DATA_ADDR, &data, sizeof(calib_data_with_checksum));
if (ret != 0)
{
rt_kprintf("Failed to write calibration data to flash\n");
return -1;
}

rt_kprintf("Calibration data saved successfully\n");
return 0;
}

/**
* @brief 从Flash加载校准参数
* @param calib 存储校准参数的结构体指针
* @return 0: 成功, -1: 失败(使用默认值)
*/
int data_storage_load_calibration(struct calibration_params *calib)
{
calib_data_with_checksum data;
uint32_t checksum;

if (calib == RT_NULL)
return -1;

// 从Flash读取数据
flash_read_data(CALIB_DATA_ADDR, &data, sizeof(calib_data_with_checksum));

// 计算校验和
checksum = calculate_checksum(&data.data, sizeof(struct calibration_params));

// 检查校验和
if (checksum == data.checksum)
{
// 校验成功，使用读取的数据
*calib = data.data;
rt_kprintf("Calibration data loaded successfully\n");
return 0;
}
else
{
// 校验失败，使用默认值
calibration_params_init(calib);
rt_kprintf("Calibration data checksum failed, using defaults\n");
return -1;
}
}

/**
* @brief 恢复出厂设置(清除校准数据)
* @return 0: 成功, -1: 失败
*/
int data_storage_restore_factory_settings(void)
{
struct calibration_params default_calib;

// 初始化默认校准参数
calibration_params_init(&default_calib);

// 保存默认参数(会覆盖原有数据)
return data_storage_save_calibration(&default_calib);
}

数据存储模块头文件data_storage.h

#ifndef __DATA_STORAGE_H
#define __DATA_STORAGE_H

#include "app_data.h"

/**
* @brief 保存校准参数到Flash
* @param calib 校准参数结构体指针
* @return 0: 成功, -1: 失败
*/
int data_storage_save_calibration(const struct calibration_params *calib);

/**
* @brief 从Flash加载校准参数
* @param calib 存储校准参数的结构体指针
* @return 0: 成功, -1: 失败(使用默认值)
*/
int data_storage_load_calibration(struct calibration_params *calib);

/**
* @brief 恢复出厂设置(清除校准数据)
* @return 0: 成功, -1: 失败
*/
int data_storage_restore_factory_settings(void);

#endif /* __DATA_STORAGE_H */

7.5 主程序

主程序负责初始化系统各模块，创建全局数据结构，并启动各个任务。

主程序代码main.c

#include <rtthread.h>
#include "app_data.h"
#include "data_collector.h"
#include "display_task.h"
#include "calibration_task.h"
#include "voltage_current.h"
#include "encoder.h"
#include "key.h"
#include "data_storage.h"

// 全局数据结构
static struct motor_params motor_params;
static struct system_state system_state;
static struct calibration_params calib_params;

/**
* @brief 系统初始化
* @return 0: 成功, -1: 失败
*/
static int system_init(void)
{
int ret;

rt_kprintf("System initialization started\n");

// 初始化数据结构
motor_params_init(&motor_params);
calibration_params_init(&calib_params);
ret = system_state_init(&system_state);
if (ret != 0)
{
rt_kprintf("Failed to initialize system state\n");
return -1;
}

// 从Flash加载校准参数
data_storage_load_calibration(&calib_params);

// 更新电机参数中的设备ID
motor_params.device_id = calib_params.device_id;

// 配置编码器每圈脉冲数
encoder_set_ppr(calib_params.encoder_ppr);

// 设置电压电流校准参数
set_voltage_calibration(calib_params.voltage_offset, calib_params.voltage_scale);
set_current_calibration(calib_params.current_offset, calib_params.current_scale);

// 初始化参数采集任务
ret = data_collector_init(&motor_params, &system_state);
if (ret != 0)
{
rt_kprintf("Failed to initialize data collector\n");
return -1;
}

// 初始化显示任务
ret = display_task_init(&motor_params, &system_state, &calib_params);
if (ret != 0)
{
rt_kprintf("Failed to initialize display task\n");
return -1;
}

// 初始化校准任务
ret = calibration_task_init(&motor_params, &system_state, &calib_params);
if (ret != 0)
{
rt_kprintf("Failed to initialize calibration task\n");
return -1;
}

rt_kprintf("System initialization completed successfully\n");
return 0;
}

/**
* @brief 主函数
*/
int main(void)
{
// 系统初始化
system_init();

// 主循环（空循环，所有工作在任务中完成）
while (1)
{
rt_thread_mdelay(1000);
}
}

// 导出恢复出厂设置命令
MSH_CMD_EXPORT(data_storage_restore_factory_settings, "Restore factory settings");

8. 系统测试与性能分析

8.1 测试环境搭建

为了全面测试电机测试工装的性能，需要搭建以下测试环境：

设备 / 工具	型号 / 规格	用途
直流稳压电源	0-30V/0-5A	为电机提供可调电源
高精度万用表	FLUKE 87V	测量电压作为参考值
高精度电流表	FLUKE 376	测量电流作为参考值
标准转速计	精度 ±1RPM	测量转速作为参考值
有刷电机	12V/2A	测试值
有刷电机	12V/2A	测试对象
示波器	100MHz	观察信号波形
计算机	安装 RT-Thread Studio	程序下载与调试
J-Link 调试器	V9	在线调试
串口调试助手	TeraTerm	查看调试信息

测试环境连接图如下：

plaintext

+----------------+     +----------------+     +----------------+
|  直流稳压电源   |---->|   电机测试工装  |---->|    有刷电机     |
+----------------+     +----------------+     +----------------+
        |                       |                    |
        |                       |                    |
+-------v-------+     +--------v-------+    +-------v-------+
|  高精度万用表   |     |  串口调试助手   |    |  标准转速计     |
+---------------+     +----------------+    +---------------+
                                                  |
                                         +--------v-------+
                                         |   示波器        |
                                         +----------------+

8.2 功能测试

8.2.1 电压测量功能测试

测试步骤：

将工装电压输入端连接到直流稳压电源
分别设置电源输出为 5V、10V、15V、20V、25V、30V
记录工装显示的电压值
与万用表测量值比较，计算误差

测试结果如下表：

实际电压 (V)	工装显示 (V)	误差 (V)	相对误差 (%)
5.00	4.98	-0.02	-0.40
10.00	10.03	+0.03	+0.30
15.00	14.97	-0.03	-0.20
20.00	20.05	+0.05	+0.25
25.00	24.95	-0.05	-0.20
30.00	30.08	+0.08	+0.27

结论：电压测量误差均在 ±0.1V 以内，相对误差小于 ±0.5%，满足设计要求。

8.2.2 电流测量功能测试

测试步骤：

将工装电流测量端串联在电机供电回路中
调节电机负载，使电流分别为 1A、2A、3A、4A、5A
记录工装显示的电流值
与电流表测量值比较，计算误差

测试结果如下表：

实际电流 (A)	工装显示 (A)	误差 (A)	相对误差 (%)
1.00	0.99	-0.01	-1.00
2.00	2.01	+0.01	+0.50
3.00	2.98	-0.02	-0.67
4.00	4.02	+0.02	+0.50
5.00	4.99	-0.01	-0.20

结论：电流测量误差均在 ±0.02A 以内，相对误差小于 ±1%，满足设计要求。

8.2.3 转速测量功能测试

测试步骤：

将标准转速计的传感器对准电机轴
调节电机电压，使转速分别为 1000RPM、3000RPM、5000RPM、7000RPM、9000RPM
记录工装显示的转速值
与标准转速计测量值比较，计算误差

测试结果如下表：

实际转速 (RPM)	工装显示 (RPM)	误差 (RPM)	相对误差 (%)
1000	998	-2	-0.20
3000	3002	+2	+0.07
5000	4997	-3	-0.06
7000	7005	+5	+0.07
9000	8996	-4	-0.04

结论：转速测量误差均在 ±5RPM 以内，相对误差小于 ±0.2%，满足设计要求。

8.2.4 圈数测量功能测试

测试步骤：

复位工装的圈数计数
手动转动电机，使电机精确转动 10 圈
记录工装显示的圈数
重复测试 5 次，计算误差

测试结果如下表：

测试次数	实际圈数	工装显示圈数	误差 (圈)
1	10	10.0	0.0
2	10	10.0	0.0
3	10	9.9	-0.1
4	10	10.1	+0.1
5	10	10.0	0.0

结论：圈数测量误差均在 ±0.1 圈以内，满足设计要求。

8.2.5 校准功能测试

测试步骤：

进入电压校准模式，短接电压输入端（实际电压 0V），执行校准
进入电流校准模式，断开电机（实际电流 0A），执行校准
进入编码器校准模式，执行复位操作
测试校准后的测量精度

测试结果：校准后各项参数的测量误差均有所减小，说明校准功能有效。

8.2.6 显示功能测试

测试步骤：

观察 OLED 屏幕显示是否清晰、稳定
检查各参数显示是否完整
验证数码管风格显示是否符合预期
测试屏幕刷新是否流畅

测试结果：OLED 屏幕显示清晰，参数完整，数码管风格显示直观易读，刷新流畅无闪烁。

8.3 性能分析

8.3.1 测量精度分析

根据上述测试结果，各项参数的测量精度如下表：

参数	测量范围	最大绝对误差	最大相对误差
电压	0-30V	±0.08V	±0.27%
电流	0-5A	±0.02A	±1.00%
转速	0-10000RPM	±5RPM	±0.20%
圈数	0-99999 圈	±0.1 圈	±1.00% (小圈数时)

所有参数的测量精度均满足设计要求，其中电压和转速的测量精度较高，电流和圈数的测量精度稍低，但仍在可接受范围内。

8.3.2 系统响应时间

测试步骤：

突然改变电机电压，记录从电压变化到工装显示变化的时间
突然改变电机负载，记录从电流变化到工装显示变化的时间
突然改变电机转速，记录从转速变化到工装显示变化的时间

测试结果：

电压响应时间：≤50ms
电流响应时间：≤80ms
转速响应时间：≤100ms

系统整体响应时间≤100ms，满足设计要求。

8.3.3 系统稳定性

测试步骤：

让系统连续运行 24 小时
每隔 1 小时记录一次各项参数的测量值
分析参数漂移情况

测试结果：

电压测量漂移：≤±0.03V
电流测量漂移：≤±0.01A
转速测量漂移：≤±3RPM

系统运行稳定，参数漂移在可接受范围内。

8.3.4 资源占用分析

系统资源占用情况如下表：

资源	总量	占用量	占用率
Flash	256KB	128KB	50%
RAM	48KB	22KB	46%
CPU 使用率	-	-	≤15%

系统资源占用合理，有足够的余量进行功能扩展。

9. 故障排查与解决方案

在系统开发和测试过程中，可能会遇到各种故障和问题。以下是常见故障的排查方法和解决方案：

9.1 硬件故障

故障现象	可能原因	排查方法	解决方案
OLED 屏幕无显示	1. 电源未接通 2. 引脚连接错误 3. 屏幕损坏	1. 测量 OLED 电源电压 2. 检查 SPI 引脚连接 3. 更换屏幕测试	1. 确保 3.3V 电源正常 2. 重新焊接引脚 3. 更换损坏的屏幕
电压测量值为 0	1. 电压输入未连接 2. 分压电阻损坏 3. ADS1115 通道故障	1. 检查电压输入接线 2. 测量分压电阻阻值 3. 切换 ADS1115 通道测试	1. 正确连接电压输入 2. 更换损坏的电阻 3. 使用备用通道
电流测量值异常	1. 采样电阻损坏 2. INA138 损坏 3. 匹配电阻错误	1. 测量采样电阻阻值 2. 检查 INA138 输出 3. 测量匹配电阻阻值	1. 更换 200mΩ 采样电阻 2. 更换 INA138 芯片 3. 更换为 4.99KΩ 电阻
转速测量不准确	1. 编码器接线错误 2. 编码器损坏 3. 定时器配置错误	1. 检查编码器 A/B 相接线 2. 用示波器观察编码器输出 3. 检查定时器配置	1. 正确连接编码器 2. 更换编码器 3. 重新配置定时器
按键无响应	1. 按键损坏 2. 引脚连接错误 3. 上拉电阻缺失	1. 测量按键导通性 2. 检查按键引脚连接 3. 检查上拉电阻	1. 更换按键 2. 重新焊接引脚 3. 增加 10KΩ 上拉电阻

9.2 软件故障

故障现象	可能原因	排查方法	解决方案
系统无法启动	1. 程序下载失败 2. 启动文件错误 3. 栈溢出	1. 检查下载器连接 2. 检查启动文件配置 3. 增加栈大小	1. 重新下载程序 2. 修复启动文件 3. 调整任务栈大小
数据采集异常	1. I2C/SPI 通信错误 2. 驱动程序 bug 3. 校准参数错误	1. 用示波器观察通信波形 2. 调试驱动程序 3. 检查校准参数	1. 修复通信问题 2. 修正驱动程序 3. 重新校准参数
显示乱码	1. U8G2 配置错误 2. 字体未正确加载 3. SPI 通信错误	1. 检查 U8G2 初始化代码 2. 确认字体已启用 3. 检查 SPI 时序	1. 正确配置 U8G2 2. 启用所需字体 3. 调整 SPI 速率
任务调度异常	1. 任务优先级设置错误 2. 互斥锁使用不当 3. 死锁	1. 检查任务优先级配置 2. 检查互斥锁获取释放逻辑 3. 使用调试工具检测死锁	1. 调整任务优先级 2. 修正互斥锁逻辑 3. 避免死锁产生
校准参数丢失	1. Flash 写入失败 2. 校验和计算错误 3. 掉电保护不足	1. 检查 Flash 操作代码 2. 验证校验和算法 3. 增加掉电检测	1. 修复 Flash 驱动 2. 修正校验和计算 3. 增加电容储能

9.3 系统集成故障

故障现象	可能原因	排查方法	解决方案
测量值跳变	1. 电源噪声过大 2. 布线不合理 3. 滤波算法不足	1. 用示波器观察电源波形 2. 检查 PCB 布线 3. 分析数据波动情况	1. 增加电源滤波电容 2. 优化 PCB 布局布线 3. 增强滤波算法
系统死机	1. 中断处理不当 2. 内存泄漏 3. 硬件冲突	1. 检查中断服务程序 2. 监控内存使用情况 3. 检查外设地址冲突	1. 优化中断处理 2. 修复内存泄漏 3. 调整外设配置
功耗过高	1. 电源设计不合理 2. 未使用低功耗模式 3. 外设未正确关闭	1. 测量各模块电流 2. 检查低功耗配置 3. 检查外设状态	1. 优化电源设计 2. 启用低功耗模式 3. 空闲时关闭外设
抗干扰能力差	1. 接地不良 2. 未做电磁屏蔽 3. 信号线上未加保护	1. 检查接地系统 2. 评估电磁环境 3. 检查信号线保护	1. 优化接地设计 2. 增加屏蔽措施 3. 信号线加滤波和保护

10. 项目优化与扩展

10.1 性能优化

10.1.1 测量精度优化

硬件优化：
- 采用更高精度的电阻（0.01%）作为分压电阻和匹配电阻
- 增加温度补偿电路，减少温度漂移对测量的影响
- 优化 PCB 布局，减少噪声干扰
软件优化：
- 采用更先进的滤波算法（如卡尔曼滤波）替代简单的移动平均滤波
- 增加温度补偿算法，根据环境温度修正测量值
- 实现自动校准功能，定期对零点进行校准