FreeRTOS消息邮箱

#include "FreeRTOS.h"
#include "task.h"
#include "queue.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 LED1_TASK_PRIO		2
#define LED1_STK_SIZE 		50  
TaskHandle_t LED1Task_Handler;
void led1_task(void *pvParameters);


#define KEYPROCESS_TASK_PRIO		3
#define KEYPROCESS_STK_SIZE 		50  
TaskHandle_t KeyprocessTask_Handler;
void Keyprocess_task(void *pvParameters);

#define KEYMSG_Q_LENGTH	1   //队列长度
#define RXMSG_Q_LENGTH	4

#define RX_BUF_NUM          30
uint8_t Rx_Buf[RX_BUF_NUM];
uint8_t Rx_HAL_Buff_Temp[2];	//HAL函数接收临时缓存

QueueHandle_t Key_Queue;			//按键队列
QueueHandle_t UartRX_Queue;			//消息队列


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();           //进入临界区
	
	//创建队列
	Key_Queue = xQueueCreate(KEYMSG_Q_LENGTH,1);
	UartRX_Queue = xQueueCreate(RXMSG_Q_LENGTH,1);
  HAL_UART_Receive_IT(&huart6,Rx_HAL_Buff_Temp,1);
		
  //创建LED1任务
  xTaskCreate((TaskFunction_t )led1_task,     
              (const char*    )"led1_task",   
              (uint16_t       )LED1_STK_SIZE, 
              (void*          )NULL,
              (UBaseType_t    )LED1_TASK_PRIO,
              (TaskHandle_t*  )&LED1Task_Handler);        
  //创建key任务
  xTaskCreate((TaskFunction_t )Keyprocess_task,     	
              (const char*    )"keyprocess_task",   	
              (uint16_t       )KEYPROCESS_STK_SIZE, 
              (void*          )NULL,				
              (UBaseType_t    )KEYPROCESS_TASK_PRIO,	
              (TaskHandle_t*  )&KeyprocessTask_Handler);   

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

//LED1任务函数
void led1_task(void *pvParameters)
{
  BaseType_t err;
  
  while(1)
  {
    //按键检测
    if(KeyScan((uint8_t *)&KeyValue) == 0)
    {
      if((KeyValue > 0) && (KeyValue < 17))
      {
        err = xQueueSend(Key_Queue,(uint8_t *)&KeyValue,10);
        if(err != pdTRUE)
        {
          printf("Queue Send Fail!\r\n");
        }
        KeyValue = 0;
      }
    }
    vTaskDelay(10);
  }
}

//key任务函数
void Keyprocess_task(void *pvParameters)
{
  BaseType_t err;
  uint8_t keyVal;
  
  while(1)
  {
    if(Key_Queue != NULL)
    {
      err = xQueueReceive(Key_Queue,&keyVal,portMAX_DELAY);
      if(err == pdTRUE)
      {
        printf("KeyVal = %d\r\n",keyVal);
      }
    }
    else
    {
      vTaskDelay(1000);
    }
  }
}

//发生溢出中断或DMA中断时
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
  huart->ErrorCode = HAL_UART_ERROR_NONE;
  HAL_UART_Receive_IT(&huart6,Rx_HAL_Buff_Temp,1);
}
//接收到1字节数据，回调函数如下
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  BaseType_t err;
  BaseType_t pxHigherPriorityTaskWoken;
  
  if(huart->Instance==USART6)
  {
    //加上自己的代码
    if(UartRX_Queue != NULL)
    {
      err = xQueueSendFromISR(UartRX_Queue,Rx_Buf,&pxHigherPriorityTaskWoken);
      if(err == pdTRUE)
      {
        HAL_UART_Receive_IT(&huart6,Rx_HAL_Buff_Temp,1);
      }
      else
      {
        printf("Queue Send ISR Fail!\r\n");
      }
      portYIELD_FROM_ISR(pxHigherPriorityTaskWoken);
    }
  	HAL_UART_Receive_IT(&huart6,Rx_HAL_Buff_Temp,1);
  } 
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  /* USER CODE BEGIN Callback 0 */
  BaseType_t err;
  BaseType_t pxHigherPriorityTaskWoken;
  /* USER CODE END Callback 0 */
  if (htim->Instance == TIM1) {
    HAL_IncTick();
  }
  /* USER CODE BEGIN Callback 1 */
  else if (htim->Instance == TIM2)
  {
    if(UartRX_Queue != NULL)
    {
      err = xQueueReceiveFromISR(UartRX_Queue,ReceiveBuf,&pxHigherPriorityTaskWoken);
      if(err == pdTRUE)
      {
        printf("Receive:%s\r\n",ReceiveBuf);
      }
      else
      {
        printf("Receive Failed!\r\n");
      }
      portYIELD_FROM_ISR(pxHigherPriorityTaskWoken);
    }
  }
  /* USER CODE END Callback 1 */
}