omnet++中tictoc8、tictoc9的学习笔记

tictoc8总结：丢包会重传，会检测是否丢包

一，ned文件

与之前的相同，只是分开定义，定义了两个模块，定义两个模块的好处就是这两个模块可以分别进行不同的操作。

simple Tic8
{
    parameters:
        @display("i=block/routing");
    gates:
        input in;
        output out;
}

simple Toc8
{
    parameters:
        @display("i=block/process");
    gates:
        input in;
        output out;
}

//现在的network
        tic: Tic8 {
            parameters:
                @display("i=,cyan;p=39,228");
        }
        toc: Toc8 {
            parameters:
                @display("i=,red;p=411,134");
        }
//之前的network
        tic: Txc7 {//继承的父类不同
            parameters:
                @display("i=,cyan;p=77,202");
        }
        toc: Txc7 {
            parameters:
                @display("i=,gold;p=390,70");
        }

二、cc文件

由于ned文件定义了两个类，所以在cc文件中写实现的时候应该写两个实现。

对于tic来说，tic每发送一个消息，他自己就会进行一个1s的计时，如果在这1s内没有接收到toc给的消息，则说明丢包，需要重新发送这消息给toc。

这个过程就相当于是，tic给toc一直发送消息，toc接收到消息之后，会发送一个相同的消息告诉tic这个消息我接受到了，倘若toc没有发送这个反馈消息就说明丢包了，tic需要重新发送。

先看tic的实现

class Tic8 : public cSimpleModule
{
  private:
    simtime_t timeout;  // timeout超时时间
    cMessage *timeoutEvent = nullptr;  
    //超时消息事件，保存指向超时自消息的指针

  public:
    virtual ~Tic8();

  protected:
    virtual void initialize() override;
    virtual void handleMessage(cMessage *msg) override;
};

Define_Module(Tic8);//别忘了这句话

Tic8::~Tic8()
{
    cancelAndDelete(timeoutEvent);
}

void Tic8::initialize()
{
    timeout = 1.0;
    timeoutEvent = new cMessage("timeoutEvent");
    EV << "Sending initial message\n";//发送初始化消息
    cMessage *msg = new cMessage("tictocMsg");//tic8发送给toc8
    send(msg, "out");//消息发送完成后，timeout时间后判断消息有没有接受到
    scheduleAt(simTime()+timeout, timeoutEvent);//1.0s，timeoutEvent发给 tic模块
}

void Tic8::handleMessage(cMessage *msg)
{
    if (msg == timeoutEvent) {
            //如果我们收到超时事件，这意味着包没有
            //及时到达，我们必须重新发送。
        EV << "Timeout expired, resending message and restarting timer\n";
        cMessage *newMsg = new cMessage("tictocMsg");
        send(newMsg, "out");//重新发送tictocmessage
        scheduleAt(simTime()+timeout, timeoutEvent);
    }
    else {      //消息到达确认已收到——删除接收到的消息并取消超时事件。
        EV << "Timer cancelled.\n";//cancelEvent取消自消息。定时消息
        cancelEvent(timeoutEvent);
        delete msg;
        cMessage *newMsg = new cMessage("tictocMsg"); 
        // 重新定义一个tictocMsg，每次重新定义一个消息都会重新定时。
        send(newMsg, "out");
        scheduleAt(simTime()+timeout, timeoutEvent);//1.2s给自己发送一个消息
    }
}

再来看toc的实现

class Toc8 : public cSimpleModule
{
  protected:
    virtual void handleMessage(cMessage *msg) override;
};

Define_Module(Toc8);//重新定义一个类，就得写这句代码

void Toc8::handleMessage(cMessage *msg)
{
    if (uniform(0, 1) < 0.1) {
        EV << "\"Losing\" message.\n";//丢失了
        bubble("message lost");  
        //出现一个闪动的动画信息提示，这就是一个提示，在图形上边显示。
        delete msg;
    }
    else {
        EV << "Sending back same message as acknowledgement.\n";//发送回与确认信息相同的消息。
        send(msg, "out");
    }
}

tictoc9总结：重传时拷贝一个新消息

一、ned文件

和之前的一样，tic和toc分开定义。

二、cc文件

发送的消息不是原始消息，而是一个拷贝的消息，tic发送消息给toc，toc接受到之后传一个ack给tic表示接收到了消息！

先看tic

class Tic9 : public cSimpleModule
{
  private:
    simtime_t timeout;  // timeout
    cMessage *timeoutEvent = nullptr;  // 保持指向超时自消息的指针
    int seq;  //消息序列号
    cMessage *message = nullptr;  // 超时时必须重新发送的消息

  public:
    virtual ~Tic9();

  protected://下边有两个没见过的函数，先不着急，下边有他的定义
    virtual cMessage *generateNewMessage();
    virtual void sendCopyOf(cMessage *msg);
    virtual void initialize() override;
    virtual void handleMessage(cMessage *msg) override;
};

Define_Module(Tic9);

Tic9::~Tic9()//重写析构函数
{
    cancelAndDelete(timeoutEvent);//取消和删除timeoutEvent
    delete message;//删除message
}

void Tic9::initialize()
{
    // 初始化变量。
    seq = 0;
    timeout = 1.0;
    timeoutEvent = new cMessage("timeoutEvent");

    // 生成并发送初始消息。
    EV << "Sending initial message\n";
    message = generateNewMessage();//重新给一个消息
    sendCopyOf(message);//拷贝这个消息并发送
    scheduleAt(simTime()+timeout, timeoutEvent);
}

void Tic9::handleMessage(cMessage *msg)
{
    //判断是否超时，
    if (msg == timeoutEvent) {
            //如果我们收到超时事件，这意味着包没有及时到达，我们必须重新发送。
        EV << "Timeout expired, resending message and restarting timer\n";
        sendCopyOf(message);
        scheduleAt(simTime()+timeout, timeoutEvent);
    }
    else {  //当前消息不是超时消息。是tic/toc发过来的消息
        EV << "Received: " << msg->getName() << "\n";//接收消息指出名字
        delete msg;
        // 删除存储的消息并取消超时事件。
        EV << "Timer cancelled.\n";
        cancelEvent(timeoutEvent);//取消定时器
        delete message;
        message = generateNewMessage();//产生一个新的消息
        sendCopyOf(message);//拷贝消息
        scheduleAt(simTime()+timeout, timeoutEvent); //重新定时
    }
}

cMessage *Tic9::generateNewMessage()
{
    // 每次生成具有不同名称的消息。
    char msgname[20];
    sprintf(msgname, "tic-%d", ++seq);
    cMessage *msg = new cMessage(msgname);
    return msg;
}

void Tic9::sendCopyOf(cMessage *msg)
//这个函数实现的是将消息拷贝，然后将拷贝后的消息发送出去
{
    // .复制消息并发送副本。
    cMessage *copy = (cMessage *)msg->dup();
    //不用dup的化，第二次发送同一个消息会报错，因为每一个消息都有id，不用dup会拷贝id
    //dup的应用：多播或广播
    send(copy, "out");
}

再看toc，都是之前的东西比较简单

class Toc9 : public cSimpleModule
{
  protected:
    virtual void handleMessage(cMessage *msg) override;
};
Define_Module(Toc9);
void Toc9::handleMessage(cMessage *msg)
{
    if (uniform(0, 1) < 0.1) {
        EV << "\"Losing\" message " << msg << endl;
        bubble("message lost");
        delete msg;
    }
    else {
        EV << msg << " received, sending back an acknowledgement.\n";
        delete msg;
        send(new cMessage("ack"), "out");
    }
}