os_timer_slist.c

路径: kernel\source\os_timer_slist.c

功能: 单链表定时器实现。使用排序单链表管理定时器，每个定时器存储相对于前一个定时器的剩余 tick 数（round_ticks），tick 中断只需递减链表头节点的 round_ticks。支持硬定时器（在 tick ISR 中回调）和软定时器（在 timer 任务中回调）两种模式。

核心数据结构:

• os_timer_t 中的 active_node: 包含 flag（定时器状态标志位）、init_ticks（初始超时 tick）、round_ticks（当前剩余 tick）
• gs_tick_sched_timer_list: 硬定时器排序单链表（OS_HARD_SINGLE_LIST_TIMER）
• gs_task_sched_timer_list: 软定时器排序单链表（OS_SOFT_SINGLE_LIST_TIMER）
• gs_task_sched_timer_task: 软定时器处理任务

状态标志位:

标志	值	说明
OS_TIMER_FLAG_DEACTIVATED	0x00	定时器未激活
OS_TIMER_FLAG_ACTIVATED	0x02	定时器已激活
OS_TIMER_FLAG_TICK_SCHED	0x00	硬定时器（tick ISR 回调）
OS_TIMER_FLAG_TASK_SCHED	0x04	软定时器（timer 任务回调）
OS_TIMER_FLAG_INITED	0x08	已初始化
OS_TIMER_FLAG_DYNAMIC	0x10	动态分配
OS_TIMER_FLAG_DO_TIMEOUT	0x20	正在执行超时回调

关键 API:

函数	说明
os_timer_create	创建定时器（静态/动态）
os_timer_destroy	销毁定时器，释放动态内存
os_timer_start	先停再启：deactivate → activate
os_timer_stop	停止定时器：deactivate
os_timer_set_timeout_ticks	设置超时 tick 数
os_timer_get_remain_ticks	获取剩余 tick 数
os_timer_set_oneshot / os_timer_set_periodic	设置单次/周期模式
k_single_list_timer_module_init	模块初始化：创建软定时器任务
k_single_list_timer_tick_proc	硬定时器 tick 处理（在 ISR 中调用）
k_single_list_timer_need_handle	软定时器 tick 处理（在 tick 中调用）

关键设计点:

1. 排序单链表 O(1) tick 更新: 每个定时器存储的是与前一个定时器的差值，tick 中断只需递减头节点，无需遍历整个链表
2. 双模式支持: 硬定时器回调在 tick ISR 上下文执行（快但受限），软定时器回调在 timer 任务上下文执行（可阻塞）
3. 周期补偿: 支持 OS_TIMER_PERIODIC_COMPENSATE 补偿回调执行时间，保持周期精度
4. 低功耗支持: k_single_list_timer_get_next_remain_ticks() 返回最近超时 tick，用于低功耗休眠唤醒

Shell 命令: show_timer — 查看所有定时器信息，包括名称、间隔、剩余 tick、状态、类型

/**
 ***********************************************************************************************************************
 * Copyright (c) 2020, China Mobile Communications Group Co.,Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * @file        os_timer.c
 *
 * @brief       This file implements the timer functions.
 *
 * @revision
 * Date         Author          Notes
 * 2020-11-18   OneOS Team      First version.
 ***********************************************************************************************************************
 */

#include <oneos_config.h>
#include <os_errno.h>
#include <os_timer.h>
#include <os_task.h>
#include <os_assert.h>
#include <os_clock.h>
#include <string.h>
#include <os_spinlock.h>
#include <arch_misc.h>
#include "os_kernel_internal.h"

#ifdef OS_USING_SINGLE_LIST_TIMER

#if (!defined OS_HARD_SINGLE_LIST_TIMER) && (!defined OS_SOFT_SINGLE_LIST_TIMER)
#error "Please select timer of hard or soft"
#endif

#define OS_TIMER_FLAG_DEACTIVATED 0x0U
#define OS_TIMER_FLAG_ACTIVATED   0x2U

#define OS_TIMER_FLAG_TICK_SCHED 0x00
#define OS_TIMER_FLAG_TASK_SCHED                                                                                       \
    0x04

#define OS_TIMER_FLAG_NOT_INITED 0x0U
#define OS_TIMER_FLAG_INITED     0x8U

#define OS_TIMER_FLAG_STATIC  0x0U
#define OS_TIMER_FLAG_DYNAMIC 0x10U

#define OS_TIMER_FLAG_DO_TIMEOUT 0x20U

#define TIMER_TAG "TIMER"

#define OS_TIMER_IS_TASK_SCHED(timer)                                                                                  \
    ((OS_TIMER_FLAG_TASK_SCHED == (timer->active_node.flag & OS_TIMER_FLAG_TASK_SCHED)) ? 1 : 0)

#ifdef OS_HARD_SINGLE_LIST_TIMER
static os_timer_t    *gs_tick_sched_timer_head;
static os_list_node_t gs_tick_sched_timer_list = OS_LIST_INIT(gs_tick_sched_timer_list);
#endif

#ifdef OS_SOFT_SINGLE_LIST_TIMER
#define OS_TIMER_TASK_PRIO 0

#if OS_TIMER_PERIODIC_COMPENSATE
#define OS_TIMER_TICK_DIFF(a, b) (a >= b) ? (a - b) : (OS_UINT32_MAX - b + a + 1)
#endif

OS_ALIGN(OS_ALIGN_SIZE)
static uint8_t        gs_sched_timer_task_stack[OS_TIMER_TASK_STACK_SIZE];
static os_task_t      gs_task_sched_timer_task;
static os_timer_t    *gs_task_sched_timer_head;
static os_bool_t      gs_task_sched_timer_need_sched;
static os_list_node_t gs_task_sched_timer_list = OS_LIST_INIT(gs_task_sched_timer_list);
#endif

static inline os_list_node_t *k_single_list_get_timer_head_list(os_timer_t *timer)
{
    os_list_node_t *timer_head_list;

    timer_head_list = OS_NULL;
    if (OS_TIMER_IS_TASK_SCHED(timer))
    {
#ifdef OS_SOFT_SINGLE_LIST_TIMER
        timer_head_list = &gs_task_sched_timer_list;
#endif
    }
    else
    {
#ifdef OS_HARD_SINGLE_LIST_TIMER
        timer_head_list = &gs_tick_sched_timer_list;
#endif
    }

    if (OS_NULL == timer_head_list)
    {
        OS_ASSERT_EX(0, "timer execption: %p", timer);
    }

    return timer_head_list;
}

/* 将定时器按 round_ticks 排序插入单链表 */
static void k_single_list_timer_insert_sort_list(os_timer_t *timer)
{
    os_list_node_t *timer_head_list;
    os_timer_t     *iter;

    timer_head_list = k_single_list_get_timer_head_list(timer);
    os_list_for_each_entry(iter, timer_head_list, os_timer_t, list)
    {
        if (timer->round_ticks >= iter->round_ticks)
        {
            timer->round_ticks -= iter->round_ticks;
        }
        else
        {
            iter->round_ticks -= timer->round_ticks;
            break;
        }
    }

    os_list_add_tail(&iter->list, &timer->list);

    if (OS_TIMER_IS_TASK_SCHED(timer))
    {
#ifdef OS_SOFT_SINGLE_LIST_TIMER
        gs_task_sched_timer_head = os_list_first_entry_or_null(timer_head_list, os_timer_t, list);
#endif
    }
    else
    {
#ifdef OS_HARD_SINGLE_LIST_TIMER
        gs_tick_sched_timer_head = os_list_first_entry_or_null(timer_head_list, os_timer_t, list);
#endif
    }

    return;
}

/* 从排序单链表中删除定时器，补偿后继定时器的 round_ticks */
static void k_single_list_timer_del_sort_list(os_timer_t *timer)
{
    os_list_node_t *timer_head_list;
    os_timer_t     *next_timer;

    timer_head_list = k_single_list_get_timer_head_list(timer);

    if (timer_head_list == timer->list.next)
    {
        os_list_del(&timer->list);
    }
    else
    {
        next_timer = os_list_entry(timer->list.next, os_timer_t, list);
        next_timer->round_ticks += timer->round_ticks;
        os_list_del(&timer->list);
    }

    if (OS_TIMER_IS_TASK_SCHED(timer))
    {
#ifdef OS_SOFT_SINGLE_LIST_TIMER
        gs_task_sched_timer_head = os_list_first_entry_or_null(timer_head_list, os_timer_t, list);
#endif
    }
    else
    {
#ifdef OS_HARD_SINGLE_LIST_TIMER
        gs_tick_sched_timer_head = os_list_first_entry_or_null(timer_head_list, os_timer_t, list);
#endif
    }

    return;
}

/* 激活定时器：设置标志位，插入排序链表 */
static void k_single_list_timer_activate(os_timer_t *timer)
{
    uint8_t test_flag;

    if (OS_TIMER_FLAG_ACTIVATED != (timer->active_node.flag & OS_TIMER_FLAG_ACTIVATED))
    {
        timer->active_node.flag |= OS_TIMER_FLAG_ACTIVATED;

        test_flag = OS_TIMER_FLAG_DO_TIMEOUT;
        if (test_flag != (timer->active_node.flag & test_flag))
        {
            timer->round_ticks = timer->init_ticks;
            k_single_list_timer_insert_sort_list(timer);
        }
    }

    return;
}

/* 停用定时器：清除标志位，从排序链表删除 */
static void k_single_list_timer_deactivate(os_timer_t *timer)
{
    uint8_t test_flag;

    if (timer->active_node.flag & OS_TIMER_FLAG_ACTIVATED)
    {
        timer->active_node.flag &= ~OS_TIMER_FLAG_ACTIVATED;
        test_flag = OS_TIMER_FLAG_DO_TIMEOUT;
        if (test_flag != (timer->active_node.flag & test_flag))
        {
            k_single_list_timer_del_sort_list(timer);
        }
    }

    return;
}

/* 计算定时器剩余 tick 数 */
static os_tick_t k_single_list_timer_calc_remain_ticks(os_timer_t *timer)
{
    os_list_node_t *timer_head_list;
    os_tick_t       remain_tick;
    os_timer_t     *iter;

    remain_tick     = 0;
    timer_head_list = k_single_list_get_timer_head_list(timer);

    if (timer->active_node.flag & OS_TIMER_FLAG_ACTIVATED)
    {
        os_list_for_each_entry(iter, timer_head_list, os_timer_t, list)
        {
            remain_tick += iter->round_ticks;
            if (iter == timer)
            {
                break;
            }
        }
    }

    return remain_tick;
}

static void k_single_list_timer_do_init(os_timer_t *timer,
                                        const char *name,
                                        void (*function)(void *parameter),
                                        void    *parameter,
                                        uint32_t timeout,
                                        uint8_t  flag)
{
    timer->active_node.flag = (flag & (~OS_TIMER_FLAG_ACTIVATED)) | OS_TIMER_FLAG_INITED;
    timer->timeout_func     = function;
    timer->parameter        = parameter;
    timer->init_ticks       = ((0 == timeout) ? 1 : timeout);
    timer->round_ticks      = timer->init_ticks;

    if (OS_NULL != name)
    {
        strncpy(&timer->name[0], name, OS_NAME_MAX);
        timer->name[OS_NAME_MAX] = '\0';
    }
    else
    {
        timer->name[0] = '\0';
    }

    os_list_init(&timer->list);
}

/* 获取最近超时的 tick 数，用于低功耗唤醒 */
os_tick_t k_single_list_timer_get_next_remain_ticks(void)
{
    os_tick_t min_timeout_tick;

    min_timeout_tick = OS_UINT32_MAX;
#ifdef OS_SOFT_SINGLE_LIST_TIMER
    if (OS_NULL != gs_task_sched_timer_head)
    {
        min_timeout_tick = gs_task_sched_timer_head->round_ticks;
    }
#endif

#ifdef OS_HARD_SINGLE_LIST_TIMER
    if (OS_NULL != gs_tick_sched_timer_head)
    {
        if (gs_tick_sched_timer_head->round_ticks < min_timeout_tick)
        {
            min_timeout_tick = gs_tick_sched_timer_head->round_ticks;
            if (min_timeout_tick >= 1)
            {
                min_timeout_tick--;
            }
        }
    }
#endif

    return min_timeout_tick;
}

/* 批量更新定时器链表：递减 ticks 个 tick */
os_bool_t k_single_list_timer_update_active_list(os_tick_t ticks)
{
    os_bool_t   need_sched;
    os_timer_t *iter;
    os_tick_t   temp;

    need_sched = OS_FALSE;

#ifdef OS_SOFT_SINGLE_LIST_TIMER
    if (OS_NULL != gs_task_sched_timer_head)
    {
        temp = ticks;
        os_list_for_each_entry(iter, &gs_task_sched_timer_list, os_timer_t, list)
        {
            if (iter->round_ticks > temp)
            {
                iter->round_ticks -= temp;
                break;
            }
            else
            {
                iter->round_ticks              = 0;
                gs_task_sched_timer_need_sched = OS_TRUE;

                if (iter->round_ticks < temp)
                {
                    temp -= iter->round_ticks;
                }
                else
                {
                    break;
                }
            }
        }
    }
#endif

#ifdef OS_HARD_SINGLE_LIST_TIMER
    if (OS_NULL != gs_tick_sched_timer_head)
    {
        temp = ticks;
        os_list_for_each_entry(iter, &gs_tick_sched_timer_list, os_timer_t, list)
        {
            if (iter->round_ticks > temp)
            {
                iter->round_ticks -= temp;
                break;
            }
            else
            {
                iter->round_ticks = 0;
                if (iter->round_ticks < temp)
                {
                    temp -= iter->round_ticks;
                }
            }
        }
    }
#endif

#ifdef OS_SOFT_SINGLE_LIST_TIMER
    if (gs_task_sched_timer_need_sched && (OS_TASK_STATE_SUSPEND == gs_task_sched_timer_task.state))
    {
        gs_task_sched_timer_task.state &= ~OS_TASK_STATE_SUSPEND;
        gs_task_sched_timer_task.state |= OS_TASK_STATE_READY;
        k_readyq_put(&gs_task_sched_timer_task);
        need_sched = OS_TRUE;
    }
#endif

    return need_sched;
}

os_timer_id os_timer_create(os_timer_dummy_t *timer_cb,
                            const char       *name,
                            void (*function)(void *parameter),
                            void     *parameter,
                            os_tick_t timeout,
                            uint8_t   flag)
{
    os_timer_t *timer;

    OS_KERNEL_INIT();

#ifndef OS_USING_HEAP
    OS_ASSERT(OS_NULL != timer_cb);
#endif

    OS_ASSERT(OS_FALSE == os_is_irq_active());

    if (timer_cb != OS_NULL)
    {
        timer = (os_timer_t *)timer_cb;

        flag = k_single_list_timer_check_flag(flag);

        OS_KERNEL_ENTER();
        k_single_list_timer_do_init(timer, name, function, parameter, timeout, flag & (~OS_TIMER_FLAG_DYNAMIC));
        OS_KERNEL_EXIT();
    }
#ifdef OS_USING_HEAP
    else
    {
        OS_ASSERT(OS_FALSE == os_is_irq_active());

        timer = (os_timer_t *)OS_KERNEL_MALLOC(sizeof(os_timer_t));
        if (OS_NULL == timer)
        {
            OS_KERN_LOG(KERN_ERROR, TIMER_TAG, "Malloc timer memory failed");
        }
        else
        {
            flag = k_single_list_timer_check_flag(flag);

            OS_KERNEL_ENTER();
            k_single_list_timer_do_init(timer, name, function, parameter, timeout, flag | OS_TIMER_FLAG_DYNAMIC);
            OS_KERNEL_EXIT();
        }
    }
#endif

    return OS_TYPE_CONVERT(os_timer_id, timer);
}

os_err_t os_timer_destroy(os_timer_id timer_id)
{
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));
    OS_ASSERT(OS_FALSE == os_is_irq_active());
#ifndef OS_USING_HEAP
    OS_ASSERT(OS_TIMER_FLAG_STATIC == (timer->active_node.flag & OS_TIMER_FLAG_DYNAMIC));
#endif

    OS_KERNEL_ENTER();

    if (OS_TIMER_FLAG_DO_TIMEOUT == (timer->active_node.flag & OS_TIMER_FLAG_DO_TIMEOUT))
    {
        timer->active_node.flag &= ~OS_TIMER_FLAG_DO_TIMEOUT;
        timer->active_node.flag &= ~OS_TIMER_FLAG_ACTIVATED;
        os_list_del(&timer->list);
    }
    else
    {
        k_single_list_timer_deactivate(timer);
    }

    timer->active_node.flag &= ~OS_TIMER_FLAG_INITED;

    OS_KERNEL_EXIT();

#ifdef OS_USING_HEAP
    if (OS_TIMER_FLAG_DYNAMIC == (timer->active_node.flag & OS_TIMER_FLAG_DYNAMIC))
    {
        OS_KERNEL_FREE(timer);
    }
#endif

    return OS_SUCCESS;
}

#ifdef OS_SOFT_SINGLE_LIST_TIMER
/* 软定时器任务入口：循环处理超时定时器 */
static void k_single_list_timer_task_entry(void *parameter)
{
    /* 核心逻辑：
     * 1. 检查 gs_task_sched_timer_need_sched 和头节点
     * 2. 无定时器需处理时将自身挂起
     * 3. 取出超时定时器，执行回调
     * 4. 周期定时器重新插入链表
     */
    /* ... 省略详细实现，完整源码见源文件 ... */
}

os_bool_t k_single_list_timer_need_handle(void)
{
    /* 软定时器 tick 处理：递减头节点 round_ticks，唤醒 timer 任务 */
    /* ... 省略详细实现，完整源码见源文件 ... */
}
#endif

#ifdef OS_HARD_SINGLE_LIST_TIMER
/* 硬定时器 tick 处理：在 ISR 中直接执行超时回调 */
void k_single_list_timer_tick_proc(void)
{
    /* 核心逻辑：
     * 1. 递减头节点 round_ticks
     * 2. 遍历所有 round_ticks == 0 的定时器
     * 3. 在 ISR 上下文中执行回调
     * 4. 周期定时器重新插入链表
     */
    /* ... 省略详细实现，完整源码见源文件 ... */
}
#endif

/* 模块初始化：创建软定时器任务 */
void k_single_list_timer_module_init(void)
{
#ifdef OS_HARD_SINGLE_LIST_TIMER
    gs_tick_sched_timer_head = OS_NULL;
#endif

#ifdef OS_SOFT_SINGLE_LIST_TIMER
    os_task_id tid;

    gs_task_sched_timer_need_sched = OS_FALSE;
    gs_task_sched_timer_head       = OS_NULL;

    tid = os_task_create((os_task_dummy_t *)&gs_task_sched_timer_task,
                         gs_sched_timer_task_stack,
                         sizeof(gs_sched_timer_task_stack),
                         "timer",
                         k_single_list_timer_task_entry,
                         OS_NULL,
                         OS_TIMER_TASK_PRIO);
    if (!tid)
    {
        OS_ASSERT_EX(0, "Why initialize timer task failed?");
    }
    else
    {
        if (OS_SUCCESS != os_task_startup(tid))
        {
            OS_ASSERT_EX(0, "Why startup timer task failed?");
        }
    }
#endif

    return;
}

os_err_t os_timer_start(os_timer_id timer_id)
{
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();

    k_single_list_timer_deactivate(timer);
    k_single_list_timer_activate(timer);

    OS_KERNEL_EXIT();

    return OS_SUCCESS;
}

os_err_t os_timer_stop(os_timer_id timer_id)
{
    os_err_t    ret;
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();
    ret = OS_SUCCESS;
    if (!(timer->active_node.flag & OS_TIMER_FLAG_ACTIVATED))
    {
        ret = OS_FAILURE;
    }
    else
    {
        k_single_list_timer_deactivate(timer);
    }
    OS_KERNEL_EXIT();

    return ret;
}

os_err_t os_timer_set_timeout_ticks(os_timer_id timer_id, os_tick_t timeout)
{
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();
    timer->init_ticks = timeout;
    OS_KERNEL_EXIT();

    return OS_SUCCESS;
}

os_tick_t os_timer_get_timeout_ticks(os_timer_id timer_id)
{
    os_tick_t   init_ticks;
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();
    init_ticks = timer->init_ticks;
    OS_KERNEL_EXIT();

    return init_ticks;
}

os_tick_t os_timer_get_remain_ticks(os_timer_id timer_id)
{
    os_tick_t   remain_ticks;
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();
    remain_ticks = k_single_list_timer_calc_remain_ticks(timer);
    OS_KERNEL_EXIT();

    return remain_ticks;
}

const char *os_timer_get_name(os_timer_id timer_id)
{
    os_timer_t *timer;

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    return timer->name;
}

os_err_t os_timer_set_oneshot(os_timer_id timer_id)
{
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();
    timer->active_node.flag &= ~OS_TIMER_FLAG_PERIODIC;
    OS_KERNEL_EXIT();

    return OS_SUCCESS;
}

os_err_t os_timer_set_periodic(os_timer_id timer_id)
{
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();
    timer->active_node.flag |= OS_TIMER_FLAG_PERIODIC;
    OS_KERNEL_EXIT();

    return OS_SUCCESS;
}

os_bool_t os_timer_is_soft(os_timer_id timer_id)
{
    os_bool_t   is_soft;
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();
    is_soft = (timer->active_node.flag & OS_TIMER_FLAG_TASK_SCHED) ? OS_TRUE : OS_FALSE;
    OS_KERNEL_EXIT();

    return is_soft;
}

os_bool_t os_timer_is_periodic(os_timer_id timer_id)
{
    os_bool_t   is_periodic;
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();
    is_periodic = (timer->active_node.flag & OS_TIMER_FLAG_PERIODIC) ? OS_TRUE : OS_FALSE;
    OS_KERNEL_EXIT();

    return is_periodic;
}

os_bool_t os_timer_is_active(os_timer_id timer_id)
{
    os_bool_t   is_active;
    os_timer_t *timer;

    OS_KERNEL_INIT();

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);
    OS_ASSERT(0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED));

    OS_KERNEL_ENTER();
    is_active = (timer->active_node.flag & OS_TIMER_FLAG_ACTIVATED) ? OS_TRUE : OS_FALSE;
    OS_KERNEL_EXIT();

    return is_active;
}

os_bool_t os_timer_check_exist(os_timer_id timer_id)
{
    os_timer_t *timer;

    timer = OS_TYPE_CONVERT(os_timer_t *, timer_id);

    OS_ASSERT(OS_NULL != timer);

    if (0 != (timer->active_node.flag & OS_TIMER_FLAG_INITED))
    {
        return OS_TRUE;
    }
    else
    {
        return OS_FALSE;
    }
}

#if defined(OS_USING_SHELL)
#include <shell.h>

/* Shell 命令 show_timer: 显示所有定时器信息 */
/* ... 省略详细实现，完整源码见源文件 ... */
SH_CMD_EXPORT(show_timer, sh_show_timer_info, "Show timer information");

#endif

#endif