STM32_HAL Freertos按键控制LED

设置GPIO引脚

根据电路图，K0为用户按键，连接在PA0引脚，当K0按下时接地，引脚电平低电平。在CubeMX中设置PA0，将IO设置为输入，上拉（上拉外部悬空时，引脚为高电平）。

添加Freertos任务

在freertos任务中，添加按键任务，通过myTask_Key不断读入PA0的引脚状态。添加一个消息队列用来给LED任务传递读取的内容。

完成任务代码

osMessageQId PWM_QueueHandle;

osMessageQDef(PWM_Queue, 16, uint16_t);
PWM_QueueHandle = osMessageCreate(osMessageQ(PWM_Queue), NULL);

void StartTask_Key(void const * argument)
{//按键读取状态并发送消息
  /* USER CODE BEGIN StartTask_Key */
  /* Infinite loop */
  for(;;)
  {
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)==0){
			osDelay(20);//消抖
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)==0){
				while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)==0){
				}
				osMessagePut(PWM_QueueHandle,0x01,1);
			}
			
		}		
  }
  /* USER CODE END StartTask_Key */
}

/* USER CODE END Header_StartTask_LED */
void StartTask_LED(void const * argument)
{
  /* USER CODE BEGIN StartTask_LED */
  /* Infinite loop */
	
	int LEDDelay = 100;
	osEvent QueueEvent;
	
  for(;;)
  {
		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
		osDelay(LEDDelay);
		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
		osDelay(LEDDelay);
		
		QueueEvent= osMessageGet(PWM_QueueHandle,1);
		if((uint8_t)QueueEvent.value.v == 0x01)
		{
			LEDDelay+=100;
		}
  }
}

消息队列

Freertos中提供了消息队列用于传递消息。以下是消息队列常用函数

//1、创建消息队列
osMessageQId osMessageCreate (const osMessageQDef_t *queue_def, osThreadId thread_id);
 
//2、往消息队列里面写消息
osStatus osMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec);
 
//3、从消息队列中获取消息，把消息拿走
osEvent osMessageGet (osMessageQId queue_id, uint32_t millisec);
 
//4、从消息队列中获取一个消息，但是不拿走，只是看一眼
osEvent osMessagePeek (osMessageQId queue_id, uint32_t millisec);
 
//5、获取消息队列中的消息数量
uint32_t osMessageWaiting(osMessageQId queue_id);
 
//6、获取消息队列还剩多少空间
uint32_t osMessageAvailableSpace(osMessageQId queue_id);
 
//7、删除消息队列
osStatus osMessageDelete (osMessageQId queue_id)

创建消息队列

/**
* @brief 创建并初始化一个消息队列
* @参数 queue_def     所定义的队列\ref osMessageQ.
* @参数  thread_id    线程ID（一般也用不上就用NULL）
* @返回值 返回消息队列的句柄，也就是消息队列的ID 
*/
osMessageQId osMessageCreate (const osMessageQDef_t *queue_def, osThreadId thread_id)
{
  (void) thread_id;
  
#if( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
     //如果同时支持动态创建和静态创建
  if ((queue_def->buffer != NULL) && (queue_def->controlblock != NULL)) {
    return xQueueCreateStatic(queue_def->queue_sz, queue_def->item_sz, queue_def->buffer, queue_def->controlblock);
  }
  else {
    return xQueueCreate(queue_def->queue_sz, queue_def->item_sz);
  }
#elif ( configSUPPORT_STATIC_ALLOCATION == 1 )
//如果只支持静态创建
  return xQueueCreateStatic(queue_def->queue_sz, queue_def->item_sz, queue_def->buffer, queue_def->controlblock);
#else  
//如果只支持动态创建
  return xQueueCreate(queue_def->queue_sz, queue_def->item_sz);
#endif
}

消息队列的要素：

  uxQueueLength：队列的长度，就是有多少个数据的意思
  uxItemSize：每个数据单元的大小

下面创建一个队列深度为16，每个消息单元为uint8_t的消息队列

//定义消息队列的ID
osMessageQId myQueue01Handle;
 
//定义消息队列的名称，大小，类型
osMessageQDef(myQueue01, 16, uint8_t);
 
//创建消息队列
myQueue01Handle = osMessageCreate(osMessageQ(myQueue01), NULL);

往消息队列中写消息

**
* @简介 往消息队列中写消息
* @参数  queue_id  消息队列的ID.
* @参数  info      消息内容，发送的消息需要强制转化为uint32_t类型
* @参数  millisec  超时时间.
* @返回值 状态信息，是否写入成功
*/
osStatus osMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec)
{
  portBASE_TYPE taskWoken = pdFALSE;
  TickType_t ticks;
  
  ticks = millisec / portTICK_PERIOD_MS; //超时时间转换为tick单位
  if (ticks == 0) {
    ticks = 1;
  }
  
  //Cortex-M3支持两种操作模式handler模式和thread模式，
  if (inHandlerMode()) { //handler模式就用中断的方式发送消息
    if (xQueueSendFromISR(queue_id, &info, &taskWoken) != pdTRUE) {
      return osErrorOS;
    }
    portEND_SWITCHING_ISR(taskWoken);
  }
  else { //thread模式
    if (xQueueSend(queue_id, &info, ticks) != pdTRUE) {
      return osErrorOS;
    }
  }
  
  return osOK;
}

往消息队列中写个0x08进去，超时时间1ms;

osMessagePut(myQueue01Handle,0x08,1);

从消息队列中获取消息

/**
* @brief 从消息队列中获取一个消息，没消息就等消息
* @param  queue_id  消息队列的ID
* @param  millisec  超时时间
* @retval event 返回event
*/
osEvent osMessageGet (osMessageQId queue_id, uint32_t millisec)
{
  portBASE_TYPE taskWoken;
  TickType_t ticks;
  osEvent event;
  
  event.def.message_id = queue_id;
  event.value.v = 0;
  
  if (queue_id == NULL) {  //找不到消息队列，那就报错
    event.status = osErrorParameter;
    return event;
  }
  
  taskWoken = pdFALSE;
  
  ticks = 0;
  if (millisec == osWaitForever) { //超时时间设置为portMAX_DELAY
    ticks = portMAX_DELAY;
  }
  else if (millisec != 0) {
    ticks = millisec / portTICK_PERIOD_MS; //超时时间转化为TICK单位
    if (ticks == 0) {
      ticks = 1;
    }
  }
  
  if (inHandlerMode()) { //中断里面获得消息
    if (xQueueReceiveFromISR(queue_id, &event.value.v, &taskWoken) == pdTRUE) {
      /* We have mail */
      event.status = osEventMessage;
    }
    else { 
      event.status = osOK;
    }
    portEND_SWITCHING_ISR(taskWoken);
  }
  else {//线程模式获得消息，把消息存到&event.value.v中
    if (xQueueReceive(queue_id, &event.value.v, ticks) == pdTRUE) {
      /* We have mail */
      event.status = osEventMessage;
    }
    else {
      event.status = (ticks == 0) ? osOK : osEventTimeout;
    }
  }
  
  return event;
}

event结构体

typedef struct  {
  osStatus                 status;     ///< status code: event or error information
  union  {
    uint32_t                    v;     ///< message as 32-bit value
    void                       *p;     ///< message or mail as void pointer
    int32_t               signals;     ///< signal flags
  } value;                             ///< event value
  union  {
    osMailQId             mail_id;     ///< mail id obtained by \ref osMailCreate
    osMessageQId       message_id;     ///< message id obtained by \ref osMessageCreate
  } def;                               ///< event definition
} osEvent;

event结构体主要包含3个内容：

status：这个成员用于存储事件或错误的状态码。可能包含有关事件状态或错误信息的信息。
value：这是一个联合体（union），它提供了不同类型的事件值的存储方式：
	v：作为一个32位无符号整数存储事件的数值信息。
	p：作为一个指向 void 类型的指针，用于存储事件或邮件的数据。
	signals：这个成员用于存储信号标志，可能是一些特定的信号标志或标志组。
def：也是一个联合体，用于存储事件的定义信息。
	mail_id：如果是邮件相关的事件，则存储邮件的ID，这个ID可能是通过 osMailCreate 创建的。
	message_id：如果是消息相关的事件，则存储消息的ID，这个ID可能是通过 osMessageCreate 创建的。

消息队列发送与接收实验（传递一个数据）

知道了消息队列的发送和接收函数就可以做一些简单的实验。建两个任务，如果的创建这里不解释，请参考任务创建章节。一个任务往队列中写消息，一个任务从队列中读消息。

//Task02用来往队列中写消息
//按键按下再松开就往队列中发送数据0x08
void StartTask02(void const * argument)
{
 
  for(;;)
  {
 
    if(HAL_GPIO_ReadPin(KEY_1_GPIO_Port,KEY_1_Pin) == GPIO_PIN_RESET)
    {
      HAL_Delay(20);
      while(HAL_GPIO_ReadPin(KEY_1_GPIO_Port,KEY_1_Pin) == GPIO_PIN_RESET);
      osMessagePut(myQueue01Handle,0x08,1);
    }
    osDelay(1);
  }
 
}
 
 
//Task03用来从队列中读消息
//消息内容如果是8的话就发送一些内容出去
//读队列任务也不添加阻塞
void StartTask03(void const * argument)
{
 
  osEvent QueueEvent;
  uint8_t Tx_Buffer[] = "FreeRTOS queue test\r\n";
 
  for(;;)
  {
  
    QueueEvent = osMessageGet (myQueue01Handle, osWaitForever);
    
    if((uint8_t)QueueEvent.value.v == 8)
    {
      HAL_UART_Transmit(&huart1,Tx_Buffer,sizeof(Tx_Buffer),10);
    }
    osDelay(1);
    
  }
}