您的位置：首页 > 大数据 > 物联网

Contiki协议栈Rime:引子introduction

2016-05-22 11:20 771 查看

更多的Contiki协议栈知识，请参考索引目录：

《Contiki协议栈:索引目录》

1. 前言

思来想去，既然是程序员，当然还是用一个程序引入比较好。当然，这个程序必须满足以下几点：

足够简单，不会把大家给吓着了

能够引入足够多的知识点，可以串起来

能够说明包如何在网络中传输

然后我就找啊找，找到了Contiki的一个demo例程：examples/rime/example-abc.c

2. 匿名广播例程

#include "contiki.h"
#include "net/rime/rime.h"
#include "random.h"

#include "dev/button-sensor.h"

#include "dev/leds.h"

#include <stdio.h>
/*---------------------------------------------------------------------------*/
PROCESS(example_abc_process, "ABC example");
AUTOSTART_PROCESSES(&example_abc_process);
/*---------------------------------------------------------------------------*/
static void
abc_recv(struct abc_conn *c)
{
printf("abc message received '%s'\n", (char *)packetbuf_dataptr());
}
static const struct abc_callbacks abc_call = {abc_recv};
static struct abc_conn abc;
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(example_abc_process, ev, data)
{
static struct etimer et;

PROCESS_EXITHANDLER(abc_close(&abc);)

PROCESS_BEGIN();

abc_open(&abc, 128, &abc_call);

while(1) {

/* Delay 2-4 seconds */
etimer_set(&et, CLOCK_SECOND * 2 + random_rand() % (CLOCK_SECOND * 2));

PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));

packetbuf_copyfrom("Hello", 6);
abc_send(&abc);
printf("abc message sent\n");
}

PROCESS_END();
}

　　这个例程估计是Contiki中最简单的、能够在节点间传输数据包的例程了。

　　abc的全称是Anonymous Broad Cast，即匿名广播。所谓广播，是指该节点发出的广播消息，在无线覆盖范围内的其它节点都需要接收。所谓匿名，是指发出的消息中没有携带发送节点的地址。

　　匿名广播是Rime协议栈中最底层的子协议，其它所有协议都直接或间接地建立在该协议之上。Rime协议的框架如下图所示。

图 Rime协议栈架构

　　咋一看！天，这么多，全是协议吗？我要学到什么时候？我的回答是：对，这些全是协议栈中的子协议，但是不要慌，每一个子协议都非常简单。比如abc协议，代码就六七十行，能复杂到哪儿去？。我们后面会慢慢讲述这些协议。

3. 基本分析

　　先讲讲我们的应用程序如何实现发送、接收匿名广播的。

　　整个例程的关键代码就三行：

abc_open(&abc, 128, &abc_call); // 打开一个abc连接
packetbuf_copyfrom("Hello", 6); // 将要发送的消息拷贝到buffer
abc_send(&abc);   // 将buffer中的消息发送出去

　　整个过程是不是与传统网络编程类似呢？

　　abc_open，创建一个abc连接，类似于创建一个socket

　　packetbuf_copyfrom，将消息放到buffer

　　abc_send，将消息发送出去，类似于socket编程中的send

　　对了，socket编程中有一个receive函数，用于接收对方发送过来消息，在这个例程中为啥没有呢？其实是用的，注意看

abc_open(&abc, 128, &abc_call)

的第三个参数，它是一个结构体，结构体里面的成员是一个函数指针。当本节点接收到其它节点发送的匿名广播消息时，会自动调用这个函数指针所指向的函数进行接收数据！我们只用将接收函数写好，完全不用考虑在何时需要接收，这真是既高级、又简单啊！

　　socket中的关闭套接字，对应本例程中的什么呢？答案是

PROCESS_EXITHANDLER(abc_close(&abc);)

。但是要注意，这里的abc_close与socket中的close稍有不同，它是放在一个宏PROCESS_EXITHANDLER里面的，且该语句放在线程的最前面，而不是放在最后面。

　　简单地说，当abc进程接收到一个退出事件时，会执行函数

abc_close(&abc)

关闭打开的abc连接。

　　简单总结一下，该例程首先打开一个匿名广播连接，然后将要发送的消息拷贝到发送buffer里面，然后发送该消息。此外，程序里加了一个事件定时器，每次进入while循环时先延迟2~4秒，再发送广播消息。如果节点接收到其它节点发送的abc消息，则自动调用回调函数abc_recv（）接收消息并做相应的处理。

　　在文章最后，我们会在cooja仿真器中运行该例程，看看运行结果。

4. 深入分析

　　俗话说，麻雀虽小五脏俱全，我们的abc例程就是一个小麻雀。我们需要深入跟踪代码了，很兴奋有木有！

PS: 下面很多术语，会在今后的笔记中慢慢体现，现在只是为了让大家知道今后要学些什么，在脑袋里有个框架，所以不明白也没关系

4.1 struct abc_conn

　　先看一个abc连接

static struct abc_conn abc;

的具体定义：

//相关代码位于core/net/rime/abc.[ch]
struct abc_conn {
struct channel channel;  // 通道
const struct abc_callbacks *u; // 回调函数
};

　　struct abc_conn有两个成员变量，一个struct channel类型的channel，一个const struct abc_callbacks类型的指针u，它们分别啥意思呢？那就得先看看abc_open(&abc, 128, &abc_call)了。

4.2 abc_open

void abc_open(struct abc_conn *c, uint16_t channelno,
const struct abc_callbacks *callbacks)
{
channel_open(&c->channel, channelno); //打开一个channel
c->u = callbacks; // 将回调结构体赋值给abc连接的结构体中的回调结构体指针
channel_set_attributes(channelno, attributes); //设置通道属性
}

　　例程中的

abc_open(&abc, 128, &abc_call);

一共有三个参数：

　　abc: 是一个struct abc_conn类型的abc连接

　　128: 表示通道的通道号

　　abc_call: 接收到消息的回调函数

　　至此，我们有两个新东西：

通道（通道号）

属性

4.3 通道

　　Rime协议栈所有通信都是通过通道channel标识的，即两个应用进程通信需要相同的channel。类似于socket编程，两个进程通信具有相同的端口号。

　　struct channel

//相关代码位于core/net/rime/channel.[ch]
struct channel {
struct channel *next;  // 指向下一个通道结构体
uint16_t channelno; // 通道号
const struct packetbuf_attrlist *attrlist; //属性链表
uint8_t hdrsize; // 头部尺寸
};

　next：一看就知道用于链表。所有的通道会放在一个通道链表之中

　channelno：通道号，16位无符号整数。类似于socket的端口号，标识一个通道

　attrlist：属性链表。存放属性

　hdrsize：发送、接收数据的缓冲包的头部大小

　

　至此，我们又多了一个新的概念：

缓冲包packetbuf

4.4 包属性

　　Rime协议的一个与众不同之处就在于属性。其它的协议，都会定义协议头，在打包的时候安装协议规定组装协议头，在解析包的时候也安装协议规定拆分协议头。而Rime协议不定义任何头部格式，它定义了很多包属性，因此可以兼容各种已经存在的协议，甚至还未开发的协议。正式由于它是如此神奇，所以你只有在慢慢研究代码的时候才能体会到它的奥妙！

4.5 包缓冲packetbuf

　　在abc的例程中，我们提过：

packetbuf_copyfrom("Hello", 6);

　　在Rime协议栈中，存在一个包缓冲——packetbuf。在发送消息时，将包缓冲里的数据通过底层mac协议发送出去，在接收消息时，底层mac协议会将接收到的数据放到packetbuf中。

packetbuf_copyfrom("Hello", 6);

就是将字符串“Hello”拷贝到packetbuf中，等待发送。

4.6 缓冲队列queuebuf

　　Rime协议中只有一个包缓冲，但是如果多个进程想发送消息该怎么办呢？将这些消息放在缓冲队列里（PS，这是我猜的，因为我还没接触过这部分的代码，后面会慢慢接触到）。

4.8 abc_send

　　上面这么多的知识点，都是由

abc_open

引出的，

abc_send

会引出多少内容呢？

int abc_send(struct abc_conn *c)
{
return rime_output(&c->channel); // 直接调用rime_output
}

　　跟踪rime_output：

int rime_output(struct channel *c)
{
RIMESTATS_ADD(tx); // 还不知道是啥，我也没看
if(chameleon_create(c)) { // 创建一个变色龙包
packetbuf_compact(); // 使包缓冲更紧凑，在packetbuf中将会学习到

NETSTACK_LLSEC.send(packet_sent, c); // 发送！！
return 1;
}
return 0;
}

　　猛然间多了很多新东西：

　　chameleon：负责将属性链表中的属性打包到packetbuf的头部

　　LLSEC：利用底层协议发送packetbuf中的消息

4.9 变色龙chameleon

　　从Rime架构中可以看出，Rime的形状类似于一个沙漏——上下两头大、中间小，而变色龙处于整个沙漏的中心。

Rime的变色龙架构图

　　chameleon主要负责两件事儿，解析和打包。

　　当接收到数据时，chameleon的unpack_header函数会解析存放到packetbuf中的包头，将解析出来的包头属性存放到属性数组中。

　　当发送数据时，chameleon的pack_header函数会根据属性链表将包属性数组中的属性打包成packetbuf头。

4.10 LLSEC层

　　我们追踪LLSEC的代码：

// 以下代码在core/net/netstack.h
#ifndef NETSTACK_LLSEC
#ifdef NETSTACK_CONF_LLSEC
#define NETSTACK_LLSEC NETSTACK_CONF_LLSEC
#else /* NETSTACK_CONF_LLSEC */
#define NETSTACK_LLSEC nullsec_driver  // 默认的LLSEC驱动
#endif /* NETSTACK_CONF_LLSEC */
#endif /* NETSTACK_LLSEC */

　　默认为nullsec_driver, 继续追踪：

const struct llsec_driver nullsec_driver = {
"nullsec",
init,
send,
input
};

　　再追踪

NETSTACK_LLSEC.send(packet_sent, c);

，即

nullsec_driver.send

：

static void send(mac_callback_t sent, void *ptr)
{
packetbuf_set_attr(PACKETBUF_ATTR_FRAME_TYPE, FRAME802154_DATAFRAME);
NETSTACK_MAC.send(sent, ptr);
}

　　最后，我们看到，NETSTACK_LLSEC.send会调用到NETSTACK_MAC.send