进程的结构
Contiki的进程由两部分组成：进程控制块和进程线程。进程控制块存储在内存中，它包含进程运行时的信息，比如：进程名、进程状态、指向进程线程的指针。
进程线程是存储在ROM中的一个代码块。
进程控制块PCB（process control block）
struct process {
struct process *next;
#if PROCESS_CONF_NO_PROCESS_NAMES
#define PROCESS_NAME_STRING(process) ""
#else
const char *name;
#define PROCESS_NAME_STRING(process) (process)->name
#endif
PT_THREAD((* thread)(struct pt *, process_event_t, process_data_t));
struct pt pt;
unsigned char state, needspoll;
};
struct pt {
lc_t lc;
};
/** \hideinitializer */
typedef unsigned short lc_t;
进程控制块包含每个进程的信息，比如进程状态、指向进程的线程的指针、进程的文本名称。进程控制块只在内核内部使用，不能被进程直接访问。
用户代码不能直接访问进程控制块的任何成员。
进程控制块是轻量级的，只需要几个字节的内存。进程控制块的结构体如上面所示。该结构体中任何成员都不能被直接访问，只有进程管理函数能够访问这些成员。
进程控制块的第一个成员 struct process *next，指向进程链表中的下一个进程控制块。
成员const char *name，指向进程的文本类型的名字。
成员PT_THREAD((* thread)(struct pt *, process_event_t, process_data_t))，一个函数指针，指向了进程的线程。
成员unsigned char state, needspoll,是内部标志，当进程被轮询时，通过函数process_poll()修改该标志。
进程的创建过程
进程控制块不是直接定义和声明的，而是通过宏PROCESS()。
PROCESS(hello_world_process, "Hello world");
如上例所示，该宏有两个参数，用于访问该进程的进程控制块变量名hello_world_process、用于调试和打印进程的进程文本名字"Hello world"。
进程线程
进程线程是一个单一的protothread，由进程调度器调度。例子如下：
PROCESS_THREAD(hello_world_process, ev, data)
{
PROCESS_BEGIN(); printf("Hello, world\n"); PROCESS_END();
}
Protothreads
当在等待某个事件发生时，protothread允许系统运行其它活动。protothread的概念是在开发Contiki的过程中提出来的，但是这个概念不是与Contiki绑定在一起的。protothread也可以很好地运行在许多其它的系统中。
Contiki运行在内存受限的系统之上，减小内存负载显得尤为重要。protothread提供了一种很好的方法，可以让C函数在没有传统线程内存负载的情况下，以类似线程的方式运行。
protothread可以看作是一个常规的C函数。该函数使用两个特殊的宏作为开始和结束：PROCESS_BEGIN()和PROCESS_END()。
C预处理器实现了protothread的主要操作：
struct pt {
lc_t lc;
};
#define PT_WAITING 0
#define PT_YIELDED 1
#define PT_EXITED 2
#define PT_ENDED 3
#define PT_INIT(pt) LC_INIT((pt)->lc)
#define PT_BEGIN(pt) { char PT_YIELD_FLAG = 1;\
if (PT_YIELD_FLAG) {;} LC_RESUME((pt)->lc)
#define PT_END(pt) LC_END((pt)->lc); PT_YIELD_FLAG = 0; \
PT_INIT(pt); return PT_ENDED; }
#define PT_WAIT_UNTIL(pt, condition) \
do { \
LC_SET((pt)->lc); \
if(!(condition)) { \
return PT_WAITING; \
} \
} while()
#define PT_EXIT(pt) \
do { \
PT_INIT(pt); \
return PT_EXITED; \
} while()
进程中的Protothreads
Contiki进程自身实现了一套protothread，它允许进程等待即将到来的事件。因此，Contiki进程中使用的protothread语句与上面介绍的纯protothread语句有微小的差异。
Contiki进程中使用的进程相关的protothread宏：
PROCESS_BEGIN(); // Declares the beginning of a process' protothread.
PROCESS_END(); // Declares the end of a process' protothread.
PROCESS_EXIT(); // Exit the process.
PROCESS_WAIT_EVENT(); // Wait for any event.
PROCESS_WAIT_EVENT_UNTIL(); // Wait for an event, but with a condition.
PROCESS_YIELD(); // Wait for any event, equivalent to PROCESS_WAIT_EVENT().
PROCESS_WAIT_UNTIL(); // Wait for a given condition; may not yield the process.
PROCESS_PAUSE(); // Temporarily yield the process.
事件
Contiki中，进程接收到一个事件后就会运行。Contiki中有两种事件：异步事件和同步事件。
当一个异步事件被发出时，该事件被放到内核中的事件队列中，并在一段时间后被传递到接收进程中。
当一个同步事件被发出时，该事件被立即传递到接收进程中。
异步事件
异步事件在被发出一段时间后才能被传递到接收进程。在事件被发出后和被传递前的这段时间，它被保存在Contiki内核的事件队列中。
内核负责将事件队列中的事件传递到接收进程。内核循环遍历事件队列，通过调用进程将队列中的事件传递到进程中。
异步事件的接收者可以是一个特殊进程（何为特殊进程？），也可以是所有正在运行的通用进程。当接收者是一个特殊进程，内核就调用该进程并传递事件到该进程中。当事件接收者是系统中的通用进程，内核将一个接一个地顺序传递事件到所有的进程中。
异步事件通过函数process_post()发出。
int
process_post(struct process *p, process_event_t ev, process_data_t data)
{
static process_num_events_t snum; if(PROCESS_CURRENT() == NULL) {
PRINTF("process_post: NULL process posts event %d to process '%s', nevents %d\n",
ev,PROCESS_NAME_STRING(p), nevents);
} else {
PRINTF("process_post: Process '%s' posts event %d to process '%s', nevents %d\n",
PROCESS_NAME_STRING(PROCESS_CURRENT()), ev,
p == PROCESS_BROADCAST? "<broadcast>": PROCESS_NAME_STRING(p), nevents);
} if(nevents == PROCESS_CONF_NUMEVENTS) {
#if DEBUG
if(p == PROCESS_BROADCAST) {
printf("soft panic: event queue is full when broadcast event %d was posted from %s\n", ev, PROCESS_NAME_STRING(process_current));
} else {
printf("soft panic: event queue is full when event %d was posted to %s frpm %s\n", ev, PROCESS_NAME_STRING(p), PROCESS_NAME_STRING(process_current));
}
#endif /* DEBUG */
return PROCESS_ERR_FULL;
} snum = (process_num_events_t)(fevent + nevents) % PROCESS_CONF_NUMEVENTS;
events[snum].ev = ev;
events[snum].data = data;
events[snum].p = p;
++nevents; #if PROCESS_CONF_STATS
if(nevents > process_maxevents) {
process_maxevents = nevents;
}
#endif /* PROCESS_CONF_STATS */ return PROCESS_ERR_OK;
}
process_post()的内部实现很简单（还是理清头绪才简单）。先检查当前事件队列的大小，检查是否还有可以存放事件的空间，然后再做决定，如果没有足够的空间，该函数返回一个错误，如果有足够的空间，该函数将事件插入到事件队列的末尾，然后返回。
同步事件
与异步事件不同的是，同步事件被发出后不经过事件队列，会被直接传递。同步事件只能被发出给一个特定进程。由于同步事件直接被传递，因此传递一个同步事件在功能上等同于一个函数调用：接收进程被直接调用，发送进程在接收进程完成处理事件前一直处于阻塞状态。不过，接收进程不会被告诉所发出的事件是同步事件还是异步事件。
同步事件是通过函数process_post_synch()发出。
void
process_post_synch(struct process *p, process_event_t ev, process_data_t data)
{
struct process *caller = process_current; call_process(p, ev, data);
process_current = caller;
}
轮询（不太理解）
轮询请求是一个特殊的事件。进程可以通过调用函数process_poll()请求被轮询。进程请求轮询后，会尽可能快地被调用。当轮询到该进程时，会传递一个特殊的事件到进程中。
事件标识(zhi)符
事件被事件标识符所标识。事件标识符是一个8比特，一个字节的数组，会被传递到接收进程中。接收进程可以根据接收到的不同的事件标识符来做相应不同的处理。
事件标识符的范围是0~255，在127一下的事件标识符可以在一个用户进程中*使用，在128以上的事件标识符只能在不同的进程间使用。在128以上的事件标识符被内核所管理。
从128开始的数字被内核静态分配，用于实现不同的目的。
Contiki内核保留的事件标识符：
#define PROCESS_EVENT_NONE 0x80 //该事件标识符 没有被使用
#define PROCESS_EVENT_INIT 0x81 //该事件被发送到一个正在初始化的新进程中
#define PROCESS_EVENT_POLL 0x82 //该事件被发送到一个轮询进程中
#define PROCESS_EVENT_EXIT 0x83 //该事件被发送到一个正在被内核杀死的进程中。
//进程接收到该事件后，因为可能不会被再次调用，因此它可以选择清空自己分派到的资源
#define PROCESS_EVENT_SERVICE_REMOVED 0x84
#define PROCESS_EVENT_CONTINUE 0x85 //该事件被内核发送到一个执行了PROCESS_YIELD()而正在等待的进程
#define PROCESS_EVENT_MSG 0x86 //该事件被发送到一个已经接收到通信消息的进程。
//它一般被用于IP栈去通知进程有消息到来了，也可以用与两个进程间表示一个通用消息到来了。
#define PROCESS_EVENT_EXITED 0x87 /*当一个进程将要退出时，该事件被发送到所有进程。
发送事件的同时，还会发送一个指向正在退出的进程的进程控制块的指针。
当接收到该事件时，接收进程将清除将要退出进程所分配的状态*/
#define PROCESS_EVENT_TIMER 0x88 //该事件被发送给一个事件定时器etimer到期的进程
#define PROCESS_EVENT_COM 0x89
#define PROCESS_EVENT_MAX 0x8a
除静态分配事件号之外，进程可以分配用于进程间的大于128的事件标识符。被分配的事件标识符被存储在一个变量中，接收进程可以使用该变量来匹配事件标识符。
摘录自：http://blog.****.net/tidyjiang/article/details/51378589