Intertask and Interprocess Communication .5 Message Queues

7.5.2 Message Creation and Use

VxWorks message queues are created, used, and deleted with the routines shown in Table 7-3. This library provides messages that are queued in FIFO order, with a single exception: there are two priority levels, and messages marked as high priority are attached to the head of the queue.

A message queue is created with msgQCreate( ). Its parameters specify the maximum number of messages that can be queued in the message queue and the maximum length in bytes of each message. Enough buffer space is allocated for the specified number and length of messages.

A task or ISR sends a message to a message queue with msgQSend( ). If no tasks are waiting for messages on that queue, the message is added to the queue’s buffer of messages. If any tasks are already waiting for a message from that message queue, the message is immediately delivered to the first waiting task.

A task receives a message from a message queue with msgQReceive( ). If messages are already available in the message queue’s buffer, the first message is immediately dequeued and returned to the caller. If no messages are available, then the calling task blocks and is added to a queue of tasks waiting for messages.

This queue of waiting tasks can be ordered either by task priority or FIFO, as specified in an option parameter when the queue is created.

Message Queue Timeout

Both msgQSend( ) and msgQReceive( ) take timeout parameters. When sending a message, the timeout specifies how many ticks to wait for buffer space to become available, if no space is available to queue the message. When receiving a message, the timeout specifies how many ticks to wait for a message to become available, if no message is immediately available. As with semaphores, the value of the timeout parameter can have the special values of NO_WAIT (0), meaning always return immediately, or WAIT_FOREVER (-1), meaning never time out the routine.

Message Queue Urgent Messages

The msgQSend( ) function allows specification of the priority of the message as either normal (MSG_PRI_NORMAL) or urgent (MSG_PRI_URGENT). Normal priority messages are added to the tail of the list of queued messages, while urgent priority messages are added to the head of the list.

Table 7-3 VxWorks Message Queue Control

Routine Description

msgQCreate( ) Allocates and initializes a message queue.

msgQDelete( ) Terminates and frees a message queue.

msgQSend( ) Sends a message to a message queue.

msgQReceive( ) Receives a message from a message queue.

Example 7-2 VxWorks Message Queues

/* In this example, task t1 creates the message queue and sends a message

* to task t2. Task t2 receives the message from the queue and simply

* displays the message.

/* get message from queue; if necessary wait until msg is available */

if (msgQReceive(myMsgQId, msgBuf, MAX_MSG_LEN, WAIT_FOREVER) == ERROR) return (ERROR);

/* display message */

printf ("Message from task 1:\n%s\n", msgBuf);

}

#define MESSAGE "Greetings from Task 1"

task1 (void) {

/* create message queue */

if ((myMsgQId = msgQCreate (MAX_MSGS, MAX_MSG_LEN, MSG_Q_PRIORITY))

== NULL) return (ERROR);

/* send a normal priority message, blocking if queue is full */

if (msgQSend (myMsgQId, MESSAGE, sizeof (MESSAGE), WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)

return (ERROR);

}

Message Queues Interruptible by Signals

By default, a task pending on a message queue is not interruptible by signals. A signal is only delivered to a task when it is no longer pending (having timed out or acquired the message queue).

This behavior can be changed by using the MSG_Q_INTERRUPTIBLE option when creating a message queue. A task can then receive a signal while pending on a message queue, and the associated signal handler is executed. However, the msgQSend( ) or msgQReceive( ) call then returns ERROR with errno set to EINTR to indicate that a signal occurred while pending on the message queue (the task does not return to pending).

Message Queues and Queuing Options

VxWorks message queues include the ability to select the queuing mechanism employed for tasks blocked on a message queue. The MSG_Q_FIFO and MSG_Q_PRIORITY options are provided to specify (to the msgQCreate( ) and msgQOpen( ) routines) the queuing mechanism that should be used for tasks that pend on msgQSend( ) and msgQReceive( ).

7 Intertask and Interprocess Communication 7.5 Message Queues

7.5.3 Displaying Message Queue Attributes

The VxWorks show( ) command produces a display of the key message queue attributes, for either kind of message queue. For example, if myMsgQId is a VxWorks message queue, the output is sent to the standard output device, and looks like the following from the shell (using the C interpreter):

-> show myMsgQId

Message Queue Id : 0x3adaf0 Task Queuing : FIFO Message Byte Len : 4 Messages Max : 30 Messages Queued : 14 Receivers Blocked : 0 Send timeouts : 0 Receive timeouts : 0

7.5.4 Servers and Clients with Message Queues

Real-time systems are often structured using a client-server model of tasks. In this model, server tasks accept requests from client tasks to perform some service, and usually return a reply. The requests and replies are usually made in the form of intertask messages. In VxWorks, message queues or pipes (see 7.6 Pipes, p.142) are a natural way to implement this functionality.

For example, client-server communications might be implemented as shown in Figure 7-8. Each server task creates a message queue to receive request messages from clients. Each client task creates a message queue to receive reply messages from servers. Each request message includes a field containing the msgQId of the client’s reply message queue. A server task’s main loop consists of reading request messages from its request message queue, performing the request, and sending a reply to the client’s reply message queue.

Figure 7-8 Client-Server Communications Using Message Queues

reply queue 1

reply queue 2

server task request queue

message message

message

client 2 client 1

The same architecture can be achieved with pipes instead of message queues, or by other means that are tailored to the needs of the particular application.

7.5.5 Message Queues and VxWorks Events

Message queues can send VxWorks events to a specified task when a message arrives on the queue and no task is waiting on it. For more information, see 7.7 VxWorks Events, p.143.

7.6 Pipes

Pipes provide an alternative interface to the message queue facility that goes through the VxWorks I/O system. Pipes are virtual I/O devices managed by the driver pipeDrv. The routine pipeDevCreate( ) creates a pipe device and the underlying message queue associated with that pipe. The call specifies the name of the created pipe, the maximum number of messages that can be queued to it, and the maximum length of each message:

status = pipeDevCreate ("/pipe/name", max_msgs, max_length);

The created pipe is a normally named I/O device. Tasks can use the standard I/O routines to open, read, and write pipes, and invoke ioctl routines. As they do with other I/O devices, tasks block when they read from an empty pipe until data is available, and block when they write to a full pipe until there is space available.

As I/O devices, pipes provide one important feature that message queues cannot—the ability to be used with select( ). This routine allows a task to wait for data to be available on any of a set of I/O devices. The select( ) routine also works with other asynchronous I/O devices including network sockets and serial devices. Thus, by using select( ), a task can wait for data on a combination of several pipes, sockets, and serial devices; see 11.6.9 Pending on Multiple File Descriptors with select( ), p.253.

Pipes allow you to implement a client-server model of intertask communications;

see 7.5.4 Servers and Clients with Message Queues, p.141.

For more information, see the ioLib API reference entry.

7 Intertask and Interprocess Communication 7.7 VxWorks Events

7.7 VxWorks Events

VxWorks events provide a means of communication and synchronization between tasks and other tasks, interrupt service routines (ISRs) and tasks, semaphores and tasks, and message queues and tasks.¹ Events can be sent explicitly by tasks and ISRs, and can be sent when message queues or semaphores are free. Only tasks can receive events.

Events can be used as a lighter-weight alternative to binary semaphores for task-to-task and ISR-to-task synchronization (because no object must be created).

They can also be used to notify a task that a semaphore has become available, or that a message has arrived on a message queue.

The events facility provides a mechanism for coordinating the activity of a task using up to thirty-two events that can be sent to it explicitly by other tasks and ISRs, or when semaphores, and message queues are free. A task can wait on multiple events from multiple sources. Events thereby provide a means for coordination of complex matrix of activity without allocation of additional system resources.

7.7.1 Configuring VxWorks for Events

To provide events facilities, VxWorks must be configured with the INCLUDE_VXEVENTS component.

The VXEVENTS_OPTIONS configuration parameter controls behavior of RTP tasks with regard to events and signals. It has the following options: