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 "underwater-bpsk.h"
#include "uwinterference.h"
#include "mac.h"
 
#include "clmsg-stats.h"
#include <phymac-clmsg.h>
#include <string.h>
 
#include <rng.h>
#include <packet.h>
#include <module.h>
#include <tclcl.h>
 
#include <iostream>
#include <string.h>
#include <cmath>
#include <limits>
#include <climits>
 
class UwPhysicalStats : public Stats
{
public:
    UwPhysicalStats();
 
    UwPhysicalStats(int mod_id, int stck_id);
 
    virtual ~UwPhysicalStats()
    {
    }
 
    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);
 
    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; 
    bool has_error; 
};
 
 
class UnderwaterPhysical : public UnderwaterMPhyBpsk
{
 
public:
    UnderwaterPhysical();
 
    virtual ~UnderwaterPhysical();
 
    virtual int command(int, const char *const *);
    virtual void recv(Packet *);
 
    int recvSyncClMsg(ClMessage* m);
 
protected:
    virtual void updateInstantaneousStats();
 
    virtual void endTx(Packet *p);
    virtual void endRx(Packet *p);
    virtual void startRx(Packet *p);
    inline virtual double
    consumedEnergyTx(const double &_duration)
    {
        return (tx_power_ * _duration);
    }
    inline virtual double
    consumedEnergyRx(const double &_duration)
    {
        return (rx_power_ * _duration);
    }
 
    virtual double getPER(double snr, int nbits, Packet *);
 
    inline const bool
    isZero(const double &value) const
    {
        return std::fabs(value) < std::numeric_limits<double>::epsilon();
    }
 
    inline double
    Get_Tx_Time()
    {
        return Tx_Time_;
    }
 
    inline double
    Get_Rx_Time()
    {
        return Rx_Time_;
    }
 
    inline double
    Get_Energy_Tx()
    {
        return Energy_Tx_;
    }
 
    inline double
    Get_Energy_Rx()
    {
        return Energy_Rx_;
    }
 
    inline double
    Get_Transmitted_bytes()
    {
        return Transmitted_bytes_;
    }
 
    inline void
    incrTot_pkts_lost()
    {
        tot_pkts_lost++;
    }
 
    inline void
    incrTotCrtl_pkts_lost()
    {
        tot_ctrl_pkts_lost++;
    }
 
    inline void
    incrErrorCtrlPktsInterf()
    {
        errorCtrlPktsInterf++;
    }
 
    inline void
    incrCollisionDATAvsCTRL()
    {
        collisionDataCTRL++;
    }
 
    inline void
    incrCollisionCTRL()
    {
        collisionCTRL++;
    }
 
    inline void
    incrCollisionDATA()
    {
        collisionDATA++;
    }
 
    inline int
    getTot_pkts_lost()
    {
        return tot_pkts_lost;
    }
 
    inline int
    getTot_CtrlPkts_lost()
    {
        return tot_ctrl_pkts_lost;
    }
 
    inline int
    getError_CtrlPktsInterf()
    {
        return errorCtrlPktsInterf;
    }
 
    inline int
    getCollisionsDATAvsCTRL()
    {
        return collisionDataCTRL;
    }
 
    inline int
    getCollisionsCTRL()
    {
        return collisionCTRL;
    }
 
    inline int
    getCollisionsDATA()
    {
        return collisionDATA;
    }
 
    inline const double
    log2(const double &_input) const
    {
        return (log10(_input) / log10(2));
    }
 
    inline const double
    get_prob_error_symbol_mpsk(const double &_snr, const uint32_t _M) const
    {
        return erfc(sqrt(_snr * log2(_M)) * sin(M_PI / _M));
    }
 
    // Variables
    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_; 
private:
    // Variables
};
 
#endif /* UWPHYSICAL_H  */