前言

在 Veins 中 node 之间使用 AirFrame 来传递 message，在仿真过程中模块并不能像现实生活那样因为信道干扰或障碍物遮挡造成报文延时或丢失。在 Omnet++ 中虽然可以控制接收间隔之类，但在 config 文件中只能比较死板地进行设置，不能根据程序参数和运行状态灵活地调整。因此在 Veins 中实际接收报文操作是先接收，走各种逻辑进行判断，之后再利用 Omnet 的机制通过其架构控制的延时操作来完成最终的接收。也因此，在报文中会包含各种信道信息、发送接收位置信息以及信号强度信息等，都是为了方便在接收逻辑中进行判断，从而模拟比较真实的通信环境。

BasePhyLayer 中接收 AirFrame 分了三步（StartReceive，Receiving，EndReceive），这几步可以理解成为了模拟实际通信环境而进行的预处理逻辑，实际处理中 Decider 承担主要部分，并且 channel，radio 以及 analogueModel 也都参与其中。中间与 Mac 层和 Decider 模块的交互都是通过父类的 Interface 被继承然后派生，最后动态绑定指针来执行的（按C++ 就是，各类 Interface 处理函数如 Decider 和 Mac 都是虚基类，由 BasePhyLayer 派生后实现，然后根据实际调用用父类指针指向子类对象从而调用其定义的接口函数）。

大致分为两个部分进行判断

  • Channel：在 ChannelInfo 类中进行判断
  • Signal：计算传输距离，使用衰落模型进行 filter，

最后在 handleAirFrame Receiving 操作中由 Decider 模块决定是否接收并上传到 Mac 层

一、handleAirFrame 部分工作

这部分没有在 PhyLayer80211p 中进行派生，因此也是处理 AirFrame 的主逻辑。

StartReceive 部分工作

  • Channel add AirFrame

  • Filter signal：提取出 Frame 中的 signal 并配置其起始终止点以及 analogueModel，从而对 signal 进行 filter。

    这里是调用了所有 analogueModel 来进行 filter，也就是说衰落是可以叠加的。

    1
    2
    3
    4
    5
    6
    7
    8
    // go on with AnalogueModels
    // attach analogue models suitable for thresholding to signal (for later evaluation)
    signal.setAnalogueModelList(&analogueModelsThresholding);

    // apply all analouge models that are *not* suitable for thresholding now
    for (auto& analogueModel : analogueModels) {
        analogueModel->filterSignal(&signal);
    }

  • 之后根据 decider 的状态以及 protocol 的类型进行判断，如果不符合条件则在一段时间之后进行丢弃。

    这里之所以需要调用 handleSelfMessage 从而实现过一段时间才丢弃，原因开头也提到了，是因为虽然我们程序中接收到了 frame，但模拟的现实环境中报文其实还没有到达的。因此这里才需要加上一个 frame->getDuration()时间来计算其真实的到达时间，从而在那个时间再作丢弃，也就算模拟了现实环境中报文到达后再丢弃的场景。

Receiving 部分工作

  • 调用 decider 模块进行处理，跳转到 decider interface 函数进行处理（这里传递的仍然是 frame 而非 signal）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    simtime_t BaseDecider::processSignal(AirFrame* frame)
    {

        ASSERT(frame);
        EV_TRACE << "Processing AirFrame..." << endl;

        switch (getSignalState(frame)) {
        case NEW:
            return processNewSignal(frame);
        case EXPECT_HEADER:
            return processSignalHeader(frame);
        case EXPECT_END:
            return processSignalEnd(frame);
        default:
            return processUnknownSignal(frame);
        }
    }

    功能大致是提取其中的 signal power 来判断其强度是否可以接收，以及信道是否存在冲突。当存在冲突信号实际的接收时间可能会延时，因此这里再返回一个 simtime 时间辅助后面判断是否可以接收，此时如果 nextHandleTime < 0 则认为该报文已经丢失了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    simtime_t nextHandleTime = decider->processSignal(frame);
    ··
    // smaller zero means don't give it to me again
    if (nextHandleTime < 0) {
       nextHandleTime = signalEndTime;
       frame->setState(static_cast<int>(AirFrameState::end_receive));

       // invalid point in time
    }

    EV_TRACE << "Handed AirFrame with ID " << frame->getId() << " to Decider. Next handling in " << nextHandleTime - simTime() << "s." << endl;

    sendSelfMessage(frame, nextHandleTime);

    反之如果大于 0 则等待一段时间后重新走一遍 handleAirFrame 的流程。

EndReceive 部分工作

  • 到这步就基本完成了接收了，剩下的就是就是恢复下信道和一些处理时状态

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    void BasePhyLayer::handleAirFrameEndReceive(AirFrame* frame)
    {
        EV_TRACE << "End of Airframe with ID " << frame->getId() << "." << endl;

        simtime_t earliestInfoPoint = channelInfo.removeAirFrame(frame);

        /* clean information in the radio until earliest time-point
         * of information in the ChannelInfo,
         * since this time-point might have changed due to removal of
         * the AirFrame
         */
        if (channelInfo.isChannelEmpty()) {
            earliestInfoPoint = simTime();
        }
    }

在 **StartReceive **过程中也简单地对报文进行了下过滤，如果 decider 无效或者报文非已知协议的话则延时丢掉（修改 frame 状态后利用 handleSelfMessage 函数处理掉）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if (decider && isKnownProtocolId(frame->getProtocolId())) {
   frame->setState(static_cast<int>(AirFrameState::receiving));

   // pass the AirFrame the first time to the Decider
   handleAirFrameReceiving(frame);

   // if no decider is defined we will schedule the message directly to its end
}
else {
   Signal& signal = frame->getSignal();

   simtime_t signalEndTime = signal.getReceptionStart() + frame->getDuration();
   frame->setState(static_cast<int>(AirFrameState::end_receive));

   sendSelfMessage(frame, signalEndTime);
}

二、Decider 模块

1. 基本功能

其功能在 Decider.cc 文件注释写的还算比较清楚，如下

1
2
3
4
5
* The Deciders tasks are:
* 1.    decide which packets should be handed up to the MAC Layer (primary task)
* 2.    decide whether the channel is busy/idle at a time point or during a time interval (channel sensing)
*
* BasePhyLayer hands every receiving AirFrame several times to the "processSignal()"-function and is returned a time point when to do so again.

在 Decider 模块中定义了 currentSignal 变量，用了跟踪当前处理报文的状态，并在初始时设置为 NEW。其具体定义如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/** @brief The current state of processing for a signal*/
enum SignalState {
    /** @brief Signal is received the first time. */
    NEW,
    /** @brief Waiting for the header of the signal. */
    EXPECT_HEADER,
     /** @brief Waiting for the end of the signal. */
    EXPECT_END,
};

/** @brief Pair of a AirFrame and the state it is in. */
typedef std::pair<AirFrame*, int> ReceivedSignal;

/** @brief pointer to the currently received AirFrame */
ReceivedSignal currentSignal;

2. 处理逻辑

下面是 Decider 模块最主要的 State Machine，针对 signal 进行一系列判断逻辑。类似于 handleAirFrame，只是是用 currentSignal 来将每个部分串起来。这个部分最后返回一个 time point 告知下次处理的时间（returned a time point when to do so again）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
simtime_t BaseDecider::processSignal(AirFrame* frame)
{

    ASSERT(frame);
    EV_TRACE << "Processing AirFrame..." << endl;

    switch (getSignalState(frame)) {
    case NEW:
        return processNewSignal(frame);
    case EXPECT_HEADER:
        return processSignalHeader(frame);
    case EXPECT_END:
        return processSignalEnd(frame);
    default:
        return processUnknownSignal(frame);
    }
}

Process 部分在 Veins 中有新的子类（Decider80211p）实现（processNewSignal 和 processSignalEnd），下面以 BaseDecider 举例说明下这几个步骤

**processNewSignal​ **

  • 处理 new signal 时并没有绑定 frame，因此在最开始时要进行 frame 有效判断

  • 进行 minPowerLevel 判断，满足要求后将其绑定到 currentSignal 上。这里的 minPowerLevel 设定大小为 0，即最低的 noise floor；

    在 Decider80211p 中扩展了这一判断，使用 CCA (Clear Channel Assessment，空闲信道判断），就如注释所说 *a superposition of low power frames might turn channel status to busy *

    关于 CCA 算法如何应用的，整理到 ((20221026215403-womm01e ‘CCA 实现细节’))

  • 信道状态置位，这里调用 setChannelIdelStatus 函数

    1
    2
    3
    4
    5
    6
    7
    8
    void Decider80211p::setChannelIdleStatus(bool isIdle)
    {
        isChannelIdle = isIdle;
        if (isIdle)
            phy->sendControlMsgToMac(new cMessage("ChannelStatus", Mac80211pToPhy11pInterface::CHANNEL_IDLE));
        else
            phy->sendControlMsgToMac(new cMessage("ChannelStatus", Mac80211pToPhy11pInterface::CHANNEL_BUSY));
    }

  • 在 Decider80211p 中还额外对 Radio 的 Status 进行了判断，当 Radio 处于 TX 状态时暂时不能发送

    1
    2
    3
    4
    5
    if (phy11p->getRadioState() == Radio::TX) {
        frame->setBitError(true);
        frame->setWasTransmitting(true);
        EV_TRACE << "AirFrame: " << frame->getId() << " (" << recvPower << ") received, while already sending. Setting BitErrors to true" << std::endl;
    }

    以及进行了 currentSignal有效性的判断，

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    if (!currentSignal.first) {
       // NIC is not yet synced to any frame, so lock and try to decode this frame
       currentSignal.first = frame;
       EV_TRACE << "AirFrame: " << frame->getId() << " with (" << recvPower << " > " << minPowerLevel << ") -> Trying to receive AirFrame." << std::endl;
       if (notifyRxStart) {
           phy->sendControlMsgToMac(new cMessage("RxStartStatus", MacToPhyInterface::PHY_RX_START));
        }
       }
       else {
        // NIC is currently trying to decode another frame. this frame will be simply treated as interference
        EV_TRACE << "AirFrame: " << frame->getId() << " with (" << recvPower << " > " << minPowerLevel << ") -> Already synced to another AirFrame. Treating AirFrame as interference." << std::endl;
    }

    这里 else 的判断不是很理解，留个坑后面再填吧。

**processSignalHeader​ **

  • 目前官方没有实现，在 processNewSignal 处理成功后直接置位 signal 为 EXPECT_END 从而跳转到 processSignalEnd 中。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    /**
     * @brief Processes the end of the header of a received Signal.
     *
     * Returns the time it wants to handle the signal again.
     *
     * Default implementation does not handle signal headers.
     */
    virtual simtime_t processSignalHeader(AirFrame* frame)
    {
        throw cRuntimeError("BaseDecider does not handle Signal headers!");
        return notAgain;
    }

**processSignalEnd​ **

  • 到这步就算接收成功，直接向上发送 frame，同时重新置位 currentSignal 和 ChannelIdleStatus。下面的例子是 BaseDecider 中的，其子类的实现稍微复杂些，具体再看源码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    simtime_t BaseDecider::processSignalEnd(AirFrame* frame)
    {
        EV_INFO << "packet was received correctly, it is now handed to upper layer...\n";
        phy->sendUp(frame, new DeciderResult(true));

        // we have processed this AirFrame and we prepare to receive the next one
        currentSignal.first = 0;

        // channel is idle now
        setChannelIdleStatus(true);

        return notAgain;
    }

    这里 phy 变量的类型是 DeciderToPhyInterface，也是 BasePhyLayer 的父类，而 decider 则是 BasePhyLayer 的成员变量。也就是说，在 DeciderToPhyInterface 以及 MacToPhyInterface 这两个 Interface 中定义可能在 Decider 中用到的接口，使用纯虚函数的形式，举个例子

    1
    2
    3
    4
    5
    6
    7
    8
    9
    /**
     * @brief Called to send an AirFrame with DeciderResult to the MACLayer
     *
     * When a packet is completely received and not noise, the Decider
     * call this function to send the packet together with
     * the corresponding DeciderResult up to MACLayer
     *
     */
    virtual void sendUp(AirFrame* packet, DeciderResult* result) = 0;

    这个纯虚函数声明在 DeciderToPhyInterface 中，其实现在 BasePhyLayer 中，而其调用则又在 decider 成员变量中。

稍微总结下，可以看到在 processNewSignal 和 processSignalEnd 中会有一些看起来重复的地方，仔细看了几遍才稍微明白些。在 processNewSignal 中有这么一句注释

1
2
// annotate the frame, so that we won't try decoding it at its end
frame->setUnderMinPowerLevel(true);

我觉得可以基本概括在 processNewSignal 中为什么要对 frame 进行参数设置，以及这些处理在 processSignalEnd 中作用了。这里也就是说，frame 本身是包含在 AirFrame 的 msg 中的，第一步的处理更多地是针对 Signal，然后在其中 Update 了 frame 的一些参数，如下

1
2
3
frame->setUnderMinPowerLevel(true);
frame->setBitError(true);
frame->setWasTransmitting(true);

其中 1 和 3 是 AirFrame11p 扩展出来的，作用在 processSignalEnd 中也看到了，辅助生成 DeciderResult 结果，而不再经过 singal 来判断。只是这里 frame 具体代指什么暂时说不清楚。

3. 与 Mac 层交互

最后上传给 Mac 的 ControlMsg 有如下几种

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// packet was received correctly, it is now handed to upper layer...
phy->sendControlMsgToMac(new cMessage("RxStartStatus", MacToPhyInterface::PHY_RX_END_WITH_SUCCESS));
// packet was received while sending, sending it as control message to upper layer
phy->sendControlMsgToMac(new cMessage("Error", RECWHILESEND));
// packet was not received correctly, sending it as control message to upper layer
phy->sendControlMsgToMac(new cMessage("RxStartStatus", MacToPhyInterface::PHY_RX_END_WITH_FAILURE));
phy->sendControlMsgToMac(new cMessage("Error", Decider80211p::COLLISION));
phy->sendControlMsgToMac(new cMessage("Error", BITERROR));
// set channel idle
phy->sendControlMsgToMac(new cMessage("ChannelStatus", Mac80211pToPhy11pInterface::CHANNEL_IDLE));
// set channel busy
phy->sendControlMsgToMac(new cMessage("ChannelStatus", Mac80211pToPhy11pInterface::CHANNEL_BUSY));
// trying to receive AirFrame
phy->sendControlMsgToMac(new cMessage("RxStartStatus", MacToPhyInterface::PHY_RX_START));

稍微有点复杂，Msg 种类并没有完全定义在一个 Interface 中，其中没有标明 namespace 调用的几个统一定义在这

1
2
3
4
5
6
enum Decider80211ControlKinds {
   NOTHING = 22100,
   BITERROR, // the phy has recognized a bit error in the packet
   LAST_DECIDER_80211_CONTROL_KIND,
   RECWHILESEND
};

根据 Message 类型可以简单分成 Error，RxStartStauts 以及 ChannelStatus 三种，具体功能留到 Mac 层解析时候再来看吧。

三、Channel 处理

这部分主要出现在 channelInfo 类中，其注释写的比较清楚，这里直接抄过来

ChannelInfo is able to return every AirFrame which intersects with a specified interval. This is mainly used to get the noise for a received signal.

ChannelInfo is a passive class meaning the user has to tell it when a new AirFrame starts and an existing ends. ​Once an AirFrame has been added to the ChannelInfo the ChannelInfo holds the ownership of this AirFrame even if the AirFrame is removed again from the ChannelInfo***. This is necessary because the ChannelInfo has to be able to store also the AirFrames which are over but still intersect with an currently running AirFrame.*

Note: ChannelInfo assumes that the AirFrames are added and removed chronologically. This means every time you add an AirFrame with a specific start time ChannelInfo assumes that start time as the current time and assumes that every following action happens after that moment. The same goes for "removeAirFrame". When removing an AirFrames, ChannelInfo assumes the start time plus the duration of the AirFrame as the current time.

This also affects "getAirFrames" in the way that you may only ask for intervals which lie before the "current time" of ChannelInfo.

留坑待填，仔细看了下细节挺多，后面有精力再一点点深挖吧。

四、radio 状态

radio 在 BasePhyLayer 中使用 std::unique_ptr 定义，也就意味着在一个 NIC 中只允许有一个 Radio 存在。其代表着当前 NIC 的通信状态，基本的有 TX，RX 和 SLEEP 三种。

1
std::unique_ptr<Radio> radio; ///< The state machine storing the current radio state (TX, RX, SLEEP).

为了更真实地模拟实际通信过程，NIC 的 radio 必须选定一个 channel 来 listen，同时记录其他可用的 channel ，以备后续可以 switch 。

1
2
3
4
5
/** @brief Currently selected channel (varies between 0 and nbChannels-1).*/
int currentChannel;

/** @brief Number of available channels. */
int nbChannels;

那么在 BasePhyLayer 中它主要承担什么功能呢？实际上，在 Decider 中 processNewSignal 时很重要的一部分就是判断当前 Signal 是否已经到达，这是通过 BasePhyLayer 中的 radio 成员对象中的 state 成员变量来存储表达的。getRadioState 以及 setRadioState 的实现都位于 BasePhyLayer 中，但其调用位置大相径庭。

getRadioState 主要在 Decider 模块中进行判断看当前是否可以接收，如下所示

1
2
3
4
5
if (phy11p->getRadioState() == Radio::TX) {
    frame->setBitError(true);
    frame->setWasTransmitting(true);
    EV_TRACE << "AirFrame: " << frame->getId() << " (" << recvPower << ") received, while already sending. Setting BitErrors to true" << std::endl;
}

而 setRadioState 则是在 Mac1609_4::handleLowerControl 中进行调用，如下所示

1
2
3
4
5
else if (msg->getKind() == MacToPhyInterface::TX_OVER) {

    EV_TRACE << "Successfully transmitted a packet on " << lastAC << std::endl;

    phy->setRadioState(Radio::RX);

至于其中的 MacToPhyInterface::TX_OVER，简单在下面列一下暂且不再提

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
/**
 * @brief Message kinds used by every phy layer.
 *
 * Physical layers should begin their additional kinds
 * at the value of LAST_BASE_PHY_KIND.
 */
enum BasePhyMessageKinds {
    /** @brief Indicates the end of a send transmission. */
    TX_OVER = 22000,
    /** @brief Indicates the end of a radio switch. */
    RADIO_SWITCHING_OVER,
    /** @brief AirFrame kind */
    AIR_FRAME,
    /** @brief PHY-RXSTART.indication. Used in ack procedure for unicast
     */
    PHY_RX_START,
    /** @brief PHY-RXEND.indication and Rx was successful
     */
    PHY_RX_END_WITH_SUCCESS,
    /** @brief PHY-RXEND.indication and Rx failed
     */
    PHY_RX_END_WITH_FAILURE,
    /** @brief Stores the id on which classes extending BasePhy should
     * continue their own kinds.*/
    LAST_BASE_PHY_KIND,
};