Zephyr RTOS 中的 k_timer定时器

目录

概述

1 k_timer主要函数

1.1 k_timer_start函数

1.2 k_timer_init 函数

1.3 k_timer_stop 函数

2  典型使用方法

2.1 周期性数据采集

2.2  看门狗超时

2.3  精确时间控制

3 高级用法

3.1 定时器组合（多速率系统）

3.2 带用户数据的定时器

3.3 定时器链（顺序执行）

4 k_timer主要函数的用法

4.1 k_timer_init 函数

4.2 k_timer_start函数

4.3  k_timer_stop 函数

5 与工作队列的对比

---

概述

本文主要介绍Zephyr RTOS 中的 k_timer定时器的函数，k_timer_start是 Zephyr RTOS 中用于启动内核定时器的核心函数，提供了精确的时间事件调度能力。k_timer_stop 是 Zephyr RTOS 中用于停止运行中定时器的核心函数。k_timer_init 是 Zephyr RTOS 中用于初始化内核定时器的核心函数，它为定时器设置基本参数和回调处理函数，是使用定时器功能前的必要步骤。

1 k_timer主要函数

1.1 k_timer_start函数

1）函数原型

void k_timer_start(struct k_timer *timer, k_timeout_t duration, k_timeout_t period);

2） 参数说明

参数	类型	说明
timer	struct k_timer *	指向定时器结构的指针
duration	k_timeout_t	首次到期时间
period	k_timeout_t	后续周期性间隔（0 表示单次定时器）

 3） 关键特性

1. 高精度计时：基于系统时钟中断，精度可达微秒级

2. 两种通知机制：

   • 到期回调函数（在中断上下文执行）

   • 状态标志（可在线程中查询）

3. 灵活的工作模式：

   • 单次模式（period = 0）

   • 周期模式（period > 0）

4. 低功耗支持：可唤醒休眠系统

5. 线程安全：所有操作都是原子的

1.2 k_timer_init 函数

1） 函数原型

void k_timer_init(struct k_timer *timer,
                  k_timer_expiry_t expiry_fn,
                  k_timer_stop_t stop_fn);

2)参数说明

参数	类型	说明
timer	struct k_timer *	指向要初始化的定时器结构体的指针
expiry_fn	k_timer_expiry_t	定时器到期回调函数（可为 NULL）
stop_fn	k_timer_stop_t	定时器停止回调函数（可为 NULL）

3)  回调函数类型定义

// 定时器到期回调
typedef void (*k_timer_expiry_t)(struct k_timer *timer);

// 定时器停止回调
typedef void (*k_timer_stop_t)(struct k_timer *timer);

1.3 k_timer_stop 函数

k_timer_stop 是 Zephyr RTOS 中用于停止运行中定时器的核心函数，它提供了对定时器生命周期的精确控制能力，是资源管理和节能的关键操作。

1）函数原型

void k_timer_stop(struct k_timer *timer);

2） 参数说明

参数	类型	说明
timer	struct k_timer *	指向要停止的定时器结构体的指针

2  典型使用方法

2.1 周期性数据采集

struct k_timer sensor_timer;

void sensor_timer_handler(struct k_timer *timer) {
    // 在中断中快速读取传感器
    int value = adc_read();
    k_fifo_put(&sensor_data_fifo, &value);
}

void main(void) {
    k_timer_init(&sensor_timer, sensor_timer_handler, NULL);
    k_timer_start(&sensor_timer, K_MSEC(10), K_MSEC(10));
    
    while (1) {
        // 主线程处理数据
        int *data = k_fifo_get(&sensor_data_fifo, K_FOREVER);
        process_sensor_data(*data);
    }
}

2.2  看门狗超时

struct k_timer watchdog_timer;

void watchdog_handler(struct k_timer *timer) {
    printk("System watchdog timeout! Resetting...\n");
    sys_reboot();
}

void feed_watchdog(void) {
    k_timer_start(&watchdog_timer, K_SECONDS(5), K_NO_WAIT);
}

void main(void) {
    k_timer_init(&watchdog_timer, watchdog_handler, NULL);
    feed_watchdog();
    
    while (1) {
        perform_critical_operation();
        feed_watchdog(); // 定期喂狗
        k_sleep(K_SECONDS(1));
    }
}

2.3  精确时间控制

// 控制LED精确闪烁
void led_blink_handler(struct k_timer *timer) {
    static bool state;
    gpio_pin_set(led_dev, LED_PIN, state);
    state = !state;
}

void start_led_blink(void) {
    static struct k_timer blink_timer;
    k_timer_init(&blink_timer, led_blink_handler, NULL);
    k_timer_start(&blink_timer, K_MSEC(100), K_MSEC(100)); // 10Hz闪烁
}

3 高级用法

3.1 定时器组合（多速率系统）

struct k_timer fast_timer, slow_timer;

void fast_handler(struct k_timer *t) { /* 高频任务 */ }
void slow_handler(struct k_timer *t) { /* 低频任务 */ }

void setup_multi_rate_system(void) {
    k_timer_init(&fast_timer, fast_handler, NULL);
    k_timer_init(&slow_timer, slow_handler, NULL);
    
    k_timer_start(&fast_timer, K_MSEC(10), K_MSEC(10));  // 100Hz
    k_timer_start(&slow_timer, K_MSEC(100), K_MSEC(100)); // 10Hz
}

3.2 带用户数据的定时器

struct custom_timer {
    struct k_timer timer;
    void *user_data;
};

void custom_handler(struct k_timer *timer) {
    struct custom_timer *ct = CONTAINER_OF(timer, struct custom_timer, timer);
    handle_event(ct->user_data);
}

void start_custom_timer(void *data) {
    static struct custom_timer ct;
    ct.user_data = data;
    k_timer_init(&ct.timer, custom_handler, NULL);
    k_timer_start(&ct.timer, K_MSEC(500), K_NO_WAIT);
}

3.3 定时器链（顺序执行）

struct k_timer step1_timer, step2_timer;

void step2_handler(struct k_timer *t) {
    // 第二步操作
}

void step1_handler(struct k_timer *t) {
    // 第一步操作
    k_timer_start(&step2_timer, K_MSEC(50), K_NO_WAIT); // 启动下一步
}

void start_sequence(void) {
    k_timer_init(&step1_timer, step1_handler, NULL);
    k_timer_init(&step2_timer, step2_handler, NULL);
    k_timer_start(&step1_timer, K_MSEC(100), K_NO_WAIT); // 启动序列
}

4 k_timer主要函数的用法

4.1 k_timer_init 函数

1) 定义定时器变量

// 静态定义
static struct k_timer my_timer;

// 或者动态分配（需确保生命周期）
struct k_timer *timer_ptr = k_malloc(sizeof(struct k_timer));

2)初始化定时器

// 带到期回调的初始化
k_timer_init(&my_timer, timer_expiry_handler, NULL);

// 带停止回调的初始化
k_timer_init(&my_timer, NULL, timer_stop_handler);

// 带完整回调的初始化
k_timer_init(&my_timer, timer_expiry_handler, timer_stop_handler);

3) 定义回调函数（可选）

// 到期回调函数
void timer_expiry_handler(struct k_timer *timer_id)
{
    printk("Timer expired at %u ms\n", k_uptime_get_32());
    
    // 可以通过CONTAINER_OF获取用户数据
    struct custom_data *data = CONTAINER_OF(timer_id, struct custom_data, timer);
    process_data(data);
}

// 停止回调函数
void timer_stop_handler(struct k_timer *timer_id)
{
    printk("Timer was stopped\n");
    // 清理资源或通知其他任务
}

4.2 k_timer_start函数

1） 定义定时器

struct k_timer my_timer;

2） 启动定时器

// 单次定时器（100ms后触发）
k_timer_start(&my_timer, K_MSEC(100), K_NO_WAIT);

// 周期性定时器（首次50ms后触发，之后每100ms触发）
k_timer_start(&my_timer, K_MSEC(50), K_MSEC(100));

3） 定时器处理

// 回调函数方式
void timer_expiry_handler(struct k_timer *timer_id)
{
    printk("Timer expired at %u ms\n", k_uptime_get_32());
}

// 状态查询方式
if (k_timer_status_get(&my_timer) > 0) {
    // 处理定时事件
    k_timer_status_sync(&my_timer); // 重置状态
}

4） 停止定时器

k_timer_stop(&my_timer);

4.3  k_timer_stop 函数

k_timer_stop 是 Zephyr RTOS 中用于停止运行中定时器的核心函数，它提供了对定时器生命周期的精确控制能力，是资源管理和节能的关键操作。

1） 基本使用

// 定义定时器
struct k_timer my_timer;

void main(void) {
    // 初始化定时器
    k_timer_init(&my_timer, timer_handler, stop_handler);
    
    // 启动定时器
    k_timer_start(&my_timer, K_MSEC(1000), K_MSEC(500));
    
    // ... 执行其他任务 ...
    
    // 停止定时器
    k_timer_stop(&my_timer);
}

2）  超时取消机制

struct k_timer timeout_timer;

void start_operation(void) {
    k_timer_start(&timeout_timer, K_SECONDS(5), K_NO_WAIT);
    // 开始操作...
}

void operation_completed(void) {
    // 操作完成，取消超时
    k_timer_stop(&timeout_timer);
}

void timeout_handler(struct k_timer *timer) {
    // 超时处理
    printk("Operation timed out!\n");
    cancel_operation();
}

 3） 节能管理

void enter_low_power_mode(void) {
    // 停止所有活动定时器
    k_timer_stop(&sensor_timer);
    k_timer_stop(&comms_timer);
    k_timer_stop(&ui_update_timer);
    
    // 进入低功耗模式
    k_sleep(K_FOREVER);
}

void wake_up(void) {
    // 唤醒后重新启动定时器
    k_timer_start(&sensor_timer, K_MSEC(100), K_MSEC(1000));
    // ...其他定时器
}

 4） 状态重置

void reset_system_state(void) {
    // 停止所有定时相关操作
    k_timer_stop(&measurement_timer);
    k_timer_stop(&transmission_timer);
    
    // 重置状态变量
    current_state = IDLE_STATE;
    
    // 可以重新配置并启动定时器
    k_timer_start(&measurement_timer, K_MSEC(500), K_MSEC(500));
}

5 与工作队列的对比

特性	k_timer	k_work_delayable
执行上下文	中断上下文（回调）	线程上下文
时间精度	高（硬件中断）	中等（依赖工作队列）
资源开销	较低	较高（需要线程栈）
阻塞操作	不允许（中断上下文）	允许
动态调整	需要重启定时器	可动态调整
最佳场景	时间敏感操作	需要线程上下文的任务