在omnet++上仿真无线传感网络4

上一节，大体了解了一下网络协议中最上层--应用层的仿真。这一节将进行网络层（networklayer）。

无线传感器网络中的路由协议和算法都是在网络层中实现的，所以对这一层的理解的好坏对协议和算法的设计与仿真这关重要。

在omnet++IDE中，双击我用红色矩形标记的图标（网络层模块），打开网络层NED文件，默认进入design模式。

我们发现，这里仅仅给了一个网络层的接口。具体使用那个模块需要我们自己指定。host802154_2400MHz的祖先结点wirelessnode指定了默认的networkType = default("BaseNetwLayer")，也就是说使用basenetwlayer模块。networkType 这个参数指定了host802154_2400MHz结点网络层使用的模块。

好吧，下面查看BaseNetwLayer模块的源码。

simple BaseNetwLayer extends BaseLayer like IBaseNetwLayer
{
    parameters:
        @class(BaseNetwLayer);

        bool coreDebug = default(false); // debug switch for core framework
        bool stats = default(false); // stats switch
        int headerLength @unit(bit); // length of the network packet header (in bits)
}

basenetwlayer的NED文件很简单。这个模块是基模块，是用来继承的。当我们实现自己的网络层协议和算法时，自己的网络层模块去继承basenetwlayer，这样，网络层的大部分功能就已经实现了，剩下的是添加自己的算法代码。下面是basenetwlayer.h中定义的成员变量和成员方法，通过查看这些成员方法就可以看出这个模块的大致功能了。basenetwlayer这个模块大致功能包括：初始化，对上下层数据进行封包或解包....。代码中我一一注明功能。

class MIXIM_API BaseNetwLayer : public BaseLayer
{
private:
BaseNetwLayer(const BaseNetwLayer&);//拷贝构造函数，这里写出原型，意味着默认拷贝构造函数不可用
BaseNetwLayer& operator=(const BaseNetwLayer&);//<span style="font-family: Arial, Helvetica, sans-serif;">拷贝构造函数，这里写出原型，意味着默认拷贝构造函数不可用</span>

public:
typedef NetwPkt* netwpkt_ptr_t;//网络层数据包
enum BaseNetwMessageKinds {
/** @brief Stores the id on which classes extending BaseNetw should
 * continue their own message kinds.*/
LAST_BASE_NETW_MESSAGE_KIND = 24000,
};
/** @brief Control message kinds used by this layer.*/
enum BaseNetwControlKinds {
/** @brief Stores the id on which classes extending BaseNetw should
 * continue their own control kinds.*/
LAST_BASE_NETW_CONTROL_KIND = 24500,
};

protected:
<span style="white-space:pre"></span>/*下面变量从<span style="font-family: Arial, Helvetica, sans-serif;">omnetpp.ini中读取*/</span>
    int headerLength;//数据包大小

    /** @brief Pointer to the arp module*/
    ArpInterface* arp;

    LAddress::L3Type myNetwAddr;//网络层地址，<span style="font-family: Arial, Helvetica, sans-serif;">LAddress::L3Type代表网络层，</span><span style="font-family: Arial, Helvetica, sans-serif;">LAddress::L2Type代表mac层地址</span>
    bool coreDebug;

public:
    BaseNetwLayer() 
      : BaseLayer()
      , headerLength(0)
      , arp(NULL)
      , myNetwAddr()
      , coreDebug(false)
    {}

    BaseNetwLayer(unsigned stacksize) 
      : BaseLayer(stacksize)
      , headerLength(0)
      , arp(NULL)
      , myNetwAddr()
      , coreDebug(false)
    {}

    /** @brief Initialization of the module and some variables*/
    virtual void initialize(int);

  protected:
    virtual void handleUpperMsg(cMessage* msg);// 处理上层来的数据
    virtual void handleLowerMsg(cMessage* msg);// 处理下层来的数据

    virtual void handleSelfMsg(cMessage* /*msg*/){
error("BaseNetwLayer does not handle self messages");
    }
    virtual void handleLowerControl(cMessage* msg);

    virtual void handleUpperControl(cMessage* /*msg*/){
        error("BaseNetwLayer does not handle control messages");
    }

    virtual cMessage*     decapsMsg(netwpkt_ptr_t); //对数据解包以备发送到上层

    virtual netwpkt_ptr_t encapsMsg(cPacket*); // 对数据封包以备发送到下层

    virtual cObject* setDownControlInfo(cMessage *const pMsg, const LAddress::L2Type& pDestAddr);

    virtual cObject* setUpControlInfo(cMessage *const pMsg, const LAddress::L3Type& pSrcAddr);
};

在仿真中不用这个模块，我们使用它的子模块wiseroute。下面是WiseRoute的NED定义：

simple WiseRoute extends BaseNetwLayer
{
    parameters:
        // debug switch
        bool debug = default(false);
        bool trace = default(false);
        bool useSimTracer = default(false);

        // sink node address (integer)
        int sinkAddress = default(0);
        // the sink directs the tree building procedure with periodic floods.
        // iterationDelay is the period between two floods.


        // RSSI threshold for route selection
        double rssiThreshold @unit(dBm) = default(-50 dBm);

        // If set to zero, this node does not initiates route tree building.
        // If set to a value larger than zero, this nodes periodically initiates route tree building.
        double routeFloodsInterval @unit(s) = default(0 s);// 默认是0即不更新路由表，但是在omnetpp.ini中设置其1200s，表示20分钟广播更新一次路由。
        @display("i=block/fork");
        @class(WiseRoute);

}

wiseroute在网络层中的功能大致是：建立路由表，并且周期性的维护路由表。根据路由表选择下一跳结点，将数据包发送到下一跳结点上。

从WiseRoute模块的c++头文件开始看起。找到路由表中的一个表项（entry）的定义：

typedef struct tRouteTableEntry {
LAddress::L3Type nextHop;
double           rssi;
} tRouteTableEntry;

nexthop下一跳结点地址，很明显是网络层地址。rssi信号强度，根据信号强度来决定路由表的更新。

下面是路由表的定义：

typedef std::map<LAddress::L3Type, tRouteTableEntry>        tRouteTable;

<span style="white-space:pre"></span>tRouteTable routeTable;

路由表数据类型troutetable定义成一个map的数据结构。定义路由表 routeTable。

下面看看WiseRoute模块的c++源文件中的关键函数：

void WiseRoute::handleSelfMsg(cMessage* msg)
{
if (msg->getKind() == SEND_ROUTE_FLOOD_TIMER) {
// Send route flood packet and restart the timer
WiseRoutePkt* pkt = new WiseRoutePkt("route-flood", ROUTE_FLOOD);
pkt->setByteLength(headerLength);
pkt->setInitialSrcAddr(myNetwAddr);
pkt->setFinalDestAddr(LAddress::L3BROADCAST);
pkt->setSrcAddr(myNetwAddr);
pkt->setDestAddr(LAddress::L3BROADCAST);
pkt->setNbHops(0);
floodTable.insert(make_pair(myNetwAddr, floodSeqNumber));
pkt->setSeqNum(floodSeqNumber);
floodSeqNumber++;
pkt->setIsFlood(1);
setDownControlInfo(pkt, LAddress::L2BROADCAST);
sendDown(pkt);
nbFloodsSent++;
nbRouteFloodsSent++;
scheduleAt(simTime() + routeFloodsInterval + uniform(0, 1), routeFloodTimer);
}
else {
EV << "WiseRoute - handleSelfMessage: got unexpected message of kind " << msg->getKind() << endl;
delete msg;
}
}

这个函数的功能相当于一个定时器，在指定时间向全网泛洪数据包用于建立路由表。当函数判定接收到的数据是routeFloodTimer就开始广播，并重新开始计时器。那么什么时候开始第一次的广播呢？当然是在初始化的时候指定的：

void WiseRoute::initialize(int stage)
{
...........

// only schedule a flood of the node is a sink!!
if (routeFloodsInterval > 0 && myNetwAddr==sinkAddress)
scheduleAt(simTime() + uniform(0.5, 1.5), routeFloodTimer);

从上面代码中可以看出，仿真开始后0.5s~1.5s之间的某个时刻开始广播建立路由。

void WiseRoute::updateRouteTable(const LAddress::L3Type& origin, const LAddress::L3Type& lastHop, double rssi, double ber)
{
tRouteTable::iterator pos;

pos = routeTable.find(origin);
if(trace) {
  receivedRSSI.record(rssi);
  receivedBER.record(ber);
}
if (pos == routeTable.end()) {
// A route towards origin does not exist yet. Insert the currently discovered one
// only if the received RSSI is above the threshold.
if (rssi > rssiThreshold) {
tRouteTableEntry newEntry;

// last hop from origin means next hop towards origin.
newEntry.nextHop = lastHop;
newEntry.rssi = rssi;
if(trace) {
  routeRSSI.record(rssi);
  routeBER.record(ber);
}
routeTable.insert(make_pair(origin, newEntry));
if(useSimTracer) {
  tracer->logLink(myNetwAddr, lastHop);
}
nbRoutesRecorded++;
if (origin == LAddress::L3NULL && trace) {
nextHopSelectionForSink.record(static_cast<double>(lastHop));
}
}
}
else {

}
}

这个函数功能是更新路由。更新的条件是1.在当前路由中没有发现到origin结点的路由。2.信号强度要比设置的阈值大。

WiseRoute::tFloodTable::key_type WiseRoute::getRoute(const tFloodTable::key_type& destAddr, bool /*iAmOrigin*/) const
{
// Find a route to dest address. As in the embedded code, if no route exists, indicate
// final destination as next hop. If we'are lucky, final destination is one hop away...
// If I am the origin of the packet and no route exists, use flood, hence return broadcast
// address for next hop.
tRouteTable::const_iterator pos = routeTable.find(destAddr);
if (pos != routeTable.end())
return pos->second.nextHop;
else
return LAddress::L3BROADCAST;
}

找到去destAddr结点的下一跳结点。