Protocolo utilizado

[TAlfaCentauro]

Qual é o protocolo utilizado pelo projeto 007 (o carro envia mensagens para outro carro via RSU), TCP ou UDP? Agradeço antecipadamente a sua resposta.

[dnatividade]

Em todoas as simulações é usado o WSMP (Wave Short Message Protocol), que já está implementada no Veins e é amplamente utilizado em redes veiculares. Ele é parte do padrão IEEE 1609.3, que especifica a pilha de protocolos da DSRC (Dedicated Short Range Communication), usada em aplicações de comunicação veicular.

Ou seja, ao invés de usar o protocolo IP para rede e TCP ou UDP para transporte é utilizado um protocolo mais simples, o WSMP.

[TAlfaCentauro]

Obrigada. Dada a natureza do protocolo WSMP, seria possível esperar que a taxa de transferência (throughput) no final da simulação fosse a mesma para todos os veículos? Porque estes foram meus resultados:

[dnatividade]

A taxa de transferência do protocolo 802.11p vai de 6Mbps a 27Mbps. Em minhas simulações, como meu objetivo não é velocidade, deixo configurado em 6Mbps (no arquivo omnetpp.ini). Ex.: https://github.com/dnatividade/Vanet-Projects/blob/d2d221a9681cffae6ca1b3da8a56ad15f9d8599a/01%20Simple%20Projects/007%20CAR%20send%20msg%20to%20another%20car%20via%20RSU/examples/veins/omnetpp.ini#L76

Mas o Throughput efetivo, vai depender dos parâmetros de sua simulação, como: obstáculos, número de nós, piso de ruído, entre outros.

Agora, quanto ao seu throughput de 336.0, como vc fez para obter esses dados? Eu precisaria dar uma olhada no seu cenário para tentar entender.

[TAlfaCentauro]

Este é o meu arquivo omnet.ini :

[General]
cmdenv-express-mode = true
cmdenv-autoflush = true
cmdenv-status-frequency = 1s
**.cmdenv-log-level = info

image-path = ../../images

network = RSUExampleScenario

##########################################################
#            Simulation parameters                       #
##########################################################
debug-on-errors = true
print-undisposed = true

sim-time-limit = 1000s

**.scalar-recording = true
**.vector-recording = true

*.playgroundSizeX = 4564m
*.playgroundSizeY = 6582m
*.playgroundSizeZ = 50m

##########################################################
# Annotation parameters                                  #
##########################################################
*.annotations.draw = true

##########################################################
# Obstacle parameters                                    #
##########################################################
*.obstacles.obstacles = xmldoc("config.xml", "//AnalogueModel[@type='SimpleObstacleShadowing']/obstacles")
#*.obstacles.debug = false

##########################################################
#            TraCIScenarioManager parameters             #
##########################################################
*.manager.updateInterval = 1s
*.manager.host = "localhost"
*.manager.port = 9999
*.manager.autoShutdown = true
*.manager.launchConfig = xmldoc("map.launchd.xml")

##########################################################
#                       RSU SETTINGS                     #
#                                                        #
#                                                        #
##########################################################
#*.rsu[0].mobility.x = 2000
#*.rsu[0].mobility.y = 2000
#*.rsu[0].mobility.z = 3
*.rsu[0].mobility.x = 1382
*.rsu[0].mobility.y = 2544
*.rsu[0].mobility.z = 3

*.rsu[1].mobility.x = 1099
*.rsu[1].mobility.y = 2333
*.rsu[1].mobility.z = 3

*.rsu[2].mobility.x = 758
*.rsu[2].mobility.y = 2744
*.rsu[2].mobility.z = 3

*.rsu[3].mobility.x = 1619
*.rsu[3].mobility.y = 2321
*.rsu[3].mobility.z = 3

*.rsu[4].mobility.x = 993
*.rsu[4].mobility.y = 2035
*.rsu[4].mobility.z = 3

*.rsu[5].mobility.x = 690
*.rsu[5].mobility.y = 1673
*.rsu[5].mobility.z = 3

*.rsu[*].applType = "TraCIDemoRSU11p"
*.rsu[*].appl.headerLength = 80 bit
*.rsu[*].appl.sendBeacons = false
*.rsu[*].appl.dataOnSch = false
*.rsu[*].appl.beaconInterval = 1s
*.rsu[*].appl.beaconUserPriority = 7
*.rsu[*].appl.dataUserPriority = 5
*.rsu[*].nic.phy80211p.antennaOffsetZ = 0 m

##########################################################
#            11p specific parameters                     #
#                                                        #
#                    NIC-Settings                        #
##########################################################
*.connectionManager.sendDirect = true
#*.connectionManager.maxInterfDist = 2600m
*.connectionManager.maxInterfDist = 300m
*.connectionManager.drawMaxIntfDist = false

*.**.nic.mac1609_4.useServiceChannel = false

*.**.nic.mac1609_4.txPower = 20mW
*.**.nic.mac1609_4.bitrate = 6Mbps
*.**.nic.phy80211p.minPowerLevel = -110dBm

*.**.nic.phy80211p.useNoiseFloor = true
*.**.nic.phy80211p.noiseFloor = -98dBm

*.**.nic.phy80211p.decider = xmldoc("config.xml")
*.**.nic.phy80211p.analogueModels = xmldoc("config.xml")
*.**.nic.phy80211p.usePropagationDelay = true

*.**.nic.phy80211p.antenna = xmldoc("antenna.xml", "/root/Antenna[@id='monopole']")
*.node[*].nic.phy80211p.antennaOffsetY = 0 m
*.node[*].nic.phy80211p.antennaOffsetZ = 1.895 m

*.**.nic.mac1609_4.phy80211p.radioMedium = xmldoc("config.xml")
*.**.nic.mac1609_4.phy80211p.radioMedium.medium = xmldoc("config.xml")
*.node[*].nic.mac1609_4.phy80211p.radioMediumType = "IdealRadioMedium"

##########################################################
#                      App Layer                         #
##########################################################
*.node[*].applType = "TraCIDemo11p"
#*.node[*].applType = "MyVeinsApp"
*.node[*].appl.headerLength = 80 bit
*.node[*].appl.sendBeacons = false
*.node[*].appl.dataOnSch = false
*.node[*].appl.beaconInterval = 1s

##########################################################
#                      Mobility                          #
##########################################################
*.node[*].veinsmobility.x = 0
*.node[*].veinsmobility.y = 0
*.node[*].veinsmobility.z = 0
*.node[*].veinsmobility.setHostSpeed = false

[Config Default]

[Config WithBeaconing]
*.rsu[*].appl.sendBeacons = true
*.node[*].appl.sendBeacons = true

[Config WithChannelSwitching]
*.**.nic.mac1609_4.useServiceChannel = true
*.node[*].appl.dataOnSch = true
*.rsu[*].appl.dataOnSch = true

E este é o trecho de código que me permite calcular a taxa de transferência.

void DemoBaseApplLayer::handleSelfMsg(cMessage* msg)
{
    switch (msg->getKind()) {
    case SEND_BEACON_EVT: {
        DemoSafetyMessage* bsm = new DemoSafetyMessage();
        populateWSM(bsm);
        sendDown(bsm);
        sentBSMs++;  // Increment the count for sent BSMs
        emit(messagesSendedSignal, sentBSMs);

        totalBits += bsm->getBitLength();  // Actualiza el contador de bits

        scheduleAt(simTime() + beaconInterval, sendBeaconEvt);
        break;
    }
    case SEND_WSA_EVT: {
        DemoServiceAdvertisment* wsa = new DemoServiceAdvertisment();
        populateWSM(wsa);
        sendDown(wsa);

        totalBits += wsa->getBitLength();  // Actualiza el contador de bits

        scheduleAt(simTime() + wsaInterval, sendWSAEvt);
        break;
    }
    default: {
        if (msg) EV_WARN << "APP: Error: Got Self Message of unknown kind! Name: " << msg->getName() << endl;
        break;
    }
    }
}

void DemoBaseApplLayer::finish()
{
    recordScalar("generatedWSMs", generatedWSMs);
    recordScalar("receivedWSMs", receivedWSMs);

    recordScalar("generatedBSMs", generatedBSMs);
    recordScalar("receivedBSMs", receivedBSMs);

    simtime_t endTime = simTime();
    double throughput = totalBits / (endTime - startTime).dbl();
    EV << "Throughput: " << throughput << " bps" << endl;
    recordScalar("Throughput", throughput);
}

[dnatividade]

Certo.

Pelo que entendi, no método initialize()você pega o startTime (você não colocou aqui, mas imagino que tenha feito isso). A cada vez que envia uma mensagem (método handleSelfMsg()), você obtém o tamanho da mensagem e acumula em um contador de bits chamado totalBits. No método finish() você pega o endTime e calcula o throughput dividindo o totalBits pela variação do tempo (endTime - startTime).

Entretanto, esta abordagem está errada, pois o throughput deve ser calculado pela razão entre o totalBits e o tempo que a mensagem levou para chegar no destino. Ex.: tamanhoMsg / (tempoDeChegadaNoDestino - tempoDeEnvio). Desta forma, você precisa calcular o throughput no destinatário da mensagem e não na origem. Para isso, ao criar uma mensagem, adicione (se não houver) um campo de timestamp com o simTime atual. Quando a mensagem chegar no destino, você pega o tempo atual e calcula a diferença de tempo entre o envio da mensagem (que estará no campo adicionado) e seu tempo de chegada. Depois, calcule o throughput dividindo o tamanho da mensagem pelo tempo gasto para chegar.

Outra informação: da forma como você fez, temos que lembrar que o veículo não fica o tempo todo enviando mensagens durante a simulação. Ou seja, muito desse tempo que passou (endTime - startTime) o veículo não mandou mensagens. E você também não sabe quando a mensagmem chegou no destino. Então sua medida de throughput não tem precisão.

Espero que eu tenho sido claro e ajudado você.

[TAlfaCentauro]

Sim, isso me ajudou, muito obrigado. Ficaria muito grato se você pudesse verificar meu código, pois também estou tendo perda de pacotes e atraso de ponta a ponta. Estes são os trechos de código:

void DemoBaseApplLayer::initialize(int stage)
{
        delaySignal = registerSignal("delay");
        messagesSendedSignal = registerSignal("sentBSMs");

        totalBits = 0;
        startTime = simTime();
}

void DemoBaseApplLayer::populateWSM(BaseFrame1609_4* wsm, LAddress::L2Type rcvId, int serial)
{
    wsm->setTimestamp(simTime());  // Timestamp
}

void DemoBaseApplLayer::handleLowerMsg(cMessage* msg)
{
    simtime_t arrivalTime = simTime();
    simtime_t sendTime = wsm->getTimestamp();
    double transmissionTime = (arrivalTime - sendTime).dbl();
    double throughput = wsm->getBitLength() / transmissionTime;
    double e2eDelay = (arrivalTime - sendTime).dbl();

    EV << "Throughput: " << throughput << " bps" << endl;
    recordScalar("Throughput", throughput);

    EV << "E2E Delay: " << e2eDelay << " s" << endl;
    recordScalar("E2E Delay", e2eDelay);

void DemoBaseApplLayer::finish()
{
    int packetsLost = sentBSMs - receivedBSMs;
    double packetLossRate = static_cast<double>(packetsLost) / receivedBSMs;
    EV << "Packet Loss Rate: " << packetLossRate * 100 << "%" << endl;
    recordScalar("Packet Loss Rate", packetLossRate * 100);
}

Estes são meus resultados:

Mais uma vez, obrigado.

[dnatividade]

As fórmulas parecem estar certas. Contudo, o local onde está gerando as estatísticas que acho que está errado. Mande todo seu código compactado pra eu testar aqui e entender melhor.

[TAlfaCentauro]

Muito bem, este é o meu código. DemoBaseApplLayer.zip

[dnatividade]

Olhando seu código, parece estar tudo certo.

Quanto as perdas de pacotes e atrasos, isso está intimamente relacionado ao seu cenário da rede veicular, como quantidade de veículos e obstáculos, por exemplo. Tente minimizar seu problema, reduzindo o número de veículos ou usando um cenário sem obstáculos.

Caso não consiga identificar o problema, mande-me a pasta toda do seu projeto, para eu testá-lo na integra aqui.

Outra coisa, qual a versão do Veins que você está utilizando?

[dnatividade]

Veja o teste simples que fiz:

O tamnaho total da mensagem deve ser calculado com a soma do método wsm->getBitLength() + o tamanho dos campos perssonalizados da sua mensagem. Acredito que não tenha uma forma mais fácil de fazer isso.

[TAlfaCentauro]

Muito obrigado, ficou mais claro para mim. No entanto, não sei como adicionar cada campo ao tamanho total da mensagem. Tentei fazer isso em meu código, mas em minhas estatísticas não aparecem valores como 6 Mbps, portanto, acho que meus cálculos ainda estão errados. Compartilho com você meu projeto completo. Project_Delay_PacketLoss-main.zip

A versão do Veins que estou usando é a 5.2.