FreeRTOS互斥信号量

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include "os_start.h"


#define START_TASK_PRIO		1
#define START_STK_SIZE 		128  
TaskHandle_t StartTask_Handler;
void start_task(void *pvParameters);

#define LOW_TASK_PRIO		2
#define LOW_STK_SIZE 		50  
TaskHandle_t LowTask_Handler;
void Low_task(void *pvParameters);


#define MIDDLE_TASK_PRIO		3
#define MIDDLE_STK_SIZE 		50  
TaskHandle_t MiddleTask_Handler;
void Middle_task(void *pvParameters);

#define HIGH_TASK_PRIO		4
#define HIGH_STK_SIZE 		50  
TaskHandle_t HighTask_Handler;
void High_task(void *pvParameters);


//互斥信号量句柄
SemaphoreHandle_t MutexSemaphore;	//互斥信号量

void os_start(void)
{
	User_SysTick_ReConfig(configTICK_RATE_HZ);

	//创建开始任务
    xTaskCreate((TaskFunction_t )start_task,            //任务函数
                (const char*    )"start_task",          //任务名称
                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
                (void*          )NULL,                  //传递给任务函数的参数
                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄  
								
    vTaskStartScheduler();          //开启任务调度
	
}

//开始任务任务函数
void start_task(void *pvParameters)
{
  taskENTER_CRITICAL();           //进入临界区
	
	//创建互斥信号量
	MutexSemaphore=xSemaphoreCreateMutex();
		
  //创建Low任务
  xTaskCreate((TaskFunction_t )Low_task,     
              (const char*    )"Low_task",   
              (uint16_t       )LOW_STK_SIZE, 
              (void*          )NULL,
              (UBaseType_t    )LOW_TASK_PRIO,
              (TaskHandle_t*  )&LowTask_Handler);        
  //创建Middle任务
  xTaskCreate((TaskFunction_t )Middle_task,     
              (const char*    )"Middle_task",   
              (uint16_t       )MIDDLE_STK_SIZE, 
              (void*          )NULL,
              (UBaseType_t    )MIDDLE_TASK_PRIO,
              (TaskHandle_t*  )&MiddleTask_Handler);        
  //创建High任务
  xTaskCreate((TaskFunction_t )High_task,     
              (const char*    )"High_task",   
              (uint16_t       )HIGH_STK_SIZE, 
              (void*          )NULL,
              (UBaseType_t    )HIGH_TASK_PRIO,
              (TaskHandle_t*  )&HighTask_Handler);        

  vTaskDelete(StartTask_Handler); //删除开始任务
  taskEXIT_CRITICAL();            //退出临界区
}  



//low任务函数
void Low_task(void *pvParameters)
{
  BaseType_t ret;
  
  while(1)
  {
    if(MutexSemaphore != NULL)
    {
      ret = xSemaphoreTake(MutexSemaphore,portMAX_DELAY);	//获取互斥信号量
      if(ret == pdTRUE)
      {
        printf("low task running!\r\n");
      }
      HAL_Delay(5000);
      xSemaphoreGive(MutexSemaphore);
      vTaskDelay(1000);
    }
    else
    {
      vTaskDelay(1000);
    }
  }
}

//Middle任务函数
void Middle_task(void *pvParameters)
{  
  while(1)
  {
      printf("middle task running!\r\n");
      vTaskDelay(1000);
  }
}

//High任务函数
void High_task(void *pvParameters)
{
  BaseType_t ret;
  
  while(1)
  {
    if(MutexSemaphore != NULL)
    {
      printf("high task Pending!\r\n");
      ret = xSemaphoreTake(MutexSemaphore,portMAX_DELAY);
      if(ret == pdTRUE)
      {
        printf("high task running!\r\n");
      }
      xSemaphoreGive(MutexSemaphore);
      vTaskDelay(1000);
    }
    else
    {
      vTaskDelay(1000);
    }
  }
}