OMNet++ 例程学习 tictoc1~tictoc9

最新推荐文章于 2023-12-20 17:51:54 发布
最新推荐文章于 2023-12-20 17:51:54 发布
阅读量1k 收藏 19
点赞数 5
分类专栏： OMNet++ 文章标签： 学习 网络 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38604345/article/details/129184253
版权

文档链接 https://docs.omnetpp.org/tutorials/tictoc/part3/

TicToc1

tictoc1.ned

// 简单模块，包含两个端口，一个输入，一个输出
simple Txc1{
	gates:
	    input in;
	    output out;
}
// 网络，包含两个子模块，这两个子模块都是Txc1的实例
// 通过connections定义子模块之间的连接关系
network Tictoc1{
	submodules:
	    tic: Txc1;
	    toc: Txc1;
	connections:
	    tic.out --> {delay = 100ms;} --> toc.in;
	    toc.out --> {delay = 100ms;} --> tic.in;		  				
}

txc1.cc

#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

class Txc1 : public cSimpleModule{
protected:
    virtual void initialize() override;
    virtual void handleMessage(cMessage *msg) override;
};
// 所有普通模块都要调用这个函数进行宏注册
Define_Module(Txc1);

// 初始化函数，在仿真开始运行一次，这里实现发送第一条消息
void Txc1::initialize(){
	// getName获取实例名称，也就是ned模块中实例名称
	// 字符串比较，tic发送第一条消息
    if(strcmp("tic", getName()) == 0){
    	// 创建消息，并通过该模块的out端口发送出去，字符串就是消息名称
        cMessage *msg = new cMessage("tictocMsg");
        send(msg, "out");
    }
}
// 当该类的对象接收到一个消息时开始执行handleMessage函数
void Txc1::handleMessage(cMessage *msg){
	// 任何一个模块收到消息之后再经过该模块的out端口发送出去
    send(msg, "out");
}

总结

所有simple模块都要继承cSimpleModule类，并重initialize()和handleMessage()两个函数。
initialize()，初始化函数，在整个程序开始运行时执行一次。
handleMessage()，每次有消息到达该模块时，都会执行一次该函数。
message和events都由cMessage对象表示

TicToc2

tictoc2.ned

这里主要是对ned模块中的设计样式进行了修改，基本连接关系不变

simple Txc2
{	
    parameters:
    	//给模块加上图片，直接对应安装目录image/block中的图片
        @display("i=block/routing");
    gates:
        input in;
        output out;
}

network Tictoc2
{
	// 绘制背景大小
    @display("bgb=300,300");
    submodules:
        tic: Txc2 {
            parameters:
            	// 修改icon的颜色，设置网络中结点的位置
                @display("i=,cyan;p=100,100");
        }
        toc: Txc2 {
            parameters:
                @display("i=,gold;p=200,200");
        }
    connections:
		tic.out --> {  delay = 100ms; } --> toc.in;
        tic.in <-- {  delay = 100ms; } <-- toc.out;
}

txc2.cc

增加了信息打印，逻辑功能没有变化

#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

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

Define_Module(Txc2);

void Txc2::initialize(){
    if(strcmp("tic", getName()) == 0){
        // EV相当于C++中的cout
        // 可以使用std::cout<< <<endl;打印在控制台
        EV << "Sending initial message\n";
        cMessage *msg = new cMessage("tictocMsg");
        send(msg, "out");
    }
}
void Txc2::handleMessage(cMessage *msg){
    // msg->getName()消息的名字，在这里就是tictocMsg
    EV << "Received message `" << msg->getName() << "', sending it out again\n";
    send(msg, "out");
}

TicToc3

该案例TicToc2的基础上增加状态变量counter，每接收一次消息计数器减一，减到0之后消息删除，事件结束。
并增加观测事件WATCH(counter)。

txc3.cc

#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

class Txc3 : public cSimpleModule{
private:
    int counter;	// 初始化私有变量
protected:
    virtual void initialize() override;
    virtual void handleMessage(cMessage *msg) override;
};

Define_Module(Txc3);

void Txc3::initialize(){
	// 赋值并观测
    counter = 10;
    WATCH(counter);

    if(strcmp("tic", getName()) == 0){
        EV << "Sending initial message\n";
        cMessage *msg = new cMessage("tictocMsg");
        send(msg, "out");
    }
}

void Txc3::handleMessage(cMessage *msg){
    counter--;
    // getName()打印出tic/toc
    // 计数器为0时，消息删除，仿真结束
    if(counter == 0){
        EV<<getName()<<"'s counter reached zero, deleting message\n";
        delete msg;
    } else{
        EV << getName() <<"'s counter is " << counter << ", sending back message\n";
        send(msg, "out");
    }
}

TicToc4

本案例主要研究了在模块中添加参数、初始化参数以及cc文件与ned文件传参三个问题。

tictoc4.ned

simple Txc4{
	parameters:
	    // 定义第一个变量，决定模块是否发送第一个消息，默认false
	    bool sendMsgOnInit = default(false);
	    // 定义接收消息限制值，默认设置为2
	    // 同时也可以在ini文件中进行初始化
	    int limit = default(2);
	    @display("i=block/routing");
	gates:
	    input in;
	    output out;
}
network Tictoc4{  
    submodules:
        tic: Txc4{
            parameters:
                sendMsgOnInit = true;		// 初始化发送第一个消息
                @display("i=,blue;p=100,100");
        }
        toc: Txc4{
        	parameters:
        	    sendMsgOnInit = false;
        	    @display("i=,yellow;p=200,200");                
        }
	connections:
	    tic.out --> {delay = 100ms;} --> toc.in;
	    toc.out --> {delay = 100ms;} --> tic.in;	    
}

txc4.cc

#include <string.h>
#include <omnetpp.h>
#include <stdio.h>

using namespace omnetpp;

class Txc4 : public cSimpleModule{
private:
    int counter;
protected:
    virtual void initialize() override;
    virtual void handleMessage(cMessage *msg) override;
};

Define_Module(Txc4);

void Txc4::initialize(){
	// counter不再直接赋值，而是通过par()进行传参
	// par()括号中的内容是ned模块中定义的变量，以字符串形式表示
    counter = par("limit");
	// 
    if(par("sendMsgOnInit").boolValue() == true){
        EV << "Sending initial message\n";
        cMessage *msg = new cMessage("tictocMsg");
        send(msg, "out");
    }
}

void Txc4::handleMessage(cMessage *msg){
    counter--;
	if(counter == 0){
        EV << getName() <<"'s counter reached zero, deleting message\n";
        delete msg;
    } else{
        EV << getName() <<"'s counter is " << counter << ", sending back message\n";
        send(msg, "out");
    }
}

关于赋值的总结

在模块中定义的变量总共有三种赋值方式，第一种是默认值，即使用default()，第二种是在生成实例时进行赋值，例如tictoc4.ned中的sendMsgOnInit = true，第三种是omnetpp.ini文件中进行赋值。三种赋值方式的优先级为第二种>第三种>第一种。
omnetpp.ini：

Tictoc4.tic.limit = 3
Tictoc4.toc.limit = 5
// ini文件支持通配符，因此如果两个值赋值相同，可以改写成
Tictoc4.*.limit = 4
// 或者
Tictoc4.t*c.limit = 4
// 甚至可以是
**.limit = 4

TicToc5

在案例tictoc4的基础上使用了ned继承方式

tictoc.ned

simple Txc5{
    parameters:
        bool sendMsgOnInit = default(false);
        int limit = default(2);
        @display("i=block/routing");
    gates:
        input in;
        output out;
}
// Tic5和Txc5作为Txc5的派生，分别进行定义并进行参数赋值
simple Tic5 extends Txc5{
    parameters:
        sendMsgOnInit = true;
        @display("i=,green;p=200,200");
}
simple Toc5 extends Txc5{
    parameters:
        sendMsgOnInit = false;
        @display("i=,orange;p=100,100");
}
network Tictoc5{
    submodules:
        tic: Tic5;
        toc: Toc5;
	connections:
	    tic.in <-- {delay=100ms;} <-- toc.out;
	    toc.in <-- {delay=100ms;} <-- tic.out;
}

txc5.cc

逻辑功能与txc4.cc相同

TicToc6

案例tictoc6在于实现消息的延迟发送，即一个模块在接收到消息之后，延迟一定时长再发送给另一个模块。
在OMNet++中这样的延时是通过模块将消息发送给自身实现的。

tictoc6.ned文件参照tictoc2.ned

txc6.cc

#include <stdio.h>
#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

class Txc6 : public cSimpleModule{
private:
    cMessage *event;        //指向用来计时的对象
    cMessage *tictocMsg;    //记录收到的消息，直到将其发回
public:
  Txc6();                   //构造函数，在txc6的基础上构造函数
  virtual ~Txc6();          //析构函数，把构造的函数删除
protected:
    virtual void initialize() override;
    virtual void handleMessage(cMessage *msg) override;
};

Define_Module(Txc6);

Txc6::Txc6(){
    // 初始化为空指针
    event = tictocMsg = nullptr;
}

Txc6::~Txc6(){
    //删除已分配的自消息
    cancelAndDelete(event);     //把自消息event先取消再删除
    delete tictocMsg;           //直接删除
}

void Txc6::initialize(){
    event = new cMessage("event");
    tictocMsg = nullptr;    //初始化实际传输的对象、
    // 这里没有直接将消息发送出去，而是创建消息之后启用定时器，定时5s
    // scheduleAt(simtime_t t, cMessage *msg)，指定时一段时间之后发送自消息
    if(strcmp("tic", getName()) == 0){
        EV <<"Scheduling first send to t=5.0s\n";
        tictocMsg = new cMessage("tictocMsg");
        scheduleAt(5.0, event);
    }
}
// 5s   tic收到自消息，然后将tictocMsg发送出去
// 5.1s toc收到tictocMsg!=event，执行else，保存收到的消息，定时1s，发送自消息
// 6.1s toc收到自消息 = event，将之前保存的消息发送出去，并清除消息
// 6.2s tic收到tictocMsg!=event，执行else，保存收到的消息，定时1s，发送自消息
void Txc6::handleMessage(cMessage *msg){
    if(msg == event){
        EV << "Wait period is over, sending back message\n";
        send(tictocMsg, "out");
        tictocMsg = nullptr;
    }else{
        EV <<"Message arrived, starting to wait 1 sec...\n";
        tictocMsg = msg;
        // simTime()当前仿真时间
        scheduleAt(simTime() + 1.0, event);
    }
}

TicToc7

案例tictoc7在前一个案例的基础上将延时时间由固定值1s修改为一个可以由ini文件设置的任意可变值，同时增加了丢包率的设计，当丢包发生时，消息删除，仿真结束

tictoc7.ned

simple Txc7
{
    parameters:
        @display("i=block/routing");
        //volatile可变的，@unit(s)属性修饰指明当前变量的单位，此处s表示单位为秒
     	volatile double delayTime @unit(s);		//设置延迟发送的时间变量
    gates:
        input in;
        output out;		
}

network Tictoc7
{
    @display("bgb=300,300");
    submodules:
        tic: Txc7 {
            parameters:
                @display("i=,green;p=200,200");
        }
        toc: Txc7 {
            parameters:
                @display("i=,red;p=100,100");
        }
    connections:
        tic.out --> {  delay = 100ms; } --> toc.in;
        toc.out --> {  delay = 100ms; } --> tic.in;
}

txc7.cc

#include <stdio.h>
#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;


class Txc7 : public cSimpleModule{
private:
    cMessage *event;
    cMessage *tictocMsg;
public:
    Txc7();
    virtual ~Txc7();
protected:
    virtual void initialize() override;
    virtual void handleMessage(cMessage *msg) override;
};

Define_Module(Txc7);

Txc7::Txc7(){
    event = tictocMsg = nullptr;
}
Txc7::~Txc7(){
    cancelAndDelete(event);
    delete tictocMsg;
}
void Txc7::initialize(){

    event = new cMessage("event");
    tictocMsg = nullptr;

    if(strcmp("tic", getName()) == 0){
        EV <<"Scheduling first send to t=5.0s\n";
        scheduleAt(5.0, event);
        tictocMsg = new cMessage("tictocMsg");
    }
}
void Txc7::handleMessage(cMessage *msg){

    double p;

    if(msg == event){
        EV <<"Wait period is over, sending back message\n";
        send(tictocMsg, "out");
        tictocMsg = nullptr;
    }else{
        // 设置丢包率，0~1之间的一个随机数
        p = uniform(0,1);
        EV << "p = "<< p <<"\n";
        if(p < 0.1){
            EV <<"\"Losing\" message\n";
            delete msg;
        }
        else{
            // 获取ned模块中delayTime参数的值
            simtime_t delay = par("delayTime");
            EV <<"Message arrived, starting to wait " << delay <<" sec...\n";
            tictocMsg = msg;
            scheduleAt(simTime()+delay, event);
        }
    }
}

omnetpp.ini文件中增加：

[Config Tictoc7]
network = Tictoc7
// argument to exponential() is the mean; truncnormal() returns values from
// the normal distribution truncated to nonnegative values
Tictoc7.tic.delayTime = exponential(3s)
Tictoc7.toc.delayTime = truncnormal(3s,1s)

如果整个程序多运行几次会发现丢包时间总是在第14次发生，这是因为这个仿真软件的随机事件实际上是确定性算法，可以在ini文件中修改种子信息，测试得到不同结果：

[General]
seed-0-mt= 8  //or any other 32-bit value

TicToc8

案例tictoc8在前一个案例的基础上，设计了tic的重传功能，tic每次发送消息之后，会开启定时，定时完成意味着信息丢失，tic会启动重传机制。
在该案例中，tic和toc的处理函数逻辑不同，因此应该分开定义。

tictou8.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 Tictoc8{
	submodules:
	    tic: Tic8 {
            parameters:
                @display("i=,green;p=200,200");
        }
        toc: Toc8 {
            parameters:
                @display("i=,red;p=100,100");
        }
	connections:
        tic.out --> {  delay = 100ms; } --> toc.in;
        toc.out --> {  delay = 100ms; } --> tic.in;	    
}

txc8.cc

#include <stdio.h>
#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

class Tic8 : public cSimpleModule{

private:
    simtime_t timeout;          // 定义超时时间
    cMessage *timeoutEvent;     // 定义超时消息事件
public:
    Tic8();
    virtual ~Tic8();
protected:
    virtual void initialize() override;
    virtual void handleMessage(cMessage *msg) override;
};

Define_Module(Tic8);

Tic8::Tic8(){
    timeoutEvent = nullptr;
}

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);
}

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");
        scheduleAt(simTime()+timeout, timeoutEvent);
    }else {
        // 没有收到超时事件消息，收到的是正常消息，取消超时事件消息
        EV << "Timer cancelled.\n";
        cancelEvent(timeoutEvent);
        delete msg;
        // 重新发送一个消息给toc8，并重新开始超时定时
        cMessage *newMsg = new cMessage("tictocMsg");
        send(newMsg, "out");
        scheduleAt(simTime()+timeout, timeoutEvent);
    }
}

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()函数在仿真界面给用户提示
        bubble("message lost");
        delete msg;
    }
    else {
        EV << "Sending back same message as acknowledgement.\n";
        // toc8->tic8
        send(msg, "out");
    }
}

TicToc9

不同于案例tictoc8中每次消息重传都要重新创建消息，tictoc9 中重传的消息是拷贝的一份副本，当tic收到toc发回的应答信息时，才删除原始数据信息。

tictoc9.ned文件参照tictoc8.ned

txc9.cc

#include <stdio.h>
#include <string.h>
#include <omnetpp.h>

using namespace omnetpp;

class Tic9 : public cSimpleModule{
private:
    simtime_t timeout;
    cMessage *timeoutEvent;
    int seq; // 采用序列号进行验证
    cMessage *message;
public:
    Tic9();
    virtual ~Tic9();
protected:
    //为了避免handleMessage()过长，创建了两个新的函数
    virtual cMessage *generateNewMessage();         // 生成新的消息
    virtual void sendCopyOf(cMessage *msg);         // 发送拷贝
    virtual void initialize() override;
    virtual void handleMessage(cMessage *msg) override;
};

Define_Module(Tic9);

Tic9::Tic9()
{
    timeoutEvent = message = nullptr;
}

Tic9::~Tic9()
{
    cancelAndDelete(timeoutEvent);
    delete 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{
        //收到应答消息"ack"
        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];
    // 利用seq记录当前发送的消息是第几条消息
    sprintf(msgname, "tic-%d", ++seq);
    cMessage *msg = new cMessage(msgname);
    return msg;
}

void Tic9::sendCopyOf(cMessage *msg){
    // 发送拷贝副本
    // dup函数还可用于多播或广播
    cMessage *copyMsg = (cMessage *)msg->dup();
    send(copyMsg,"out");
}


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.\n";
        bubble("message lost");
        delete msg;
    }else{
        EV << msg << " received, sending back an acknowledgement.\n";
        delete msg;
        // 成功收到消息，发送一个ack进行响应
        send(new cMessage("ack"), "out");
    }
}
HPUM
关注
专栏目录
omnet++tictoc10案例解析
weixin_48044206的博客
10-31 945
tictoc10.ned文件 //节点的输入门或输出门之间的连接是一一对应的 //一个节点的输入门或输出门只能连接对应的输出门或输入门一次 //多个连接以自加的方式增加门向量，不过也可以固定门向量的长度 simple Txc10 { parameters: @display("i=block/routing"); gates: input in[]; // declare in[] and out[] to be vector gates o
omnet++中tictoc实例（中文注释） 1-6
weixin_44554554的博客
11-11 1517
文章目录具体效果请自行复制运行tictoc1tictoc2tictoc3tictoc4tictoc5 4、5相差不大tictoc6 具体效果请自行复制运行 tictoc1 tictoc1.ned simple Txc1 { gates: input in; output out; } network Tictoc1 { @display("bgb=171,129"); submodules: tic: Txc1;
OMNet++ Tic Toc例程的解析1
xpj8888的博客
06-19 3957
1、为什么要介绍Tic Toc例程？Tic Toc例程是学习这款软件的关键，它是由Monash大学的Ahmet Sekercioglu提供的一个例程： 实际上，我自己新建了一一些工程tictoc1、tictoc2、tictoc3.....，可以随意修改而不改变例程里面的东西。 2、打开tictoc1,Tictoc1是这个网络的名称，Txc1是子模块： 3、在这个网络中，包含有两个节点...
OMNet++ tictoc1
qq_44588244的博客
04-11 191
打开软件找到tictoc的文件夹打开可以看到里面的所有代码。
OMNeT++下载、安装及实例tictoc1-tictoc18
weixin_43797015的博客
01-17 7036
文章主要介绍了OMNeT++网络仿真软件的下载、安装步骤以及小白学习必看的18个例子，tictoc1---tictoc18
OMNet++ TicToc学习
weixin_43849363的博客
12-20 1465
在tictoc10中引入的一个类型节点的多个门，在11中进行改进，使用了自定义通道。10和11的整体逻辑是：生成6个节点，且每个节点由一个或多个出、入门。在0号节点初始化时发送一条消息到随机节点（可以到的节点），之后这条消息在各个节点之间随机传送，直到发送到3号节点。消息还存储了关于其最后一次发送的信息，包括发送时间、到达时间、到达模块和门。这里使用自定义channel替换了原来的{delay=100ms}，使得仿真图中的各个节点分开，不在重合。这里有官方的api可以自行查看，这里只涉及案例中提到的。
Omnet++ Example ：tictoc source 2024/4/16
最新发布
04-16
在Omnet++中，tictoc通常分为两个部分：`tictoc1`和`tictoc2`。这两个部分分别代表发送和接收端，它们通过自定义的消息类型进行通信。在这个例子中，我们可以学习到以下几个关键知识点： 1. **NED（Network ...
OMNeT++基础入门：TicToc案例教程指南
资源摘要信息:"OMNeT++ TicToc案例是针对OMNeT++这一离散事件模拟框架的入门级教程。OMNeT++是使用C++语言编写的一款开源、模块化、可扩展的网络仿真平台，广泛应用于网络协议的设计与评估、通信系统的建模、计算机...
OMNeTPP-TicToc.rar_6txc cc_Omnetpp_omnet++tictoc案例_omnetpp-4.5_o
09-24
标题中的"6txc cc"可能是指一个特定的学习社群或教程系列，而"OMNeTPP-TicToc.rar_6txc cc_Omnetpp_omnet++tictoc案例_omnetpp-4.5_o"则是该资源的文件名，包含了关键信息：OMNeT++ TicToc案例，以及使用的OMNeT++...
OMNeT++平台下的Tictoc实例教程：初学者必备
资源摘要信息:"本资源主要介绍OMNeT++仿真平台上的Tictoc实例，提供了多个tictoc相关的仿真项目文件，适合初学者学习和掌握OMNeT++仿真软件的使用。OMNeT++是一个开源的离散事件模拟框架，常用于研究和教育领域中的...
OMNET++实践实例
04-05
在OMNeT++仿真平台上，建立一个典型通信项目：两简单通信模型信息交换，通过实例说明，熟悉OMNeT++编程的基本方法。
omnet仿真完整实例
12-23
仿真实例，新手必备！16个实例，包括ned文件，c++文件，初始化文件，一应俱全。
omnet++ 仿真实例
03-06
omnet +++ flooding
OMNET++的tictoc的例子
05-03
omnet++ 初学的tictoc的例子，VS2005运行环境。
OMNeT++ 5.1 leach 可运行实例
01-02
OMNeT++ 5.1 仿真实例 leach ，可运行，供参考实现WSN其他协议
OMNeT++学习程序6
weixin_30634661的博客
10-11 281
构建处理延时：在以前的实验中都是，tic和toc模块都是在接收到消息后立即传送消息，这里讲添加计时器。tic和toc都会在接收到消息后保存一个仿真时间，然后再发送消息。在OMNeT++中这样的延时是通过自消息实现的。需要修改初始化函数和事件处理函数，初始化函数应该注意消息空间的申请，事件处理函数中处理的是两种消息，不再是一个消息来回发送，所以通信用的消息存在属于谁的问题，每次接收到tictocMs...
OMNeT++学习---TicToc(1)
weixin_39115615的博客
01-15 3764
       首先，让我们从一个由两个节点组成的“网络”开始。节点将做一些简单的事情：其中一个节点将创建一个数据包，两个节点将继续来回传递相同的数据包。我们将节点称为“tic”和“toc”。 以下是从头开始实施第一个模拟的步骤： 1.创建一个名为tictoc的工作目录，并cd到此目录。 2.通过创建拓扑文件来描述您的示例网络。拓扑文件是一个文本文件，用于标识网络的节点及其之间的链接。您可以使...
omnet学习记录之tictoc1-18
weixin_62271468的博客
02-02 2746
omnet中的tictoc例程学习记录
omnet++中的tictoc例子
skr？
04-06 249
https://zhuanlan.zhihu.com/p/435677891
while (t < simTime) { /*USER_RDB_MSG_TRIGGER_t rdbMsgTrigger = PackRDBTrigger(t, frameNo); //SendData48191((char *)(&rdbMsgTrigger), sizeof(USER_RDB_MSG_TRIGGER_t)); SendData48190ClientTCP((char *)(&rdbMsgTrigger), sizeof(USER_RDB_MSG_TRIGGER_t)); USER_RDB_MSG_EGO_t egoMsg = PackRDBEgoData(t, frameNo); //SendData48191((char *)(&egoMsg), sizeof(USER_RDB_MSG_EGO_t)); SendData48190ClientTCP((char *)(&egoMsg), sizeof(USER_RDB_MSG_EGO_t));*/ USER_RDB_MSG_Trigger_EGO_t rdbMsgTriggerEgo = PackRDBTriggerEgoData(t, frameNo); SendData48190ClientTCP((char *)(&rdbMsgTriggerEgo), sizeof(USER_RDB_MSG_Trigger_EGO_t)); // USER_RDB_MSG_TRIGGER_t rdbMsgTrigger = PackRDBTrigger(t, frameNo); // SendData48190ClientTCP((char *)(&rdbMsgTrigger), sizeof(USER_RDB_MSG_TRIGGER_t)); int retLen = ReceiveData48190ClientTCP(objBuf, 20480); rdbMapperClearBuffer(); bool startMSG = false; while (retLen != -1) { rdbMapperHandleIncomingData(objBuf, retLen); unsigned int noElements; size_t elSize; int endFrame = 0; int initState = 0; DynamicParse(&endFrame, &initState); if (endFrame == 1) { //printf("EndFrame"); break; } retLen = ReceiveData48190ClientTCP(objBuf, 20480); }
07-15
这段代码看起来是一个循环，其中包含了一些发送和接收数据的操作。 在循环开始处，我看到了一段被注释掉的代码，似乎是用于发送一些RDB消息的数据。根据代码注释，它使用了两个不同的函数`SendData48191`和`SendData48190ClientTCP`来发送数据。如果您需要发送RDB消息，请确保选择正确的函数来发送数据。 接下来，代码使用`PackRDBTriggerEgoData`函数打包了一些触发器和自车数据，并通过`SendData48190ClientTCP`函数发送出去。 接下来，代码调用`ReceiveData48190ClientTCP`函数接收数据，并将接收到的数据传递给`rdbMapperHandleIncomingData`函数进行处理。随后，代码执行了一些处理逻辑，包括解析数据，检查是否结束帧等。 整体来说，这段代码是一个循环，在每次循环中发送一些RDB消息，并接收处理返回的数据。如果您有特定的问题或需要进一步的解释，请告诉我，我将尽力帮助您。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值