FreeRTOS互斥信号量实验结果和二值信号量实验结果一样，这个是怎么回事呢？？

超级无敌磊果果

这是程序，就一个互斥信号量的基础运用实验，但是他硬是不行，high_task请求高优先级任务的时候 low_task占用互斥信号量，那他的优先级应该会被临时拉高到high_task一样的优先级，使得medium_task任务阻塞，但是程序跑起来，中等优先级任务并未被阻塞

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   
7. #include "./KEY/key.h"
   
8. #include "./TIM_Basic/tim_basic.h"
   
9. #include "semphr.h"
   
10. 
    
11. //任务优先级
    
12. #define START_TASK_PRIO                1
    
13. //任务堆栈大小        
    
14. #define START_STK_SIZE                 128  
    
15. //任务句柄
    
16. TaskHandle_t StartTask_Handler;
    
17. //任务函数
    
18. void Start_Task(void *pvParameters);
    
19. 
    
20. //任务优先级
    
21. #define LOW_TASK_PRIO                2
    
22. //任务堆栈大小        
    
23. #define LOW_STK_SIZE                 256
    
24. //任务句柄
    
25. TaskHandle_t Low_Handler;
    
26. //任务函数
    
27. void Low_Task(void *pvParameters);
    
28. 
    
29. //任务优先级
    
30. #define MEDIUM_TASK_PRIO                3
    
31. //任务堆栈大小        
    
32. #define MEDIUM_STK_SIZE                 256
    
33. //任务句柄
    
34. TaskHandle_t Medium_Task_Handler;
    
35. //任务函数
    
36. void Medium_Task(void *pvParameters);
    
37. 
    
38. //任务优先级
    
39. #define HIGH_TASK_PRIO                        4
    
40. //任务堆栈大小        
    
41. #define HIGH_STK_SIZE                         256
    
42. //任务句柄
    
43. TaskHandle_t High_Task_Handler;
    
44. //任务函数
    
45. void High_Task(void *pvParameters);
    
46. 
    
47. //定义互斥信号量
    
48. SemaphoreHandle_t mutexsemaphore;
    
49. 
    
50. int main(void)
    
51. {
    
52.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    
53.         delay_init();                                            //延时函数初始化
    
54.         uart_init(115200);                                //初始化串口
    
55.         LED_Init();                                                          //初始化LED
    
56.         KEY_Config();                                                        //初始化按键
    
57.         
    
58.         printf("\r\n互斥信号量操作实验\r\n\r\n");
    
59.         
    
60.         //创建开始任务
    
61.         xTaskCreate((TaskFunction_t )Start_Task,            //任务函数
    
62.                                                         (const char*    )"start_task",          //任务名称
    
63.                                                         (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
64.                                                         (void*          )NULL,                  //传递给任务函数的参数
    
65.                                                         (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
66.                                                         (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    
67.         vTaskStartScheduler();          //开启任务调度
    
68. }
    
69. 
    
70. //开始任务任务函数
    
71. void Start_Task(void *pvParameters)
    
72. {
    
73.         taskENTER_CRITICAL();           //进入临界区
    
74. 
    
75.         //创建互斥信号量
    
76.         mutexsemaphore=xSemaphoreCreateMutex();
    
77.         if(mutexsemaphore==NULL)
    
78.                 printf("semaphorebinary Create Failed in start_task()!\r\n");
    
79. 
    
80.         //创建Low任务
    
81.         xTaskCreate((TaskFunction_t )Low_Task,            
    
82.                                                         (const char*    )"Task1_Task",           
    
83.                                                         (uint16_t       )LOW_STK_SIZE,
    
84.                                                         (void*          )NULL,                                
    
85.                                                         (UBaseType_t    )LOW_TASK_PRIO,        
    
86.                                                         (TaskHandle_t*  )&Low_Handler);
    
87.         //创建Medium任务
    
88.         xTaskCreate((TaskFunction_t )Medium_Task,            
    
89.                                                         (const char*    )"Medium_task",           
    
90.                                                         (uint16_t       )MEDIUM_STK_SIZE,
    
91.                                                         (void*          )NULL,                                
    
92.                                                         (UBaseType_t    )MEDIUM_TASK_PRIO,        
    
93.                                                         (TaskHandle_t*  )&Medium_Task_Handler);
    
94.         //创建High任务
    
95.         xTaskCreate((TaskFunction_t )High_Task,            
    
96.                                                         (const char*    )"High_task",           
    
97.                                                         (uint16_t       )HIGH_STK_SIZE,
    
98.                                                         (void*          )NULL,                                
    
99.                                                         (UBaseType_t    )HIGH_TASK_PRIO,        
    
100.                                                         (TaskHandle_t*  )&High_Task_Handler);
     
101.                                                         
     
102.         vTaskDelete(StartTask_Handler); //删除开始任务
     
103.         taskEXIT_CRITICAL();            //退出临界区
     
104. }
     
105. 
     
106. //Low任务函数
     
107. void Low_Task(void *pvParameters)
     
108. {
     
109.         uint8_t i=0;
     
110.         while(1)
     
111.         {
     
112.                 if(mutexsemaphore!=NULL)
     
113.                         xSemaphoreTake(mutexsemaphore,portMAX_DELAY);        //获取互斥信号量
     
114.                 printf("Low Priority Task Running!\r\n");
     
115.                 for(i=0;i<20;i++)
     
116.                 {
     
117.                         delay_ms(300);
     
118.                 }
     
119.                 xSemaphoreGive(mutexsemaphore);        //释放互斥信号量
     
120.                 vTaskDelay(1000);
     
121.         }
     
122. }
     
123. 
     
124. //Medium_Task任务函数
     
125. void Medium_Task(void *pvParameters)
     
126. {
     
127.         while(1)
     
128.         {
     
129.                 printf("Medium Priority Task Running!\r\n");
     
130.                 vTaskDelay(1000);
     
131.         }
     
132. }
     
133. 
     
134. 
     
135. //High_Task任务函数
     
136. void High_Task(void *pvParameters)
     
137. {
     
138.         while(1)
     
139.         {
     
140.                 printf("High Priority Task apply Semaphare!\r\n");
     
141.                 xSemaphoreTake(mutexsemaphore,portMAX_DELAY);        //获取互斥信号量
     
142.                 printf("High Priority Task Running!\r\n");
     
143.                 xSemaphoreGive(mutexsemaphore);        //释放互斥信号量
     
144.                 vTaskDelay(1000);
     
145.         }
     
146. }
     
147. 
     

复制代码

decai

自己写一个for死循环,不要用原子例程里的delay_ms(300),因为它那个可能是调用了系统的api函数把cpu释放掉了.
自己写个真正把cpu完全吃死的.

超级无敌磊果果

发现只要把low_task的for循环改一下
                for(i=0;i<40000;i++)
                {
                        delay_us(100);        //注意这里时间要短一些
                }
改成这样子，增加循环的次数，但是减少每次循环的时间就可以了，这是为什么呢？求解

decai

300ms的延时函数里有系统阻塞的api函数,你可以跟踪进去看看