軟體定時器的基本概念

TencentOS tiny 的軟體定時器是由作業系統提供的一類系統介面，它構建在硬體定時器基礎之上，使系統能夠提供不受硬體定時器資源限制的定時器服務，本質上軟體定時器的使用相當于擴展了定時器的數量，允許創建更多的定時業務，它實作的功能與硬體定時器也是類似的，

硬體定時器是芯片本身提供的定時功能，一般是由外部晶振提供給芯片輸入時鐘，芯片向軟體模塊提供一組配置暫存器，接受控制輸入，到達設定時間值后芯片中斷控制器產生時鐘中斷，硬體定時器的精度一般很高，可以達到納秒級別，并且是中斷觸發方式，

軟體定時器的超時處理是指：在定時時間到達之后就會自動觸發一個超時，然后系統跳轉到對應的函式去處理這個超時，此時，呼叫的函式也被稱回呼函式，

回呼函式的執行環境可以是中斷，也可以是任務，這就需要你自己在tos_config.h通過TOS_CFG_TIMER_AS_PROC宏定義選擇回呼函式的執行環境了，

TOS_CFG_TIMER_AS_PROC 為 1 ：回呼函式的執行環境是中斷
TOS_CFG_TIMER_AS_PROC 為 0 ：回呼函式的執行環境是任務

這與硬體定時器的中斷服務函式很類似，無論是在中斷中還是在任務中，回呼函式的處理盡可能簡短，快進快出，

軟體定時器在被創建之后，當經過設定的超時時間后會觸發回呼函式，定時精度與系統時鐘的周期有關，一般可以采用SysTick作為軟體定時器的時基（在m核單片機中幾乎都是采用SysTick作為系統時基，而軟體定時器又是基于系統時基之上），

TencentOS tiny提供的軟體定時器支持單次模式和周期模式，單次模式和周期模式的定時時間到之后都會呼叫軟體定時器的回呼函式，

單次模式：當用戶創建了定時器并啟動了定時器后，指定超時時間到達，只執行一次回呼函式之后就將該定時器停止，不再重新執行，
周期模式：這個定時器會按照指定的定時時間回圈執行回呼函式，直到將定時器洗掉，

在很多應用中，可能需要一些定時器任務，硬體定時器受硬體的限制，數量上不足以滿足用戶的實際需求，無法提供更多的定時器，可以采用軟體定時器，由軟體定時器代替硬體定時器任務，但需要注意的是軟體定時器的精度是無法和硬體定時器相比的，因為在軟體定時器的定時程序中是極有可能被其他中斷打斷，因此軟體定時器更適用于對時間精度要求不高的任務，

軟體定時器以tick為基本計時單位，當用戶創建并啟動一個軟體定時器時， TencentOS tiny會根據當前系統tick與用戶指定的超時時間計算出該定時器超時的時間expires，并將該定時器插入軟體定時器串列，

軟體定時器的資料結構

以下軟體定時器的相關資料結構都在tos_global.c中定義

軟體定時器串列

軟體定時器串列用于記錄系統中所有的軟體定時器，這些軟體定時器將按斬訓醒時間升序插入軟體定時器串列k_timer_ctl.list 中，它的資料型別是timer_ctl_t，

timer_ctl_t         k_timer_ctl = { TOS_TIME_FOREVER, TOS_LIST_NODE(k_timer_ctl.list) };

typedef struct timer_control_st {
    k_tick_t    next_expires;
    k_list_t    list;
} timer_ctl_t;

next_expires：記錄下一個到期的軟體定時器時間，
list：軟體定時器串列，所有的軟體定時器都會被掛載到這個串列中，

軟體定時器任務相關的資料結構

如果 TOS_CFG_TIMER_AS_PROC 宏定義為0，則表示使用軟體定時器任務處理軟體定時器的回呼函式，那么此時軟體定時器的回呼函式執行環境為任務；反之軟體定時器回呼函式的處理將在中斷背景關系環境中，

k_task_t            k_timer_task;
k_stack_t           k_timer_task_stk[TOS_CFG_TIMER_TASK_STK_SIZE];
k_prio_t            const k_timer_task_prio         = TOS_CFG_TIMER_TASK_PRIO;
k_stack_t          *const k_timer_task_stk_addr     = &k_timer_task_stk[0];
size_t              const k_timer_task_stk_size     = TOS_CFG_TIMER_TASK_STK_SIZE;

k_timer_task：軟體定時器任務控制塊
k_timer_task_stk：軟體定時器任務堆疊，其大小為TOS_CFG_TIMER_TASK_STK_SIZE
k_timer_task_prio：軟體定時器任務優先級，值為TOS_CFG_TIMER_TASK_PRIO，默認值是 (k_prio_t)(K_TASK_PRIO_IDLE - (k_prio_t)1u)，比空閑任務高1個數值優先級，杰杰認為這也是很低的優先級了，這樣一來軟體定時器的精度將更低，不過好在這個值是可以被用戶自定義的，想讓精度高一點就將這個軟體定時器任務優先級設定得高一點就好，
k_timer_task_stk_addr：軟體定時器任務堆疊起始地址，
k_timer_task_stk_size：軟體定時器任務堆疊大小，

以下軟體定時器的相關資料結構都在tos_timer.h中定義

軟體定時器的回呼函式

// 軟體定時器的回呼函式型別
typedef void (*k_timer_callback_t)(void *arg);

軟體定時器的回呼函式是一個函式指標的形式，它支持傳入一個void指標型別的資料，

軟體定時器控制塊

每個軟體定時器都有對應的軟體定時器控制塊，每個軟體定時器控制塊都包含了軟體定時器的基本資訊，如軟體定時器的狀態、軟體定時器作業模式、軟體定時器的周期，剩余時間，以及軟體定時器回呼函式等資訊，

typedef struct k_timer_st {
#if TOS_CFG_OBJECT_VERIFY_EN > 0u
    knl_obj_t               knl_obj;    /**< 僅為了驗證,測驗當前內核物件是否真的是一個軟體定時器 */
#endif

    k_timer_callback_t      cb;         /**< 時間到時回呼函式 */
    void                   *cb_arg;     /**< 回呼函式中傳入的引數 */
    k_list_t                list;       /**< 掛載到軟體定時器串列的節點 */
    k_tick_t                expires;    /**< 距離軟體定時器的到期時間到期還剩多少時間（單位為tick） */
    k_tick_t                delay;      /**< 還剩多少時間運行第一個到期的軟體定時器（的回呼函式） */
    k_tick_t                period;     /**< 軟體定時器的周期 */
    k_opt_t                 opt;        /**< 軟體定時器的作業模式選項，可以是單次模式TOS_OPT_TIMER_ONESHOT，也可以是周期模式TOS_OPT_TIMER_PERIODIC */
    timer_state_t           state;      /**< 軟體定時器的狀態 */
} k_timer_t;

軟體定時器的作業模式

// if we just want the timer to run only once, this option should be passed to tos_timer_create.
#define TOS_OPT_TIMER_ONESHOT                   (k_opt_t)(0x0001u)

// if we want the timer run periodically, this option should be passed to tos_timer_create.
#define TOS_OPT_TIMER_PERIODIC                  (k_opt_t)(0x0002u)

TOS_OPT_TIMER_ONESHOT：單次模式，軟體定時器在超時后，只會執行一次回呼函式，它的狀態將被設定為TIMER_STATE_COMPLETED，不再重新執行它的回呼函式，當然，用戶還是可以重新啟動這個單次模式的軟體定時器，它并未被洗掉，

如果只希望計時器運行一次，則應將此選項傳遞給tos_timer_create()，

TOS_OPT_TIMER_PERIODIC ：周期模式，軟體定時器在超時后，會執行對應的回呼函式，同時根據軟體定時器控制塊中的period成員變數的值再重新插入軟體定時器串列中，這個定時器會按照指定的定時時間回圈執行（周期性執行）回呼函式，直到用戶將定時器洗掉，

如果我們希望計時器周期運行，則應將此選項傳遞給tos_timer_create()，

軟體定時器的狀態

定時器狀態有以下幾種：

typedef enum timer_state_en {
    TIMER_STATE_UNUSED,     /**< the timer has been destroyed */
    TIMER_STATE_STOPPED,    /**< the timer has been created but not been started, or just be stopped(tos_timer_stop) */
    TIMER_STATE_RUNNING,    /**< the timer has been created and been started */
    TIMER_STATE_COMPLETED   /**< the timer has finished its expires, it can only happen when the timer's opt is TOS_OPT_TIMER_ONESHOT */
} timer_state_t;

TIMER_STATE_UNUSED：未使用狀態，
TIMER_STATE_STOPPED：創建了軟體定時器，但此時軟體定時器未啟動或者處于停止狀態，呼叫tos_timer_create()函式介面或者在軟體定時器啟動后呼叫tos_timer_stop()函式介面后，定時器將變成該狀態，
TIMER_STATE_RUNNING：軟體定時器處于運行狀態，在定時器被創建后呼叫tos_timer_start()函式介面，定時器將變成該狀態，表示定時器運行時的狀態，
TIMER_STATE_COMPLETED：軟體定時器已到期，只有在軟體定時器的模式選擇為TOS_OPT_TIMER_ONESHOT時才可能發生，表示軟體定時器已經完成了，

創建軟體定時器

函式

__API__ k_err_t tos_timer_create(k_timer_t *tmr,
                                 k_tick_t delay,
                                 k_tick_t period,
                                 k_timer_callback_t callback,
                                 void *cb_arg,
                                 k_opt_t opt);

引數

引數	說明（杰杰）
tmr	軟體定時器控制塊指標
delay	軟體定時器第一次運行的延遲時間間隔
period	軟體定時器的周期
callback	軟體定時器的回呼函式，在超時時呼叫（由用戶自己定義）
cb_arg	用于回呼函式傳入的形參（void指標型別）
opt	軟體定時器的作業模式（單次 / 周期）

杰杰覺得 delay與 period 比較有意思，就簡單提一下 delay 引數與 period 引數的意義與區別：

delay引數其實是第一次運行的延遲時間間隔（即第一次呼叫回呼函式的時間），如果軟體定時器是單次模式，那么只用 delay 引數作為軟體定時器的回呼時間，因為軟體定時器是單次作業模式的話，只會運行一次回呼函式，那么就沒有周期一說（period 引數將不起作用），只能是以第一次運行的延遲時間間隔作為它的回呼時間，

period 引數則是作為軟體定時器的周期性回呼的時間間隔，就好比你的鬧鐘，每天 7 點叫你起床，但是delay引數在周期作業模式下的軟體定時器也是有作用的，它是對第一次回呼函式的延遲時間，舉個例子：今天晚上9點的時候，你設定了一個鬧鐘，鬧鐘時間是每天早上7點的，那么在10個小時后，鬧鐘將叫你起床，那么這10個小時就相當于delay引數的值，因為鬧鐘第一次叫你起床并不是在24小時后，而在明天7點后，鬧鐘響了，此時鬧鐘將在一天后才會再響，這24小時則相當于 period 引數的值，

系統中每個軟體定時器都有對應的軟體定時器控制塊，軟體定時器控制塊中包含了軟體定時器的所有資訊，那么可以想象一下，創建軟體定時器的本質是不是就是對軟體定時器控制塊進行初始化呢？很顯然就是這樣子的，因為在后續對軟體定時器的操作都是通過軟體定時器控制塊來操作的，如果控制塊沒有資訊，那怎么能操作嘛~

步驟如下：

判斷傳入的引數是否正確：軟體定時器控制塊不為null，回呼函式不為null，如果是創建周期模式的軟體定時器，那么 period 引數則不可以為0，而如果是單次模式的軟體定時器，引數delay則不可以為0，無論是何種模式的軟體定時器，delay 引數與 period 引數都不可以為K_ERR_TIMER_PERIOD_FOREVER，因為這代表著軟體定時器不需要運行，那還創建個錘子啊，
根據傳入的引數將軟體定時器控制塊的成員變數賦初值，軟體定時器狀態state被設定為TIMER_STATE_STOPPED，expires 則被設定為0，因為還尚未啟動軟體定時器，
呼叫tos_list_init()函式將軟體定時器控制塊中可掛載到k_tick_list串列的節點初始化，

__API__ k_err_t tos_timer_create(k_timer_t *tmr,
                                 k_tick_t delay,
                                 k_tick_t period,
                                 k_timer_callback_t callback,
                                 void *cb_arg,
                                 k_opt_t opt)
{
    TOS_PTR_SANITY_CHECK(tmr);
    TOS_PTR_SANITY_CHECK(callback);

    if (opt == TOS_OPT_TIMER_PERIODIC && period == (k_tick_t)0u) {
        return K_ERR_TIMER_INVALID_PERIOD;
    }

    if (opt == TOS_OPT_TIMER_ONESHOT && delay == (k_tick_t)0u) {
        return K_ERR_TIMER_INVALID_DELAY;
    }

    if (opt != TOS_OPT_TIMER_ONESHOT && opt != TOS_OPT_TIMER_PERIODIC) {
        return K_ERR_TIMER_INVALID_OPT;
    }

    if (delay == TOS_TIME_FOREVER) {
        return K_ERR_TIMER_DELAY_FOREVER;
    }

    if (period == TOS_TIME_FOREVER) {
        return K_ERR_TIMER_PERIOD_FOREVER;
    }

#if TOS_CFG_OBJECT_VERIFY_EN > 0u
    knl_object_init(&tmr->knl_obj, KNL_OBJ_TYPE_TIMER);
#endif

    tmr->state          = TIMER_STATE_STOPPED;
    tmr->delay          = delay;
    tmr->expires        = (k_tick_t)0u;
    tmr->period         = period;
    tmr->opt            = opt;
    tmr->cb             = callback;
    tmr->cb_arg         = cb_arg;
    tos_list_init(&tmr->list);
    return K_ERR_NONE;
}

銷毀軟體定時器

軟體定時器銷毀函式是根據軟體定時器控制塊直接銷毀的，銷毀之后軟體定時器的所有資訊都會被清除，而且不能再次使用這個軟體定時器，如果軟體定時器處于運行狀態，那么就需要將被銷毀的軟體定時器停止，然后再進行銷毀操作，
其程序如下：

判斷軟體定時器是否有效，然后根據軟體定時器狀態判斷軟體定時器是否創建，如果是未使用狀態TIMER_STATE_UNUSED，則直接回傳錯誤代碼K_ERR_TIMER_INACTIVE，
如果軟體定時器狀態是 運行狀態 TIMER_STATE_RUNNING，那么呼叫timer_takeoff()函式將軟體定時器停止，
最后呼叫timer_reset()函式將軟體定時器控制塊的內容重置，主要是將軟體定時器的狀態設定為未使用狀態TIMER_STATE_UNUSED，將對應的回呼函式設定為null，

__API__ k_err_t tos_timer_destroy(k_timer_t *tmr)
{
    TOS_PTR_SANITY_CHECK(tmr);

#if TOS_CFG_OBJECT_VERIFY_EN > 0u
    if (!knl_object_verify(&tmr->knl_obj, KNL_OBJ_TYPE_TIMER)) {
        return K_ERR_OBJ_INVALID;
    }
#endif

    if (tmr->state == TIMER_STATE_UNUSED) {
        return K_ERR_TIMER_INACTIVE;
    }

    if (tmr->state == TIMER_STATE_RUNNING) {
        timer_takeoff(tmr);
    }

    timer_reset(tmr);
    return K_ERR_NONE;
}

停止軟體定時器（內部函式）

在銷毀軟體定時器的時候提到了timer_takeoff()函式，那么就來看看這個函式具體是怎么樣停止軟體定時器的，其實本質上就是將軟體定時器從軟體定時器串列中移除，

注意，這個函式是內部靜態函式，不是給用戶使用的，它與tos_timer_stop()不同，

首先通過TOS_LIST_FIRST_ENTRY宏定義將軟體定時器串列k_timer_ctl.list中的第一個軟體定時器取出，因為防止軟體定時器串列中的第一個軟體定時器被移除了，而沒有重置軟體定時器串列中的相關的資訊，因此此時要記錄一下第一個軟體定時器，
呼叫tos_list_del()將軟體定時器從軟體定時器串列中移除，表示中國軟體定時器就被停止了，因為不知軟體定時器串列中，中國軟體定時器也就不會被處理，
判斷一下移除的軟體定時器是不是第一個軟體定時器，如果是，則重置相關資訊，如果軟體定時器串列中不存在其他軟體定時器，則將軟體定時器串列的下一個到期時間設定為TOS_TIME_FOREVER，反正則讓軟體定時器串列的下一個到期時間為第二個軟體定時器，

__STATIC__ void timer_takeoff(k_timer_t *tmr)
{
    TOS_CPU_CPSR_ALLOC();
    k_timer_t *first, *next;

    TOS_CPU_INT_DISABLE();

    first = TOS_LIST_FIRST_ENTRY(&k_timer_ctl.list, k_timer_t, list);

    tos_list_del(&tmr->list);

    if (first == tmr) {
        // if the first guy removed, we need to refresh k_timer_ctl.next_expires
        next = TOS_LIST_FIRST_ENTRY_OR_NULL(&tmr->list, k_timer_t, list);
        if (!next) {
            // the only guy removed
            k_timer_ctl.next_expires = TOS_TIME_FOREVER;
        } else {
            k_timer_ctl.next_expires = next->expires;
        }
    }

    TOS_CPU_INT_ENABLE();
}

啟動軟體定時器

在創建成功軟體定時器的時候，軟體定時器的狀態從TIMER_STATE_UNUSED（未使用狀態）變成TIMER_STATE_STOPPED（創建但未啟動 / 停止狀態），創建完成的軟體定時器是未運行的，用戶在需要的時候可以啟動它，TencentOS tiny提供了軟體定時器啟動函式tos_timer_start()，啟動軟體定時器的本質就是將軟體定時器插入軟體定時器串列k_timer_ctl.list 中，既然是這樣子，那么很顯然需要根據軟體定時器的不同狀態進行不同的處理，

其實作程序如下：判斷軟體定時器控制塊是否為null，然后判斷軟體定時器狀態，如果為未使用狀態TIMER_STATE_UNUSED則直接回傳錯誤代碼K_ERR_TIMER_INACTIVE；如果為已經運行狀態TIMER_STATE_RUNNING，那么將軟體定時器停止，然重新插入軟體定時器串列k_timer_ctl.list中；如果是TIMER_STATE_STOPPED 或者TIMER_STATE_COMPLETED狀態，則將軟體定時器的狀態重新設定為運行狀態TIMER_STATE_RUNNING，并且插入軟體定時器串列k_timer_ctl.list中，

注意：插入軟體定時器串列的函式是timer_place()，

tos_timer_start()函式將軟體定時器控制塊的period或者delay成員變數的值賦值給expires，但這個值是相對的到期時間，而不是絕對值，因此在timer_place()函式中將重新計算得出絕對的到期時間，

__API__ k_err_t tos_timer_start(k_timer_t *tmr)
{
    TOS_PTR_SANITY_CHECK(tmr);

#if TOS_CFG_OBJECT_VERIFY_EN > 0u
    if (!knl_object_verify(&tmr->knl_obj, KNL_OBJ_TYPE_TIMER)) {
        return K_ERR_OBJ_INVALID;
    }
#endif

    if (tmr->state == TIMER_STATE_UNUSED) {
        return K_ERR_TIMER_INACTIVE;
    }

    if (tmr->state == TIMER_STATE_RUNNING) {
        timer_takeoff(tmr);
        tmr->expires = tmr->delay;
        timer_place(tmr);
        return K_ERR_NONE;
    }

    if (tmr->state == TIMER_STATE_STOPPED ||
        tmr->state == TIMER_STATE_COMPLETED) {
        tmr->state = TIMER_STATE_RUNNING;
        if (tmr->delay == (k_tick_t)0u) {
            tmr->expires = tmr->period;
        } else {
            tmr->expires = tmr->delay;
        }
        timer_place(tmr);
        return K_ERR_NONE;
    }
    return K_ERR_TIMER_INVALID_STATE;
}

插入軟體定時器串列

插入軟體定時器串列的函式是timer_place()，這個函式會根據軟體定時器的到期時間升序排序，然后再插入，

該函式是一個內部實作的靜態函式

實作程序如下：

根據軟體定時器的到期時間expires（相對值）與系統當前時間k_tick_count計算得出到期時間expires（絕對值），

舉個例子，鬧鐘將在10分鐘后叫我起床（這是一個相對值），鬧鐘將在當前時間（7:00）的10分鐘后叫我起床，那么鬧鐘響的時間是7:10分，此時的時間就是絕對值，

通過for回圈TOS_LIST_FOR_EACH找到合適的位置插入軟體定時器串列，此時插入軟體定時器串列安裝到期時間升序插入，
找到合適的位置后，呼叫tos_list_add_tail()函式將軟體定時器插入軟體定時器串列，
如果插入的軟體定時器是唯一定時器串列中的第一個，那么相應的，下一個到期時間就是這個軟體定時器的到期時間，將到期時間更新： k_timer_ctl.next_expires = tmr->expires，如果TOS_CFG_TIMER_AS_PROC 宏定義為0，則判斷一下軟體定時器任務是否處于睡眠狀態，如果是則呼叫tos_task_delay_abort()函式恢復軟體定時器任務運行，以便于更新它休眠的時間，因為此時是需要更新軟體定時器任務睡眠的時間的，畢竟第一個軟體定時器到期時間已經改變了，
如果軟體定時器任務處于掛起狀態，表示并沒有軟體定時器在作業，現在插入了軟體定時器，需要呼叫tos_task_resume()函式將軟體定時器任務喚醒，

關于喚醒軟體定時器任務是為了什么，我們在后續講解

__STATIC__ void timer_place(k_timer_t *tmr)
{
    TOS_CPU_CPSR_ALLOC();
    k_list_t *curr;
    k_timer_t *iter = K_NULL;

    TOS_CPU_INT_DISABLE();

    tmr->expires += k_tick_count;

    TOS_LIST_FOR_EACH(curr, &k_timer_ctl.list) {
        iter = TOS_LIST_ENTRY(curr, k_timer_t, list);
        if (tmr->expires < iter->expires) {
            break;
        }
    }
    tos_list_add_tail(&tmr->list, curr);

    if (k_timer_ctl.list.next == &tmr->list) {
        // we are the first guy now
        k_timer_ctl.next_expires = tmr->expires;

#if TOS_CFG_TIMER_AS_PROC == 0u
        if (task_state_is_sleeping(&k_timer_task)) {
            tos_task_delay_abort(&k_timer_task);
        }
#endif
    }

#if TOS_CFG_TIMER_AS_PROC == 0u
    if (task_state_is_suspended(&k_timer_task)) {
        tos_task_resume(&k_timer_task);
    }
#endif

    TOS_CPU_INT_ENABLE();
}

停止軟體定時器（外部函式）

在前文也提及停止軟體定時器，但是那個timer_takeoff()函式是內部函式，而tos_timer_stop()函式是外部函式，可以被用戶使用，

停止軟體定時器的本質也是呼叫timer_takeoff()函式將軟體定時器從軟體定時器串列中移除，但是在呼叫這個函式之前還好做一些相關的判斷，這樣能保證系統的穩定性，

對軟體定時器控制塊檢測，如果軟體定時器控制塊為null，則直接回傳錯誤代碼，
如果軟體定時器狀態為未使用狀態TIMER_STATE_UNUSED，則直接回傳錯誤代碼K_ERR_TIMER_INACTIVE，
如果軟體定時器狀態為TIMER_STATE_COMPLETED 或者是TIMER_STATE_STOPPED，則不需要停止軟體定時器，因為這個軟體定時器是未啟動的，則直接回傳錯誤代碼K_ERR_TIMER_STOPPED，
如果軟體定時器狀態為TIMER_STATE_RUNNING ，就將軟體定時器狀態設定為停止狀態TIMER_STATE_STOPPED，并且呼叫timer_takeoff()函式將軟體定時器從軟體定時器串列中移除，

__API__ k_err_t tos_timer_stop(k_timer_t *tmr)
{
    TOS_PTR_SANITY_CHECK(tmr);

#if TOS_CFG_OBJECT_VERIFY_EN > 0u
    if (!knl_object_verify(&tmr->knl_obj, KNL_OBJ_TYPE_TIMER)) {
        return K_ERR_OBJ_INVALID;
    }
#endif

    if (tmr->state == TIMER_STATE_UNUSED) {
        return K_ERR_TIMER_INACTIVE;
    }

    if (tmr->state == TIMER_STATE_COMPLETED ||
        tmr->state == TIMER_STATE_STOPPED) {
        return K_ERR_TIMER_STOPPED;
    }

    if (tmr->state == TIMER_STATE_RUNNING) {
        tmr->state = TIMER_STATE_STOPPED;
        timer_takeoff(tmr);
    }

    return K_ERR_NONE;
}

軟體定時器的處理（在中斷背景關系環境）

我們知道，TencentOS tiny的軟體定時器是可以在中斷背景關系環境來處理回呼函式的，因此當軟體定時器到期后，會在tos_tick_handler()函式中呼叫timer_update()來處理軟體定時器，這個函式在每次tick中斷到來的時候都會判斷一下是否有軟體定時器到期，如果有則去處理它，
程序如下：

判斷軟體定時器的下一個到期時間k_timer_ctl.next_expires是否小于k_tick_count，如果是小于則表示還未到期，直接退出，
反之則表示到期，此時要遍歷軟體定時器串列，找到所有到期的軟體定時器，并處理他們，

因為有可能不只是一個軟體定時器到期，很可能有多個定時器到期，當然啦，當軟體定時器沒到期的時候就會退出遍歷，

到期后的處理就是：呼叫timer_takeoff()函式將到期的軟體定時器停止，如果是周期作業的定時器就呼叫timer_place()函式將它重新插入軟體定時器串列中（它到期的相對時間就是軟體定時器的周期值：tmr->expires = tmr->period）；如果是單次作業模式的軟體定時器，就僅將軟體定時器狀態設定為TIMER_STATE_COMPLETED，
呼叫軟體定時器的回呼函式處理相關的作業：(*tmr->cb)(tmr->cb_arg)

__KERNEL__ void timer_update(void)
{
    k_timer_t *tmr;
    k_list_t *curr, *next;

    if (k_timer_ctl.next_expires < k_tick_count) {
        return;
    }

    tos_knl_sched_lock();

    TOS_LIST_FOR_EACH_SAFE(curr, next, &k_timer_ctl.list) {
        tmr = TOS_LIST_ENTRY(curr, k_timer_t, list);
        if (tmr->expires > k_tick_count) {
            break;
        }

        // time's up
        timer_takeoff(tmr);

        if (tmr->opt == TOS_OPT_TIMER_PERIODIC) {
            tmr->expires = tmr->period;
            timer_place(tmr);
        } else {
            tmr->state = TIMER_STATE_COMPLETED;
        }

        (*tmr->cb)(tmr->cb_arg);
    }

    tos_knl_sched_unlock();
}

軟體定時器的處理（在任務背景關系環境）

關于使用軟體定時器任務處理回呼函式（即回呼函式執行的背景關系環境是任務），則必須打開TOS_CFG_TIMER_AS_PROC 宏定義，

創建軟體定時器任務

既然是軟體定時器任務，那么就必須創建軟體定時器任務，那么這個任務將在timer_init()函式中被創建，它是一個內核呼叫的函式，在內核初始化時就被呼叫（在tos_knl_init()函式中呼叫），

創建軟體定時器任務也是跟創建其他任務沒啥差別，都是通過tos_task_create()函式創建，軟體定時器任務控制塊、任務主體、優先級、任務堆疊起始地址與大小等都在前面的資料結構中指定了，任務的名字為"timer"，

__KERNEL__ k_err_t timer_init(void)
{
#if TOS_CFG_TIMER_AS_PROC > 0u
    return K_ERR_NONE;
#else
    return tos_task_create(&k_timer_task,
				            "timer",
				            timer_task_entry,
				            K_NULL,
				            k_timer_task_prio,
				            k_timer_task_stk_addr,
				            k_timer_task_stk_size,
				            0);
#endif
}

軟體定時器任務主體

軟體定時器任務的主體也是一個while (K_TRUE)回圈，在回圈中處理對應的事情，

呼叫timer_next_expires_get()函式獲取軟體定時器串列中的下一個到期時間，并且更新next_expires 的值，

注意：這里的時間已經在函式內部轉換為相對到期時間，比如10分鐘后鬧鐘叫我起床，而不是7:10分鬧鐘叫我起床）

根據next_expires的值，判斷一下軟體定時器任務應該休眠多久，在多久后到期時才喚醒軟體定時器任務并且處理回呼函式，也就是說，軟體定時器任務在軟體定時器沒有到期的時候是不會被喚醒的，都是處于休眠狀態，呼叫tos_task_delay()函式將任務進入休眠狀態，此時任務會被掛載到系統的延時（時基）串列中，

注意：如果next_expires的值為TOS_TIME_FOREVER，則不是休眠而是直接掛起，因為掛起狀態的任務對調度器而言是不可見的，這樣子的處理效率更高~掛起任務的函式是tos_task_suspend()，

任務如果被喚醒了，或者被恢復運行了，則表明軟體定時器到期了或者有新的軟體定時器插入串列了，那么在喚醒之后就要判斷一下是哪種情況，如果是到期了則處理對應的回呼函式：首先呼叫timer_takeoff()函式將到期的軟體定時器停止，如果是周期作業的定時器就呼叫timer_place()函式將它重新插入軟體定時器串列中（它到期的相對時間就是軟體定時器的周期值：tmr->expires = tmr->period）；如果是單次作業模式的軟體定時器，就僅將軟體定時器狀態設定為TIMER_STATE_COMPLETED，（這里也是會遍歷軟體定時器串列以處理所有到期的軟體定時器）
最后將呼叫軟體定時器的回呼函式處理相關的作業：(*tmr->cb)(tmr->cb_arg)，
如果定時器還未到期，并且軟體定時器任務被喚醒了，那么就表示有新的軟體定時器插入串列了，此時要更新一下任務的睡眠時間，因為軟體定時器任務主體是一個while回圈，還是會回到 timer_next_expires_get()函式中重新獲取下一個喚醒任務的時間的，

注意：軟體定時器的處理都是在鎖調度器中處理的，就是為了避免其他任務打擾回呼函式的執行，

__STATIC__ void timer_task_entry(void *arg)
{
    k_timer_t *tmr;
    k_list_t *curr, *next;
    k_tick_t next_expires;

    arg = arg; // make compiler happy
    while (K_TRUE) {
        next_expires = timer_next_expires_get();
        if (next_expires == TOS_TIME_FOREVER) {
            tos_task_suspend(K_NULL);
        } else if (next_expires > (k_tick_t)0u) {
            tos_task_delay(next_expires);
        }

        tos_knl_sched_lock();

        TOS_LIST_FOR_EACH_SAFE(curr, next, &k_timer_ctl.list) {
            tmr = TOS_LIST_ENTRY(curr, k_timer_t, list);
            if (tmr->expires > k_tick_count) { // not yet
                break;
            }

            // time's up
            timer_takeoff(tmr);

            if (tmr->opt == TOS_OPT_TIMER_PERIODIC) {
                tmr->expires = tmr->period;
                timer_place(tmr);
            } else {
                tmr->state = TIMER_STATE_COMPLETED;
            }

            (*tmr->cb)(tmr->cb_arg);
        }

        tos_knl_sched_unlock();
    }
}

獲取軟體定時器下一個到期時間

timer_next_expires_get()就是用于獲取軟體定時器下一個到期時間，如果軟體定時器到期時間是TOS_TIME_FOREVER，就回傳TOS_TIME_FOREVER，如果下一個到期時間小于k_tick_count則直接回傳0，表示已經到期了，可以直接處理它，而如果是其他值，則需要減去k_tick_count，將其轉變為相對值，因為呼叫這個函式就是為了知道任務能休眠多少時間，

打個比方，我7點醒來了，而7:10分的鬧鐘才會響，那么我就能再睡10分鐘，就是這個道理，

__KERNEL__ k_tick_t timer_next_expires_get(void)
{
    TOS_CPU_CPSR_ALLOC();
    k_tick_t next_expires;

    TOS_CPU_INT_DISABLE();

    if (k_timer_ctl.next_expires == TOS_TIME_FOREVER) {
        next_expires = TOS_TIME_FOREVER;
    } else if (k_timer_ctl.next_expires <= k_tick_count) {
        next_expires = (k_tick_t)0u;
    } else {
        next_expires = k_timer_ctl.next_expires - k_tick_count;
    }

    TOS_CPU_INT_ENABLE();
    return next_expires;
}

喜歡就關注我吧！

歡迎關注我公眾號

相關代碼可以在公眾號后臺回復 “ 19 ” 獲取，
更多資料歡迎關注“物聯網IoT開發”公眾號！

轉載請註明出處，本文鏈接：https://www.uj5u.com/caozuo/30540.html

標籤：嵌入式

上一篇：【TencentOS tiny】深度原始碼分析（7）——事件

下一篇：2020秋招嵌入式面經——地平線、小米、CVTE、大華、綠米

【TencentOS tiny】深度原始碼分析（8）——軟體定時器