FreeRTOS任务间通信

一、消息队列

消息队列，一种用于任务与任务间、中断和任务间传递信息的数据结构，实现了任务接收来自其他任务或中断的不等长的消息。

消息队列能够接收来自线程或中断服务例程中不固定长度的消息，并把消息缓存在自己的内存空间中。其他线程也能够从消息队列中读取相应的消息，而当消息队列是空的时候，可以挂起读取线程。当有新的消息到达时，挂起的线程将被唤醒以接收并处理消息。消息队列是一种异步的通信方式。

创建消息队列 ，FreeRTOS系统会分配一块单个消息大小与消息队列长度乘积的空间；(创建成功后，每个消息的大小及消息队列长度无法更改，不能写入大于单个消息大小的数据，并且只有删除消息队列时，才能释放队列占用的内存) 。写入消息队列 ，当消息队列未满或允许覆盖入队时，FreeRTOS系统会直接将消息复制到队列末端；否则，程序会根据指定的阻塞时间进入阻塞状态，直到消息队列未满或者是阻塞时间超时，程序就会进入就绪状态；写入紧急消息，本质上与普通消息差不多，不同的是其将消息直接复制到消息队列队首；读取消息队列，在指定阻塞时间内，未读取到消息队列中的数据（消息队列为空），程序进入阻塞状态，等待消息队列中有数据；一旦阻塞时间超时，程序进入就绪态；

二、消息队列应用实例

cpp 复制代码

函数解释
//创建队列
QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength,//队列长度
							UBaseType_t uxItemSize );//队列中消息单元的大小，以字节为单位

//队列发送消息，队尾写入
BaseType_t xQueueSend(QueueHandle_t xQueue,//队列句柄
				const void * pvItemToQueue,//指针，指向要发送到队列尾部的队列消息
				TickType_t xTicksToWait);//等待时间

//中断服务程序中使用的发送函数
BaseType_t xQueueSendFromISR(QueueHandle_t xQueue,
							const void *pvItemToQueue,
						    BaseType_t *pxHigherPriorityTaskWoken//为一个可选参数， 可以设置为 NULL。
						    );

//向队列首发送消息
BaseType_t xQueueSendToFront( QueueHandle_t xQueue,
						const void * pvItemToQueue,
							TickType_t xTicksToWait );

//从一个队列中接收消息并把消息从队列中删除
BaseType_t xQueueReceive(QueueHandle_t xQueue,
							void *pvBuffer,
					TickType_t xTicksToWait);

//在中断服务程序中接收消息队列的函数，总之就是在任务中调用和在中断服务程序中调用函数不同。
BaseType_t xQueueReceiveFromISR( 
							QueueHandle_t xQueue,
                            void * const pvBuffer,
                            BaseType_t * const pxHigherPriorityTaskWoken
                                );


举例说明
QueueHandle_t Test_Queue =NULL;
#define  QUEUE_LEN    4   /*消息队列长度*/
#define  QUEUE_SIZE   4   /*每个消息大小 */

static void AppTaskCreate(void)
{
  BaseType_t xReturn = pdPASS;
·taskENTER_CRITICAL();     //进入临界区
  /* 创建Test_Queue */
  Test_Queue = xQueueCreate((UBaseType_t ) QUEUE_LEN,(UBaseType_t ) QUEUE_SIZE);
  
 创建任务一：Send_Task
 创建任务二：Receive_Task

  vTaskDelete(AppTaskCreate_Handle); 
  taskEXIT_CRITICAL();  
}

/
  
//任务一：发送
static void Send_Task(void* parameter)
{	 
  BaseType_t xReturn = pdPASS;
  uint32_t send_data1 = 1;
  uint32_t send_data2 = 2;
  while (1)
  {
      xReturn = xQueueSend( Test_Queue,&send_data1,0 );       
      if(pdPASS == xReturn)
        printf("send_data1 发送成功!\n\n");
    vTaskDelay(20);
  }
}

//任务二：接收
static void Receive_Task(void* parameter)
{	
  BaseType_t xReturn = pdTRUE;
  uint32_t r_queue;
  while (1)
  {
    xReturn = xQueueReceive( Test_Queue, &r_queue,portMAX_DELAY); 
    if(pdTRUE == xReturn)
      printf("收到数据%d\n\n",r_queue);
    else
      printf("没有收到数据0x%lx\n",xReturn);
  }
}

三、信号量

二值信号量任务之间同步或临界资源的互斥访问

同步：比如说，买包子

我要去买包子，如果包子店没有包子了，则需要等待卖包子的把包子做出来我才能买到包子，这个等待的过程就叫做同步。(在实际应用中：一个采集数据的传感器任务，一个处理数据的任务，则处理数据的任务需要等待传感器去采用数据，则在FreeRTOS系统中等待不能干等着，在该任务等待的过程中，CPU转而可以去执行其他任务，则就可以提高效率，则就是队列的阻塞机制)

互斥：比如说，抢厕所

只有一个厕所，一个人进去上了，另一个人也要上，则必须等待前人上完厕所才能上，等待的过程就是同步，而保护厕所只能一个人上的过程叫做互斥，厕所就是所谓的临界资源，同一时间只能一个人使用厕所。

以生活中的停车场为例来理解信号量的概念：

①当停车场空的时候，停车场的管理员发现有很多空车位，此时会让外面的车陆续进入停车场获得停车位；

②当停车场的车位满的时候，管理员发现已经没有空车位，将禁止外面的车进入停车场，车辆在外排队等候；

③当停车场内有车离开时，管理员发现有空的车位让出，允许外面的车进入停车场；待空车位填满后，又禁止外部车辆进入。

在此例子中，管理员就相当于信号量，管理员手中空车位的个数就是信号量的值（非负数，动态变化）；停车位相当于公共资源（临界区），车辆相当于线程。车辆通过获得管理员的允许取得停车位，就类似于线程通过获得信号量访问公共资源。

四、信号量实例

二值信号量用于同步：在多任务系统中，经常会使用二值信号量来实现任务之间或者任务与中断之间的同步，比如，某个任务需要等待一个标记，那么任务可以在轮询中查询这个标记有没有被置位，则任务在等待的过程也会消耗CPU的资源，代码如下所示：

cpp 复制代码

SemaphoreHandle_t BinarySem_Handle =NULL;

static void AppTaskCreate(void)
{
  BaseType_t xReturn = pdPASS;
  taskENTER_CRITICAL(); 
  
  /* 创建二值信号量*/
  BinarySem_Handle = xSemaphoreCreateBinary();	 
  if(NULL != BinarySem_Handle)
    printf("BinarySem_Handle create successful!\r\n");

	创建任务一：Receive_Task
	创建任务二：Send_Task
  
  vTaskDelete(AppTaskCreate_Handle); 
  taskEXIT_CRITICAL();  
}

static void Receive_Task(void* parameter)
{	
  BaseType_t xReturn = pdPASS;
  while (1) {
  	//获取二值信号量，没有获取则一直等待
	xReturn = xSemaphoreTake(BinarySem_Handle,portMAX_DELAY); 
    if(pdTRUE == xReturn)
      printf("BinarySem_Handle  get successful |!\n\n");
  }
}


static void Send_Task(void* parameter)
{	 
  BaseType_t xReturn = pdPASS;
  while (1)
  {
    if( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON )
    {
      xReturn = xSemaphoreGive( BinarySem_Handle );//给出信号量
      if( xReturn == pdTRUE )
        printf("BinarySem_Handle  释放成功\r\n");
      else
        printf("BinarySem_Handle  释放失败\r\n");
    } 
    vTaskDelay(20);
  }
}

五、事件组

事件是一种实现任务/中断间通信的机制，主要用于实现多任务间的同步，但事件通信只能是事件类型的通信，无数据传输。其实事件组的本质就是一个整数(16/32位)。

事件组与队列/信号量的区别：

1.信号量/队列当事件发生时只会去唤醒一个任务，而事件组可以唤醒多个任务 起到一个广播的作用。

2.信号量/队列是一个消耗性资源，即数据读走了则就减少，而事件组可以选择清除事件也可以选择保留事件 。

3.事件组只能是起到一个同步的作用，并不能传递数据 。

4.最重要的一点事件组可以实现多个任务之间的同步，队列/信号量则只能是两个任务之间的同步

事件组的特点：

1.一个 32 位的事件集合（EventBits_t 类型的变量，实际可用与表示事件的只有 24 位，还有8位用于管理事件），其中每一位表示一种事件类型（0 表示该事件类型未发生、1 表示该事件类型已经发生）。

2.事件仅用于同步，不提供数据传输功能。

与信号量/队列不同设置事件组不会阻塞，即多次向任务设置同一事件等效于只设置一次。
支持事件等待超时机制，即等待该事件类型(该事件还未发生)的任务会进入阻塞态。

5.事件获取的时候，有两个选择：1.逻辑或:任务所期望的事件中只要有任意一个事件发生，任务即可被唤醒。2.逻辑或:任务所期望的事件必须全部发生，任务才能被唤醒。

六、事件组实例

cpp 复制代码

static EventGroupHandle_t Event_Handle =NULL;

#define KEY1_EVENT  (0x01 << 0) 
#define KEY2_EVENT  (0x01 << 1) 

static void AppTaskCreate(void)
{
  BaseType_t xReturn = pdPASS;
  taskENTER_CRITICAL(); 
  
  /* 创建事件 Event_Handle */
  Event_Handle = xEventGroupCreate();	 
  if(NULL != Event_Handle)
    printf("Event_Handle创建成功\r\n");
    
	创建任务一：LED_Task
	创建任务二：KEY_Task

  vTaskDelete(AppTaskCreate_Handle); 
  taskEXIT_CRITICAL(); 
}

static void LED_Task(void* parameter)
{	
    EventBits_t r_event;
    while (1)
	{
    r_event = xEventGroupWaitBits(Event_Handle, 
                                  KEY1_EVENT|KEY2_EVENT,//事件
                                  pdTRUE,pdTRUE,  portMAX_DELAY);
                        
    if((r_event & (KEY1_EVENT|KEY2_EVENT)) == (KEY1_EVENT|KEY2_EVENT)) 
    {
      printf ( "收到事件\n");		
    }
    else
      printf ( "事件 错误\n");	
  }
}

static void KEY_Task(void* parameter)
{	 
  while (1)
  {
       if( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON )  {
			xEventGroupSetBits(Event_Handle,KEY1_EVENT); //触发事件一 					
		}
   
		if( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON )  {
			xEventGroupSetBits(Event_Handle,KEY2_EVENT); 触发事件二				
		}
		vTaskDelay(20); 
  }
}

七、任务通知

前言：任务间通信的机制，包括队列、事件组和各种不同类型的信号量。使用这些机制都需要创建一个通信对象。事件和数据不会直接发送到接收任务或接收ISR，而是发送到通信对象（也就是发送到队列、事件组、信号量）。同样，任务和ISR从通信对象接收事件和数据，而不是直接从发送事件或数据的任务或ISR接收事件和数据。

**任务通知允许任务与其他任务交互，并与ISR同步，而不需要单独的通信对象。**通过使用任务通知，任务或ISR可以直接向接收任务发送事件。

每个任务都有一个 32 位的通知值，在大多数情况下，任务通知可以替代二值信号量、计数信号量、事件组，也可以替代长度为 1 的队列；任务通知的使用无需创建队列；

（1）任务通知的缺点：按照FreeRTOS官方的说法使用任务通知比通过队列、事件标志组或信号量通信方式解除阻塞的任务要快 45%，并且更加省 RAM 内存空间，因为像队列、信号量、事件组这些通信方式使用前必须先创建，拿队列来说如下图所示，申请内存的时候至少需要下图这么多变量，而任务通知是任务结构体中自带的一个32位的无符号整数，一个8位的通知状态变量，一共就5个字节。

(2).任务通知的缺点

虽然说任务通知可以模拟这么多通信方式，但是肯定有限制、有缺点，不然还要这些队列、信号量、事件组干嘛。

1.不能发送通知到中断

原因很简单，任务通知、任务通知，人家通知的是任务，是修改任务控制块中那个32位无符号整数的值，中断并没有任务控制块这一说，但为什么队列、信号量、事件组这些就可以呢，说到底人家创建了一个独立的队列、信号量、事件组结构体当然谁都可以访问里面的内容，但是可以在中断中发送通知给其他任务，这个是没毛病的。

2.不能发送通知给多个任务

任务通知只能指定发送给某一个任务而不能广播，而队列、信号量、事件组任何中断和任务都能访问，不过很少出现多个任务或中断接收同一个通讯对象的情况

3.发送通知的任务不能进入阻塞

只有等待通知的任务可以被阻塞，发送通知的任务，在任何情况下都不会因为发送失败而进入阻塞态，像队列：写队列当队列满的时候，可以进入阻塞态

八、任务通知实例

cpp 复制代码

获取任务通知 
BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, //任务句柄
                                      uint32_t ulValue, //值
                                      eNotifyAction eAction ); 
     eNotifyAction 的取值                                 
       * eNoAction = 0//通知任务而不更新其通知值
       * eSetBits//设置任务通知值中的值
       * eIncrement//增加任务的通道值
       * eSetvaluewithoverwrite//覆盖当前通知
       * eSetValueWithoutoverwrite//不覆盖当前通知

cpp 复制代码

等待任务通知
BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry,//将从任务的通知值中清除的位（Bit）。这个参数可以用来指定只关心特定的位。可以使用 0 来表示不清除任何位。
							uint32_t ulBitsToClearOnExit,//从任务的通知值中清除的位。如果希望在任务等待结束时清除某些位，可以通过此参数指定。如果不需要清除，可以使用 0
							uint32_t *pulNotificationValue,//函数将把接收到的通知值存储在这个指针指向的内存中。如果不需要接收到的通知值，可以传递 NULL
							TickType_t xTicksToWait );//任务没有接收到通知值的情况下等待的时间（以滴答计时，毫秒为单位）。如果这个时间到了还没有收到通知，函数将返回。使用 portMAX_DELAY 可以让任务无限期等待，直到收到通知。

cpp 复制代码

#define EVENTBIT_0	(1<<0)				//CAN_0
#define EVENTBIT_1	(1<<1)              //CAN_1
#define EVENTBIT_2	(1<<2)              //USART_0
#define EVENTBIT_3	(1<<3)              //USART_1

举例说明
static void AppTaskCreate(void)
{
  BaseType_t xReturn = pdPASS;
  taskENTER_CRITICAL(); 

  创建任务一： Receive1_Task
  创建任务二 ：Send_Task
  
  vTaskDelete(AppTaskCreate_Handle);
  taskEXIT_CRITICAL();  
}


//发送任务
static void Send_Task(void* parameter)
{	 
  BaseType_t xReturn = pdPASS;
  uint32_t send1 = 1;
  
  while (1)
  {

    if( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON )
    {

      xReturn = xTaskNotify( Receive1_Task_Handle, /*任务句柄*/
                             (uint32_t)EVENTBIT_3, /*任务内容 */
                             eSetValueWithOverwrite );/*覆盖当前通知*/
      
      if( xReturn == pdPASS )
        printf("Receive1_Task_Handle ÈÎÎñÍ¨ÖªÏûÏ¢·¢ËÍ³É¹¦!\r\n");
    } 
    vTaskDelay(20);
  }
}


//接收任务
static void Receive1_Task(void* parameter)
{	
  BaseType_t xReturn = pdTRUE;
  uint32_t r_num；
  xReturn=xTaskNotifyWait(0x0,			//进入函数的时候不清除任务bit
                            ULONG_MAX,	  //退出函数的时候清除所有bit
                            (uint32_t *)&r_num,		  //任务通知值
                            portMAX_DELAY);	//阻塞事件
    if( pdTRUE == xReturn )
      printf("Receive1_Task 任务通知消息 %d \n",r_num);                      
}

九、互斥锁

信号量的一个特例，信号量可以实现一对一和一对多，而对于互斥锁只能实现一对一。互斥锁是一种用于保护共享资源的机制。当一个任务需要使用一个共享资源时，它必须首先获取互斥锁。如果互斥锁已经被另一个任务获取，那么这个任务就需要等待，直到互斥锁被释放。在FreeRTOS中，可以使用xSemaphoreCreateMutex()函数来创建一个互斥锁。

互斥量又叫相互排斥的信号量，是一种特殊的二值信号量。互斥量类似于只有一个车位的停车场：当有一辆车进入的时候，将停车场大门锁住，其他车辆在外面等候。当里面的车出来时，将停车场大门打开，下一辆车才可以进入。

cpp 复制代码

SemaphoreHandle_t xMutex;

void vTask(void  pvParameters)
{
    for(;;)
    {
        if(xSemaphoreTake(xMutex, (TickType_t)10) == pdTRUE)
        {
            // The mutex was successfully taken, so the shared resource can be accessed.
            printf("Task: Mutex taken!\n");

            // ...
            // Access the shared resource.
            // ...

            // Release the mutex.
            xSemaphoreGive(xMutex);
        }
        else
        {
            // The mutex could not be taken.
            printf("Task: Mutex not taken!\n");
        }
    }
}

信号量 vs 互斥锁区别：

互斥锁是一种所有权的概念，即一个任务获取了互斥锁后，只有它自己可以释放这个互斥锁，其他任务不能释放。而信号量没有所有权的概念，任何任务都可以释放信号量。
在FreeRTOS中，互斥锁有优先级翻转的解决机制，当一个低优先级的任务获取了互斥锁，而高优先级的任务需要这个互斥锁时，低优先级的任务的优先级会被提升，以减少优先级反转的问题。而信号量没有这个机制。
互斥锁通常用于保护共享资源，即在同一时间只能有一个任务访问某个资源。信号量则更多是用于任务同步，它可以被用来唤醒一个或多个等待的任务。
在FreeRTOS中，信号量可以有计数的概念，即可以被"给"多次，每次"给"都会增加一个计数，而互斥锁没有这个概念，它只有锁定和解锁两种状态。
信号量可以被用作二元信号量（即只有两种状态，0和1，类似互斥锁），而互斥锁不能被用作计数信号量。

十、总结

消息队列：不同任务或进程之间传递消息

互斥锁：侧重于保证同一时刻只有一个线程可以访问共享资源

信号量：控制对共享资源访问的同步机制，用于控制多个线程对共享资源的访问数量。

事件组：管理多个事件的同步机制，允许多个任务等待多个事件的发生

任务通知：任务之间直接发送通知，任务间通信

线程间同步：信号量，互斥锁，事件组

线程间通信：消息队列，任务通知