uwphysical.cpp

Go to the documentation of this file.

//
// Copyright (c) 2017 Regents of the SIGNET lab, University of Padova.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. Neither the name of the University of Padova (SIGNET lab) nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
 
#include "uwphysical.h"
#include "uwphy-clmsg.h"
#include "uwstats-utilities.h"
#include <mac.h>
#include <phymac-clmsg.h>
#include <sstream>
#include <string>
 
UwPhysicalStats::UwPhysicalStats()
    : Stats()
    , has_error(false)
    , last_rx_power(0)
    , last_noise_power(0)
    , instant_noise_power(0)
    , last_interf_power(0)
    , last_sinr(0)
    , last_ber(0)
    , last_per(0)
{
    type_id = (int) StatsEnum::STATS_PHY_LAYER;
}
UwPhysicalStats::UwPhysicalStats(int mod_id, int stck_id)
    : Stats(mod_id, stck_id)
    , has_error(false)
    , last_rx_power(0)
    , last_noise_power(0)
    , instant_noise_power(0)
    , last_interf_power(0)
    , last_sinr(0)
    , last_ber(0)
    , last_per(0)
{
    type_id = (int) StatsEnum::STATS_PHY_LAYER;
}
 
void
UwPhysicalStats::updateStats(int mod_id, int stck_id, double rx_pwr,
        double noise_pwr, double interf_pwr, double sinr, double ber,
        double per, bool error)
{
    module_id = mod_id;
    stack_id = stck_id;
    last_rx_power = rx_pwr;
    last_noise_power = noise_pwr;
    instant_noise_power = noise_pwr;
    last_interf_power = interf_pwr;
    last_sinr = sinr;
    last_ber = ber;
    last_per = per;
    has_error = error;
}
 
Stats *
UwPhysicalStats::clone() const
{
    return new UwPhysicalStats(*this);
}
 
static class UwPhysicalClass : public TclClass
{
public:
    UwPhysicalClass()
        : TclClass("Module/UW/PHYSICAL")
    {
    }
    TclObject *
    create(int, const char *const *)
    {
        return (new UnderwaterPhysical);
    }
} class_module_uwphysical;
 
UnderwaterPhysical::UnderwaterPhysical()
    : modulation_name_("BPSK")
    , time_ready_to_end_rx_(0)
    , Tx_Time_(0)
    , Rx_Time_(0)
    , Energy_Tx_(0)
    , Energy_Rx_(0)
    , Transmitted_bytes_(0)
    , tx_power_(3.3)
    , rx_power_(0.620)
    , tot_pkts_lost(0)
    , tot_ctrl_pkts_lost(0)
    , errorCtrlPktsInterf(0)
    , collisionDataCTRL(0)
    , collisionCTRL(0)
    , collisionDATA(0)
    , Interference_Model("CHUNK")
    , interference_(nullptr)
{
    bind("rx_power_consumption_", &rx_power_);
    bind("tx_power_consumption_", &tx_power_);
    stats_ptr = new UwPhysicalStats();
}
 
UnderwaterPhysical::~UnderwaterPhysical()
{
    delete stats_ptr;
    stats_ptr = nullptr;
}
 
int
UnderwaterPhysical::command(int argc, const char *const *argv)
{
    Tcl &tcl = Tcl::instance();
 
    if (argc == 2) {
        if (strcasecmp(argv[1], "getTxTime") == 0) {
            tcl.resultf("%f", Get_Tx_Time());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getRxTime") == 0) {
            tcl.resultf("%f", Get_Rx_Time());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getConsumedEnergyTx") == 0) {
            tcl.resultf("%f", Get_Energy_Tx());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getConsumedEnergyRx") == 0) {
            tcl.resultf("%f", Get_Energy_Rx());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getTransmittedBytes") == 0) {
            tcl.resultf("%f", Get_Transmitted_bytes());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getTotPktsLost") == 0) {
            tcl.resultf("%d", getTot_pkts_lost());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getCollisionsDATAvsCTRL") == 0) {
            tcl.resultf("%d", getCollisionsDATAvsCTRL());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getCollisionsCTRL") == 0) {
            tcl.resultf("%d", getCollisionsCTRL());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getCollisionsDATA") == 0) {
            tcl.resultf("%d", getCollisionsDATA());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getTotCtrlPktsLost") == 0) {
            tcl.resultf("%d", getTot_CtrlPkts_lost());
            return TCL_OK;
        } else if (strcasecmp(argv[1], "getErrorCtrlPktsInterf") == 0) {
            tcl.resultf("%d", getError_CtrlPktsInterf());
            return TCL_OK;
        }
    } else if (argc == 3) {
        if (strcasecmp(argv[1], "modulation") == 0) {
            modulation_name_ = ((char *) argv[2]);
            if (modulation_name_ == "" ||
                    (modulation_name_ != "BPSK" && modulation_name_ != "BFSK" &&
                            modulation_name_ != "8PSK" &&
                            modulation_name_ != "16PSK" &&
                            modulation_name_ != "32PSK")) {
                tcl.result("Empty or wrong name for the modulation scheme");
                return TCL_ERROR;
            }
 
            return TCL_OK;
        } else if (strcasecmp(argv[1], "setInterferenceModel") == 0) {
            Interference_Model = (std::string) argv[2];
            if (Interference_Model != "CHUNK" &&
                    Interference_Model != "MEANPOWER") {
                tcl.result(
                        "Empty or wrong name of the Interference Model: "
                        "CHUNK or MEANPOWER are valid interference models");
                return TCL_ERROR;
            }
 
            return TCL_OK;
        } else if (strcasecmp(argv[1], "setInterference") == 0) {
            interference_ =
                    dynamic_cast<uwinterference *>(TclObject::lookup(argv[2]));
            if (!interference_) {
                return TCL_ERROR;
            }
 
            return TCL_OK;
        }
    }
    return UnderwaterMPhyBpsk::command(argc, argv);
} /* UnderwaterPhysical::command */
 
void
UnderwaterPhysical::recv(Packet *p)
{
    hdr_cmn *ch = HDR_CMN(p);
    hdr_MPhy *ph = HDR_MPHY(p);
 
    if (ch->direction() == hdr_cmn::UP) {
        ph->dstSpectralMask = getRxSpectralMask(p);
        ph->dstPosition = getPosition();
        ph->dstAntenna = getRxAntenna(p);
 
        assert(ph->dstSpectralMask);
        assert(ph->dstPosition);
 
        ph->Pr = getRxPower(p);
 
        p->txinfo_.RxPr = 0;
        p->txinfo_.CPThresh = 0;
 
        if (ph->Pr > 0) {
            ph->Pn = getNoisePower(p);
 
            if (interference_) {
                interference_->addToInterference(p);
            }
 
            ph->rxtime = NOW;
            ph->worth_tracing = true;
 
            if (isOn == true) {
                PacketEvent *pe = new PacketEvent(p);
                Scheduler::instance().schedule(&rxtimer, pe, ph->duration);
 
                startRx(p);
            } else {
                Packet::free(p);
            }
        } else {
            Packet::free(p);
        }
    } else { // Direction DOWN
        assert(isOn);
 
        ph->Pr = 0;
        ph->Pn = 0;
        ph->Pi = 0;
        ph->txtime = NOW;
        ph->rxtime = ph->txtime;
 
        ph->worth_tracing = false;
 
        ph->srcSpectralMask = getTxSpectralMask(p);
        ph->srcAntenna = getTxAntenna(p);
        ph->srcPosition = getPosition();
        ph->dstSpectralMask = 0;
        ph->dstPosition = 0;
        ph->dstAntenna = 0;
        ph->modulationType = getModulationType(p);
        ph->duration = getTxDuration(p);
 
        ph->Pt = getTxPower(p);
 
        assert(ph->srcSpectralMask);
        assert(ph->srcPosition);
        assert(ph->duration > 0);
        assert(ph->Pt > 0);
 
        PacketEvent *pe = new PacketEvent(p->copy());
        Scheduler::instance().schedule(&txtimer, pe, ph->duration);
 
        startTx(p);
    }
} /* UnderwaterPhysical::recv */
 
void
UnderwaterPhysical::endTx(Packet *p)
{
    hdr_cmn *ch = HDR_CMN(p);
    hdr_MPhy *ph = HDR_MPHY(p);
 
    Tx_Time_ += ph->duration;
    Energy_Tx_ += consumedEnergyTx(ph->duration);
 
    Transmitted_bytes_ += ch->size();
 
    return UnderwaterMPhyBpsk::endTx(p);
} /* UnderwaterPhysical::endTx */
 
void
UnderwaterPhysical::startRx(Packet *p)
{
    hdr_mac *mach = HDR_MAC(p);
    hdr_MPhy *ph = HDR_MPHY(p);
 
    static int mac_addr = -1;
 
    ClMsgPhy2MacAddr msg;
    sendSyncClMsg(&msg);
    mac_addr = msg.getAddr();
 
    if ((PktRx == 0) && (txPending == false)) {
        // The receiver is is not synchronized on any transmission
        // so we can sync on this packet
        std::stringstream log_sstr;
        double snr_dB = 10 * log10(ph->Pr / ph->Pn);
 
        log_sstr << "startRx(Packet *)::"
                 << "snr_dB = " << snr_dB
                 << "; AcquisitionThreshold_dB_ = " << getAcquisitionThreshold()
                 << " pr " << 10 * log10(ph->Pr) << " pn " << 10 * log10(ph->Pn)
                 << " end " << NOW + ph->duration << " src "
                 << HDR_CMN(p)->prev_hop_ << " dest " << HDR_CMN(p)->next_hop()
                 << " size " << HDR_CMN(p)->size();
        printOnLog(Logger::LogLevel::DEBUG, "UWPHY", log_sstr.str());
 
        if (snr_dB > getAcquisitionThreshold()) {
            if (ph->modulationType == modid) {
                // This is a BPSK packet so we sync on it
                PktRx = p;
                // Notify the MAC
                Phy2MacStartRx(p);
 
                log_sstr.str("");
                log_sstr << "startRx(Packet *)::"
                         << "sync on PktRx = " << PktRx << " end "
                         << NOW + HDR_CMN(p)->txtime() << " src "
                         << HDR_CMN(p)->prev_hop_ << " dest "
                         << HDR_CMN(p)->next_hop() << " size "
                         << HDR_CMN(p)->size();
                printOnLog(Logger::LogLevel::DEBUG, "UWPHY", log_sstr.str());
 
                return;
            } else {
                printOnLog(Logger::LogLevel::DEBUG,
                        "UWPHY",
                        "startRx(Packet *)::dropping pkt, wrong modid");
 
                if ((mach->macDA() == mac_addr) &&
                        (mach->ftype() != MF_CONTROL)) {
                    incrTot_pkts_lost();
                } else if ((mach->macDA() == mac_addr) &&
                        (mach->ftype() == MF_CONTROL)) {
                    incrTotCrtl_pkts_lost();
                }
            }
        } else {
            printOnLog(Logger::LogLevel::DEBUG,
                    "UWPHY",
                    "startRx(Packet *)::dropping pkt, below threshold");
 
            incrErrorPktsNoise();
            if (mach->ftype() != MF_CONTROL) {
                incrTot_pkts_lost();
            } else if (mach->ftype() == MF_CONTROL) {
                incrTotCrtl_pkts_lost();
            }
        }
    } else if (txPending == true) {
        printOnLog(Logger::LogLevel::DEBUG,
                "UWPHY",
                "startRx(Packet *)::dropping pkt, tx pending");
 
        if (mach->ftype() != MF_CONTROL) {
            incrTot_pkts_lost();
        }
        if (mach->ftype() == MF_CONTROL) {
            incrTotCrtl_pkts_lost();
        }
    } else {
        if (mach->ftype() != MF_CONTROL) {
            incrTot_pkts_lost();
        } else if (mach->ftype() == MF_CONTROL) {
            incrTotCrtl_pkts_lost();
        }
    }
} /* UnderwaterPhysical::startRx */
 
void
UnderwaterPhysical::endRx(Packet *p)
{
    hdr_cmn *ch = HDR_CMN(p);
    hdr_MPhy *ph = HDR_MPHY(p);
    hdr_mac *mach = HDR_MAC(p);
    counter interferent_pkts;
 
    ClMsgPhy2MacAddr msg;
    sendSyncClMsg(&msg);
 
    if (PktRx != 0) {
        if (PktRx == p) {
            double per_ni;
            double ber_ni;
            double sinr;
            int nbits = ch->size() * 8;
            double x = RNG::defaultrng()->uniform_double();
            bool error_n = 0; // x <= per_n;
            bool error_ni = 0;
            double interference_power = 0;
            if (interference_) {
                if (Interference_Model == "CHUNK") {
                    const PowerChunkList &power_chunk_list =
                            interference_->getInterferencePowerChunkList(p);
                    if (power_chunk_list.size() < 1) {
                        // we have no interferent
                        sinr = ph->Pr / ph->Pn;
                        per_ni = getPER(sinr, nbits, p);
                        ber_ni = getPER(sinr, 1, p);
                        error_ni = x <= per_ni;
                    } else {
                        for (PowerChunkList::const_iterator itInterf =
                                        power_chunk_list.begin();
                                itInterf != power_chunk_list.end();
                                itInterf++) {
                            int nbits2 = itInterf->second * BitRate_;
                            interference_power = itInterf->first;
                            sinr = ph->Pr / (ph->Pn + itInterf->first);
                            per_ni = getPER(sinr, nbits2, p);
                            ber_ni = getPER(sinr, 1, p);
                            x = RNG::defaultrng()->uniform_double();
                            error_ni = x <= per_ni;
                            if (error_ni) {
                                break;
                            }
                        }
                    }
                } else if (Interference_Model == "MEANPOWER") {
                    interference_power = interference_->getInterferencePower(p);
                    sinr = ph->Pr / (ph->Pn + interference_power);
                    per_ni = getPER(sinr, nbits, p);
                    ber_ni = getPER(sinr, 1, p);
                    error_ni = x <= per_ni;
                } else {
                    printOnLog(Logger::LogLevel::ERROR,
                            "UWPHY",
                            "endRx(Packet *)::Please choose the right "
                            "interference model "
                            "to use: CHUNK or MEANPOWER");
 
                    exit(1);
                }
                interferent_pkts = interference_->getCounters(p);
 
            } else {
                interference_power = ph->Pi;
                sinr = ph->Pr / (ph->Pn + ph->Pi);
                per_ni = getPER(sinr, nbits, p);
                ber_ni = getPER(sinr, 1, p);
                error_ni = x <= per_ni;
            }
 
            if (interference_power < (ph->Pn / 10)) {
                error_n = error_ni;
                error_ni = 0; // error transfered on noise
            }
            // update stats and trigger the modules that collect the stats
            auto uwphystats = dynamic_cast<UwPhysicalStats *>(stats_ptr);
            if (uwphystats) {
                uwphystats->updateStats(getId(),
                        getStackId(),
                        ph->Pr,
                        ph->Pn,
                        interference_power,
                        sinr,
                        ber_ni,
                        per_ni,
                        (error_n > 0 || error_ni > 0));
            }
            ClMsgTriggerStats m = ClMsgTriggerStats();
            sendSyncClMsg(&m);
 
            if (time_ready_to_end_rx_ > Scheduler::instance().clock()) {
                Rx_Time_ = Rx_Time_ + ph->duration - time_ready_to_end_rx_ +
                        Scheduler::instance().clock();
            } else {
                Rx_Time_ += ph->duration;
            }
            time_ready_to_end_rx_ =
                    Scheduler::instance().clock() + ph->duration;
            Energy_Rx_ += consumedEnergyRx(ph->duration);
            ch->error() = error_n || error_ni;
            if (debug_) {
                if (error_ni == 1) {
                    if (debug_) {
                        printOnLog(Logger::LogLevel::ERROR,
                                "UWPHY",
                                "endRx(Packet *)::packet " +
                                        to_string(ch->uid()) +
                                        " contains errors due to noise and "
                                        "interference.");
                    }
                } else if (error_n == 1) {
                    if (debug_) {
                        printOnLog(Logger::LogLevel::ERROR,
                                "UWPHY",
                                "endRx(Packet *)::packet " +
                                        to_string(ch->uid()) +
                                        " contains errors due to noise");
                    }
                }
            }
            if (error_n) {
                incrErrorPktsNoise();
                if (mach->ftype() != MF_CONTROL) {
                    incrTot_pkts_lost();
                } else if (mach->ftype() == MF_CONTROL) {
                    incrTotCrtl_pkts_lost();
                }
            } else if (error_ni) {
                if (mach->ftype() != MF_CONTROL) {
                    incrErrorPktsInterf();
                    incrTot_pkts_lost();
                    if (interferent_pkts.second >= 1) {
                        incrCollisionDATA();
                    } else {
                        if (interferent_pkts.first > 0) {
                            incrCollisionDATAvsCTRL();
                        }
                    }
                } else if (mach->ftype() == MF_CONTROL) {
                    incrTotCrtl_pkts_lost();
                    incrErrorCtrlPktsInterf();
                    if (interferent_pkts.first > 0) {
                        incrCollisionCTRL();
                    }
                }
            }
            sendUp(p);
            PktRx = 0;
        } else {
            dropPacket(p);
        }
    } else {
        dropPacket(p);
    }
} /* UnderwaterPhysical::endRx */
 
double
UnderwaterPhysical::getPER(double _snr, int _nbits, Packet *_p)
{
    double snr_with_penalty = _snr * pow(10, RxSnrPenalty_dB_ / 10.0);
 
    double ber_ = 0;
    if (modulation_name_ == "BPSK") {
        ber_ = 0.5 * erfc(sqrt(snr_with_penalty));
    } else if (modulation_name_ == "BFSK") {
        ber_ = 0.5 * exp(-snr_with_penalty / 2);
    } else if (modulation_name_ == "8PSK") {
        double const M = 8;
        ber_ = (1 / this->log2(M)) *
                get_prob_error_symbol_mpsk(snr_with_penalty, M);
    } else if (modulation_name_ == "16PSK") {
        double const M = 16;
        ber_ = (1 / this->log2(M)) *
                get_prob_error_symbol_mpsk(snr_with_penalty, M);
    } else if (modulation_name_ == "32PSK") {
        double const M = 32;
        ber_ = (1 / this->log2(M)) *
                get_prob_error_symbol_mpsk(snr_with_penalty, M);
    }
 
    if (_nbits == 1) {
        return ber_;
    }
    // PER calculation
    return 1 - pow(1 - ber_, _nbits);
} /* UnderwaterPhysical::getPER */
 
int
UnderwaterPhysical::recvSyncClMsg(ClMessage *m)
{
    if (m->type() == CLMSG_UWPHY_LOSTPKT) {
        int lost_packet = ((ClMsgUwPhyGetLostPkts *) m)->isControl()
                ? getTot_CtrlPkts_lost()
                : getTot_pkts_lost();
        ((ClMsgUwPhyGetLostPkts *) m)->setLostPkts(lost_packet);
        return 0;
    }
    if (m->type() == CLMSG_STATS) {
        updateInstantaneousStats();
        (dynamic_cast<ClMsgStats *>(m))->setStats(stats_ptr);
        return 0;
    }
    return UnderwaterMPhyBpsk::recvSyncClMsg(m);
}
 
void
UnderwaterPhysical::updateInstantaneousStats()
{
    Packet *temp = Packet::alloc();
    hdr_MPhy *ph = HDR_MPHY(temp);
    ph->dstSpectralMask = getRxSpectralMask(temp);
    ph->dstPosition = getPosition();
    ph->dstAntenna = getRxAntenna(temp);
    assert(ph->dstSpectralMask);
    assert(ph->dstPosition);
 
    ph->srcSpectralMask = getTxSpectralMask(temp);
    ph->srcAntenna = getTxAntenna(temp);
    ph->srcPosition = getPosition();
    assert(ph->srcSpectralMask);
 
    (dynamic_cast<UwPhysicalStats *>(stats_ptr))->instant_noise_power =
            getNoisePower(temp);
    Packet::free(temp);
}