之前都是从各个模块开始看起，从底层开始看起。应该改变一下思路，从高往下看，站得高看得远。

源码：contiki-release-2-7platformstm32testcontiki-main.c

int
main()
{
  dbg_setup_uart();
  printf("Initialising
");
  
  clock_init();
  process_init();
  process_start(&etimer_process, NULL);
  autostart_start(autostart_processes);
  printf("Processes running
");
  while(1) {
    do {
    } while(process_run() > 0);
    idle_count++;
    /* Idle! */
    /* Stop processor clock */
    /* asm("wfi"::); */ 
  }
  return 0;
}

主函数中，关于进程的操作：

先对进程进行初始化process_init()。

用process_start(&etimer_process, NULL)，启动etimer_process进程。

用autostart_start(autostart_processes)，启动需要自动启动的进程，看自启动进程相关知识。

最后循环执行进程调度函数process_run。

二、进程初始化

void
process_init(void)
{
  lastevent = PROCESS_EVENT_MAX;

  nevents = fevent = 0;
#if PROCESS_CONF_STATS
  process_maxevents = 0;
#endif /* PROCESS_CONF_STATS */

  process_current = process_list = NULL;
}

初始化最后一个事件标识lastevent为PROCESS_EVENT_MAX

初始化事件总数nevents和事件队列头指针fevent为0。

初始化进程链表头process_list和当前进程process_current为NULL。

三、启动进程

void
process_start(struct process *p, const char *arg)
{
  struct process *q;

  //确保要运行的进程没有在进程链表（已经运行了的进程）中
  /* First make sure that we don't try to start a process that is
     already running. */
  for(q = process_list; q != p && q != NULL; q = q->next);

  /* If we found the process on the process list, we bail out. */
  if(q == p) {//已在进程链表中，返回
    return;
  }
  /* Put on the procs list.*/
  p->next = process_list;//添加要启动的进程到进程链表中
  process_list = p;
  p->state = PROCESS_STATE_RUNNING;//设置进程状态为准备就绪状态
  PT_INIT(&p->pt);//初始化进程pt（lc）

  PRINTF("process: starting '%s'
", PROCESS_NAME_STRING(p));

  /* Post a synchronous initialization event to the process. */
  process_post_synch(p, PROCESS_EVENT_INIT, (process_data_t)arg);//用同步事件启动进程p
}

先确保要启动的进程没有在进程链表中。

再将进程添加到进程链表中。

设置进程状态为PROCESS_STATE_RUNNING，即就绪状态，并初始化pt。

最后传递同步事件给进程p，其中事件标识为PROCSS_EVENT_INIT，事件携带数据data为NULL。

1、传递同步事件

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_current，然后传递事件给进程，最后恢复process_current变量。

2、调用进程

static void
call_process(struct process *p, process_event_t ev, process_data_t data)
{
  int ret;//进程执行主体函数返回值

#if DEBUG
  if(p->state == PROCESS_STATE_CALLED) {//再次调用？
    printf("process: process '%s' called again with event %d
", PROCESS_NAME_STRING(p), ev);
  }
#endif /* DEBUG */
  
  if((p->state & PROCESS_STATE_RUNNING) &&
     p->thread != NULL) {//就绪状态并且执行主体函数不为NULL？
    PRINTF("process: calling process '%s' with event %d
", PROCESS_NAME_STRING(p), ev);
    process_current = p;//设置当前进程变量
    p->state = PROCESS_STATE_CALLED;//设置进程状体为已被调用
    ret = p->thread(&p->pt, ev, data);//执行进程主体函数
    if(ret == PT_EXITED ||
       ret == PT_ENDED ||
       ev == PROCESS_EVENT_EXIT) {//返回值为PT_EXITED或PT_ENDED或传递进来的事件为PROCESS_EVENT_EXIT
      exit_process(p, p);//执行退出进程函数
    } else {
      p->state = PROCESS_STATE_RUNNING;//重新设置为就绪状态，等待事件的到来
    }
  }
}

在进程状态为就绪状态PROCESS_STATE_RUNNING，并且执行主体函数不为NULL的情况下。

设置当前进程变量为p，并设置状态为已被调用状态PROCESS_STATE_CALLED。

调用执行主体函数p->thread(&p->pt, ev, data)。

如果返回值为PT_EXITED或者返回值为PT_ENDED或者这个事件是PROCESS_EVENT_EXIT，则这个进程已经执行完毕了。执行退出进程操作exit_process，做一些善后工作。

否则重新设置进程状态为就绪状态，继续等待事件的到来。

注：注意区分PROCESS_EVENT_EXIT事件和PROCESS_EVENT_EXITED事件，PROCESS_EVENT_EXIT是通知要退出的进程p本身，而PROCESS_EVENT_EXITED是通知其他进程，有进程p即将退出。

退出进程操作有两种情况，一种是自己要退出，即上述情况：返回值为PT_EXITED或者返回值为PT_ENDED或者这个事件是PROCESS_EVENT_EXIT。

另一种是其他进程要这个进程退出。

退出进程

static void
exit_process(struct process *p, struct process *fromprocess)
{
  register struct process *q;
  struct process *old_current = process_current;//先保存当前进程变量

  PRINTF("process: exit_process '%s'
", PROCESS_NAME_STRING(p));

  /* Make sure the process is in the process list before we try to
     exit it. */
  for(q = process_list; q != p && q != NULL; q = q->next);
  if(q == NULL) {
    return;
  }//确定要退出的进程在进程链表中，否则返回

  if(process_is_running(p)) {//进程状态不是PROCESS_STATE_NONE才进入
    /* Process was running */
    p->state = PROCESS_STATE_NONE;//设置状态为PROCESS_STATE_NONE

    /*
     * Post a synchronous event to all processes to inform them that
     * this process is about to exit. This will allow services to
     * deallocate state associated with this process.
     */
    for(q = process_list; q != NULL; q = q->next) {
      if(p != q) {
    call_process(q, PROCESS_EVENT_EXITED, (process_data_t)p);
      }
    }//通知其他所有进程，p进程即将退出

    if(p->thread != NULL && p != fromprocess) {
      /* Post the exit event to the process that is about to exit. */
      process_current = p;
      p->thread(&p->pt, PROCESS_EVENT_EXIT, NULL);
    }
  }//再次执行p进程的执行主体函数（p和fromprocess不同的情况下）

  if(p == process_list) {
    process_list = process_list->next;
  } else {
    for(q = process_list; q != NULL; q = q->next) {
      if(q->next == p) {
    q->next = p->next;
    break;
      }
    }
  }//将进程p从进程链表中删除

  process_current = old_current;//恢复当前进程变量
}

先确定要退出的进程在进程链表中，并且进程状态不是PROCESS_STATE_NONE。

先给其他所有进程，传递同步事件PROCESS_EVENT_EXITED，通知p这个进程即将退出。

如果是其他进程要p退出的话，则再次执行p的执行主体函数。

如果是p要p退出的话，那么执行主体函数都已经执行过了，所以不用再执行。

最后将进程p从进程链表中删除。

int
process_is_running(struct process *p)
{
  return p->state != PROCESS_STATE_NONE;
}

process_is_running

四、进程调度

int
process_run(void)
{
  /* Process poll events. */
  if(poll_requested) {
    do_poll();
  }

  /* Process one event from the queue */
  do_event();

  return nevents + poll_requested;
}

进程调度函数中先处理抢占式进程，然后再处理协同式进程（非同步事件）。

1、推举抢占式进程

void
process_poll(struct process *p)
{
  if(p != NULL) {
    if(p->state == PROCESS_STATE_RUNNING ||
       p->state == PROCESS_STATE_CALLED) {
      p->needspoll = 1;
      poll_requested = 1;
    }
  }
}

最主要的工作时将进程p的needspoll标志设置为1，以及是否有poll请求标志poll_requested设置为1。

2、抢占式进程处理

static void
do_poll(void)
{
  struct process *p;

  poll_requested = 0;//恢复标志
  /* Call the processes that needs to be polled. */
  for(p = process_list; p != NULL; p = p->next) {//遍历进程链表，调用所有需要poll的进程
    if(p->needspoll) {
      p->state = PROCESS_STATE_RUNNING;
      p->needspoll = 0;//恢复标志
      call_process(p, PROCESS_EVENT_POLL, NULL);
    }
  }
}

注：从上边我们知道，抢占式进程会全部都执行完之后，再从事件队列中取出一个事件传递给目的进程处理。

总结

要先用process_start或者autostart_start先将进程启动。

后续的进程调度函数process_run时在进程启动后进行的一些调度，准确的说是传递事件。

进程的状态：

#define PROCESS_STATE_NONE 0　　　　退出前的一个状态，就差从进程链表中删除。
#define PROCESS_STATE_RUNNING 1　　就绪状态，即已经初始化完毕，等待事件的到来，然后执行进程执行主体函数。
#define PROCESS_STATE_CALLED 2　　　进程正在被调用，也就是执行主体函数正在运行中。

Contiki进程间的交互 一、Main函数 二、进程初始化 三、启动进程 四、进程调度 总结