• FreeRTOS个人笔记-支持时间片

    根据个人的学习方向，学习FreeRTOS。由于野火小哥把FreeRTOS讲得比较含蓄，打算在本专栏尽量细化一点。作为个人笔记，仅供参考或查阅。

    配套资料：FreeRTOS内核实现与应用开发实战指南、野火FreeRTOS配套视频源码、b站野火FreeRTOS视频。搭配来看更佳哟！！！

    支持时间片

    FreeRTOS与RT-Thread和uC/OS一样，都支持时间片功能。

    时间片：同一优先级下可以有多个任务，每个任务轮流地享有相同的CPU时间。享有相同的CPU时间称为时间片。

    在FreeRTOS中，最小的时间单位为1个tick，即SysTick的中断周期，时间片只能是一个tick。RT-Thread和uC/OS可以指定时间片的大小为多个tick。

    时间片测试实验

    假设目前系统中有三个任务就绪（算上空闲任务就是4个），Task1和Task2的优先级为2，Task3的优先级为3。IdeaTask的优先级默认为0。

    为了方便在逻辑分析仪中分辨出Task1和Task2使用的时间片大小， Task1和Task2的主体编写成一个无限循环函数（优先级低于2的Task就会被饿死，得不到执行，比如idleTask），不会阻塞，Task3的阻塞时间设置为1个tick。在真正的项目中，不会这么写，这只是为了实验方便。

    main函数如下

    1. /*
    2. *************************************************************************
    3. *                              全局变量
    4. *************************************************************************
    5. */
    6. portCHAR flag1;
    7. portCHAR flag2;
    8. portCHAR flag3;
    9.  
    10. extern List_t pxReadyTasksLists[ configMAX_PRIORITIES ];
    11.  
    12. /*
    13. *************************************************************************
    14. *                        任务控制块 & STACK 
    15. *************************************************************************
    16. */
    17. TaskHandle_t Task1_Handle;
    18. #define TASK1_STACK_SIZE                    128
    19. StackType_t Task1Stack[TASK1_STACK_SIZE];
    20. TCB_t Task1TCB;
    21.  
    22. TaskHandle_t Task2_Handle;
    23. #define TASK2_STACK_SIZE                    128
    24. StackType_t Task2Stack[TASK2_STACK_SIZE];
    25. TCB_t Task2TCB;
    26.  
    27. TaskHandle_t Task3_Handle;
    28. #define TASK3_STACK_SIZE                    128
    29. StackType_t Task3Stack[TASK3_STACK_SIZE];
    30. TCB_t Task3TCB;
    31.  
    32. /*
    33. *************************************************************************
    34. *                               函数声明 
    35. *************************************************************************
    36. */
    37. void delay (uint32_t count);
    38. void Task1_Entry( void *p_arg );
    39. void Task2_Entry( void *p_arg );
    40. void Task3_Entry( void *p_arg );
    41.  
    42.  
    43. /*
    44. ************************************************************************
    45. *                                main函数
    46. ************************************************************************
    47. */
    48. int main(void)
    49. {	
    50.     /* 硬件初始化 */
    51. 	/* 将硬件相关的初始化放在这里，如果是软件仿真则没有相关初始化代码 */
    52.     
    53.     /* 创建任务 */
    54.     Task1_Handle = xTaskCreateStatic( (TaskFunction_t)Task1_Entry,   /* 任务入口 */
    55. 					                  (char *)"Task1",               /* 任务名称，字符串形式 */
    56. 					                  (uint32_t)TASK1_STACK_SIZE ,   /* 任务栈大小，单位为字 */
    57. 					                  (void *) NULL,                 /* 任务形参 */
    58.                                       (UBaseType_t) 2,               /* 任务优先级，数值越大，优先级越高 */
    59. 					                  (StackType_t *)Task1Stack,     /* 任务栈起始地址 */
    60. 					                  (TCB_t *)&Task1TCB );          /* 任务控制块 */
    61.                                 
    62.     Task2_Handle = xTaskCreateStatic( (TaskFunction_t)Task2_Entry,   /* 任务入口 */
    63. 					                  (char *)"Task2",               /* 任务名称，字符串形式 */
    64. 					                  (uint32_t)TASK2_STACK_SIZE ,   /* 任务栈大小，单位为字 */
    65. 					                  (void *) NULL,                 /* 任务形参 */
    66.                                       (UBaseType_t) 2,               /* 任务优先级，数值越大，优先级越高 */                                          
    67. 					                  (StackType_t *)Task2Stack,     /* 任务栈起始地址 */
    68. 					                  (TCB_t *)&Task2TCB );          /* 任务控制块 */
    69.                                       
    70.     Task3_Handle = xTaskCreateStatic( (TaskFunction_t)Task3_Entry,   /* 任务入口 */
    71. 					                  (char *)"Task3",               /* 任务名称，字符串形式 */
    72. 					                  (uint32_t)TASK3_STACK_SIZE ,   /* 任务栈大小，单位为字 */
    73. 					                  (void *) NULL,                 /* 任务形参 */
    74.                                       (UBaseType_t) 3,               /* 任务优先级，数值越大，优先级越高 */                                          
    75. 					                  (StackType_t *)Task3Stack,     /* 任务栈起始地址 */
    76. 					                  (TCB_t *)&Task3TCB );          /* 任务控制块 */                                      
    77.                                       
    78.     portDISABLE_INTERRUPTS();
    79.                                       
    80.     /* 启动调度器，开始多任务调度，启动成功则不返回 */
    81.     vTaskStartScheduler();                                      
    82.     
    83.     for(;;)
    84. 	{
    85. 		/* 系统启动成功不会到达这里 */
    86. 	}
    87. }
    88.  
    89. /*
    90. *************************************************************************
    91. *                               函数实现
    92. *************************************************************************
    93. */
    94. /* 软件延时 */
    95. void delay (uint32_t count)
    96. {
    97. 	for(; count!=0; count--);
    98. }
    99. /* 任务1 */
    100. void Task1_Entry( void *p_arg )
    101. {
    102. 	for( ;; )
    103. 	{
    104. 		flag1 = 1;
    105.         //vTaskDelay( 1 );
    106.         delay (100);		
    107. 		flag1 = 0;
    108.         delay (100);
    109.         //vTaskDelay( 1 );        
    110. 	}
    111. }
    112.  
    113. /* 任务2 */
    114. void Task2_Entry( void *p_arg )
    115. {
    116. 	for( ;; )
    117. 	{
    118. 		flag2 = 1;
    119.         //vTaskDelay( 1 );
    120.         delay (100);		
    121. 		flag2 = 0;
    122.         delay (100);
    123.         //vTaskDelay( 1 );        
    124. 	}
    125. }
    126.  
    127.  
    128. void Task3_Entry( void *p_arg )
    129. {
    130. 	for( ;; )
    131. 	{
    132. 		flag3 = 1;
    133.         vTaskDelay( 1 );
    134.         //delay (100);		
    135. 		flag3 = 0;
    136.         vTaskDelay( 1 );
    137.         //delay (100);
    138. 	}
    139. }
    140.  
    141. /* 获取空闲任务的内存 */
    142. StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
    143. TCB_t IdleTaskTCB;
    144. void vApplicationGetIdleTaskMemory( TCB_t **ppxIdleTaskTCBBuffer, 
    145.                                     StackType_t **ppxIdleTaskStackBuffer, 
    146.                                     uint32_t *pulIdleTaskStackSize )
    147. {
    148. 		*ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    149. 		*ppxIdleTaskStackBuffer=IdleTaskStack; 
    150. 		*pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    151. }

    进入软件调试，全速运行程序，从逻辑分析仪中可以看出Task1和Task2轮流执行，每一次运行的时间等于Task3中flag3输出高电平或低电平的时间，即一个tick。

     

    之所以在同一个优先级下可以有多个任务，最终还是得益于taskRESET_READY_PRIORITY()和taskSELECT_HIGHEST_PRIORITY_TASK()这两个函数。

    系统在任务切换的时候总会从就绪列表中寻找优先级最高的任务来执行，寻找优先级最高的任务。

    这个功能由 taskSELECT_HIGHEST_PRIORITY_TASK()函数来实现，该函数在 task.c 中定义。

    目前我们的实验是在优先级 2 上有任务 1和任务 2，假设任务 1 运行了一个 tick，那接下来再从对应优先级 2 的就绪列表上选择任务来运行就应该是选择任务 2？怎么选择，代码上
    怎么实现？奥妙就在 listGET_OWNER_OF_NEXT_ENTRY()函数中，该函数在 list.h 中定义。

    前面还谈到了另一个函数，taskRESET_READY_PRIORITY()。

    1. #define taskRESET_READY_PRIORITY( uxPriority )	\
    2. {												\
    3. 	if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ ( uxPriority ) ] ) ) == ( UBaseType_t ) 0 )	\
    4. 	{				\
    5. 		portRESET_READY_PRIORITY( ( uxPriority ), ( uxTopReadyPriority ) );	\
    6. 	}																		\
    7. }

    taskRESET_READY_PRIORITY() 函 数 的 妙 处 在 于 清 除 优 先 级 位 图 表 uxTopReadyPriority 中相应的位时候，会先判断当前优先级链表下是否还有其它任务，如果有则不清零。
    假设当前实验中，任务 1 会调用 vTaskDelay()，会将自己挂起，只能是将任务 1 从就绪列表删除，不能将任务 1 在优先级位图表 uxTopReadyPriority 中对应的位清 0，因为该优先级下还有任务 2，否则任务 2 将得不到执行。
     

    当xTaskIncrementTick()函数返回为真时才进行任务切换， 原来的 xTaskIncrementTick()是不带返回值的， 执行到最后会调用 taskYIELD()执行任务切换。

    xTaskIncrementTick()函数如下

    1. /*
    2. *************************************************************************
    3. *                             SysTick中断服务函数
    4. *************************************************************************
    5. */
    6. void xPortSysTickHandler( void )
    7. {
    8. 	/* 关中断 */
    9.     vPortRaiseBASEPRI();
    10.     
    11.     {
    12.         //xTaskIncrementTick();
    13.         
    14.         /* 更新系统时基 */
    15. 		if( xTaskIncrementTick() != pdFALSE )
    16. 		{
    17. 			/* 任务切换，即触发PendSV */
    18.             //portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
    19.             taskYIELD();
    20. 		}
    21. 	}
    22.  
    23. 	/* 开中断 */
    24.     vPortClearBASEPRIFromISR();
    25. }

    xTaskIncrementTick()函数如下

    1. //返回值为pdTrue时，需要执行一次任务切换
    2. BaseType_t xTaskIncrementTick( void )
    3. {
    4. 	TCB_t * pxTCB;
    5. 	TickType_t xItemValue;    
    6.     BaseType_t xSwitchRequired = pdFALSE;    //默认返回值
    7.     
    8. 	const TickType_t xConstTickCount = xTickCount + 1;
    9. 	xTickCount = xConstTickCount;
    10.  
    11. 	/* 如果xConstTickCount溢出，则切换延时列表 */
    12. 	if( xConstTickCount == ( TickType_t ) 0U )
    13. 	{
    14. 		taskSWITCH_DELAYED_LISTS();
    15. 	}
    16.  
    17. 	/* 最近的延时任务延时到期 */
    18. 	if( xConstTickCount >= xNextTaskUnblockTime )
    19. 	{
    20. 		for( ;; )
    21. 		{
    22. 			if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )
    23. 			{
    24. 				/* 延时列表为空，设置xNextTaskUnblockTime为可能的最大值 */
    25. 				xNextTaskUnblockTime = portMAX_DELAY;
    26. 				break;
    27. 			}
    28. 			else /* 延时列表不为空 */
    29. 			{
    30. 				pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );
    31. 				xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xStateListItem ) );
    32.  
    33. 				/* 直到将延时列表中所有延时到期的任务移除才跳出for循环 */
    34.                 if( xConstTickCount < xItemValue )
    35. 				{
    36. 					xNextTaskUnblockTime = xItemValue;
    37. 					break;
    38. 				}
    39.  
    40. 				/* 将任务从延时列表移除，消除等待状态 */
    41. 				( void ) uxListRemove( &( pxTCB->xStateListItem ) );
    42.  
    43. 				/* 将解除等待的任务添加到就绪列表 */
    44. 				prvAddTaskToReadyList( pxTCB );
    45.                 
    46.  
    47.                 #if (  configUSE_PREEMPTION == 1 )    //宏，默认设为1
    48.                 {   
    49.                     //有任务就绪且就绪任务的优先级比当前优先级高时
    50.                     if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
    51.                     {       
    52.                         xSwitchRequired = pdTRUE;    //需要执行一次任务切换
    53.                     }
    54.                 }
    55.                 #endif /* configUSE_PREEMPTION */
    56. 			}
    57. 		}
    58. 	}/* xConstTickCount >= xNextTaskUnblockTime */
    59.     
    60.     //时间片功能相关
    61.     #if ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) )
    62.     {
    63.         //当前优先级下不止一个任务时
    64.         if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ pxCurrentTCB->uxPriority ] ) ) 
    65.                                      > ( UBaseType_t ) 1 )
    66.         {
    67.             xSwitchRequired = pdTRUE;    //执行一次任务切换
    68.         }
    69.     }
    70.     #endif /* ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) ) */
    71.     
    72.     
    73.     /* 任务切换 */
    74.     //portYIELD();
    75. }

    这节没什么好写的，看不懂的话多看看配套文档和源码。

  • 相关阅读:
    1527. 患某种疾病的患者
    Hbase和Clickhouse对比简单总结
    【浅谈DBA 最重要的素质---读书笔记】
    秋招每日一题T31——二叉搜索子树的最大键值和
    基于yolov3的行人目标检测算法在图像和视频中识别检测
    vue播放报警音实现过程
    IP地址处理攻略：数据库中的存储与转换方法
    java毕业生设计中华二十四节气文化传承宣展平台计算机源码+系统+mysql+调试部署+lw
    【角点检测】 基于各向异性高斯方向导数滤波器实现图像角点检测附matlab代码
    《windows核心编程》第1章 错误处理
  • 原文地址：https://blog.csdn.net/weixin_47077788/article/details/125872315