如何知道从任务 B 发送到任务 A 的数据类型？

Question

假设我有一个任务 (taskA) 接受来自另一个任务 (taskB) 的数据。如何使 taskA 可以接受泛型类型？ void 数组是不允许的，所以这是不可能的。

void buff[100];  // not allowed !!

void taskB(void *params)
{
  while(1) {
    xQueueReceive(queueA, buff, portMAX_DELAY);
  }

}

void taskA(void *params) 
{
   char data[] = "something";
   while(1) {
     xQueueSend(queueA, data, portMAX_DELAY);
   }
}

Answer 1

一个选项是使用“字节数组”（例如unsigned char 数组）并从中复制您需要的任何数据（注意不要引入未定义的行为）。您可以使用第一个字节来知道您发送了什么样的数据。

另一个是在struct 中使用union 和一个附加变量（在struct 中），该变量包含一个“标签”，告诉您union 中有哪些类型的数据。

两者本质上是一样的。

Answer 2

如果类型容易频繁变化（b/w不同的调用），一个简单的方法是，将类型数据添加到函数装饰中，例如；

typedef enum {enumInt, enumDbl, enumChr, ... <add other types>} TypeInfo;

void taskB(void *ptr, TypeInfo t) {
    switch (t) {
        case enumInt:
            int *p = (int *)ptr;
            // do stuff as if data is integer
            break;
        case enumDbl:
            double *p = (double *)ptr;
            // do stuff as if data is double
            break;
        case enumChr:
            char *p = (char *)ptr;
            // do stuff as if data is char
            break;
    }
}

void taskA(void *ptr, TypeInfo t) {
    ...
    taskB(ptr, t);
    ...
}

Answer 3

请参阅以下注释良好的示例。

您可以编辑xMessage 结构来存储您想要发送/接收的任何数据。

这个例子也以两种方式发送消息：发送分配缓冲区的地址和发送缓冲区的值。您必须考虑使用您的程序以哪种方式子表。

请注意，该项目是通过副本接收的，因此必须提供足够大小的缓冲区。复制到缓冲区的字节数是在创建队列时定义的。

参考：https://www.freertos.org/a00118.html

/* Define a variable of type struct AMMessage.  The examples below demonstrate
how to pass the whole variable through the queue, and as the structure is
moderately large, also how to pass a reference to the variable through a queue. */
struct AMessage
{
   char ucMessageID;
   char ucData[ 20 ];
} xMessage;

/* Queue used to send and receive complete struct AMessage structures. */
QueueHandle_t xStructQueue = NULL;

/* Queue used to send and receive pointers to struct AMessage structures. */
QueueHandle_t xPointerQueue = NULL;


void vCreateQueues( void )
{
   xMessage.ucMessageID = 0xab;
   memset( &( xMessage.ucData ), 0x12, 20 );

   /* Create the queue used to send complete struct AMessage structures.  This can
   also be created after the schedule starts, but care must be task to ensure
   nothing uses the queue until after it has been created. */
   xStructQueue = xQueueCreate(
                         /* The number of items the queue can hold. */
                         10,
                         /* Size of each item is big enough to hold the
                         whole structure. */
                         sizeof( xMessage ) );

   /* Create the queue used to send pointers to struct AMessage structures. */
   xPointerQueue = xQueueCreate(
                         /* The number of items the queue can hold. */
                         10,
                         /* Size of each item is big enough to hold only a
                         pointer. */
                         sizeof( &xMessage ) );

   if( ( xStructQueue == NULL ) || ( xPointerQueue == NULL ) )
   {
      /* One or more queues were not created successfully as there was not enough
      heap memory available.  Handle the error here.  Queues can also be created
      statically. */
   }
}

/* Task that writes to the queues. */
void vATask( void *pvParameters )
{
struct AMessage *pxPointerToxMessage;

   /* Send the entire structure to the queue created to hold 10 structures. */
   xQueueSend( /* The handle of the queue. */
               xStructQueue,
               /* The address of the xMessage variable.  sizeof( struct AMessage )
               bytes are copied from here into the queue. */
               ( void * ) &xMessage,
               /* Block time of 0 says don't block if the queue is already full.
               Check the value returned by xQueueSend() to know if the message
               was sent to the queue successfully. */
               ( TickType_t ) 0 );

   /* Store the address of the xMessage variable in a pointer variable. */
   pxPointerToxMessage = &xMessage;

   /* Send the address of xMessage to the queue created to hold 10    pointers. */
   xQueueSend( /* The handle of the queue. */
               xPointerQueue,
               /* The address of the variable that holds the address of xMessage.
               sizeof( &xMessage ) bytes are copied from here into the queue. As the
               variable holds the address of xMessage it is the address of xMessage
               that is copied into the queue. */
               ( void * ) &pxPointerToxMessage,
               ( TickType_t ) 0 );

   /* ... Rest of task code goes here. */
}

/* Task that reads from the queues. */
void vADifferentTask( void *pvParameters )
{
struct AMessage xRxedStructure, *pxRxedPointer;

   if( xStructQueue != NULL )
   {
      /* Receive a message from the created queue to hold complex struct AMessage
      structure.  Block for 10 ticks if a message is not immediately available.
      The value is read into a struct AMessage variable, so after calling
      xQueueReceive() xRxedStructure will hold a copy of xMessage. */
      if( xQueueReceive( xStructQueue,
                         &( xRxedStructure ),
                         ( TickType_t ) 10 ) == pdPASS )
      {
         /* xRxedStructure now contains a copy of xMessage. */
      }
   }

   if( xPointerQueue != NULL )
   {
      /* Receive a message from the created queue to hold pointers.  Block for 10
      ticks if a message is not immediately available.  The value is read into a
      pointer variable, and as the value received is the address of the xMessage
      variable, after this call pxRxedPointer will point to xMessage. */
      if( xQueueReceive( xPointerQueue,
                         &( pxRxedPointer ),
                         ( TickType_t ) 10 ) == pdPASS )
      {
         /* *pxRxedPointer now points to xMessage. */
      }
   }

   /* ... Rest of task code goes here. */
}