[Rime 协议栈] 引子 introduction

前言

打算写一个系列的博客来介绍 Rime 协议栈,思来想去,既然是程序员,当然还是用一个程序引入比较好。当然,这个程序必须满足以下几点:

  • 足够简单,不会把大家给吓着了
  • 能够引入足够多的知识点,可以串起来
  • 能够说明包如何在网络中传输

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

匿名广播例程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#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协议的框架如下图所示。

![这里写图片描述](http://img.blog.csdn.net/20160522104844086)

图 Rime协议栈架构

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

基本分析

  先讲讲我们的应用程序如何实现发送、接收匿名广播的。
  整个例程的关键代码就三行:

1
2
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仿真器中运行该例程,看看运行结果。

深入分析

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

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

struct abc_conn

  先看一个abc连接static struct abc_conn abc;的具体定义:

1
2
3
4
5
//相关代码位于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)了。

abc_open

1
2
3
4
5
6
7
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: 接收到消息的回调函数

  至此,我们有两个新东西:

  • 通道(通道号)
  • 属性

通道

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

  struct channel

1
2
3
4
5
6
7
//相关代码位于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

包属性

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

包缓冲packetbuf

  在abc的例程中,我们提过:

1
packetbuf_copyfrom("Hello", 6);

  在Rime协议栈中,存在一个包缓冲——packetbuf。在发送消息时,将包缓冲里的数据通过底层mac协议发送出去,在接收消息时,底层mac协议会将接收到的数据放到packetbuf中。packetbuf_copyfrom("Hello", 6);就是将字符串“Hello”拷贝到packetbuf中,等待发送。

缓冲队列queuebuf

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

abc_send

  上面这么多的知识点,都是由abc_open引出的,abc_send会引出多少内容呢?

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

  跟踪rime_output:

1
2
3
4
5
6
7
8
9
10
11
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中的消息

变色龙chameleon

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

![这里写图片描述](http://img.blog.csdn.net/20160522123723165)

Rime的变色龙架构图

  chameleon主要负责两件事儿,解析和打包。
  当接收到数据时,chameleon的unpack_header函数会解析存放到packetbuf中的包头,将解析出来的包头属性存放到属性数组中。
  当发送数据时,chameleon的pack_header函数会根据属性链表将包属性数组中的属性打包成packetbuf头。

LLSEC层

  我们追踪LLSEC的代码:

1
2
3
4
5
6
7
8
// 以下代码在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, 继续追踪:

1
2
3
4
5
6
const struct llsec_driver nullsec_driver = {
"nullsec",
init,
send,
input
};

  再追踪NETSTACK_LLSEC.send(packet_sent, c);,即nullsec_driver.send

1
2
3
4
5
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

MAC层

  继续追踪代码,会发现NETSTACK_MAC.send会依次调用到更底层的NETSTACK_RDC, NETSTACK_FRAME, NETSTACK_RADIO。这些底层的东西目前还没有研究过,等待后续学习再补充。
  MAC层主要负责进行csma算法。
  下面是一张底层的参考图:

![这里写图片描述](http://anrg.usc.edu/contiki/images/c/c3/Contiki-layers.jpg)

RDC层

  rdc层主要负责周期性唤醒。

FRAME层

  frame层主要负责将数据包封装成帧

RADIO层

  radio层主要负责将帧通过无线收发器发送出去吧

在Cooja中仿真

  进入cooja仿真器目录:

1
cd tools/cooja/

  运行cooja仿真器:

1
ant run

  此时应该出现仿真器界面,依次点击菜单上的:File->New Semulation->,输入仿真器名,然后点击->create,出现仿真界面

![这里写图片描述](http://img.blog.csdn.net/20160522143839016)

![这里写图片描述](http://img.blog.csdn.net/20160522143852200)

![这里写图片描述](http://img.blog.csdn.net/20160522144354640)

添加节点。选择motes->add motes->create new motes type->然后选择一种仿真节点,比如 ->Z1 mote。

![这里写图片描述](http://img.blog.csdn.net/20160522144437656)

弹出节点编译、配置界面,依次完成1,2,3,4.

![这里写图片描述](http://img.blog.csdn.net/20160522144451015)

在number of new motes处输入2,然后点击create new motes。

![这里写图片描述](http://img.blog.csdn.net/20160522145102720)>

此时在network区域将出现两个节点。单机其中一个节点,会显示该节点的覆盖范围。拖动该节点,确保另一个节点出现在其无线覆盖范围内。

![这里写图片描述](http://img.blog.csdn.net/20160522145112736)

点击simulation control区域的start按钮,此时两个节点都会开始运行。在左侧的network区域可以看到两个节点在收发数据。点击pause按钮暂停。在mote output区域有两个节点的打印信息。

![这里写图片描述](http://img.blog.csdn.net/20160522145415850)

可以在mote output区域内的Filter框内输入过滤条件,比如输入ID:1就只显示节点1的打印消息

![这里写图片描述](http://img.blog.csdn.net/20160522145550509)

我们可以从打印消息中看到,节点1发出了广播消息,且收到了节点2发出的广播消息(但是它不知道是节点2发出的)。

总结

  一个最简单的发送匿名广播的消息的程序,在协议栈方面就涉及到如此多的内容。但是这不是我们的终点,而是中点。我们将走过中点,走到终点!
  最后,我只能想到一句话“路漫漫其修远兮”!