嵌入式软件开发实战：基于STM32的定时器注册机制设计与解耦

在嵌入式开发中，尤其是在使用定时器时，开发者常常会遇到一个棘手的难题：为了控制各个任务的时序，不得不在程序中到处定义 flag、holdtime 等状态变量和时间变量。这不仅导致中断函数里“标志位满天飞”，也让程序模块间高度耦合，使得代码难以维护、复用和移植，完全违背了模块化编程“高内聚、低耦合”的初衷。

如何通过注册机制解决耦合问题？

解决这一问题的核心思想是引入注册机制。为了更直观地理解，我们可以将其类比为手机相机的功能：相机模块负责拍照，但它可能被微信、QQ、微博等多种应用调用以发送图片。

一种最简单的实现方式是在相机模块内部写死所有发送逻辑：

if (选择发送) {
    if (选择微信发送) {
        获取发送人；
        选择发送人；
    } else if (选择QQ发送) {
        获取发送人；
        选择发送人；
    } else if (选择微博发送) {
        获取发送人；
        选择发送人；
    }
    // ... 此处省略其他应用
}

这种方式与在程序中随意定义定时器变量类似，耦合度极高。一旦出现新的应用（如“叮叮”），就必须回头修改相机模块的代码，这与我们频繁修改定时器相关代码的困境如出一辙。

注册机制的精髓正在于解耦。它倡导“高内聚，低耦合”的设计理念。高内聚意味着每个模块（如.c文件）专注完成一项核心功能；低耦合则意味着模块间通过清晰、有限的接口进行交互。注册机制通过一个中心化的“服务台”（注册中心）来协调模块间的调用关系，极大地降低了直接依赖。

何为注册机制？

以相机为例，我们可以让相机模块提供一个注册函数。任何想要使用相机发送功能的应用（如微信），在初始化时调用这个注册函数，将自己的“发送函数”地址告诉相机。相机内部维护一个已注册应用的列表和对应的函数指针。

这样，当用户选择通过某个应用发送图片时，相机只需从列表中查找并调用对应的函数即可。新旧应用的增删，完全不影响相机模块本身，实现了完美的解耦。理解这种函数指针和回调机制是掌握许多高级软件设计模式的基础，它不仅是嵌入式开发的核心，也是深入理解网络/系统底层通信模型的重要桥梁。

下面是一个简化的相机注册机制数据结构示例：

#define NUM_MAX 20 // 最大注册设备数

typedef struct {
    u8 num; // 当前注册设备数
    u8 list_name[NUM_MAX]; // 保存注册设备名列表
    void (*click[NUM_MAX])(u8 *data); // 存放各应用的发送函数地址
} Equipment;

Equipment COM;

// 提供给外部的注册接口
void Photo_Register(void (*send_func)(u8 *data), u8 app_name) {
    if (COM.num < NUM_MAX) {
        COM.click[COM.num] = send_func; // 保存函数地址
        COM.list_name[COM.num] = app_name; // 保存应用名
        COM.num++;
    } else {
        // 错误处理：超过最大设备数
    }
}

// 相机统一的发送入口
void Click_Send(u8 *image_data) {
    u8 i, choice;
    // ... 显示已注册应用列表供用户选择 ...
    choice = Get_User_Choice(); // 获取用户选择
    if (choice < COM.num) {
        COM.click[choice](image_data); // 回调对应应用的发送函数
    }
}

通过这种方式，新应用只需注册一次，相机模块无需做任何修改，两者之间实现了彻底的解耦。

在STM32定时器中运用注册机制

我们将上述思想应用于STM32的定时器管理，目标是消除全局散落的时间变量和标志位。

核心思路：维护一个唯一的、持续自增的32位系统时间戳（如systime.now）。任何需要定时功能的任务，都向时间管理模块“注册”以获取一个唯一的ID，并记录下自己开始计时的时间点（systime.last[ID]）。通过比较当前时间与记录的时间，即可判断时间间隔是否到期。

这种设计巧妙地利用了数据结构来管理多个定时任务，是算法/数据结构思想在嵌入式系统资源管理中的典型应用。

1. 头文件定义 (time.h)

#ifndef __TIME_H
#define __TIME_H

#include "stm32f10x.h"

#define TIMER_ID_MAX 20 // 最大可注册定时任务数
// 判断指定ID的任务是否已超时（ms）
#define TIME_OUT(ID, ms) (systime.now - systime.last[(ID)-1] >= (ms))

typedef struct {
    u8 id_cnt; // 已分配的ID计数
    u32 now; // 当前系统时间（单位：ms）
    u32 last[TIMER_ID_MAX]; // 各任务记录的时间起点
    void (*timer_init)(u16, u16); // 定时器硬件初始化函数指针
    u8 (*get_id)(void); // 获取任务ID函数指针
    void (*refresh)(u8); // 刷新任务时间起点函数指针
} SYSTIME;

extern SYSTIME systime;

#endif

2. 源文件实现 (time.c)

#include "time.h"

// 对外提供的API
void Timer_Init(u16 CountData, u16 FreqData);
u8 systime_get_id(void);
void Refresh_Task_Time(u8 task_id);

SYSTIME systime = {
    .get_id = systime_get_id,
    .refresh = Refresh_Task_Time,
    .timer_init = Timer_Init
};

// 定时器硬件初始化（STM32 TIM4示例）
void Timer_Init(u16 Prescaler, u16 Period) {
    // ... 具体STM32定时器配置代码（初始化TIM4，设置1ms中断）...
}

// 获取一个新的任务ID，并记录当前时间作为该任务的起点
u8 systime_get_id(void) {
    if (systime.id_cnt < TIMER_ID_MAX) {
        systime.last[systime.id_cnt] = systime.now;
        systime.id_cnt++;
        return systime.id_cnt; // 返回ID（从1开始）
    } else {
        return 0; // 注册失败，ID已满
    }
}

// 刷新指定任务的开始时间
void Refresh_Task_Time(u8 task_id) {
    if (task_id > 0 && task_id <= systime.id_cnt) {
        systime.last[task_id - 1] = systime.now;
    }
}

// TIM4中断服务函数，每1ms执行一次
void TIM4_IRQHandler(void) {
    if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET) {
        TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
        systime.now++; // 系统时间戳自增
    }
}

定时器注册机制的使用方法

任何任务想要使用定时功能，只需三步：获取ID、判断超时、超时后刷新时间起点。

示例：两个LED以不同频率闪烁

// 任务1：LED以1秒周期闪烁
void task1(void) {
    static u8 task1_id = 0;
    if (task1_id == 0) {
        task1_id = systime.get_id(); // 1. 注册，获取唯一ID
    }

    if (TIME_OUT(task1_id, 1000)) {
        LED1_ON();
    } else if (TIME_OUT(task1_id, 2000)) {
        LED1_OFF();
    } else if (TIME_OUT(task1_id, 3000)) {
        LED1_ON();
    } else if (TIME_OUT(task1_id, 4000)) {
        LED1_OFF();
    } else if (TIME_OUT(task1_id, 5000)) {
        LED1_ON();
        systime.refresh(task1_id); // 3. 一个完整周期结束，刷新时间，重新开始计时
    }
}

// 任务2：另一个LED以500ms周期闪烁
void task2(void) {
    static u8 task2_id = 0;
    if (task2_id == 0) {
        task2_id = systime.get_id();
    }

    if (TIME_OUT(task2_id, 500)) {
        LED2_TOGGLE(); // 翻转LED状态
        systime.refresh(task2_id); // 每次动作后立即刷新，实现周期性触发
    }
}

// 主循环调度
int main(void) {
    static u8 main_task_id = 0;
    System_Init(); // 系统初始化
    systime.timer_init(7199, 9999); // 初始化定时器硬件，配置为1ms中断

    while (1) {
        if (main_task_id == 0) {
            main_task_id = systime.get_id();
        }

        // 主循环也可以使用相同的机制进行任务调度
        if (TIME_OUT(main_task_id, 10000)) {
            task1(); // 前10秒执行task1
        } else {
            task2(); // 之后执行task2
            systime.refresh(main_task_id); // 刷新主任务时间
        }
    }
}

优势与局限性

优势：

1. 彻底解耦：定时器管理模块与具体应用任务分离，接口清晰（仅get_id, refresh, TIME_OUT宏）。
2. 易于移植：更换硬件平台时，只需修改Timer_Init等硬件相关部分，应用层任务代码几乎无需改动。
3. 资源集中管理：所有时间变量集中在systime结构体中，避免了全局变量滥用。

局限性：
本文实现的是一种“超时检测”机制，而非精确的“周期调度”。由于主循环的执行时间不确定，它无法保证任务在精确的100ms时刻被执行。若需要严格的实时周期调度，通常需要结合定时器中断和就绪任务列表来实现，将“时间到”的事件捕捉放在中断中，主循环只处理已就绪的任务。

总结

通过引入注册机制管理STM32定时器，我们成功将分散的、高耦合的定时逻辑，重构为集中、低耦合的模块化设计。这种方法的核心是使用函数指针和结构体封装，为每个定时任务提供独立的“计时沙漏”。它极大地提升了代码的整洁性、可维护性和可移植性，是嵌入式软件走向高质量设计的重要一步。