• 基于STM32结合CubeMX学习Free-RT-OS的源码之深入学习软件定时器实现过程

    概述

    关于在CUBEMX上的配置

     介绍

            软件定时器基于硬件定时器实现。

            软件定时器允许设置一段时间，当设置的时间到达之后就执行指定的功能函数，被定时器
    调用的这个功能函数叫做定时器的回调函数。回调函数的两次执行间隔叫做定时器的定时周期，
    简而言之，软件定时器的定时周期到了以后就会执行回调函数。

            Free RT OS基于systick中断产生计数值。软件定时其开始计数，当计数值到了所设置的时间时执行回调函数。

            在RT-Thread中 软件定时器的定时回调函数直接放到了systick的中断回调函数里进行处理，但Free-RT-OS并没有这样做，主要原因是在于不知道定时处理回调函数需要花费多少时间，使得systick的节拍受到影响。

    那么软件定时器是如何处理回调函数的?

    答:Free RT OS创建了一个管理软件定时器的任务，叫做DaemonTask 也被称为守护任务，由它处理软件定时器的定时回调函数。
     

            Free RT OS允许用户自己选择是否使用软件定时器。

    当选择使用软件定时器时，Free RTOS内部的具体流程：  

    Free RT OS为管理软件定时器创建的 守护任务，定时器链表，超时链表，定时器命令队列。对应下面的代码。

    具体过程：

    1 ：  当使用了软件定时器，则在开启调度器时，创建Daemon Task(守护任务)

     osKernelStart() ->vTaskStartScheduler()（启动调度器）->    xTimerCreateTimerTask(); （创建守护任务)

    创建守护任务

    2：守护任务内部定时任务的函数入口   prvTimerTask

    3： 同时在创建内部调用  prvCheckForValidListAndQueue

      prvCheckForValidListAndQueue  (创建定时器命令队列，创建当前定时器链表和超时定时器链表。

      

    4：守护任务的函数入口 prvTimerTask

    • 查询计时器列表，看看它是否包含任何计时器，如果包含，获取下一个计时器将过期的时间。
    • 如果计时器已过期，则处理它。否则，阻塞此任务。直到计时器过期或收到命令为止。
    • 处理软件定时器的命令接受。（开启，关闭，调整周期，复位）

    到这，已经能摸清除软件定时器工作流程的大概了。

    以上都是RTOS内部为管理软件定时器所做的辅助工作。

    再看看创建软件定时器：

    软件定时器刚创建处于休眠态。

            调用开启软件定时器的API(xTimerStart)后则把封装一个message对象 ,写入定时器命令队列。（这个定时器命令队列就是在守护函数中所创建的那个）

    #define xTimerStart( xTimer, xTicksToWait )      xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xTicksToWait ) )

     //这个开启软件定时器的函数向定时器服务任务发送相应命令

    调用宏 xTimerGenericCommand( ( xTimer ) 发message到定时器命令队列

           

         同理，停止某个软件定时器,调整软件定时器的定时周期也是通过写命令队列的方式实现。

            不能在软件定时器的回调函数中调用会阻塞当前任务的API.(如不能调用 vTaskDelay()、vTaskDelayUnti()，还有一些访问队列或者信号量的非零阻塞时间的 API 函数也不能调用。） 
     

    为什么？因为软件定时器的回调函数都依赖于守护任务去处理实现其回调函数，在软件定时器的回调函数中阻塞则意味在守护任务中阻塞，守护任务将无法继续管理所有的软件定时器。

     

    再剖析守护任务的回调函数。

     

       prvGetNextExpireTime  获取定时器下一次超时时间。

    定时器列表（pxCurrentTimerList）按定时器的溢出时间按升序排列，最前面的任务首先超时。

    1. static TickType_t prvGetNextExpireTime( BaseType_t * const pxListWasEmpty )
    2. {
    3. TickType_t xNextExpireTime;
    4.  
    5. 	/* Timers are listed in expiry time order, with the head of the list
    6. 	referencing the task that will expire first.  Obtain the time at which
    7. 	the timer with the nearest expiry time will expire.  If there are no
    8. 	active timers then just set the next expire time to 0.  That will cause
    9. 	this task to unblock when the tick count overflows, at which point the
    10. 	timer lists will be switched and the next expiry time can be
    11. 	re-assessed.  */
    12. 	*pxListWasEmpty = listLIST_IS_EMPTY( pxCurrentTimerList );
    13. 	if( *pxListWasEmpty == pdFALSE )
    14. 	{
    15. 		xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );
    16. 	}
    17. 	else
    18. 	{
    19. 		/* Ensure the task unblocks when the tick count rolls over. */
    20. 		xNextExpireTime = ( TickType_t ) 0U;
    21. 	}
    22.  
    23. 	return xNextExpireTime;
    24. }

    prvProcessTimerOrBlock()  //处理软件定时器任务（溢出超时）  |  让软件定时器阻塞（未溢出）

    过程:

    取出当前systick的计数值，stm32默认以systick作为os的时基，而systick是24位计数器。

    把获取到的计数值与上一次进行比较，正常情况是现在的计数值>上一次计数值。若小于则计数值发生了溢出。

    1. static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime, BaseType_t xListWasEmpty )
    2. {
    3. TickType_t xTimeNow;
    4. BaseType_t xTimerListsWereSwitched;
    5.  
    6. 	vTaskSuspendAll();
    7. 	{
    8. 		/* Obtain the time now to make an assessment as to whether the timer
    9. 		has expired or not.  If obtaining the time causes the lists to switch
    10. 		then don't process this timer as any timers that remained in the list
    11. 		when the lists were switched will have been processed within the
    12. 		prvSampleTimeNow() function. */
    13. 		xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );
    14. 		if( xTimerListsWereSwitched == pdFALSE )
    15. 		{
    16. 			/* The tick count has not overflowed, has the timer expired? */
    17. 			if( ( xListWasEmpty == pdFALSE ) && ( xNextExpireTime <= xTimeNow ) )
    18. 			{
    19. 				( void ) xTaskResumeAll();
    20. 				prvProcessExpiredTimer( xNextExpireTime, xTimeNow );
    21. 			}
    22. 			else
    23. 			{
    24. 				/* The tick count has not overflowed, and the next expire
    25. 				time has not been reached yet.  This task should therefore
    26. 				block to wait for the next expire time or a command to be
    27. 				received - whichever comes first.  The following line cannot
    28. 				be reached unless xNextExpireTime > xTimeNow, except in the
    29. 				case when the current timer list is empty. */
    30. 				if( xListWasEmpty != pdFALSE )
    31. 				{
    32. 					/* The current timer list is empty - is the overflow list
    33. 					also empty? */
    34. 					xListWasEmpty = listLIST_IS_EMPTY( pxOverflowTimerList );
    35. 				}
    36.  
    37. 				vQueueWaitForMessageRestricted( xTimerQueue, ( xNextExpireTime - xTimeNow ), xListWasEmpty );
    38.  
    39. 				if( xTaskResumeAll() == pdFALSE )
    40. 				{
    41. 					/* Yield to wait for either a command to arrive, or the
    42. 					block time to expire.  If a command arrived between the
    43. 					critical section being exited and this yield then the yield
    44. 					will not cause the task to block. */
    45. 					portYIELD_WITHIN_API();
    46. 				}
    47. 				else
    48. 				{
    49. 					mtCOVERAGE_TEST_MARKER();
    50. 				}
    51. 			}
    52. 		}
    53. 		else
    54. 		{
    55. 			( void ) xTaskResumeAll();
    56. 		}
    57. 	}
    58. }

    处理软件定时器溢出任务（这个函数是最为关键的函数,更新下一次溢出值,并插入正确的链表中）

    1. static void prvProcessExpiredTimer( const TickType_t xNextExpireTime, const TickType_t xTimeNow )
    2. {
    3. BaseType_t xResult;
    4. Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList );
    5.  
    6. 	/* Remove the timer from the list of active timers.  A check has already
    7. 	been performed to ensure the list is not empty. */
    8. 	( void ) uxListRemove( &( pxTimer->xTimerListItem ) );
    9. 	traceTIMER_EXPIRED( pxTimer );
    10.  
    11. 	/* If the timer is an auto reload timer then calculate the next
    12. 	expiry time and re-insert the timer in the list of active timers. */
    13. 	if( pxTimer->uxAutoReload == ( UBaseType_t ) pdTRUE )
    14. 	{
    15. 		/* The timer is inserted into a list using a time relative to anything
    16. 		other than the current time.  It will therefore be inserted into the
    17. 		correct list relative to the time this task thinks it is now. */
    18. 		if( prvInsertTimerInActiveList( pxTimer, ( xNextExpireTime + pxTimer->xTimerPeriodInTicks ), xTimeNow, xNextExpireTime ) != pdFALSE )
    19. 		{
    20. 			/* The timer expired before it was added to the active timer
    21. 			list.  Reload it now.  */
    22. 			xResult = xTimerGenericCommand( pxTimer, tmrCOMMAND_START_DONT_TRACE, xNextExpireTime, NULL, tmrNO_DELAY );
    23. 			configASSERT( xResult );
    24. 			( void ) xResult;
    25. 		}
    26. 		else
    27. 		{
    28. 			mtCOVERAGE_TEST_MARKER();
    29. 		}
    30. 	}
    31. 	else
    32. 	{
    33. 		mtCOVERAGE_TEST_MARKER();
    34. 	}
    35.  
    36. 	/* Call the timer callback. */
    37. 	pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
    38. }

    prvProcessReceiveCommands()   //对定时器命令队列中的数据进行处理。

    遍历并处理定时器命令队列的所有message。

    1. static void	prvProcessReceivedCommands( void )
    2. {
    3. DaemonTaskMessage_t xMessage;
    4. Timer_t *pxTimer;
    5. BaseType_t xTimerListsWereSwitched, xResult;
    6. TickType_t xTimeNow;
    7.  
    8. 	while( xQueueReceive( xTimerQueue, &xMessage, tmrNO_DELAY ) != pdFAIL ) /*lint !e603 xMessage does not have to be initialised as it is passed out, not in, and it is not used unless xQueueReceive() returns pdTRUE. */
    9. 	{
    10. 		#if ( INCLUDE_xTimerPendFunctionCall == 1 )
    11. 		{
    12. 			/* Negative commands are pended function calls rather than timer
    13. 			commands. */
    14. 			if( xMessage.xMessageID < ( BaseType_t ) 0 )
    15. 			{
    16. 				const CallbackParameters_t * const pxCallback = &( xMessage.u.xCallbackParameters );
    17.  
    18. 				/* The timer uses the xCallbackParameters member to request a
    19. 				callback be executed.  Check the callback is not NULL. */
    20. 				configASSERT( pxCallback );
    21.  
    22. 				/* Call the function. */
    23. 				pxCallback->pxCallbackFunction( pxCallback->pvParameter1, pxCallback->ulParameter2 );
    24. 			}
    25. 			else
    26. 			{
    27. 				mtCOVERAGE_TEST_MARKER();
    28. 			}
    29. 		}
    30. 		#endif /* INCLUDE_xTimerPendFunctionCall */
    31.  
    32. 		/* Commands that are positive are timer commands rather than pended
    33. 		function calls. */
    34. 		if( xMessage.xMessageID >= ( BaseType_t ) 0 )
    35. 		{
    36. 			/* The messages uses the xTimerParameters member to work on a
    37. 			software timer. */
    38. 			pxTimer = xMessage.u.xTimerParameters.pxTimer;
    39.  
    40. 			if( listIS_CONTAINED_WITHIN( NULL, &( pxTimer->xTimerListItem ) ) == pdFALSE ) /*lint !e961. The cast is only redundant when NULL is passed into the macro. */
    41. 			{
    42. 				/* The timer is in a list, remove it. */
    43. 				( void ) uxListRemove( &( pxTimer->xTimerListItem ) );
    44. 			}
    45. 			else
    46. 			{
    47. 				mtCOVERAGE_TEST_MARKER();
    48. 			}
    49.  
    50. 			traceTIMER_COMMAND_RECEIVED( pxTimer, xMessage.xMessageID, xMessage.u.xTimerParameters.xMessageValue );
    51.  
    52. 			/* In this case the xTimerListsWereSwitched parameter is not used, but
    53. 			it must be present in the function call.  prvSampleTimeNow() must be
    54. 			called after the message is received from xTimerQueue so there is no
    55. 			possibility of a higher priority task adding a message to the message
    56. 			queue with a time that is ahead of the timer daemon task (because it
    57. 			pre-empted the timer daemon task after the xTimeNow value was set). */
    58. 			xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );
    59.  
    60. 			switch( xMessage.xMessageID )
    61. 			{
    62. 				case tmrCOMMAND_START :
    63. 			    case tmrCOMMAND_START_FROM_ISR :
    64. 			    case tmrCOMMAND_RESET :
    65. 			    case tmrCOMMAND_RESET_FROM_ISR :
    66. 				case tmrCOMMAND_START_DONT_TRACE :
    67. 					/* Start or restart a timer. */
    68. 					if( prvInsertTimerInActiveList( pxTimer,  xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow, xMessage.u.xTimerParameters.xMessageValue ) != pdFALSE )
    69. 					{
    70. 						/* The timer expired before it was added to the active
    71. 						timer list.  Process it now. */
    72. 						pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
    73. 						traceTIMER_EXPIRED( pxTimer );
    74.  
    75. 						if( pxTimer->uxAutoReload == ( UBaseType_t ) pdTRUE )
    76. 						{
    77. 							xResult = xTimerGenericCommand( pxTimer, tmrCOMMAND_START_DONT_TRACE, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, NULL, tmrNO_DELAY );
    78. 							configASSERT( xResult );
    79. 							( void ) xResult;
    80. 						}
    81. 						else
    82. 						{
    83. 							mtCOVERAGE_TEST_MARKER();
    84. 						}
    85. 					}
    86. 					else
    87. 					{
    88. 						mtCOVERAGE_TEST_MARKER();
    89. 					}
    90. 					break;
    91.  
    92. 				case tmrCOMMAND_STOP :
    93. 				case tmrCOMMAND_STOP_FROM_ISR :
    94. 					/* The timer has already been removed from the active list.
    95. 					There is nothing to do here. */
    96. 					break;
    97.  
    98. 				case tmrCOMMAND_CHANGE_PERIOD :
    99. 				case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR :
    100. 					pxTimer->xTimerPeriodInTicks = xMessage.u.xTimerParameters.xMessageValue;
    101. 					configASSERT( ( pxTimer->xTimerPeriodInTicks > 0 ) );
    102.  
    103. 					/* The new period does not really have a reference, and can
    104. 					be longer or shorter than the old one.  The command time is
    105. 					therefore set to the current time, and as the period cannot
    106. 					be zero the next expiry time can only be in the future,
    107. 					meaning (unlike for the xTimerStart() case above) there is
    108. 					no fail case that needs to be handled here. */
    109. 					( void ) prvInsertTimerInActiveList( pxTimer, ( xTimeNow + pxTimer->xTimerPeriodInTicks ), xTimeNow, xTimeNow );
    110. 					break;
    111.  
    112. 				case tmrCOMMAND_DELETE :
    113. 					/* The timer has already been removed from the active list,
    114. 					just free up the memory if the memory was dynamically
    115. 					allocated. */
    116. 					#if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
    117. 					{
    118. 						/* The timer can only have been allocated dynamically -
    119. 						free it again. */
    120. 						vPortFree( pxTimer );
    121. 					}
    122. 					#elif( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
    123. 					{
    124. 						/* The timer could have been allocated statically or
    125. 						dynamically, so check before attempting to free the
    126. 						memory. */
    127. 						if( pxTimer->ucStaticallyAllocated == ( uint8_t ) pdFALSE )
    128. 						{
    129. 							vPortFree( pxTimer );
    130. 						}
    131. 						else
    132. 						{
    133. 							mtCOVERAGE_TEST_MARKER();
    134. 						}
    135. 					}
    136. 					#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
    137. 					break;
    138.  
    139. 				default	:
    140. 					/* Don't expect to get here. */
    141. 					break;
    142. 			}
    143. 		}
    144. 	}
    145. }

    参考:

    FreeRTOS源码探析之——软件定时器 - 墨天轮 (modb.pro)

  • 相关阅读:
    基于Struts2开发仓库管理系统
    使用docker-compose搭建mysql主从复制
    vue中Computed、Methods、Watch区别
    TensorRT--学习笔记
    vue 或 js 使用谷歌翻译实现国际化
    今天给大家介绍一篇基基于SSM超市管理系统的设计与实现
    gan与dcgan训练自己的数据集
    程序员都不知道的代码
    Java面试题：通过实例说明工厂模式和抽象工厂模式的用法，以及它们在解耦中的作用
    Java项目：ssm汽车租赁系统
  • 原文地址：https://blog.csdn.net/PHILICS7/article/details/127874851