uwphysical.h

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.
//
 
#ifndef UWPHYSICAL_H
#define UWPHYSICAL_H
 
#include "clmsg-stats.h"
#include "underwater-bpsk.h"
#include "uwinterference.h"
 
#include <cmath>
#include <limits>
 
class UwPhysicalStats : public Stats
{
public:
    UwPhysicalStats();
 
    UwPhysicalStats(int mod_id, int stck_id);
 
    virtual ~UwPhysicalStats() = default;
 
    virtual Stats *clone() const;
 
    virtual void updateStats(int mod_id, int stck_id, double rx_pwr,
            double noise_pwr, double interf_pwr, double sinr, double ber,
            double per, bool error);
 
    bool has_error; 
    double last_rx_power; 
    double last_noise_power; 
    double instant_noise_power; 
    double last_interf_power; 
    double last_sinr; 
    double last_ber; 
    double last_per; 
};
 
class UnderwaterPhysical : public UnderwaterMPhyBpsk
{
 
public:
    UnderwaterPhysical();
 
    virtual ~UnderwaterPhysical();
 
    virtual int command(int, const char *const *) override;
    virtual void recv(Packet *) override;
 
    int recvSyncClMsg(ClMessage *m) override;
 
protected:
    virtual void updateInstantaneousStats();
 
    virtual void endTx(Packet *p) override;
 
    virtual void endRx(Packet *p) override;
 
    virtual void startRx(Packet *p) override;
 
    virtual double
    consumedEnergyTx(const double &_duration) const
    {
        return (tx_power_ * _duration);
    }
 
    virtual double
    consumedEnergyRx(const double &_duration) const
    {
        return (rx_power_ * _duration);
    }
 
    virtual double getPER(double snr, int nbits, Packet *_p);
 
    bool
    isZero(const double &value) const
    {
        return std::fabs(value) < std::numeric_limits<double>::epsilon();
    }
 
    double
    Get_Tx_Time() const
    {
        return Tx_Time_;
    }
 
    double
    Get_Rx_Time() const
    {
        return Rx_Time_;
    }
 
    double
    Get_Energy_Tx() const
    {
        return Energy_Tx_;
    }
 
    double
    Get_Energy_Rx() const
    {
        return Energy_Rx_;
    }
 
    double
    Get_Transmitted_bytes() const
    {
        return Transmitted_bytes_;
    }
 
    void
    incrTot_pkts_lost()
    {
        tot_pkts_lost++;
    }
 
    void
    incrTotCrtl_pkts_lost()
    {
        tot_ctrl_pkts_lost++;
    }
 
    void
    incrErrorCtrlPktsInterf()
    {
        errorCtrlPktsInterf++;
    }
 
    void
    incrCollisionDATAvsCTRL()
    {
        collisionDataCTRL++;
    }
 
    void
    incrCollisionCTRL()
    {
        collisionCTRL++;
    }
 
    void
    incrCollisionDATA()
    {
        collisionDATA++;
    }
 
    int
    getTot_pkts_lost() const
    {
        return tot_pkts_lost;
    }
 
    int
    getTot_CtrlPkts_lost() const
    {
        return tot_ctrl_pkts_lost;
    }
 
    int
    getError_CtrlPktsInterf() const
    {
        return errorCtrlPktsInterf;
    }
 
    int
    getCollisionsDATAvsCTRL() const
    {
        return collisionDataCTRL;
    }
 
    int
    getCollisionsCTRL() const
    {
        return collisionCTRL;
    }
 
    int
    getCollisionsDATA() const
    {
        return collisionDATA;
    }
 
    double
    log2(const double &_input) const
    {
        return (log10(_input) / log10(2));
    }
 
    double
    get_prob_error_symbol_mpsk(const double &_snr, const uint32_t _M) const
    {
        return erfc(sqrt(_snr * log2(_M)) * sin(M_PI / _M));
    }
 
    std::string modulation_name_; 
    double time_ready_to_end_rx_; 
    double Tx_Time_; 
    double Rx_Time_; 
    double Energy_Tx_; 
    double Energy_Rx_; 
    double Transmitted_bytes_; 
    double tx_power_; 
    double rx_power_; 
    int tot_pkts_lost; 
    int tot_ctrl_pkts_lost; 
    int errorCtrlPktsInterf; 
    int collisionDataCTRL; 
    int collisionCTRL; 
    int collisionDATA; 
    std::string Interference_Model; 
    uwinterference *interference_; 
};
 
#endif /* UWPHYSICAL_H  */