VxWorks多任务--生产者消费者模型

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_36195711/article/details/77160849

VxWorks多任务–生产者消费者模型

给出了多任务之间使用消息队列通信的例子–生产者和消费者模型，记录一下

msgQDemo.h

例子头文件

#define  CONSUMER_TASK_PRI          99   /* Priority of the consumer task */
#define  PRODUCER_TASK_PRI          98   /* Priority of the producer task */
#define  TASK_STACK_SIZE          5000   /* stack size for spawned tasks */

struct msg {                             /* data structure for msg passing */
        int tid;                         /* task id */         
        int value;                       /* msg value */
        };

LOCAL MSG_Q_ID msgQId;                   /* message queue id */
LOCAL int numMsg = 8;                    /* number of messages */
LOCAL BOOL notDone;                      /* Flag to indicate the completion 
                                            of this demo */

msgQDemo.c

例子实现

#include "vxWorks.h"
#include "taskLib.h"
#include "msgQLib.h"
#include "msgQDemo.h"
#include "sysLib.h"
#include "stdio.h"

/* function prototypes */

LOCAL STATUS producerTask ();           /* producer task */
LOCAL STATUS consumerTask ();           /* consumer task */

/*****************************************************************************
 *  msgQDemo - Demonstrates intertask communication using Message Queues 
 *
 *  DESCRIPTION
 *  Creates a Message Queue for interTask communication between the 
 *  producerTask and the consumerTask. Spawns the producerTask that creates 
 *  messages and sends messages to the consumerTask using the message queue. 
 *  Spawns the consumerTask that reads messages from the message queue. 
 *  After consumerTask has consumed all the messages, the message queue is 
 *  deleted.
 *
 *  RETURNS: OK or ERROR
 *
 *  EXAMPLE
 *
 *  -> sp msgQDemo
 *
 */

STATUS msgQDemo()
    {
    notDone = TRUE;  /* initialize the global flag */

    /* Create the message queue*/
    if ((msgQId = msgQCreate (numMsg, sizeof (struct msg), MSG_Q_FIFO)) 
                                                                      == NULL)
        {
        perror ("Error in creating msgQ");
        return (ERROR);
        }

     /* Spwan the producerTask task */
    if (taskSpawn ("tProducerTask", PRODUCER_TASK_PRI, 0, TASK_STACK_SIZE, 
                   (FUNCPTR) producerTask, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) 
                    == ERROR)
        {
        perror ("producerTask: Error in spawning demoTask");
        return (ERROR);
        } 

    /* Spwan the consumerTask task */
    if (taskSpawn ("tConsumerTask", CONSUMER_TASK_PRI, 0, TASK_STACK_SIZE, 
                   (FUNCPTR) consumerTask, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) 
                   == ERROR)
        {
        perror ("consumerTask: Error in spawning demoTask");
        return (ERROR);
        }

    /* polling is not recommended. But used to make this demonstration simple*/
    while (notDone)
        taskDelay (sysClkRateGet ());

    if (msgQDelete (msgQId) == ERROR)
        {
        perror ("Error in deleting msgQ");
        return (ERROR);
        }

    return (OK);
    }


/*****************************************************************************
 *  producerTask - produces messages, and sends messages to the consumerTask 
 *                 using the message queue. 
 *
 *  RETURNS: OK or ERROR
 *
 */

STATUS producerTask (void)
    {
    int count;
    int value;
    struct msg producedItem;           /* producer item - produced data */ 

    printf ("producerTask started: task id = %#x \n", taskIdSelf ());

    /* Produce numMsg number of messages and send these messages */

    for (count = 1; count <= numMsg; count++)
        {
        value = count * 10;   /* produce a value */

        /* Fill in the data structure for message passing */
        producedItem.tid = taskIdSelf ();
        producedItem.value = value;

        /* Send Messages */
        if ((msgQSend (msgQId, (char *) &producedItem, sizeof (producedItem), 
                       WAIT_FOREVER,  MSG_PRI_NORMAL)) == ERROR)
            {
                perror ("Error in sending the message");
                return (ERROR);
            }
        else
            printf ("ProducerTask: tid = %#x, produced value = %d \n", 
                                                      taskIdSelf (), value);
        }

    return (OK);
    }

/*****************************************************************************
 *  consumerTask - consumes all the messages from the message queue. 
 *
 *  RETURNS: OK or ERROR
 *
 */

STATUS consumerTask (void)
    {
    int count;
    struct msg consumedItem;           /* consumer item - consumed data */

    printf ("\n\nConsumerTask: Started -  task id = %#x\n", taskIdSelf());

    /* consume numMsg number of messages */
    for (count = 1; count <= numMsg; count++)
        {
        /* Receive messages */
        if ((msgQReceive (msgQId, (char *) &consumedItem, 
                          sizeof (consumedItem), WAIT_FOREVER)) == ERROR)
            {
            perror ("Error in receiving the message");
            return (ERROR);
            }
        else 
            printf ("ConsumerTask: Consuming msg of value %d from tid = %#x\n",
                            consumedItem.value, consumedItem.tid);
        }

    notDone = FALSE;   /* set the global flag to FALSE to indicate completion*/
    return (OK);
    }

测试

main.c

#include "vxWorks.h"
#include "taskLib.h"
#include "msgQLib.h"
#include "msgQDemo.h"
#include "sysLib.h"
#include "stdio.h"
int main()
{
    msgQDemo();
    return 0;
}