上传文件至 'src'

src/zf_task.c

@@ -0,0 +1,525 @@
+/**
+  *****************************************************************************
+  * @file    zf_task.c
+  * @author  Zorb
+  * @version V1.0.0
+  * @date    2018-06-28
+  * @brief   任务管理的头文件
+  *****************************************************************************
+  * @history
+  *
+  * 1. Date:2018-06-28
+  *    Author:Zorb
+  *    Modification:建立文件
+  *
+  *****************************************************************************
+  */
+
+#include "zf_task.h"
+#include "zf_task_schedule.h"
+#include "zf_critical.h"
+#include "zf_malloc.h"
+#include "zf_debug.h"
+#include "zf_assert.h"
+#include "zf_list.h"
+
+/* 空闲任务堆栈大小 */
+#define IDLE_TASK_STK_SIZE 512  /* 4字节对齐 */
+
+List *pmTaskList = NULL;        /* 任务列表 */
+Task *pTopPriorityTask = NULL;  /* 最高优先级任务 */
+Task *pCurrentTask = NULL;      /* 当前任务 */
+Task *pIdleTask = NULL;         /* 空闲任务 */
+ /* 空闲任务事件处理器 */
+EventHandler *pIdleTaskEventHandler;
+
+/* 任务调度开的标志 */
+bool mIsScheduleOn = true;
+
+/* 任务系统是否开始的标志 */
+bool mIsTaskSystemRun = false;
+
+/* 空闲任务程序 */
+static void Task_idleTaskProcess(void *pArg);
+
+/******************************************************************************
+ * 描述  ：获取任务列表
+ * 参数  ：无
+ * 返回  ：任务列表指针
+******************************************************************************/
+List *Task_getTaskList(void)
+{
+    return pmTaskList;
+}
+
+/******************************************************************************
+ * 描述  ：创建任务
+ * 参数  ：(out)-ppTask        任务指针的地址
+ *         (in)-taskProcess    任务程序的指针
+ *         (in)-parg           任务程序的参数指针(动态任务需自己销毁)
+ *         (in)-priority       任务的优先级
+ *         (in)-stkSize        任务的堆栈大小(内部分配)
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool Task_create(Task **ppTask, ITaskProcess taskProcess, void *pArg,
+    uint8_t priority, uint32_t stkSize)
+{
+    Task *pTask;
+    uint32_t *pStkBase;
+    ListNode *pNode;
+    
+    ZF_ASSERT(ppTask != (Task **)0)
+    ZF_ASSERT(taskProcess != (ITaskProcess)0)
+    ZF_ASSERT(stkSize > 255)
+    ZF_ASSERT(priority <= TASK_LOWEST_PRIORITY)
+    
+    /* 分配任务空间 */
+    if (!List_mallocNode(&pNode, (void **)&pTask, sizeof(Task)))
+    {
+        ZF_DEBUG(LOG_E, "malloc task space error\r\n");
+        
+        return false;
+    }
+    
+    pTask->Priority = priority;
+    pTask->State = TASK_STATE_RUNNING;
+    pTask->DelayTime = 0;
+    pTask->RunTime = 0;
+    
+    /* 分配堆栈空间 */
+    pStkBase = ZF_MALLOC(stkSize);
+    if (pTask == NULL)
+    {
+        ZF_DEBUG(LOG_E, "malloc task stack space error\r\n");
+        
+        return false;
+    }
+    
+    pTask->pStkBase = pStkBase;
+    pTask->StkSize = stkSize;
+    
+    /* 初始化堆栈值 */
+    ZF_initTaskStack(pTask, taskProcess, pArg);
+    
+    /* 初始化方法 */
+    pTask->Start = Task_start;
+    pTask->Stop = Task_stop;
+    pTask->Dispose = Task_dispose;
+    
+    /* 创建任务列表 */
+    if (pmTaskList == NULL)
+    {
+        List_create(&pmTaskList);
+        
+        if (pmTaskList == NULL)
+        {
+            ZF_DEBUG(LOG_E, "malloc task list space error\r\n");
+            
+            /* 输出 */
+            *ppTask = NULL;
+            
+            return false;
+        }
+    }
+    
+    /* 关闭任务调度 */
+    TASK_SCHEDULE_DISABLE();
+    
+    /* 添加到任务列表 */
+    pmTaskList->Add(pmTaskList, pNode);
+    
+    /* 开启任务调度 */
+    TASK_SCHEDULE_ENABLE();
+    
+    /* 输出 */
+    *ppTask = pTask;
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：开始任务(仅标记状态，Task_run才是所有任务执行的入口)
+ * 参数  ：(in)-pTask  任务指针
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool Task_start(Task * const pTask)
+{
+    ZF_ASSERT(pTask != (Task *)0)
+    
+    /* 关闭任务调度 */
+    TASK_SCHEDULE_DISABLE();
+    
+    pTask->State = TASK_STATE_RUNNING;
+    
+    /* 开启任务调度 */
+    TASK_SCHEDULE_ENABLE();
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：停止任务
+ * 参数  ：(in)-pTask  任务指针
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool Task_stop(Task * const pTask)
+{
+    ZF_ASSERT(pTask != (Task *)0)
+    
+    /* 空闲任务不能关闭 */
+    if (pTask == pIdleTask)
+    {
+        return false;
+    }
+    
+    /* 要关闭的任务正在运行 */
+    if (mIsTaskSystemRun && pTask->State == TASK_STATE_RUNNING)
+    {
+        /* 关闭任务调度 */
+        TASK_SCHEDULE_DISABLE();
+        
+        pTask->State = TASK_STATE_STOP;
+        
+        /* 开启任务调度 */
+        TASK_SCHEDULE_ENABLE();
+        
+        /* 触发调度 */
+        Task_schedule();
+    }
+    else
+    {
+        /* 关闭任务调度 */
+        TASK_SCHEDULE_DISABLE();
+        
+        pTask->State = TASK_STATE_STOP;
+        
+        /* 开启任务调度 */
+        TASK_SCHEDULE_ENABLE();
+    }
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：空闲任务执行销毁任务
+ * 参数  ：(in)-pArgList  参数列表
+ * 返回  ：无
+******************************************************************************/
+static void Task_disposeByIdleTask(List *pArgList)
+{
+    /* SR变量 */
+    ZF_SR_VAL();
+    
+    ListNode *pNode;
+    Task *pTask;
+    
+    ZF_ASSERT(pArgList != (List *)0)
+    ZF_ASSERT(pmTaskList != (List *)0)
+    
+    /* 空闲任务不能销毁 */
+    if (pTask == pIdleTask)
+    {
+        return;
+    }
+    
+    /* 进入临界区 */
+    ZF_CRITICAL_ENTER();
+    
+    /* 节点0数据区指向的内容为任务指针 */
+    pTask = *((Task **)pArgList->GetElementDataAt(pArgList, 0));
+    
+    /* 移除任务 */
+    while(pmTaskList->GetElementByData(pmTaskList, pTask, &pNode))
+    {
+        if (pNode == NULL)
+        {
+            break;
+        }
+        
+        if (!pmTaskList->Delete(pmTaskList, pNode))
+        {
+            ZF_DEBUG(LOG_E, "delete task node from list error\r\n");
+            
+            break;
+        }
+    }
+    
+    /* 退出临界区 */
+    ZF_CRITICAL_EXIT();
+}
+
+/******************************************************************************
+ * 描述  ：销毁任务(真正销毁动作在空闲任务完成)
+ * 参数  ：(in)-pTask  任务指针
+ * 返回  ：无
+******************************************************************************/
+void Task_dispose(Task * const pTask)
+{
+    /* SR变量 */
+    ZF_SR_VAL();
+    
+    Event *pEvent;
+    
+    ZF_ASSERT(pTask != (Task *)0)
+    ZF_ASSERT(pmTaskList != (List *)0)
+    
+    /* 空闲任务不能销毁 */
+    if (pTask == pIdleTask)
+    {
+        return;
+    }
+    
+    /* 创建销毁事件 */
+    Event_create(&pEvent);
+    
+    pEvent->Priority = TASK_HIGHEST_PRIORITY;
+    pEvent->EventProcess = (IEventProcess)Task_disposeByIdleTask;
+    /* 参数为任务的指针 */
+    pEvent->AddArg(pEvent, (void *)&pTask, sizeof(Task *));
+    
+    /* 推送销毁事件到空闲任务 */
+    EVENT_POST(pIdleTaskEventHandler, pEvent);
+    
+    /* 进入临界区 */
+    ZF_CRITICAL_ENTER();
+    
+    /* 停止任务 */
+    pTask->State = TASK_STATE_STOP;
+    
+    /* 设置空闲任务等级最高 */
+    pIdleTask->Priority = TASK_HIGHEST_PRIORITY;
+    
+    /* 退出临界区 */
+    ZF_CRITICAL_EXIT();
+    
+    /* 任务调度 */
+    Task_schedule();
+}
+
+/******************************************************************************
+ * 描述  ：延时任务
+ * 参数  ：(in)-pTask  任务指针
+ *         (in)-time   要延时的系统周期数
+ * 返回  ：无
+******************************************************************************/
+void Task_delay(struct _Task * const pTask, uint32_t tick)
+{
+    ZF_ASSERT(pTask != (Task *)0)
+    
+    pTask->DelayTime = tick;
+}
+
+/******************************************************************************
+ * 描述  ：任务调度开关
+ * 参数  ：(in)-on      true:开调度 flase:关调度
+ * 返回  ：无
+******************************************************************************/
+void Task_scheduleSwitch(bool on)
+{
+    mIsScheduleOn = on;
+}
+
+/******************************************************************************
+ * 描述  ：任务调度
+ * 参数  ：无
+ * 返回  ：无
+******************************************************************************/
+void Task_schedule(void)
+{
+    /* SR变量 */
+    ZF_SR_VAL();
+    
+    /* 任务调度没开则退出 */
+    if (!mIsTaskSystemRun || !mIsScheduleOn)
+    {
+        return;
+    }
+    
+    /* 没有任务则退出 */
+    if (pmTaskList == NULL || pmTaskList->Count == 0)
+    {
+        return;
+    }
+    
+    /* 进入临界区 */
+    ZF_CRITICAL_ENTER();
+    
+    /* 查找最高优先级的任务 */
+    pTopPriorityTask = Task_getTopPriorityTask();
+    
+    /* 获取任务失败 */
+    if (pTopPriorityTask == NULL)
+    {
+        /* 退出临界区 */
+        ZF_CRITICAL_EXIT();
+        
+        ZF_DEBUG(LOG_D, "\r\n");
+        ZF_DEBUG(LOG_E, "get top priority task error\r\n");
+        ZF_DEBUG(LOG_E, "task schedule stop\r\n");
+        
+        /* 关闭任务调度 */
+        TASK_SCHEDULE_DISABLE();
+        
+        return;
+    }
+    
+    /* 如果最高优先级的任务是当前任务则直接返回，不进行任务切换 */
+    if (pTopPriorityTask == pCurrentTask)
+    {
+        /* 退出临界区 */
+        ZF_CRITICAL_EXIT();
+        
+        return;
+    }
+    
+    /* 退出临界区 */
+    ZF_CRITICAL_EXIT();
+    
+    /* 任务切换 */
+    TASK_SWITCH();
+}
+
+/******************************************************************************
+ * 描述  ：任务时间更新
+ * 参数  ：无
+ * 返回  ：无
+******************************************************************************/
+void Task_timeUpdate(void)
+{
+    /* SR变量 */
+    ZF_SR_VAL();
+    
+    uint32_t i;
+    ListNode *pNode;
+    Task *pTask;
+    
+    /* 任务系统没启动则退出 */
+    if (!mIsTaskSystemRun)
+    {
+        return;
+    }
+    
+    /* 没有任务则退出 */
+    if (pmTaskList == NULL || pmTaskList->Count == 0)
+    {
+        return;
+    }
+    
+    /* 进入临界区 */
+    ZF_CRITICAL_ENTER();
+    
+    /* 遍历所有任务 */
+    for (i = 0; i < pmTaskList->Count; i++)
+    {
+        if (pmTaskList->GetElementAt(pmTaskList, i, &pNode))
+        {
+            pTask = (Task *)pNode->pData;
+            
+            /* 任务延时倒计数 */
+            if (pTask->DelayTime > 0)
+            {
+                pTask->DelayTime--;
+            }
+            
+            /* 任务运行时间计数 */
+            if (pTask == pCurrentTask)
+            {
+                pTask->RunTime++;
+            }
+        }
+    }
+    
+    /* 退出临界区 */
+    ZF_CRITICAL_EXIT();
+}
+
+/******************************************************************************
+ * 描述  ：空闲任务程序
+ * 参数  ：(in)-pArg   参数列表
+ * 返回  ：无
+******************************************************************************/
+void Task_idleTaskProcess(void *pArg)
+{
+    Event *pEvent;
+    
+    while(1)
+    {
+        /* 事件处理器运行 */
+        pIdleTaskEventHandler->Execute(pIdleTaskEventHandler);
+        
+        /* 还有事件处理 */
+        if (pIdleTaskEventHandler->GetEventCount(pIdleTaskEventHandler) > 0)
+        {
+            /* 获取事件 */
+            pEvent = (Event *)pIdleTaskEventHandler->pEventList
+                ->GetElementDataAt(pIdleTaskEventHandler->pEventList, 0);
+            
+            if (pEvent == NULL || pEvent->EventProcess == NULL)
+            {
+                ZF_DEBUG(LOG_E, "idle task get event error:event is null\r\n");
+                while(1);
+            }
+            
+            /* 空闲任务的优先级等于事件的优先级 */
+            pIdleTask->Priority = pEvent->Priority;
+            
+            /* 开始调度 */
+            Task_schedule();
+        }
+        /* 没有事件处理 */
+        else
+        {
+            /* 空闲任务恢复到最低优先级 */
+            if (pIdleTask->Priority != TASK_LOWEST_PRIORITY)
+            {
+                pIdleTask->Priority = TASK_LOWEST_PRIORITY;
+                
+                /* 开始调度 */
+                Task_schedule();
+            }
+            
+            /* 可实现低功耗 */
+        }
+    }
+}
+
+/******************************************************************************
+ * 描述  ：运行所有任务,程序不返回
+ * 参数  ：无
+ * 返回  ：无
+******************************************************************************/
+void Task_run(void)
+{
+    /* 没有任务则退出 */
+    if (pmTaskList == NULL || pmTaskList->Count == 0)
+    {
+        ZF_DEBUG(LOG_E, "run task system error\r\n");
+        return;
+    }
+    
+    /* 创建空闲任务 */
+    if (!Task_create(&pIdleTask, Task_idleTaskProcess, NULL,
+        TASK_LOWEST_PRIORITY, IDLE_TASK_STK_SIZE))
+    {
+        ZF_DEBUG(LOG_E, "create idle task error\r\n");
+        
+        while(1);
+    }
+    
+    /* 创建空闲任务事件处理器 */
+    EventHandler_create(&pIdleTaskEventHandler);
+    
+    /* 标记系统运行 */
+    mIsTaskSystemRun = true;
+    
+    /* 查找最高优先级的任务 */
+    pTopPriorityTask = Task_getTopPriorityTask();
+    
+    /* 启动任务调度 */
+    SF_readyGo();
+}
+
+/******************************** END OF FILE ********************************/

src/zf_task_schedule.c

@@ -0,0 +1,77 @@
+/**
+  *****************************************************************************
+  * @file    zf_task_schedule.c
+  * @author  Zorb
+  * @version V1.0.0
+  * @date    2018-06-28
+  * @brief   任务调度算法的实现
+  *****************************************************************************
+  * @history
+  *
+  * 1. Date:2018-06-28
+  *    Author:Zorb
+  *    Modification:建立文件
+  *
+  *****************************************************************************
+  */
+
+#include "zf_task_schedule.h"
+#include "zf_assert.h"
+#include "stdlib.h"
+
+/******************************************************************************
+ * 描述  ：获取最高优先级任务(抢占式任务调度)
+ * 参数  ：无
+ * 返回  ：最高优先级任务
+******************************************************************************/
+Task *Task_getTopPriorityTask(void)
+{
+    Task *pTask = NULL;
+    List *pTaskList;
+    
+    pTaskList = TASK_GET_TASK_LIST();
+    if (pTaskList == NULL)
+    {
+        return NULL;
+    }
+    
+    if (pTaskList->Count > 0)
+    {
+        Task *pTaski = NULL;
+        uint32_t i;
+        
+        pTask = TASK_GET_IDLE_TASK();
+        if (pTask == NULL)
+        {
+            return NULL;
+        }
+        
+        /* 遍历所有任务 */
+        for (i = 0; i < pTaskList->Count; i++)
+        {
+            pTaski = (Task *)pTaskList->GetElementDataAt(pTaskList, i);
+            if (pTaski != NULL)
+            {
+                /* 任务在运行状态，同时不在延时则可以参与优先级排序 */
+                if (pTaski->State == TASK_STATE_RUNNING
+                    && pTaski->DelayTime == 0)
+                {
+                    /* 优先级排序 */
+                    if (pTask->Priority > pTaski->Priority)
+                    {
+                        pTask = pTaski;
+                    }
+                }
+            }
+        }
+        
+        if (pTask->State != TASK_STATE_RUNNING || pTask->DelayTime > 0)
+        {
+            pTask = NULL;
+        }
+    }
+    
+    return pTask;
+}
+
+/******************************** END OF FILE ********************************/

src/zf_time.c

@@ -0,0 +1,100 @@
+/**
+  *****************************************************************************
+  * @file    zf_time.h
+  * @author  Zorb
+  * @version V1.0.0
+  * @date    2018-06-28
+  * @brief   系统时间的实现
+  *****************************************************************************
+  * @history
+  *
+  * 1. Date:2018-06-28
+  *    Author:Zorb
+  *    Modification:建立文件
+  *
+  *****************************************************************************
+  */
+
+#include "zf_time.h"
+#include "zf_timer.h"
+#include "zf_task.h"
+#include "zf_critical.h"
+#include "stdlib.h"
+
+/* 系统滴答数 */
+uint32_t ZF_tick = 0;
+
+/******************************************************************************
+ * 描述  ：获取系统滴答数
+ * 参数  ：无
+ * 返回  ：系统滴答数
+******************************************************************************/
+uint32_t ZF_getSystemTick(void)
+{
+    return ZF_tick;
+}
+
+/******************************************************************************
+ * 描述  ：获取系统时间(ms)
+ * 参数  ：无
+ * 返回  ：系统时间(ms)
+******************************************************************************/
+uint32_t ZF_getSystemTimeMS(void)
+{
+    return ZF_tick * ZF_TICK_PERIOD;
+}
+
+/******************************************************************************
+ * 描述  ：系统延时
+ * 参数  ：(in)-tick   需要延时的系统周期数
+ * 返回  ：无
+******************************************************************************/
+void ZF_delayTick(uint32_t tick)
+{
+    /* 有任务时的延时 */
+    if (TASK_IS_SYSTEM_RUN() && TASK_IS_SCHEDULE_ON())
+    {
+        /* SR变量 */
+        ZF_SR_VAL();
+        
+        /* 进入临界区 */
+        ZF_CRITICAL_ENTER();
+        
+        /* 当前任务延时 */
+        Task_delay(pCurrentTask, tick);
+        
+        /* 退出临界区 */
+        ZF_CRITICAL_EXIT();
+        
+        /* 任务调度 */
+        Task_schedule();
+    }
+    /* 没任务时的死延时 */
+    else
+    {
+        uint32_t startTick = ZF_getSystemTick();
+        while((ZF_getSystemTick() - startTick) < tick);
+    }
+}
+
+/******************************************************************************
+ * 描述  ：系统滴答程序(需挂在硬件的时间中断里边)
+ * 参数  ：无
+ * 返回  ：无
+******************************************************************************/
+void ZF_timeTick (void)
+{
+    /* 系统滴答计数 */
+    ZF_tick++;
+    
+    /* 软件定时器程序 */
+    Timer_process();
+    
+    /* 任务时间更新 */
+    Task_timeUpdate();
+    
+    /* 任务调度 */
+    Task_schedule();
+}
+
+/******************************** END OF FILE ********************************/

src/zf_timer.c

@@ -0,0 +1,271 @@
+/**
+  *****************************************************************************
+  * @file    zf_timer.c
+  * @author  Zorb
+  * @version V1.0.0
+  * @date    2018-06-28
+  * @brief   软件定时器(精度1ms)的实现
+  *****************************************************************************
+  * @history
+  *
+  * 1. Date:2018-06-28
+  *    Author:Zorb
+  *    Modification:建立文件
+  *
+  *****************************************************************************
+  */
+
+#include "zf_timer.h"
+#include "zf_assert.h"
+#include "zf_debug.h"
+#include "zf_list.h"
+#include "zf_malloc.h"
+#include "zf_time.h"
+#include "zf_task.h"
+
+/* 打开定时器运行程序 */
+#define TIMER_PROCESS_ENABLE() mIsTimerProcessOn = true
+/* 关闭定时器运行程序 */
+#define TIMER_PROCESS_DISABLE() mIsTimerProcessOn = false
+
+/* 定时器运行程序开的标志 */
+static bool mIsTimerProcessOn = false;
+
+/* 定时器列表 */
+static List *pmTimerList = NULL;
+
+/******************************************************************************
+ * 描述  ：刷新定时器定时到达时间
+ * 参数  ：(in)-pTimer 定时器指针
+ * 返回  ：无
+******************************************************************************/
+static void RefreshAlarmTime(Timer * const pTimer)
+{
+    ZF_ASSERT(pTimer != (Timer *)0)
+    
+    pTimer->AlarmTime = ZF_SYSTIME_MS() + pTimer->Interval;
+}
+
+/******************************************************************************
+ * 描述  ：创建定时器(内部分配空间)
+ * 参数  ：(out)-ppTimer 定时器指针的指针
+ * 返回  ：无
+******************************************************************************/
+bool Timer_create(Timer **ppTimer)
+{
+    ListNode *pNode;
+    Timer *pTimer;
+    
+    ZF_ASSERT(ppTimer != (Timer **)0)
+    
+    if (!List_mallocNode(&pNode, (void **)&pTimer, sizeof(Timer)))
+    {
+        ZF_DEBUG(LOG_E, "malloc timer space error\r\n");
+        
+        return false;
+    }
+    
+    pTimer->Priority = EVENT_LOWEST_PRIORITY;
+    pTimer->Interval = 0;
+    pTimer->IsAutoReset = true;
+    pTimer->IsRunning = false;
+    pTimer->pEventHandler = NULL;
+    pTimer->TimerProcess = NULL;
+    
+    pTimer->Start = Timer_start;
+    pTimer->Stop = Timer_stop;
+    pTimer->Restart = Timer_restart;
+    pTimer->Dispose = Timer_dispose;
+    
+    /* 创建定时器列表 */
+    if (pmTimerList == NULL)
+    {
+        if (!List_create(&pmTimerList))
+        {
+            ZF_DEBUG(LOG_E, "malloc timer list space error\r\n");
+            
+            /* 输出 */
+            *ppTimer = NULL;
+            return false;
+        }
+        
+        /* 打开定时器运行程序 */
+        TIMER_PROCESS_ENABLE();
+    }
+    
+    /* 添加到定时器列表 */
+    pmTimerList->Add(pmTimerList, pNode);
+    
+    /* 输出 */
+    *ppTimer = pTimer;
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：开始定时器
+ * 参数  ：(in)-pTimer 定时器指针
+ * 返回  ：无
+******************************************************************************/
+void Timer_start(Timer * const pTimer)
+{
+    ZF_ASSERT(pTimer != (Timer *)0)
+    
+    if (!pTimer->IsRunning)
+    {
+        RefreshAlarmTime(pTimer);
+        pTimer->IsRunning = true;
+    }
+}
+
+/******************************************************************************
+ * 描述  ：关闭定时器
+ * 参数  ：(in)-pTimer 定时器指针
+ * 返回  ：无
+******************************************************************************/
+void Timer_stop(Timer * const pTimer)
+{
+    ZF_ASSERT(pTimer != (Timer *)0)
+    
+    pTimer->IsRunning = false;
+}
+
+/******************************************************************************
+ * 描述  ：重新运行定时器
+ * 参数  ：(in)-pTimer 定时器指针
+ * 返回  ：无
+******************************************************************************/
+void Timer_restart(Timer * const pTimer)
+{
+    ZF_ASSERT(pTimer != (Timer *)0)
+    
+    Timer_stop(pTimer);
+    
+    Timer_start(pTimer);
+}
+
+/******************************************************************************
+ * 描述  ：销毁定时器(释放空间)
+ * 参数  ：(in)-pTimer 定时器指针
+ * 返回  ：无
+******************************************************************************/
+bool Timer_dispose(Timer * const pTimer)
+{
+    ListNode *pNode;
+    
+    ZF_ASSERT(pTimer != (Timer *)0)
+    ZF_ASSERT(pmTimerList != (List *)0)
+    
+    Timer_stop(pTimer);
+    
+    /* 删除定时器 */
+    while(pmTimerList->GetElementByData(pmTimerList, pTimer, &pNode))
+    {
+        if (pNode == NULL)
+        {
+            break;
+        }
+        
+        if (!pmTimerList->Delete(pmTimerList, pNode))
+        {
+            ZF_DEBUG(LOG_E, "delete timer node from list error\r\n");
+            
+            break;
+        }
+    }
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：推送定时事件
+ * 参数  ：(in)-pTimer 定时器指针
+ * 返回  ：无
+******************************************************************************/
+static void Timer_postEvent(Timer *pTimer)
+{
+    /* 创建事件 */
+    Event *pEvent;
+    Event_create(&pEvent);
+    pEvent->Priority = pTimer->Priority;
+    pEvent->EventProcess = (IEventProcess)pTimer->TimerProcess;
+    pEvent->pArgList = NULL; 
+    
+    /* 推送事件 */
+    EVENT_POST(pTimer->pEventHandler, pEvent);
+    
+    /* 任务定时器 */
+    if (pTimer->pEventHandler == TASK_GET_IDLE_TASK_HANDLER())
+    {
+        /* 设置空闲任务等级 */
+        if (TASK_GET_IDLE_TASK()->Priority > pTimer->Priority)
+        {
+            TASK_GET_IDLE_TASK()->Priority = pTimer->Priority;
+        }
+    }
+}
+
+/******************************************************************************
+ * 描述  ：后台运行程序(放在1ms内的循环里边)
+ * 参数  ：无
+ * 返回  ：无
+******************************************************************************/
+void Timer_process(void)
+{
+    /* 没有打开定时器运行程序则返回 */
+    if (!mIsTimerProcessOn)
+    {
+        return;
+    }
+    
+    if (pmTimerList != NULL && pmTimerList->Count > 0)
+    {
+        int i = 0;
+        ListNode *pNode;
+        Timer *pTimer;
+        
+        /* 遍历所有定时器 */
+        for (i = 0; i < pmTimerList->Count; i++)
+        {
+            if (pmTimerList->GetElementAt(pmTimerList, i, &pNode))
+            {
+                pTimer = (Timer *)pNode->pData;
+                
+                /* 定时器在工作 */
+                if (pTimer->IsRunning)
+                {
+                    /* 到达定时时间 */
+                    if (ZF_SYSTIME_MS() >= pTimer->AlarmTime)
+                    {
+                        /* 重复运行 */
+                        if(pTimer->IsAutoReset)
+                        {
+                            pTimer->Restart(pTimer);
+                        }
+                        else
+                        {
+                            pTimer->Stop(pTimer);
+                        }
+                        
+                        /* 执行事件 */
+                        if (pTimer->TimerProcess != NULL)
+                        {
+                            if (pTimer->pEventHandler == NULL)
+                            {
+                                /* 本地执行 */
+                                pTimer->TimerProcess();
+                            }
+                            else
+                            {
+                                /* 推送事件 */
+                                Timer_postEvent(pTimer);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/******************************** END OF FILE ********************************/