【FreeRTOS】提高任务的优先级之后没有立马执行该任务

XUYILUO

1. 这里按照《FreeRTOS实时内核使用指南》------中文译文，更改任务优先级的例程

复制代码

1. static void TASK1_task(void *pvParameters)
   
2. {
   
3.         unsigned portBASE_TYPE uxPriority;
   
4.         uxPriority = uxTaskPriorityGet(NULL);
   
5.         for(;;)
   
6.         {
   
7.                 printf("TASK1 is running\r\n");
   
8.                 printf("raise the TASK2 priority,%d\r\n",(uxPriority+1));
   
9.                 vTaskPrioritySet(TASK2_Handler,(uxPriority+1) );
   
10.                 //vTaskDelay(1);
    
11.         }
    
12. }
    
13. 
    
14. static void TASK2_task(void *pvParameters)
    
15. {
    
16.         unsigned portBASE_TYPE uxPriority;
    
17.         uxPriority = uxTaskPriorityGet(NULL);
    
18.         for(;;)
    
19.         {
    
20.                 printf("TASK2 is running\r\n");
    
21.                 printf("lower the TASK2 priority,%d\r\n",(uxPriority-2));
    
22.                 vTaskPrioritySet(NULL,(uxPriority-2) );
    
23.                 //vTaskDelay(1);
    
24.         }
    
25. }
    
26. 
    
27. void TaskInit(void)
    
28. {
    
29. 
    
30.         xTaskCreate((TaskFunction_t )TASK1_task,
    
31.                                 (const char*    )"TASK1",
    
32.                                 (uint16_t       )configMINIMAL_STACK_SIZE,
    
33.                                 (void*          )NULL,
    
34.                                 (UBaseType_t    )1,
    
35.                                 (TaskHandle_t*  )NULL);
    
36.         xTaskCreate((TaskFunction_t )TASK2_task,
    
37.                                 (const char*    )"TASK2",
    
38.                                 (uint16_t       )configMINIMAL_STACK_SIZE,
    
39.                                 (void*          )NULL,
    
40.                                 (UBaseType_t    )2,
    
41.                                 (TaskHandle_t*  )&TASK2_Handler);
    
42. }
    

复制代码

ChenRyan

把优先级部分代码也截图看看

XUYILUO

1. #if ( INCLUDE_vTaskPrioritySet == 1 )
   
2. 
   
3.         void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority )
   
4.         {
   
5.         TCB_t *pxTCB;
   
6.         UBaseType_t uxCurrentBasePriority, uxPriorityUsedOnEntry;
   
7.         BaseType_t xYieldRequired = pdFALSE;
   
8. 
   
9.                 configASSERT( ( uxNewPriority < configMAX_PRIORITIES ) );
   
10. 
    
11.                 /* Ensure the new priority is valid. */
    
12.                 if( uxNewPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
    
13.                 {
    
14.                         uxNewPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
    
15.                 }
    
16.                 else
    
17.                 {
    
18.                         mtCOVERAGE_TEST_MARKER();
    
19.                 }
    
20. 
    
21.                 taskENTER_CRITICAL();
    
22.                 {
    
23.                         /* If null is passed in here then it is the priority of the calling
    
24.                         task that is being changed. */
    
25.                         pxTCB = prvGetTCBFromHandle( xTask );
    
26. 
    
27.                         traceTASK_PRIORITY_SET( pxTCB, uxNewPriority );
    
28. 
    
29.                         #if ( configUSE_MUTEXES == 1 )
    
30.                         {
    
31.                                 uxCurrentBasePriority = pxTCB->uxBasePriority;
    
32.                         }
    
33.                         #else
    
34.                         {
    
35.                                 uxCurrentBasePriority = pxTCB->uxPriority;
    
36.                         }
    
37.                         #endif
    
38. 
    
39.                         if( uxCurrentBasePriority != uxNewPriority )
    
40.                         {
    
41.                                 /* The priority change may have readied a task of higher
    
42.                                 priority than the calling task. */
    
43.                                 if( uxNewPriority > uxCurrentBasePriority )
    
44.                                 {
    
45.                                         if( pxTCB != pxCurrentTCB )
    
46.                                         {
    
47.                                                 /* The priority of a task other than the currently
    
48.                                                 running task is being raised.  Is the priority being
    
49.                                                 raised above that of the running task? */
    
50.                                                 if( uxNewPriority >= pxCurrentTCB->uxPriority )
    
51.                                                 {
    
52.                                                         xYieldRequired = pdTRUE;
    
53.                                                 }
    
54.                                                 else
    
55.                                                 {
    
56.                                                         mtCOVERAGE_TEST_MARKER();
    
57.                                                 }
    
58.                                         }
    
59.                                         else
    
60.                                         {
    
61.                                                 /* The priority of the running task is being raised,
    
62.                                                 but the running task must already be the highest
    
63.                                                 priority task able to run so no yield is required. */
    
64.                                         }
    
65.                                 }
    
66.                                 else if( pxTCB == pxCurrentTCB )
    
67.                                 {
    
68.                                         /* Setting the priority of the running task down means
    
69.                                         there may now be another task of higher priority that
    
70.                                         is ready to execute. */
    
71.                                         xYieldRequired = pdTRUE;
    
72.                                 }
    
73.                                 else
    
74.                                 {
    
75.                                         /* Setting the priority of any other task down does not
    
76.                                         require a yield as the running task must be above the
    
77.                                         new priority of the task being modified. */
    
78.                                 }
    
79. 
    
80.                                 /* Remember the ready list the task might be referenced from
    
81.                                 before its uxPriority member is changed so the
    
82.                                 taskRESET_READY_PRIORITY() macro can function correctly. */
    
83.                                 uxPriorityUsedOnEntry = pxTCB->uxPriority;
    
84. 
    
85.                                 #if ( configUSE_MUTEXES == 1 )
    
86.                                 {
    
87.                                         /* Only change the priority being used if the task is not
    
88.                                         currently using an inherited priority. */
    
89.                                         if( pxTCB->uxBasePriority == pxTCB->uxPriority )
    
90.                                         {
    
91.                                                 pxTCB->uxPriority = uxNewPriority;
    
92.                                         }
    
93.                                         else
    
94.                                         {
    
95.                                                 mtCOVERAGE_TEST_MARKER();
    
96.                                         }
    
97. 
    
98.                                         /* The base priority gets set whatever. */
    
99.                                         pxTCB->uxBasePriority = uxNewPriority;
    
100.                                 }
     
101.                                 #else
     
102.                                 {
     
103.                                         pxTCB->uxPriority = uxNewPriority;
     
104.                                 }
     
105.                                 #endif
     
106. 
     
107.                                 /* Only reset the event list item value if the value is not
     
108.                                 being used for anything else. */
     
109.                                 if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0UL )
     
110.                                 {
     
111.                                         listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxNewPriority ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
     
112.                                 }
     
113.                                 else
     
114.                                 {
     
115.                                         mtCOVERAGE_TEST_MARKER();
     
116.                                 }
     
117. 
     
118.                                 /* If the task is in the blocked or suspended list we need do
     
119.                                 nothing more than change it's priority variable. However, if
     
120.                                 the task is in a ready list it needs to be removed and placed
     
121.                                 in the list appropriate to its new priority. */
     
122.                                 if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xStateListItem ) ) != pdFALSE )
     
123.                                 {
     
124.                                         /* The task is currently in its ready list - remove before adding
     
125.                                         it to it's new ready list.  As we are in a critical section we
     
126.                                         can do this even if the scheduler is suspended. */
     
127.                                         if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
     
128.                                         {
     
129.                                                 /* It is known that the task is in its ready list so
     
130.                                                 there is no need to check again and the port level
     
131.                                                 reset macro can be called directly. */
     
132.                                                 portRESET_READY_PRIORITY( uxPriorityUsedOnEntry, uxTopReadyPriority );
     
133.                                         }
     
134.                                         else
     
135.                                         {
     
136.                                                 mtCOVERAGE_TEST_MARKER();
     
137.                                         }
     
138.                                         prvAddTaskToReadyList( pxTCB );
     
139.                                 }
     
140.                                 else
     
141.                                 {
     
142.                                         mtCOVERAGE_TEST_MARKER();
     
143.                                 }
     
144. 
     
145.                                 if( xYieldRequired != pdFALSE )
     
146.                                 {
     
147.                                         taskYIELD_IF_USING_PREEMPTION();
     
148.                                 }
     
149.                                 else
     
150.                                 {
     
151.                                         mtCOVERAGE_TEST_MARKER();
     
152.                                 }
     
153. 
     
154.                                 /* Remove compiler warning about unused variables when the port
     
155.                                 optimised task selection is not being used. */
     
156.                                 ( void ) uxPriorityUsedOnEntry;
     
157.                         }
     
158.                 }
     
159.                 taskEXIT_CRITICAL();
     
160.         }
     
161. 
     
162. #endif /* INCLUDE_vTaskPrioritySet */

复制代码

XUYILUO

ChenRyan 发表于 2022-8-5 18:20
把优先级部分代码也截图看看

优先级部分代码是指？？
就只有这两个任务，我在TASK1中提高TASK2的优先级，之后不是应该直接被TASK2抢占CPU使用权，直接执行TASK2？但是看打印是执行了两次TASK1之后，TASK2才开始执行，不太理解为什么，难道在vTaskPrioritySet里面不会发生任务调度吗？

如果在提高TASK2优先级之后加上vTaskDelay(1);里面会执行一次任务调度，然后直接转到TASK1运行，这个感觉就跟预想的逻辑一样了
static void TASK1_task(void *pvParameters)
{
        unsigned portBASE_TYPE uxPriority;
        uxPriority = uxTaskPriorityGet(NULL);
        for(;;)
        {
                printf("TASK1 is running\r\n");
                printf("raise the TASK2 priority,%d\r\n",(uxPriority+1));
                vTaskPrioritySet(TASK2_Handler,(uxPriority+1) );
                //vTaskDelay(1);
        }
}

static void TASK2_task(void *pvParameters)
{
        unsigned portBASE_TYPE uxPriority;
        uxPriority = uxTaskPriorityGet(NULL);
        for(;;)
        {
                printf("TASK2 is running\r\n");
                printf("lower the TASK2 priority,%d\r\n",(uxPriority-2));
                vTaskPrioritySet(NULL,(uxPriority-2) );
                //vTaskDelay(1);
        }
}
void TaskInit(void)
{

        xTaskCreate((TaskFunction_t )TASK1_task,
                                (const char*    )"TASK1",
                                (uint16_t       )configMINIMAL_STACK_SIZE,
                                (void*          )NULL,
                                (UBaseType_t    )1,
                                (TaskHandle_t*  )NULL);
        xTaskCreate((TaskFunction_t )TASK2_task,
                                (const char*    )"TASK2",
                                (uint16_t       )configMINIMAL_STACK_SIZE,
                                (void*          )NULL,
                                (UBaseType_t    )2,
                                (TaskHandle_t*  )&TASK2_Handler);
}

橘子汁真好喝

你提升优先级之后，不在自己加vtaskdelay这种调度函数，起码也要等到滴答定时器中断这种，才能有机会执行任务调度