文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

鸿蒙轻内核M核源码分析系列九 软件定时器Swtmr

2024-12-03 04:41

关注

想了解更多内容，请访问：

51CTO和华为官方合作共建的鸿蒙技术社区

https://harmonyos.51cto.com

软件定时器(Software Timer)是基于系统Tick时钟中断且由软件来模拟的定时器。当经过设定的Tick数后，会触发用户自定义的回调函数。硬件定时器受硬件的限制，数量上不足以满足用户的实际需求。鸿蒙轻内核提供了软件定时器功能可以提供更多的定时器，满足用户需求。

本文通过分析鸿蒙轻内核定时器模块的源码，掌握定时器使用上的差异。

接下来，我们看下定时器的结构体，定时器初始化，定时器常用操作的源代码。

1、定时器结构体定义和常用宏定义

1.1 定时器结构体定义

在文件kernel\include\los_swtmr.h定义的定时器控制块结构体为SWTMR_CTRL_S，结构体源代码如下。定时器状态.ucState取值OS_SWTMR_STATUS_UNUSED、OS_SWTMR_STATUS_CREATED或OS_SWTMR_STATUS_TICKING，定时器模式.mode取值LOS_SWTMR_MODE_ONCE、LOS_SWTMR_MODE_PERIOD或LOS_SWTMR_MODE_NO_SELFDELETE。其他结构体成员的解释见注释部分。

  1. typedef struct tagSwTmrCtrl { 
  2.     struct tagSwTmrCtrl *pstNext;        
  3.     UINT8               ucState;         
  4.     UINT8               ucMode;          
  5. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  6.     UINT8               ucRouses;        
  7.     UINT8               ucSensitive;     
  8. #endif 
  9.     UINT32              usTimerID;       
  10.     UINT32              uwCount;         
  11.     UINT32              uwInterval;      
  12.     UINT32              uwArg;           
  13.     SWTMR_PROC_FUNC     pfnHandler;      
  14.     SortLinkList        stSortList;      
  15. } SWTMR_CTRL_S; 

另外，还对回调函数及其参数单独定义了一个结构体SwtmrHandlerItem，如下：

  1. typedef struct { 
  2.     SWTMR_PROC_FUNC handler;     
  3.     UINTPTR arg;                 
  4. } SwtmrHandlerItem; 

1.2 定时器常用宏定义

定时器头文件kernel\include\los_swtmr.h中还提供了相关的枚举和宏，从定时器池里获取定时器控制块的宏定义OS_SWT_FROM_SID如下：

  1. #define OS_SWT_FROM_SID(swtmrId)    ((SWTMR_CTRL_S *)g_swtmrCBArray + ((swtmrId) % LOSCFG_BASE_CORE_SWTMR_LIMIT)) 

头文件中定义的定时器几个枚举如下：

  1. enum SwtmrState { 
  2.     OS_SWTMR_STATUS_UNUSED,      
  3.     OS_SWTMR_STATUS_CREATED,     
  4.     OS_SWTMR_STATUS_TICKING      
  5. }; 
  6.  
  7. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  8.  
  9. enum enSwTmrRousesType { 
  10.     OS_SWTMR_ROUSES_IGNORE,  
  11.     OS_SWTMR_ROUSES_ALLOW,   
  12. }; 
  13.  
  14. enum enSwTmrAlignSensitive { 
  15.     OS_SWTMR_ALIGN_SENSITIVE,    
  16.     OS_SWTMR_ALIGN_INSENSITIVE,  
  17. }; 
  18. #endif 
  19.  
  20. enum EnSwTmrType { 
  21.     LOS_SWTMR_MODE_ONCE,             
  22.     LOS_SWTMR_MODE_PERIOD,           
  23.     LOS_SWTMR_MODE_NO_SELFDELETE,    
  24.     LOS_SWTMR_MODE_OPP,              
  25. }; 

2、定时器初始化

定时器在内核中默认开启，用户可以通过宏LOSCFG_BASE_CORE_SWTMR进行关闭。开启定时器的情况下，在系统启动时，在kernel\src\los_init.c中调用OsSwtmrInit()进行定时器模块初始化。下面，我们分析下定时器初始化的代码。

⑴处如果开启定时器对齐宏LOSCFG_BASE_CORE_SWTMR_ALIGN，清零g_swtmrAlignID数组。定时器的数量由宏LOSCFG_BASE_CORE_SWTMR_LIMIT定义，

⑵处计算定时器池需要的内存大小，然后为定时器申请内存，如果申请失败，则返回错误。

⑶初始化空闲定时器链表g_swtmrFreeList，维护未使用的定时器。循环每一个定时器进行初始化，为每一个定时器节点指定索引timerId，定时器控制块依次指向下一个定时器控制块。

⑷处代码为定时器创建队列，队列的消息大小OS_SWTMR_HANDLE_QUEUE_SIZE等于定时器的数量LOSCFG_BASE_CORE_SWTMR_LIMIT，消息内容的最大大小sizeof(SwtmrHandlerItem)。后文分析定时器队列读取写入消息的时候具体来看是什么消息。

⑸处调用函数OsSwtmrTaskCreate()创建定时器任务，定时器任务优先级最高，任务的入口函数为OsSwtmrTask()，后文会分析该函数。

⑹处初始化定时器排序链表，源码分析系列之前的文章分析过，可以阅读下排序链表数据结构章节。⑺处注册定时器扫描函数OsSwtmrScan。

  1. LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID) 
  2. { 
  3.     UINT32 size; 
  4.     UINT16 index; 
  5.     UINT32 ret; 
  6.  
  7. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  8.     // Ignore the return code when matching CSEC rule 6.6(1). 
  9. ⑴  (VOID)memset_s((VOID *)g_swtmrAlignID, sizeof(SwtmrAlignData) * LOSCFG_BASE_CORE_SWTMR_LIMIT, 
  10.                    0, sizeof(SwtmrAlignData) * LOSCFG_BASE_CORE_SWTMR_LIMIT); 
  11. #endif 
  12.  
  13. ⑵  size = sizeof(SWTMR_CTRL_S) * LOSCFG_BASE_CORE_SWTMR_LIMIT; 
  14.     SWTMR_CTRL_S *swtmr = (SWTMR_CTRL_S *)LOS_MemAlloc(m_aucSysMem0, size); 
  15.     if (swtmr == NULL) { 
  16.         return LOS_ERRNO_SWTMR_NO_MEMORY; 
  17.     } 
  18.     // Ignore the return code when matching CSEC rule 6.6(3). 
  19.     (VOID)memset_s((VOID *)swtmr, size, 0, size); 
  20.     g_swtmrCBArray = swtmr; 
  21. ⑶  g_swtmrFreeList = swtmr; 
  22.     swtmr->usTimerID = 0; 
  23.     SWTMR_CTRL_S *temp = swtmr; 
  24.     swtmr++; 
  25.     for (index = 1; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr++) { 
  26.         swtmr->usTimerID = index; 
  27.         temp->pstNext = swtmr; 
  28.         temp = swtmr; 
  29.     } 
  30.  
  31. ⑷  ret = LOS_QueueCreate((CHAR *)NULL, OS_SWTMR_HANDLE_QUEUE_SIZE, 
  32.                           &g_swtmrHandlerQueue, 0, sizeof(SwtmrHandlerItem)); 
  33.     if (ret != LOS_OK) { 
  34.         (VOID)LOS_MemFree(m_aucSysMem0, swtmr); 
  35.         return LOS_ERRNO_SWTMR_QUEUE_CREATE_FAILED; 
  36.     } 
  37.  
  38. ⑸  ret = OsSwtmrTaskCreate(); 
  39.     if (ret != LOS_OK) { 
  40.         (VOID)LOS_MemFree(m_aucSysMem0, swtmr); 
  41.         return LOS_ERRNO_SWTMR_TASK_CREATE_FAILED; 
  42.     } 
  43.  
  44. ⑹  g_swtmrSortLinkList = OsGetSortLinkAttribute(OS_SORT_LINK_SWTMR); 
  45.     if (g_swtmrSortLinkList == NULL) { 
  46.         (VOID)LOS_MemFree(m_aucSysMem0, swtmr); 
  47.         return LOS_NOK; 
  48.     } 
  49.  
  50.     ret = OsSortLinkInit(g_swtmrSortLinkList); 
  51.     if (ret != LOS_OK) { 
  52.         (VOID)LOS_MemFree(m_aucSysMem0, swtmr); 
  53.         return LOS_NOK; 
  54.     } 
  55.  
  56. ⑺  ret = OsSchedSwtmrScanRegister((SchedScan)OsSwtmrScan); 
  57.     if (ret != LOS_OK) { 
  58.         (VOID)LOS_MemFree(m_aucSysMem0, swtmr); 
  59.         return LOS_NOK; 
  60.     } 
  61.  
  62.     return LOS_OK; 
  63. } 

我们再看一下定时器任务的入口函数为OsSwtmrTask()。

⑴进行for永久循环，队列读取不到数据时会阻塞，因为优先级比较高，定时器队列有数据时该任务就会执行。从定时器队列中读取定时器处理函数地址放入指针地址&swtmrHandle，读取的长度为sizeof(SwtmrHandlerItem)。成功读取后，获取定时器回调函数及其参数，然后

⑵处执行定时器回调函数。记录定时器回调函数的执行时间，

⑶处判断执行时间是否超时，如果超时，打印警告信息。

  1. LITE_OS_SEC_TEXT VOID OsSwtmrTask(VOID) 
  2. { 
  3.     SwtmrHandlerItem swtmrHandle; 
  4.     UINT32 readSize; 
  5.     UINT32 ret; 
  6.     UINT64 tick; 
  7.     readSize = sizeof(SwtmrHandlerItem); 
  8.  
  9.     for (;;) { 
  10. ⑴      ret = LOS_QueueReadCopy(g_swtmrHandlerQueue, &swtmrHandle, &readSize, LOS_WAIT_FOREVER); 
  11.         if ((ret == LOS_OK) && (readSize == sizeof(SwtmrHandlerItem))) { 
  12.             if (swtmrHandle.handler == NULL) { 
  13.                 continue; 
  14.             } 
  15.  
  16.             tick = LOS_TickCountGet(); 
  17. ⑵          swtmrHandle.handler(swtmrHandle.arg); 
  18.             tick = LOS_TickCountGet() - tick; 
  19.  
  20. ⑶          if (tick >= SWTMR_MAX_RUNNING_TICKS) { 
  21.                 PRINT_WARN("timer_handler(%p) cost too many ms(%d)\n", 
  22.                            swtmrHandle.handler, 
  23.                            (UINT32)((tick * OS_SYS_MS_PER_SECOND) / LOSCFG_BASE_CORE_TICK_PER_SECOND)); 
  24.             } 
  25.         } 
  26.     } 
  27. } 

3、定时器常用操作

3.1 定时器创建

我们分析下创建定时器函数LOS_SwtmrCreate()的代码。先不考虑定时器对齐LOSCFG_BASE_CORE_SWTMR_ALIGN的情况。先看下函数参数，interval是定时器执行时间间隔，mode是创建的定时器模式，handler、arg是定时器回调函数及其参数。swtmrId是定时器编号。

⑴处对传入参数定时器超时间隔、定时器模式、回调函数，定时器编号进行校验。

⑵判断空闲定时器池是否为空，为空则返回错误，无法创建定时器。

⑶处如果定时器不为空，则获取定时器控制块swtmr。⑷处对定时器控制块信息进行初始化。

⑸处把该定时器排序链表节点的响应时间responseTime初始化为-1。

  1. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  2. LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval, 
  3.                                              UINT8 mode, 
  4.                                              SWTMR_PROC_FUNC handler, 
  5.                                              UINT32 *swtmrId, 
  6.                                              UINT32 arg, 
  7.                                              UINT8 rouses, 
  8.                                              UINT8 sensitive) 
  9. #else 
  10. LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval, 
  11.                                              UINT8 mode, 
  12.                                              SWTMR_PROC_FUNC handler, 
  13.                                              UINT32 *swtmrId, 
  14.                                              UINT32 arg) 
  15. #endif 
  16. { 
  17.     SWTMR_CTRL_S  *swtmr = NULL; 
  18.     UINT32 intSave; 
  19.  
  20. ⑴  if (interval == 0) { 
  21.         return LOS_ERRNO_SWTMR_INTERVAL_NOT_SUITED; 
  22.     } 
  23.  
  24.     if ((mode != LOS_SWTMR_MODE_ONCE) && 
  25.         (mode != LOS_SWTMR_MODE_PERIOD) && 
  26.         (mode != LOS_SWTMR_MODE_NO_SELFDELETE)) { 
  27.         return LOS_ERRNO_SWTMR_MODE_INVALID; 
  28.     } 
  29.  
  30.     if (handler == NULL) { 
  31.         return LOS_ERRNO_SWTMR_PTR_NULL; 
  32.     } 
  33.  
  34.     if (swtmrId == NULL) { 
  35.         return LOS_ERRNO_SWTMR_RET_PTR_NULL; 
  36.     } 
  37.  
  38. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  39.     if ((rouses != OS_SWTMR_ROUSES_IGNORE) && (rouses != OS_SWTMR_ROUSES_ALLOW)) { 
  40.         return OS_ERRNO_SWTMR_ROUSES_INVALID; 
  41.     } 
  42.  
  43.     if ((sensitive != OS_SWTMR_ALIGN_INSENSITIVE) && (sensitive != OS_SWTMR_ALIGN_SENSITIVE)) { 
  44.         return OS_ERRNO_SWTMR_ALIGN_INVALID; 
  45.     } 
  46. #endif 
  47.  
  48.     intSave = LOS_IntLock(); 
  49. ⑵  if (g_swtmrFreeList == NULL) { 
  50.         LOS_IntRestore(intSave); 
  51.         return LOS_ERRNO_SWTMR_MAXSIZE; 
  52.     } 
  53.  
  54. ⑶  swtmr = g_swtmrFreeList; 
  55.     g_swtmrFreeList = swtmr->pstNext; 
  56.     LOS_IntRestore(intSave); 
  57. ⑷  swtmr->pfnHandler    = handler; 
  58.     swtmr->ucMode        = mode; 
  59.     swtmr->uwInterval    = interval; 
  60.     swtmr->pstNext       = (SWTMR_CTRL_S *)NULL; 
  61.     swtmr->uwCount       = 0; 
  62.     swtmr->uwArg         = arg; 
  63. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  64.     swtmr->ucRouses      = rouses; 
  65.     swtmr->ucSensitive   = sensitive; 
  66. #endif 
  67.     swtmr->ucState       = OS_SWTMR_STATUS_CREATED; 
  68.     *swtmrId = swtmr->usTimerID; 
  69. ⑸  SET_SORTLIST_VALUE(&swtmr->stSortList, OS_SORT_LINK_INVALID_TIME); 
  70.  
  71.     return LOS_OK; 
  72. } 

3.2 定时器删除

我们可以使用函数LOS_SwtmrDelete(UINT32 swtmrId)来删除定时器，下面通过分析源码看看如何删除定时器的。

⑴处判断定时器swtmrId是否超过OS_SWTMR_MAX_TIMERID，如果超过则返回错误码。如果定时器编号没有问题，获取定时器控制块LosSwtmrCB *swtmr。

⑵处判断要删除的定时器swtmrId是否匹配，不匹配则返回错误码。

⑶处判断定时器的状态，如果定时器定时器没有创建，不能删除。如果定时器计时中，需要先停止OsSwtmrStop(swtmr)，然后再删除OsSwtmrDelete(swtmr)。

  1. LITE_OS_SEC_TEXT UINT32 LOS_SwtmrDelete(UINT32 swtmrId) 
  2. { 
  3.     SWTMR_CTRL_S *swtmr = NULL; 
  4.     UINT32 intSave; 
  5.     UINT32 ret = LOS_OK; 
  6.     UINT16 swtmrCbId; 
  7.  
  8. ⑴  if (swtmrId >= OS_SWTMR_MAX_TIMERID) { 
  9.         return LOS_ERRNO_SWTMR_ID_INVALID; 
  10.     } 
  11.     intSave = LOS_IntLock(); 
  12.     swtmrCbId = swtmrId % LOSCFG_BASE_CORE_SWTMR_LIMIT; 
  13.     swtmr = g_swtmrCBArray + swtmrCbId; 
  14. ⑵  if (swtmr->usTimerID != swtmrId) { 
  15.         LOS_IntRestore(intSave); 
  16.         return LOS_ERRNO_SWTMR_ID_INVALID; 
  17.     } 
  18.  
  19. ⑶  switch (swtmr->ucState) { 
  20.         case OS_SWTMR_STATUS_UNUSED: 
  21.             ret = LOS_ERRNO_SWTMR_NOT_CREATED; 
  22.             break; 
  23.         case OS_SWTMR_STATUS_TICKING: 
  24.             OsSwtmrStop(swtmr); 
  25.              
  26.         case OS_SWTMR_STATUS_CREATED: 
  27.             OsSwtmrDelete(swtmr); 
  28.             break; 
  29.         default: 
  30.             ret = LOS_ERRNO_SWTMR_STATUS_INVALID; 
  31.             break; 
  32.     } 
  33.  
  34.     LOS_IntRestore(intSave); 
  35.     return ret; 
  36. } 

接下来，我们继续看看如何调用函数OsSwtmrDelete(swtmr)删除定时器。函数特别简单，把定时器放入空闲定时器链表g_swtmrFreeList头部，然后把定时器状态改为未使用状态就完成了删除。

  1. STATIC_INLINE VOID OsSwtmrDelete(SWTMR_CTRL_S *swtmr) 
  2. { 
  3.      
  4.     swtmr->pstNext = g_swtmrFreeList; 
  5.     g_swtmrFreeList = swtmr; 
  6.     swtmr->ucState = OS_SWTMR_STATUS_UNUSED; 
  7.  
  8. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  9.     (VOID)memset_s((VOID *)&g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT], 
  10.                    sizeof(SwtmrAlignData), 0, sizeof(SwtmrAlignData)); 
  11. #endif 
  12. } 

3.3 定时器启动

创建完毕定时器后，我们可以使用函数LOS_SwtmrStart(UINT32 swtmrId)来启动定时器，下面通过分析源码看看如何启动定时器的。

⑴处判断定时器swtmrId是否超过OS_SWTMR_MAX_TIMERID，如果超过则返回错误码。如果定时器编号没有问题，获取定时器控制块LosSwtmrCB *swtmr。

⑵处判断要启动的定时器swtmrId是否匹配，不匹配则返回错误码。

⑶处判断定时器的状态，如果定时器定时器没有创建，不能启动。如果定时器计时中，需要先停止OsSwtmrStop(swtmr)，然后再启动OsSwtmrStart(swtmr)。

  1. LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStart(UINT32 swtmrId) 
  2. { 
  3.     UINT32 intSave; 
  4.     UINT32 ret = LOS_OK; 
  5.  
  6. ⑴  if (swtmrId >= OS_SWTMR_MAX_TIMERID) { 
  7.         return LOS_ERRNO_SWTMR_ID_INVALID; 
  8.     } 
  9.  
  10.     intSave = LOS_IntLock(); 
  11.     SWTMR_CTRL_S *swtmr = g_swtmrCBArray + swtmrId % LOSCFG_BASE_CORE_SWTMR_LIMIT; 
  12. ⑵  if (swtmr->usTimerID != swtmrId) { 
  13.         LOS_IntRestore(intSave); 
  14.         return LOS_ERRNO_SWTMR_ID_INVALID; 
  15.     } 
  16.  
  17. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  18.     if ((swtmr->ucSensitive == OS_SWTMR_ALIGN_INSENSITIVE) && (swtmr->ucMode == LOS_SWTMR_MODE_PERIOD)) { 
  19.         UINT32 swtmrAlignIdIndex = swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT; 
  20.         g_swtmrAlignID[swtmrAlignIdIndex].canAlign = 1; 
  21.         if ((swtmr->uwInterval % LOS_COMMON_DIVISOR) == 0) { 
  22.             g_swtmrAlignID[swtmrAlignIdIndex].canMultiple = 1; 
  23.             g_swtmrAlignID[swtmrAlignIdIndex].times = swtmr->uwInterval / LOS_COMMON_DIVISOR; 
  24.         } 
  25.     } 
  26. #endif 
  27.  
  28. ⑶  switch (swtmr->ucState) { 
  29.         case OS_SWTMR_STATUS_UNUSED: 
  30.             ret = LOS_ERRNO_SWTMR_NOT_CREATED; 
  31.             break; 
  32.         case OS_SWTMR_STATUS_TICKING: 
  33.             OsSwtmrStop(swtmr); 
  34.              
  35.         case OS_SWTMR_STATUS_CREATED: 
  36.             OsSwtmrStart(swtmr); 
  37.             break; 
  38.         default: 
  39.             ret = LOS_ERRNO_SWTMR_STATUS_INVALID; 
  40.             break; 
  41.     } 
  42.  
  43.     LOS_IntRestore(intSave); 
  44.     return ret; 
  45. } 

接下来，我们继续看看如何调用函数OsSwtmrStart(swtmr)启动定时器。函数特别简单，⑴设置定时器的等待超时时间，并把定时器状态改为计时中。⑵处把该定时器插入超时排序链表中。如果已使能任务调度，则修改过期时间。

  1. LITE_OS_SEC_TEXT VOID OsSwtmrStart(SWTMR_CTRL_S *swtmr) 
  2. { 
  3.     UINT64 currTime = OsGetCurrSchedTimeCycle(); 
  4.  
  5. ⑴  swtmr->uwCount = swtmr->uwInterval; 
  6.     swtmr->ucState = OS_SWTMR_STATUS_TICKING; 
  7.  
  8. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  9.     if ((g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].canAlign == 1) && 
  10.         (g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].isAligned == 0)) { 
  11.         g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].isAligned = 1; 
  12.         OsSwtmrFindAlignPos(currTime, swtmr); 
  13.     } 
  14. #endif 
  15. ⑵  OsAdd2SortLink(&swtmr->stSortList, currTime, swtmr->uwCount, OS_SORT_LINK_SWTMR); 
  16.     if (LOS_TaskIsRunning()) { 
  17. ⑶      OsSchedUpdateExpireTime(currTime); 
  18.     } 
  19. } 

3.4 定时器停止

我们可以使用函数LOS_SwtmrStop(UINT32 swtmrId)来停止定时器，下面通过分析源码看看如何停止定时器的。

⑴处判断定时器swtmrId是否超过OS_SWTMR_MAX_TIMERID，如果超过则返回错误码。如果定时器编号没有问题，获取定时器控制块LosSwtmrCB *swtmr。

⑵处判断要启动的定时器swtmrId是否匹配，不匹配则返回错误码。

⑶处判断定时器的状态，如果定时器定时器没有创建，没有启动，不能停止。如果定时器计时中，会继续调用OsSwtmrStop(swtmr)停止定时器。

  1. LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStop(UINT32 swtmrId) 
  2. { 
  3.     SWTMR_CTRL_S *swtmr = NULL; 
  4.     UINT32 intSave; 
  5.     UINT16 swtmrCbId; 
  6.     UINT32 ret = LOS_OK; 
  7.  
  8. ⑴  if (swtmrId >= OS_SWTMR_MAX_TIMERID) { 
  9.         return LOS_ERRNO_SWTMR_ID_INVALID; 
  10.     } 
  11.     intSave = LOS_IntLock(); 
  12.     swtmrCbId = swtmrId % LOSCFG_BASE_CORE_SWTMR_LIMIT; 
  13.     swtmr = g_swtmrCBArray + swtmrCbId; 
  14. ⑵  if (swtmr->usTimerID != swtmrId) { 
  15.         LOS_IntRestore(intSave); 
  16.         return LOS_ERRNO_SWTMR_ID_INVALID; 
  17.     } 
  18.  
  19. ⑶  switch (swtmr->ucState) { 
  20.         case OS_SWTMR_STATUS_UNUSED: 
  21.             ret = LOS_ERRNO_SWTMR_NOT_CREATED; 
  22.             break; 
  23.         case OS_SWTMR_STATUS_CREATED: 
  24.             ret = LOS_ERRNO_SWTMR_NOT_STARTED; 
  25.             break; 
  26.         case OS_SWTMR_STATUS_TICKING: 
  27.             OsSwtmrStop(swtmr); 
  28.             break; 
  29.         default: 
  30.             ret = LOS_ERRNO_SWTMR_STATUS_INVALID; 
  31.             break; 
  32.     } 
  33.  
  34.     LOS_IntRestore(intSave); 
  35.     return ret; 
  36. } 

接下来，我们继续看看如何调用函数OsSwtmrStop(swtmr)停止定时器。函数特别简单，⑴处从排序链表中删除该定时器的排序链表节点，更改定时器的状态。⑵如果已使能任务调度，则修改过期时间。

  1. LITE_OS_SEC_TEXT VOID OsSwtmrStop(SWTMR_CTRL_S *swtmr) 
  2. { 
  3. ⑴  OsDeleteSortLink(&swtmr->stSortList, OS_SORT_LINK_SWTMR); 
  4.     swtmr->ucState = OS_SWTMR_STATUS_CREATED; 
  5.  
  6.     if (LOS_TaskIsRunning()) { 
  7. ⑵       OsSchedUpdateExpireTime(OsGetCurrSchedTimeCycle()); 
  8. #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1) 
  9.         g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].isAligned = 0; 
  10. #endif 
  11.     } 
  12. } 

4、定时器和Tick时间关系

定时器加入到超时排序链表后，随时时间一个tick一个tick的逝去，需要不断的检查定时器是否超时到期。从之前的文章，已经知道系统每走过一个tick，系统就会调用一次Tick中断的处理函数OsTickHandler()，该函数会调用定时器扫描函数OsSwtmrScan()来扫描、更新定时器时间。我们看下OsSwtmrScan()的代码。

⑴处获取超时排序链表的链表节点listObject，

⑵判断排序链表是否为空，为空则返回。

⑶获取排序链表的下一个链表节点sortList。

⑷循环遍历超时排序链表上响应时间小于等于当前时间的链表节点，意味着定时器到期，需要处理定时器的回调函数。

⑸从超时排序链表中删除超时的节点，

⑹获取定时器控制块SWTMR_CTRL_S *swtmr，调用函数OsSwtmrTimeoutHandle(swtmr)执行定时器回调函数，并设置需要调度的标记needSchedule。

⑺如果超时排序链表为空则终止循环。

  1. STATIC BOOL OsSwtmrScan(VOID) 
  2. { 
  3.     BOOL needSchedule = FALSE; 
  4. ⑴  LOS_DL_LIST *listObject = &g_swtmrSortLinkList->sortLink; 
  5.  
  6. ⑵  if (LOS_ListEmpty(listObject)) { 
  7.         return needSchedule; 
  8.     } 
  9.  
  10. ⑶  SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode); 
  11.     UINT64 currTime = OsGetCurrSchedTimeCycle(); 
  12. ⑷  while (sortList->responseTime <= currTime) { 
  13. ⑸      OsDeleteNodeSortLink(g_swtmrSortLinkList, sortList); 
  14.  
  15. ⑹      SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList); 
  16.         OsSwtmrTimeoutHandle(swtmr); 
  17.  
  18.         needSchedule = TRUE; 
  19. ⑺      if (LOS_ListEmpty(listObject)) { 
  20.             break; 
  21.         } 
  22.  
  23.         sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode); 
  24.     } 
  25.  
  26.     return needSchedule; 
  27. } 

我们最后看下函数OsSwtmrTimeoutHandle()。

⑴处把定时器回调函数写入定时器队列。

⑵如果是一次性定时器，会把这个定时器删除，回收到空闲定时器链表，状态设置为未使用状态，然后更新定时器的编号timerId。

⑶如果定时器属于周期性定时器，重新启动定时器。

⑷如果是一次性定时器但不删除，则把定时器状态设置为创建状态。

  1. STATIC VOID OsSwtmrTimeoutHandle(SWTMR_CTRL_S *swtmr) 
  2. { 
  3.     SwtmrHandlerItem swtmrHandler; 
  4.  
  5.     swtmrHandler.handler = swtmr->pfnHandler; 
  6.     swtmrHandler.arg = swtmr->uwArg; 
  7.  
  8. ⑴  (VOID)LOS_QueueWriteCopy(g_swtmrHandlerQueue, &swtmrHandler, sizeof(SwtmrHandlerItem), LOS_NO_WAIT); 
  9. ⑵  if (swtmr->ucMode == LOS_SWTMR_MODE_ONCE) { 
  10.         OsSwtmrDelete(swtmr); 
  11.         if (swtmr->usTimerID < (OS_SWTMR_MAX_TIMERID - LOSCFG_BASE_CORE_SWTMR_LIMIT)) { 
  12.             swtmr->usTimerID += LOSCFG_BASE_CORE_SWTMR_LIMIT; 
  13.         } else { 
  14.             swtmr->usTimerID %= LOSCFG_BASE_CORE_SWTMR_LIMIT; 
  15.         } 
  16. ⑶  } else if (swtmr->ucMode == LOS_SWTMR_MODE_PERIOD) { 
  17.         OsSwtmrStart(swtmr); 
  18. ⑷  } else if (swtmr->ucMode == LOS_SWTMR_MODE_NO_SELFDELETE) { 
  19.         swtmr->ucState = OS_SWTMR_STATUS_CREATED; 
  20.     } 
  21. } 

小结

本文带领大家一起剖析了鸿蒙轻内核的定时器模块的源代码，包含定时器的结构体、定时器池初始化、定时器创建、删除、启动停止等。

想了解更多内容，请访问：

51CTO和华为官方合作共建的鸿蒙技术社区

https://harmonyos.51cto.com

 

来源：鸿蒙社区内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

鸿蒙轻内核M核源码分析系列九 软件定时器Swtmr

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列十四 软件定时器Swtmr

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列九互斥锁Mutex

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列之Musl LibC

后端开发鸿蒙HarmonyOS2024-12-02

鸿蒙轻内核M核源码分析系列之Newlib C

后端开发鸿蒙HarmonyOS2024-12-02

鸿蒙轻内核M核源码分析系列五-时间管理

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列十二事件Event

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列四中断Hwi

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列八 静态内存MemoryBox

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列之虚拟文件系统VFS

后端开发鸿蒙HarmonyOS2024-12-02

鸿蒙轻内核M核源码分析系列十三 消息队列Queue

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列七 动态内存Dynamic Memory

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列十一 信号量Semaphore

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列十五CPU使用率CPUP

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列十八Fault异常处理

后端开发鸿蒙HarmonyOS2024-12-02

鸿蒙轻内核A核源码分析系列八—事件Event

后端开发鸿蒙事件模块2024-12-02

鸿蒙轻内核M核源码分析系列十三（续） 消息队列QueueMail接口

后端开发鸿蒙HarmonyOS2024-12-02

鸿蒙轻内核M核源码分析系列二数据结构-任务就绪队列

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列三数据结构-任务排序链表

后端开发鸿蒙HarmonyOS2024-12-03

鸿蒙轻内核M核源码分析系列一 数据结构-双向循环链表

后端开发鸿蒙HarmonyOS2024-12-03
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯