RTAI API 5.1
|
Files | |
file | msg.c |
Message handling functions. | |
Functions | |
RTAI_SYSCALL_MODE RT_TASK * | rt_send (RT_TASK *task, unsigned long msg) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_send_if (RT_TASK *task, unsigned long msg) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_send_until (RT_TASK *task, unsigned long msg, RTIME time) |
brief Send a message with an absolute timeout. More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_send_timed (RT_TASK *task, unsigned long msg, RTIME delay) |
brief Send a message with a relative timeout. More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_evdrp (RT_TASK *task, void *msg) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_receive (RT_TASK *task, void *msg) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_receive_if (RT_TASK *task, void *msg) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_receive_until (RT_TASK *task, void *msg, RTIME time) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_receive_timed (RT_TASK *task, void *msg, RTIME delay) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_sendx (RT_TASK *task, void *msg, int size) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_sendx_if (RT_TASK *task, void *msg, int size) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_sendx_until (RT_TASK *task, void *msg, int size, RTIME time) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_sendx_timed (RT_TASK *task, void *msg, int size, RTIME delay) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_evdrpx (RT_TASK *task, void *msg, int size, long *len) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_receivex (RT_TASK *task, void *msg, int size, long *len) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_receivex_if (RT_TASK *task, void *msg, int size, long *len) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_receivex_until (RT_TASK *task, void *msg, int size, long *len, RTIME time) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * | rt_receivex_timed (RT_TASK *task, void *msg, int size, long *len, RTIME delay) |
More... | |
RTAI_SYSCALL_MODE RT_TASK * rt_evdrp | ( | RT_TASK * | task, |
void * | msg | ||
) |
Eavedrop (spy) the content of a message.
rt_evdrp spies the content of a message from the task specified by task while leaving it on the queue. To actually receive the message any of the rt_receive function must be used specifically. If task is equal to 0, the caller eavdrops the first message of its receive queue, if any. rt_evdrp never blocks.
task | is a pointer to a RT_TASK structure. |
msg | points to any 4 bytes word buffer provided by the caller. |
Referenced by rt_evdrpx().
RTAI_SYSCALL_MODE RT_TASK * rt_evdrpx | ( | RT_TASK * | task, |
void * | msg, | ||
int | size, | ||
long * | len | ||
) |
Eavedrop (spy) the content of an extended message.
rt_evdrpx spies the content of a message from the task specified by task while leaving it on the queue. To actually receive the message any of the rt_receivex function must be used specifically. If task is equal to 0, the caller eavdrops the first message of its receive queue, if any. rt_evdrpix never blocks.
task | is a pointer to a RT_TASK structure. |
msg | points to the message to be eavedropped, without receive. |
size | size of the message to be eavedropped. |
len | is a pointer to an integer to be set to the actual len of the eavedropped message. |
References rt_evdrp().
RTAI_SYSCALL_MODE RT_TASK * rt_receive | ( | RT_TASK * | task, |
void * | msg | ||
) |
Receive a message.
rt_receive gets a message from the task specified by task. If task is equal to 0, the caller accepts messages from any task. If there is a pending message, rt_receive does not block but can be preempted if the task that rt_sent the just received message has a higher priority. The task will not block if it receives rpced messages since rpcing tasks always waits for a returned message. Moreover it inheredits the highest priority of any rpcing task waiting on the receive queue. The receiving task will then recover its priority as explained in rt_return. Otherwise the caller task is blocked waiting for any message to be sent/rpced.
task | is a pointer to a RT_TASK structure. |
msg | points to any 4 bytes word buffer provided by the caller. |
References rt_return().
Referenced by rt_receivex().
RTAI_SYSCALL_MODE RT_TASK * rt_receive_if | ( | RT_TASK * | task, |
void * | msg | ||
) |
Receive a message, only if the calling task is not blocked.
rt_receive_if tries to get a message from the task specified by task. If task is equal to 0, the caller accepts messages from any task. The caller task is never blocked but can be preempted if the task that rt_sent the just received message has a higher priority. The task will not block if it receives rpced messages since rpcing tasks always waits for a returned message. Moreover it inheredits the highest priority of any rpcing task waiting on the receive queue. The receiving task will then recover its priority as explained in rt_return. Otherwise the caller task is blocked waiting for any message to be sent/rpced.
task | is a pointer to the task structure. |
msg | points to a buffer provided by the caller. |
Since all the messaging functions return a task address 0xFFFF could seem an inappropriate return value. However on all the CPUs RTAI runs on 0xFFFF is not an address that can be used by any RTAI task, so it is should be always safe.
References rt_return().
Referenced by rt_receivex_if().
RTAI_SYSCALL_MODE RT_TASK * rt_receive_timed | ( | RT_TASK * | task, |
void * | msg, | ||
RTIME | delay | ||
) |
Receive a message with a relative timeout.
rt_receive_timed receives a message from the task specified by task. If task is equal to 0, the caller accepts messages from any task. If there is a pending message, rt_receive does not block but but can be preempted if the task that rt_sent the just received message has a higher priority. The task will not block if it receives rpced messages since rpcing tasks always waits for a returned message. Moreover it inheredits the highest priority of any rpcing task waiting on the receive queue. The receiving task will then recover its priority as explained in rt_return. Otherwise the caller task is blocked waiting for any message to be sent/rpced. In this case these functions return if: a sender sends a message and has a lower priority; any rpced message is received;
task | is a pointer to the task structure. |
msg | points to a buffer provided by the caller. |
delay | is a timeout relative to the current time. |
See also: rt_receive_until().
References rt_receive_until().
Referenced by rt_receivex_timed().
RTAI_SYSCALL_MODE RT_TASK * rt_receive_until | ( | RT_TASK * | task, |
void * | msg, | ||
RTIME | time | ||
) |
Receive a message with an absolute timeout.
rt_receive_until receives a message from the task specified by task. If task is equal to 0, the caller accepts messages from any task. If there is a pending message, rt_receive does not block but but can be preempted if the task that rt_sent the just received message has a higher priority. The task will not block if it receives rpced messages since rpcing tasks always waits for a returned message. Moreover it inheredits the highest priority of any rpcing task waiting on the receive queue. The receiving task will then recover its priority as explained in rt_return. Otherwise the caller task is blocked waiting for any message to be sent/rpced. In this case these functions return if: a sender sends a message and has a lower priority; any rpced message is received;
task | is a pointer to the task structure. |
msg | points to a buffer provided by the caller. |
time | is an absolute timout value. |
See also: rt_receive_timed().
References rt_return().
Referenced by rt_receive_timed(), and rt_receivex_until().
RTAI_SYSCALL_MODE RT_TASK * rt_receivex | ( | RT_TASK * | task, |
void * | msg, | ||
int | size, | ||
long * | len | ||
) |
Receive an extended message.
rt_receivex gets an extended message msg of size size from the task specified by task task. If task is equal to 0, the caller accepts messages from any task. If there is a pending message, rt_receivex does not block but can be preempted if the task that rt_sent the just received message has a higher priority. The task will not block if it receives rpcxed messages since rpcxing tasks always wait for a returned message. Moreover it inheredits the highest priority of any rpcxing task waiting on the receive queue. The receiving task will then recover its priority as explained in rt_returnx. Otherwise the caller task is blocked waiting for any message to be sentx/rpcxed.
task | is a pointer to a RT_TASK structure. |
msg | points to the message to be eavedropped, without receive. |
size | size of the message to be eavedropped. |
len | is a pointer to an integer to be set to the actual len of the eavedropped message. |
References rt_receive().
RTAI_SYSCALL_MODE RT_TASK * rt_receivex_if | ( | RT_TASK * | task, |
void * | msg, | ||
int | size, | ||
long * | len | ||
) |
Receive an extended message, only if the calling task is not blocked.
rt_receivex gets an extended message msg of size size from the task specified by task task. If task is equal to 0, the caller accepts messages from any task. The caller task is never blocked but can be preempted if the task that rt_sentx the just received message has a higher priority. The task will not block if it receives rpcxed messages since rpcxing tasks always wait for a returned message. Moreover it inheredits the highest priority of any rpcxing task waiting on the receive queue. The receiving task will then recover its priority as explained in rt_returnx. Otherwise the caller task is blocked waiting for any message to be sentx/rpcxed.
task | is a pointer to a RT_TASK structure. |
msg | points to the message to be eavedropped, without receive. |
size | size of the message to be eavedropped. |
len | is a pointer to an integer to be set to the actual len of the eavedropped message. |
References rt_receive_if().
RTAI_SYSCALL_MODE RT_TASK * rt_receivex_timed | ( | RT_TASK * | task, |
void * | msg, | ||
int | size, | ||
long * | len, | ||
RTIME | delay | ||
) |
Receive an extended message with a relative timeout.
rt_receivex_until gets an extended message msg of size size from the task specified by task task. If task is equal to 0, the caller accepts messages from any task. If there is a pending message, rt_receivex does not block but can be preempted if the task that rt_sent the just received message has a higher priority. The task will not block if it receives rpcxed messages since rpcxing tasks always wait for a returned message. Moreover it inheredits the highest priority of any rpcxing task waiting on the receive queue. The receiving task will then recover its priority as explained in rt_returnx. Otherwise the caller task is blocked waiting for any message to be sentx/rpcxed.
In this case these functions return if: a sender sendxs a message and has a lower priority; any rpcxed message is received;
task | is a pointer to a RT_TASK structure. |
msg | points to the message to be eavedropped, without receive. |
size | size of the message to be eavedropped. |
len | is a pointer to an integer to be set to the actual len of the eavedropped message. |
delay | is a timeout relative to the current time. |
References rt_receive_timed().
RTAI_SYSCALL_MODE RT_TASK * rt_receivex_until | ( | RT_TASK * | task, |
void * | msg, | ||
int | size, | ||
long * | len, | ||
RTIME | time | ||
) |
Receive an extended message with an absolute timeout.
rt_receivex_until gets an extended message msg of size size from the task specified by task task. If task is equal to 0, the caller accepts messages from any task. If there is a pending message, rt_receivex does not block but can be preempted if the task that rt_sent the just received message has a higher priority. The task will not block if it receives rpcxed messages since rpcxing tasks always wait for a returned message. Moreover it inheredits the highest priority of any rpcxing task waiting on the receive queue. The receiving task will then recover its priority as explained in rt_returnx. Otherwise the caller task is blocked waiting for any message to be sentx/rpcxed.
In this case these functions return if: a sender sendxs a message and has a lower priority; any rpcxed message is received;
task | is a pointer to a RT_TASK structure. |
msg | points to the message to be eavedropped, without receive. |
size | size of the message to be eavedropped. |
len | is a pointer to an integer to be set to the actual len of the eavedropped message. |
time | is an absolute timout value. |
References rt_receive_until().
RTAI_SYSCALL_MODE RT_TASK * rt_send | ( | RT_TASK * | task, |
unsigned long | msg | ||
) |
Send a message.
rt_send sends the message msg to the task task. If the receiver task is ready to get the message rt_send does not block the sending task, but its execution can be preempted if the receiving task has a higher priority. Otherwise the caller task is blocked and queued up in priority order on the receive list of the sent task.
task | is a pointer to a task structure. |
msg | corresponds to the message that has to be sent. |
RTAI_SYSCALL_MODE RT_TASK * rt_send_if | ( | RT_TASK * | task, |
unsigned long | msg | ||
) |
Send a message, only if the calling task will not be blocked.
rt_send_if sends the message msg to the task task if the latter is ready to receive, so that the caller task is never blocked, but its execution can be preempted if the receiving task is ready to receive and has a higher priority.
task | is a pointer to a task structure. |
msg | corresponds to the message that has to be sent. |
RTAI_SYSCALL_MODE RT_TASK * rt_send_timed | ( | RT_TASK * | task, |
unsigned long | msg, | ||
RTIME | delay | ||
) |
brief Send a message with a relative timeout.
rt_send_timed sends the message msg to the task task. If the receiver task is ready to get the message, this function does not block the sending task, but its execution can be preempted if the receiving task has a higher priority. Otherwise the caller task is blocked and queued up in priority order on the receive list of the sent task. In this case the function returns if:
task | is a pointer to a task structure. |
msg | corresponds to the message that has to be sent. |
delay | is the timeout relative to the current time. |
See also: rt_send_until().
References rt_send_until().
RTAI_SYSCALL_MODE RT_TASK * rt_send_until | ( | RT_TASK * | task, |
unsigned long | msg, | ||
RTIME | time | ||
) |
brief Send a message with an absolute timeout.
rt_send_until sends the message msg to the task task. If the receiver task is ready to get the message, this function does not block the sending task, but its execution can be preempted if the receiving task has a higher priority. Otherwise the caller task is blocked and queued up in priority order on the receive list of the sent task. In this case the function returns if:
task | is a pointer to a task structure. |
msg | corresponds to the message that has to be sent. |
time | is the absolute timeout value. |
See also: rt_send_timed().
Referenced by rt_send_timed().
RTAI_SYSCALL_MODE RT_TASK * rt_sendx | ( | RT_TASK * | task, |
void * | msg, | ||
int | size | ||
) |
Send an extended message.
rt_sendx sends an arbitrary message msg of size size bytes to the task task. If the receiver task is ready to get the message rt_sendx does not block the sending task, but its execution can be preempted if the receiving task has a higher priority. Otherwise the caller task is blocked and queued up in priority order on the receive list of the sent task.
task | is a pointer to a task structure. |
msg | points to the message to be sent. |
size | size of the message to be sent. |
References rt_rpc().
RTAI_SYSCALL_MODE RT_TASK * rt_sendx_if | ( | RT_TASK * | task, |
void * | msg, | ||
int | size | ||
) |
Send an extended message, only if the calling task will not be blocked.
rt_sendx_if sends an arbitrary message msg of size size bytes to the task task if the latter is ready to receive. So the caller task in never blocked but its execution can be preempted if the receiving task has a higher priority.
task | is a pointer to a task structure. |
msg | points to the message to be sent. |
size | size of the message to be sent. |
RTAI_SYSCALL_MODE RT_TASK * rt_sendx_timed | ( | RT_TASK * | task, |
void * | msg, | ||
int | size, | ||
RTIME | delay | ||
) |
Send an extended message with relative timeout.
rt_sendx_until sends an arbitrary message msg of size size bytes to the task task. If the receiver task is ready to get the message rt_sendx_until does not block the sending task, but its execution can be preempted if the receiving task has a higher priority. Otherwise the caller task is blocked and queued up in priority order on the receive list of the sent task. In this case the function returns if:
task | is a pointer to a task structure. |
msg | points to the message to be sent. |
size | size of the message to be sent. |
delay | is r timeout elative to the current time. |
References rt_rpc_timed().
RTAI_SYSCALL_MODE RT_TASK * rt_sendx_until | ( | RT_TASK * | task, |
void * | msg, | ||
int | size, | ||
RTIME | time | ||
) |
Send an extended message with absolute timeout.
rt_sendx_until sends an arbitrary message msg of size size bytes to the task task. If the receiver task is ready to get the message rt_sendx_until does not block the sending task, but its execution can be preempted if the receiving task has a higher priority. Otherwise the caller task is blocked and queued up in priority order on the receive list of the sent task. In this case the function returns if:
task | is a pointer to a task structure. |
msg | points to the message to be sent. |
size | size of the message to be sent. |
time | is an absolute timeout value. |
References rt_rpc_until().