BasicSnrEval.cc

Go to the documentation of this file.

/***************************************************************************
 * file:        BasicSnrEval.cc
 *
 * author:      Marc Loebbers
 *
 * copyright:   (C) 2004 Telecommunication Networks Group (TKN) at
 *              Technische Universitaet Berlin, Germany.
 *
 *              This program is free software; you can redistribute it
 *              and/or modify it under the terms of the GNU General Public
 *              License as published by the Free Software Foundation; either
 *              version 2 of the License, or (at your option) any later
 *              version.
 *              For further information see file COPYING
 *              in the top level directory
 ***************************************************************************
 * part of:     framework implementation developed by tkn
 ***************************************************************************/


#include "BasicSnrEval.h"
//#include "MacPkt_m.h"
#include "TransmComplete_m.h"


#define coreEV (ev.isDisabled()||!coreDebug) ? ev : ev << logName() << "::BasicSnrEval: "

Define_Module(BasicSnrEval);

void BasicSnrEval::initialize(int stage)
{
    ChannelAccess::initialize(stage);

    coreEV << "Initializing BasicSnrEval, stage=" << stage << endl;

    if (stage == 0)
    {
        gate("radioIn")->setDeliverOnReceptionStart(true);

        uppergateIn = findGate("uppergateIn");
        uppergateOut = findGate("uppergateOut");

        headerLength = par("headerLength");
        bitrate = par("bitrate");

        transmitterPower = par("transmitterPower");

        // transmitter power CANNOT be greater than in ChannelControl
        if (transmitterPower > (double) (cc->par("pMax")))
            error("transmitterPower cannot be bigger than pMax in ChannelControl!");
    }
}

void BasicSnrEval::handleMessage(cMessage *msg)
{
    if (msg->getArrivalGateId() == uppergateIn)
    {
        AirFrame *frame = encapsMsg(PK(msg));
        handleUpperMsg(frame);
    }
    else if (msg->isSelfMessage())
    {
        if (dynamic_cast<TransmComplete *>(msg) != 0)
        {
            coreEV << "frame is completely received now\n";

            // unbuffer the message
            AirFrame *frame = unbufferMsg(msg);

            handleLowerMsgEnd(frame);
        }
        else
            handleSelfMsg(msg);
    }
    else if (check_and_cast<AirFrame *>(msg)->getChannelNumber() == getChannelNumber())
    {
        // must be an AirFrame
        AirFrame *frame = (AirFrame *) msg;
        handleLowerMsgStart(frame);
        bufferMsg(frame);
    }
    else
    {
        EV << "listening to different channel when receiving message -- dropping it\n";
        delete msg;
    }
}

void BasicSnrEval::bufferMsg(AirFrame * frame) //FIXME: add explicit simtime_t atTime arg?
{
    // set timer to indicate transmission is complete
    TransmComplete *endRxTimer = new TransmComplete(NULL);
    endRxTimer->setContextPointer(frame);
    frame->setContextPointer(endRxTimer);
    // NOTE: use arrivalTime instead of simTime, because we might be calling this
    // function during a channel change, when we're picking up ongoing transmissions
    // on the channel -- and then the message's arrival time is in the past!
    scheduleAt(frame->getArrivalTime() + frame->getDuration(), endRxTimer);
}

AirFrame *BasicSnrEval::encapsMsg(cPacket *msg)
{
    AirFrame *frame = createCapsulePkt();
    frame->setName(msg->getName());
    frame->setPSend(transmitterPower);
    frame->setBitLength(headerLength);
    frame->setChannelNumber(getChannelNumber());
    frame->encapsulate(msg);
    frame->setDuration(calcDuration(frame));
    frame->setSenderPos(getMyPosition());
    return frame;
}

double BasicSnrEval::calcDuration(cPacket *af)
{
    double duration;
    duration = (double) af->getBitLength() / (double) bitrate;
    return duration;
}

void BasicSnrEval::sendUp(AirFrame *msg, SnrList& list)
{
    // create ControlInfo
    SnrControlInfo *cInfo = new SnrControlInfo;
    // attach the list to cInfo
    cInfo->setSnrList(list);
    // attach the cInfo to the AirFrame
    msg->setControlInfo(cInfo);

    send(msg, uppergateOut);
}

void BasicSnrEval::sendDown(AirFrame *msg)
{
    sendToChannel(msg);
}

AirFrame *BasicSnrEval::unbufferMsg(cMessage *msg)
{
    AirFrame *frame = (AirFrame *) msg->getContextPointer();
    //delete the self message
    delete msg;

    return frame;
}

void BasicSnrEval::handleUpperMsg(AirFrame * frame)
{
    sendDown(frame);
}

void BasicSnrEval::handleLowerMsgEnd(AirFrame * frame)
{
    coreEV << "in handleLowerMsgEnd\n";

    // We need to create a "dummy" snr list that we can pass together
    // with the message to the decider module so that also the
    // BasicSnrEval is able to work.
    SnrList snrList;

    // However you can take this as a reference how to create your own
    // snr entries.

    // Everytime you want to add something to the snr information list
    // it has to look like this:
    // 1. create a list entry and fill the fields
    SnrListEntry listEntry;
    listEntry.time = simTime();
    listEntry.snr = 3;          //just a senseless example

    // 2. add an entry to the SnrList
    snrList.push_back(listEntry);

    // 3. pass the message together with the list to the decider
    sendUp(frame, snrList);
}

void BasicSnrEval::handleLowerMsgStart(AirFrame * frame)
{
    coreEV << "in handleLowerMsgStart, receiving frame " << frame->getName() << endl;

    //calculate the receive power

    // calculate snr information, like snr=pSend/noise or whatever....

    // if receive power is actually high enough to be able to read the
    // message and no other message is currently being received, store
    // the snr information for the message someweher where you can find
    // it in handleLowerMsgEnd
}