关于MQX操作系统，也使用了一段时间了，一直想总结一下，今天就算开个头吧，希望后续整理一下思路，多做一些关于MQX的专题总结。言归正传！
在MQX应用程序中可采用如下方式实现任务间的资源共享：
1. 事件、轻量级事件
2. 信号量、轻量级信号
3. 互斥锁
4. 消息、轻量级消息
事件和轻量级事件是MQX的可选组件。他们是通过改变状态位实现。优点是低开销，反应快。适用于传递简单信息。如下：
一个任务创建一个事件组，同时创建一个任务。打开事件组。等待事件发生，当任务发生时清除任务标志位，执行事件发生后的操作。在另一个任务中，打开事件组，做该任务需要做的任务，当需要让这个事件发生时，设置事件位。
The example
The event example code shows how a task waits for an event. This event
can be set by any other process or interrupt in the system. The example
simulates an ISR event using another simple task.
Explanation of the example
The example application creates two tasks. The service_task task
creates an event group, opens it and enters a loop in which it waits
for an event bit. When the appropriate event bit is set, it clears it
and prints "Tick.". The simulated_ISR_task task opens a connection to
the event group and periodically sets the corresponding event bit with
a delay in between.
轻量级信号量是MQX的核心组件，通过低开销就可以实现对共享资源的同步访问。轻量级事件消耗的空间小并且反应快。仅通过FIFO方式统计轻量级信号量。
信号量是可选组件。计数信号量。可使用信号量同步任务，保护访问共享资源。信号量提供FIFO队列、优先级队列、优先级继承操作。
The lwsem example
The lwsem example code shows how lightweight semaphores works. The code is written in a way that two different semaphores are synchronized to ensure mutual exclusion of a common memory space.
Explaining the example
The light weight semaphores example uses four tasks:
1 read_task
3 write_task
The read_task starts by creating two lightweight semaphores (WRITE_SEM and
READ_SEM) that govern the access to a data memory location (FIFO.Data). The
WRITE_SEM starts enabled, while the REA_SEM is disabled.
Result = _lwsem_create(&fifo.READ_SEM, 0);
Result = _lwsem_create(&fifo.WRITE_SEM, 1);
Parameters:
&fifo.READ_SEM = pointer to the lightweight semaphore to create
0 = Initial semaphore counter
Then 3 write task are created with initial_data equal to ‘A’, ‘B’, ‘C’ correspondingly.
If the READ_SEM is available (_lwsem_wait), the read_task prints on the HyperTerminal
whatever the shared memory space contains.
Result = _lwsem_wait(&fifo.READ_SEM);
putchar(‘\n’);
putchar(fifo.DATA);
Finally the WRITE_SEM is posted
_lwsem_post(&fifo.WRITE_SEM);
The write task verifies if the WRITE_SEM is available (_lwsem_wait), then writes at the
shared memory space, task initial_value.
Result = _lwsem_wait(&fifo.WRITE_SEM)
fifo.DATA = (uchar)initial_data;
Finally the READ_SEM is posted
_lwsem_post(&fifo.READ_SEM);
The following figure shows how the tasks behave in the lwsem example.
互斥锁是一个可选组件。当任务访问共享资源时，互斥锁提供了任务之间的相互排斥。互斥对象提供轮询、FIFO排队、优先级排队、spin-only limited-spin排队,优先级继承,优先级保护。任务不能解锁互斥锁,除非它首次锁定的互斥锁。
The example
The mutex example code is used to demonstrate how to use a mutex to
synchronize two tasks. It creates a mutex and two tasks. Both tasks use
STDOUT to print out messages. Each task will lock the mutex before
printing and unlock it after printing to ensure that the outputs from
tasks are not mixed together.
Explanation of the example
The application demo creates the main task first. The main task then
creates two print tasks. The flows of the tasks are described in the
next figure.
The main task first initializes the mutex with the following line:
_mutex_init(&print_mutex, &mutexattr)
Then the main task creates a print task with parameter sting1, and
creates a second print task with parameter strings withthe following
line:
_task_create(0, PRINT_TASK, (uint_32)string1);
_task_create(0, PRINT_TASK, (uint_32)string2);
Then the main task blocks itself.
The two print tasks both use the STDOUT. If they used it in the same
time, there would be conflicts, so a mutex is used to synchronize the
two tasks.
Each print task will try to lock the mutex before printing the message;
it will wait for the mutex as long as needed. Once the mutex is locked
it prints the message and then unlocks the mutex so that the other task
can lock it. This process is repeated indefinitely.
消息是一个可选组件，任务可以通过消息队列相互通信。每个任务打开自己的input-message队列，MQX创建队列时给消息队列分配队列ID。只有打开这个消息队列的任务才可以从这个队列中接收消息。任何任务如果知道消息队列的ID都可以发送消息到这个消息队列。任务从消息池分配消息。
轻量级消息队列是一个可选组件。它低开销实现标准MQX消息机制。任务从轻量级消息队列发送和接收消息。消息在消息池中的大小是确定的，是4字节的倍数。
The lwmsgq example
This client/server model shows communication and task synchronization
using message passing.
Server task initializes the message queues, creates three client tasks,
and then waits for a message.
After receiving a message, the task returns the message to the sender.
Client task sends a message to the server_task and then waits for a
reply.
Explanation of the example
The flow of the tasks is described in the next figure. There is a
server task that receives all the incoming data and responds to them.
There are three client tasks. Each client sends a message to the server
and receives the answer back from it.
上述例程所涉及代码可参考mqx/examples例程。
本文出自 “KenoTu” 博客，请务必保留此出处http://kenotu.blog.51cto.com/4006069/1584451
原文地址：http://kenotu.blog.51cto.com/4006069/1584451
