Contiki事件

一、事件相关数据结构

1、事件结构体

struct event_data {
  process_event_t ev;
  process_data_t data;
  struct process *p;
};

其中process_event_t和process_data_t的定义：

typedef unsigned char process_event_t;
typedef void *        process_data_t;

所以event_data结构体中的ev是一个unsigned char型数据，标识事件的类型。

（1）事件标识ev

其中0-127为用户进程内使用，128-255用于不同进程之间的通信。

Event identifiers below 127 can be freely used within a user process, whereas event identifiers above 128 are intended to be used between different processes. Identifiers above 128 are managed by the kernel. The first numbers over 128 are statically allocated by the kernel, to be used for a range of different purposes.

• 系统定义的事件标识：

#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
#define PROCESS_EVENT_MSG             0x86
#define PROCESS_EVENT_EXITED          0x87
#define PROCESS_EVENT_TIMER           0x88
#define PROCESS_EVENT_COM             0x89
#define PROCESS_EVENT_MAX             0x8a

PROCESS_EVENT_NONE : This event identifier is not used.

PROCESS_EVENT_INIT : This event is sent to new processes when they are initiated.

PROCESS_EVENT_POLL : This event is sent to a process that is being polled.

PROCESS_EVENT_EXIT : This event is sent to a process that is being killed by the kernel. The process may choose to clean up any allocated resources, as the process will not be invoked again after receiving this event.

PROCESS_EVENT_CONTINUE : This event is sent by the kernel to a process that is waiting in aPROCESS_YIELD() statement.

PROCESS_EVENT_MSG : This event is sent to a process that has received a communication message. It is typically used by the IP stack to inform a process that a message has arrived, but can also be used between processes as a generic event indicating that a message has arrived.

PROCESS_EVENT_EXITED : This event is sent to all processes when another process is about to exit. A pointer to the process control block of the process that is existing is sent along the event. When receiving this event, the receiving processes may clean up state that was allocated by the process that is about to exit.

PROCESS_EVENT_TIMER : This event is sent to a process when an event timer (etimer) has expired.

• 最后一个事件标识lastevent

我们知道128-255用于不同进程之间的通信，lastevent用来记录最后一个分配出去的事件标识，下个事件标识应该是lastevent加1。lastevent初始化为PROCESS_EVENT_MAX。

/*---------------------------------------------------------------------------*/
process_event_t
process_alloc_event(void)
{
  return lastevent++;
}

  lastevent = PROCESS_EVENT_MAX;

（2）事件数据

event_data是事件发生时，所携带的相关信息，其类型为指向void型的指针。

（3）事件所要传递到的目的进程的指针

struct process *p;

p为指向这个事件所要传递到的进程的指针。

在http://www.cnblogs.com/songdechiu/p/5801136.html我们知道，进程执行实体函数如下

static char process_thread_name(struct pt *process_pt, process_event_t ev, process_data_t data);

进程是由事件驱动的，并采用了protothread机制。进程执行实体函数，三个参数，

struct pt *process_pt, process_event_t ev, process_data_t data

其中process_pt可以理解为lc，ev就是本次传递给本进程的事件标识，data为本次传递给本进程事件所携带的信息。

2、事件队列

static struct event_data events[PROCESS_CONF_NUMEVENTS];

#define PROCESS_CONF_NUMEVENTS 32

这个事件队列是由数组实现的循环队列，默认最多可以存放32个事件。当超过32个事件后，从头开始循环存储。

大致示意图：

参考百度百科

（1）事件总数nevents和队列头指针fevent

static process_num_events_t nevents, fevent;
typedef unsigned char process_num_events_t;

在do_event中可看出

/* Since we have seen the new event, we move pointer upwards
       and decrese the number of events. */
    fevent = (fevent + ) % PROCESS_CONF_NUMEVENTS;
    --nevents;

nevents是需要处理的事件总数，也是队列大小。

fevent是当前需要处理的事件在数组数组中的偏移，这里fevent相当于头指针head。

（2）process_maxevents

#if PROCESS_CONF_STATS
process_num_events_t process_maxevents;
#endif

#if PROCESS_CONF_STATS
  if(nevents > process_maxevents) {
    process_maxevents = nevents;
  }
#endif /* PROCESS_CONF_STATS */

process_maxevents为最多事件数，注意与PROCESS_CONF_NUMEVENTS区分，PROCESS_CONF_NUMEVENTS为队列的最大容量。

二、事件相关处理函数

1、process_nevents

int
process_nevents(void)
{
  return nevents + poll_requested;
}

返回需要处理的事件总数nevents和poll请求标志的和。进程分为两种，协调式和抢占式。nevents代表需药给协调式进程处理的事件，poll_requested代表需要给抢占式进程处理的事件。

2、非同步事件处理

非同步事件处理中，函数process_post先将事件放到事件队列中。

事件处理函数do_event()再把事件传递给接收事件的进程。

（1）非同步事件传递函数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) {//队列已满，返回错误信息RPOCESS_ERR_FULL
#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;//事件总数加1

#if PROCESS_CONF_STATS
  if(nevents > process_maxevents) {
    process_maxevents = nevents;//更新process_maxevents
  }
#endif /* PROCESS_CONF_STATS */

  return PROCESS_ERR_OK;//返回成功信息
}

这个函数就是把事件放到事件队列中去。先判断队列是否已经满，满了就返回错误信息。没满则先找到尾指针，将事件添加到队列尾部，返回成功信息。

（2）事件处理函数do_event

static void
do_event(void)
{
  static process_event_t ev;
  static process_data_t data;
  static struct process *receiver;
  static struct process *p;

  /*
   * If there are any events in the queue, take the first one and walk
   * through the list of processes to see if the event should be
   * delivered to any of them. If so, we call the event handler
   * function for the process. We only process one event at a time and
   * call the poll handlers inbetween.
   */

  if(nevents > ) {//有事件需要处理，取出第一个事件

    /* There are events that we should deliver. */
    ev = events[fevent].ev;

    data = events[fevent].data;
    receiver = events[fevent].p;

    /* Since we have seen the new event, we move pointer upwards
       and decrese the number of events. */
    fevent = (fevent + ) % PROCESS_CONF_NUMEVENTS;//头指针后移
    --nevents;//事件总数减1

    /* If this is a broadcast event, we deliver it to all events, in
       order of their priority. */
    if(receiver == PROCESS_BROADCAST) {//广播事件？
      for(p = process_list; p != NULL; p = p->next) {//遍历所有进程

    /* If we have been requested to poll a process, we do this in
       between processing the broadcast event. */
    if(poll_requested) {//在此期间，如果有抢占式进程需要执行，则先执行抢占式进程
      do_poll();
    }
    call_process(p, ev, data);//没有的话，将事件依次传给所有进程
      }
    } else {//不是广播事件
      /* This is not a broadcast event, so we deliver it to the
     specified process. */
      /* If the event was an INIT event, we should also update the
     state of the process. */
      if(ev == PROCESS_EVENT_INIT) {//初始化事件？
    receiver->state = PROCESS_STATE_RUNNING;//设置状态，这个状态是就绪状态
      }

      /* Make sure that the process actually is running. */
      call_process(receiver, ev, data);//传递事件给特定进程
    }
  }
}

这个函数最终就是调用call_process函数，将事件传递给特定进程。进程执行主体函数开始执行。

3、同步事件处理

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;//恢复当前进程指针
}

同步事件处理中，事件立马就传递给了特定的进程，表现为立马执行ProcessB的执行实体函数。