uwUFetch_NODE.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 UWUFETCH_NODE_H_
#define UWUFETCH_NODE_H_
 
#include <mmac.h>
#include <stdio.h>
#include <time.h>
#include <iostream>
#include <clmessage.h>
#include <mphy.h>
#include <string>
#include <fstream>
#include <ostream>
#include <cassert>
#include <queue>
#include <map>
//#include "uwmphy_modem_cmn_hdr.h"
 
#define UWFETCH_NODE_DROP_REASON_UNKNOWN_TYPE \
    "DUT" 
#define UWFETCH_NODE_DROP_REASON_WRONG_RECEIVER \
    "DWR" 
#define UWFETCH_NODE_DROP_REASON_CBEACON_AND_DATA_ALREADY_TX            \
    "DCDAT" 
#define UWFETCH_NODE_DROP_REASON_ERROR \
    "DRE" 
#define UWUFETCH_NODE_DROP_REASON_BUFFER_FULL \
    "DBF" 
#define UWUFETCH_NODE_DROP_REASON_NOT_ENABLE                               \
    "DNE" 
#define UWUFETCH_NODE_DROP_REASON_NOT_MY_TURN \
    "DNMT" 
#define UWUFETCH_NODE_DROP_CAN_NOT_RX_THIS_PCK \
    "CNRP" 
extern packet_t
        PT_TRIGGER_UFETCH; 
extern packet_t PT_RTS_UFETCH; 
extern packet_t PT_CTS_UFETCH; 
extern packet_t PT_BEACON_UFETCH; 
extern packet_t PT_PROBE_UFETCH; 
extern packet_t PT_POLL_UFETCH; 
extern packet_t
        PT_CBEACON_UFETCH; 
typedef struct probbed_node {
    uint id_node_; // Id of the NODE
    int n_pcks_NODE_want_tx_; // Number of packets that the NODE want to
                              // transmit at the HN
    int mac_address_; // Mac Address of the NODE
    double backoff_time_; // Back-off time chosen by the NODE before
                          // transmitting the PROBE
 
    inline uint &
    Id_node()
    {
        return (id_node_);
    }
 
    inline int &
    n_pcks_NODE_want_tx()
    {
        return n_pcks_NODE_want_tx_;
    }
 
    inline double &
    backoff_time()
    {
        return backoff_time_;
    }
 
    inline int &
    mac_address()
    {
        return mac_address_;
    }
} probbed_node;
 
class uwUFetch_NODE : public MMac
{
public:
    uwUFetch_NODE();
 
    virtual ~uwUFetch_NODE();
 
    virtual int command(int argc, const char *const *argv);
 
    virtual int crLayCommand(ClMessage *m);
 
protected:
    enum UWUFETCH_NODE_STATUS {
        UWUFETCH_NODE_STATUS_IDLE,
        UWUFETCH_NODE_STATUS_BEACON_RECEIVE,
        UWUFETCH_NODE_STATUS_TRANSMIT_PROBE,
        UWUFETCH_NODE_STATUS_WAIT_POLL_PACKET,
        UWUFETCH_NODE_STATUS_POLL_RECEIVE,
        UWUFETCH_NODE_STATUS_TRANSMIT_DATA,
        UWUFETCH_NODE_STATUS_TRIGGER_RECEIVE,
        UWUFETCH_NODE_STATUS_RTS_TRANSMIT,
        UWUFETCH_NODE_STATUS_WAIT_CTS_PACKET,
        UWUFETCH_NODE_STATUS_CTS_RECEIVE,
        UWUFETCH_NODE_STATUS_TRANSMIT_BEACON,
        UWUFETCH_NODE_STATUS_WAIT_PROBE_PACKET,
        UWUFETCH_NODE_STATUS_PROBE_RX,
        UWUFETCH_NODE_STATUS_POLL_TX,
        UWUFETCH_NODE_STATUS_WAIT_DATA_NODE,
        UWUFETCH_NODE_STATUS_DATA_RX,
        UWUFETCH_NODE_STATUS_WAIT_CBEACON_PACKET,
        UWUFETCH_NODE_STATUS_CBEACON_RECEIVE
    };
 
    enum UWUFETCH_NODE_STATUS_CHANGE {
        UWFETCH_NODE_STATUS_CHANGE_STATE_IDLE,
        UWFETCH_NODE_STATUS_CHANGE_PACKET_ERROR,
        UWFETCH_NODE_STATUS_CHANGE_PACKET_FOR_ANOTHER_NODE,
        UWFETCH_NODE_STATUS_CHANGE_PACKET_UNKNOWN_TYPE,
        UWUFETCH_NODE_STATUS_CHANGE_BEACON_RX,
        UWUFETCH_NODE_STATUS_CHANGE_PROBE_TX,
        UWUFETCH_NODE_STATUS_CHANGE_TO_WAIT_POLL_EXPIRED,
        UWUFETCH_NODE_STATUS_CHANGE_POLL_RX,
        UWFETCH_NODE_STATUS_CHANGE_CBEACON_RX_DATA_ALREADY_TX,
        UWUFETCH_NODE_STATUS_CHANGE_MAX_DATA_PCK_TX,
        UWUFETCH_NODE_STATUS_CHANGE_DATA_PCK_TX,
        UWUFETCH_NODE_STATUS_CHANGE_TRIGGER_RX,
        UWUFETCH_NODE_STATUS_CHANGE_RTS_TX,
        UWUFETCH_NODE_STATUS_CHANGE_TO_WAIT_CTS_EXPIRED,
        UWUFETCH_NODE_STATUS_CHANGE_CTS_RX,
        UWUFETCH_NODE_STATUS_CHANGE_BEACON_TX,
        UWUFETCH_NODE_STATUS_CHANGE_CBEACON_TX,
        UWUFETCH_NODE_STATUS_CHANGE_PROBE_RX,
        UWUFETCH_NODE_STATUS_CHANGE_CBEACON_MAX_ALLOWED_TX_0_PROBE_RX,
        UWUFETCH_NODE_STATUS_CHANGE_CBEACON_ALLOWED_TX_0_PROBE_RX,
        UWUFETCH_NODE_STATUS_CHANGE_MAX_PROBE_RX_PROBE_TO_NOT_EXPIRED,
        UWUFETCH_NODE_STATUS_CHANGE_TO_EXPIRED_AT_LEAST_1_PROBE_RX,
        UWUFETCH_NODE_STATUS_CHANGE_POLL_TX,
        UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED,
        UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_0_NODE_TO_POLL_NO_OTHER_CBEACON,
        UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_0_NODE_TO_POLL_YES_OTHER_CBEACON,
        UWUFETCH_NODE_STATUS_CHANGE_DATA_TO_EXPIRED_ANOTHER_NODE_TO_POLL,
        UWUFETCH_NODE_STATUS_CHANGE_DATA_RX,
        UWUFETCH_NODE_STATUS_CHANGE_LAST_DATA_PCK_RX,
        UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_0_NODE_TO_POLL_NO_OTHER_CBEACON,
        UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_0_NODE_TO_POLL_YES_OTHER_CBEACON,
        UWUFETCH_NODE_STATUS_CHANGE_DATA_MAX_ALLOWED_PCK_RX_YES_NODE_TO_POLL,
        UWUFETCH_NODE_STATUS_CHANGE_CBEACON_MAX_ALLOWED_TX,
        UWUFETCH_NODE_STATUS_CHANGE_BEACON_TO_EXPIRED,
        UWUFETCH_NODE_STATUS_CHANGE_TRIGGER_RX_BUT_HN_NO_DATA_TO_TX,
        UWUFETCH_NODE_STATUS_CHANGE_HN_TX_ALL_DATA_TO_AUV,
        UWUFETCH_NODE_STATUS_CHANGE_HN_RX_TRIGGER_FROM_AUV_CORRUPTED,
        UWUFETCH_NODE_STATUS_CHANGE_HN_FINISH_TX_DATA_PCK_TO_AUV_RETURN_CBEACON_TX
    };
 
    enum UWUFETCH_NODE_PACKET_TYPE {
        UWUFETCH_NODE_PACKET_TYPE_DATA,
        UWUFETCH_NODE_PACKET_TYPE_PROBE,
        UWUFETCH_NODE_PACKET_TYPE_POLL,
        UWUFETCH_NODE_PACKET_TYPE_BEACON,
        UWUFETCH_NODE_PACKET_TYPE_TRIGGER,
        UWUFETCH_NODE_PACKET_TYPE_RTS,
        UWUFETCH_NODE_PACKET_TYPE_CTS
    };
 
    enum UWUFETCH_TIMER_STATUS {
        UWUFETCH_TIMER_STATUS_IDLE,
        UWUFETCH_TIMER_STATUS_RUNNING,
        UWUFETCH_TIMER_STATUS_FROZEN,
        UWUFETCH_TIMER_STATUS_EXPIRED
    };
 
    class uwUFetch_NODE_timer : public TimerHandler
    {
    public:
        uwUFetch_NODE_timer(uwUFetch_NODE *m)
            : TimerHandler()
            , start_time(0.0)
            , left_duration(0.0)
            , counter(0)
            , module(m)
            , timer_status(UWUFETCH_TIMER_STATUS_IDLE)
        {
            assert(m != NULL);
        }
 
        virtual ~uwUFetch_NODE_timer(){};
 
        virtual void
        freeze()
        {
            assert(timer_status == UWUFETCH_TIMER_STATUS_RUNNING);
            left_duration = NOW - start_time;
            if (left_duration <= 0.0) {
                left_duration = module->mac2phy_delay_;
            }
            force_cancel();
            timer_status = UWUFETCH_TIMER_STATUS_FROZEN;
        }
 
        virtual void
        unFreeze()
        {
            assert(timer_status == UWUFETCH_TIMER_STATUS_FROZEN);
            start_time = NOW;
            assert(left_duration > 0);
            sched(left_duration); 
            timer_status = UWUFETCH_TIMER_STATUS_RUNNING;
        }
 
        virtual void
        stop()
        {
            timer_status = UWUFETCH_TIMER_STATUS_IDLE;
            force_cancel();
        }
 
        virtual void
        schedule(double val)
        {
            start_time = NOW;
            left_duration = val;
            timer_status = UWUFETCH_TIMER_STATUS_RUNNING;
            resched(val);
        }
 
        bool
        isIdle()
        {
            return (timer_status == UWUFETCH_TIMER_STATUS_IDLE);
        }
 
        bool
        isRunning()
        {
            return (timer_status == UWUFETCH_TIMER_STATUS_RUNNING);
        }
 
        bool
        isFroozen()
        {
            return (timer_status == UWUFETCH_TIMER_STATUS_FROZEN);
        }
 
        bool
        isExpired()
        {
            return (timer_status == UWUFETCH_TIMER_STATUS_EXPIRED);
        }
 
        bool
        isActive()
        {
            return (timer_status == isRunning() || timer_status == isFroozen());
        }
 
        void
        resetCounter()
        {
            counter = 0;
        }
 
        void
        incrCounter()
        {
            ++counter;
        }
 
        int
        getCounter()
        {
            return counter;
        }
 
        double
        getDuration()
        {
            return left_duration;
        }
 
    protected:
        double start_time; 
        double left_duration; 
        int counter; 
        uwUFetch_NODE
                *module; 
        UWUFETCH_TIMER_STATUS timer_status; 
    }; // END class uwUFetch_NODE_timer
 
    class uwUFetch_BEACON_timer : public uwUFetch_NODE_timer
    {
    public:
        uwUFetch_BEACON_timer(uwUFetch_NODE *m)
            : uwUFetch_NODE_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_BEACON_timer
         */
        virtual ~uwUFetch_BEACON_timer(){};
 
    protected:
        virtual void expire(Event *e);
 
    }; // END class uwUFetch_BEACON_timer
 
    class uwUFetch_BackOffTimer : public uwUFetch_NODE_timer
    {
    public:
        uwUFetch_BackOffTimer(uwUFetch_NODE *m)
            : uwUFetch_NODE_timer(m)
        {
        }
 
        virtual ~uwUFetch_BackOffTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    }; // end class uwUFetch_BackOffTimer
 
    class uwUFetch_PROBE_timer : public uwUFetch_NODE_timer
    {
    public:
        uwUFetch_PROBE_timer(uwUFetch_NODE *m)
            : uwUFetch_NODE_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_PROBE_timer
         */
        virtual ~uwUFetch_PROBE_timer(){};
 
    protected:
        virtual void expire(Event *e);
    }; // END class uwUFetch_PROBE_timer
 
    class uwUFetch_POLL_timer : public uwUFetch_NODE_timer
    {
    public:
        uwUFetch_POLL_timer(uwUFetch_NODE *m)
            : uwUFetch_NODE_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_POLL_timer
         */
        virtual ~uwUFetch_POLL_timer(){};
 
    protected:
        virtual void expire(Event *e);
    }; // END class uwUFetch_POLL_timer
 
    class uwUFetch_DATA_BEFORE_TX_timer : public uwUFetch_NODE_timer
    {
    public:
        uwUFetch_DATA_BEFORE_TX_timer(uwUFetch_NODE *m)
            : uwUFetch_NODE_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_DATA_BEFORE_TX_timer class
         */
        virtual ~uwUFetch_DATA_BEFORE_TX_timer(){};
 
    protected:
        virtual void expire(Event *e);
    }; // END class uwUFetch_DATA_BEFORE_TX_timer
 
    class uwUFetch_DATA_timer : public uwUFetch_NODE_timer
    {
    public:
        uwUFetch_DATA_timer(uwUFetch_NODE *m)
            : uwUFetch_NODE_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_DATA_timer class
         */
        virtual ~uwUFetch_DATA_timer(){};
 
    protected:
        virtual void expire(Event *e);
    }; // END class uwUFetch_DATA_timer
 
    class uwUFetch_CBeacon_timer : public uwUFetch_NODE_timer
    {
    public:
        uwUFetch_CBeacon_timer(uwUFetch_NODE *m)
            : uwUFetch_NODE_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_Beacon_timer class
         */
        virtual ~uwUFetch_CBeacon_timer(){};
 
    protected:
        virtual void expire(Event *e);
 
    }; // END class uwUFetch_CBeacon_timer
 
    class uwUFetch_CTS_timer : public uwUFetch_NODE_timer
    {
    public:
        uwUFetch_CTS_timer(uwUFetch_NODE *m)
            : uwUFetch_NODE_timer(m)
        {
        }
 
        /*
         * Destructor of UWUFetch_CTS_timer class
         */
        virtual ~uwUFetch_CTS_timer(){};
 
    protected:
        virtual void expire(Event *e);
    }; // END class uwUFetch_CTS_timer
 
    class uwUFetch_TRIGGER_timer : public uwUFetch_NODE_timer
    {
    public:
        uwUFetch_TRIGGER_timer(uwUFetch_NODE *m)
            : uwUFetch_NODE_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_TRIGGER_time class
         */
        virtual ~uwUFetch_TRIGGER_timer(){};
 
    protected:
        virtual void expire(Event *e);
    }; // END class uwUFetch_TRIGGER_timer
 
    /******************************************************************************
     *                           GENERAL METHODS *
     ******************************************************************************/
 
    virtual void Phy2MacStartRx(const Packet *p);
 
    virtual void Phy2MacStartRx_HN(const Packet *p);
 
    virtual void Phy2MacEndRx(Packet *p);
 
    virtual void Phy2MacEndRx_HN_without(Packet *p);
 
    virtual void Phy2MacEndRx_HN(Packet *p);
 
    virtual void Mac2PhyStartTx(Packet *p);
 
    virtual void Mac2PhyStartTx_HN(Packet *p);
 
    virtual void Phy2MacEndTx(const Packet *p);
 
    virtual void Phy2MacEndTx_HN(const Packet *p);
 
    virtual void recvFromUpperLayers(Packet *p);
 
    virtual void recvFromUpperLayers_HN(Packet *p);
 
    virtual void printStateInfo(double delay = 0);
 
    virtual void initInfo();
 
    virtual void waitForUser();
 
    virtual void
    refreshReason(UWUFETCH_NODE_STATUS_CHANGE reason)
    {
        last_reason = reason;
    }
 
    /*
     *  Refresh the state of the protocol
     *
     * @param UWUFETCH_NODE_STATUS current state of the protocol
     */
    virtual void
    refreshState(UWUFETCH_NODE_STATUS state)
    {
        prev_state = curr_state;
        curr_state = state;
    }
 
    /******************************************************************************
     *                        SENSOR NODE METHODS *
     ******************************************************************************/
 
    virtual void stateIdle_NODE();
 
    virtual void BEACON_rx();
 
    virtual void BCKTOExpired();
 
    virtual void state_PROBE_tx();
 
    virtual void PROBE_tx();
 
    virtual void state_wait_POLL();
 
    virtual void PollTOExpired();
 
    virtual void POLL_rx();
 
    virtual void state_DATA_NODE_first_tx();
 
    virtual void DataBeforeTxTOExpired();
 
    virtual void state_DATA_NODE_tx();
 
    virtual void state_DATA_NODE_finish_tx();
 
    virtual void DATA_NODE_tx();
 
    virtual void state_wait_CBEACON();
 
    virtual void CBeaconTOExpired();
 
    virtual void CBEACON_rx();
 
    /****************************************************************************
     *                          HEAD NODE METHODS *
     ****************************************************************************/
 
    virtual void stateIdle_HN();
 
    virtual void BeaconTxTOExpire();
 
    virtual void state_BEACON_tx();
 
    virtual void BEACON_tx();
 
    virtual void state_wait_PROBE();
 
    virtual void PROBE_rx();
 
    virtual void state_wait_other_PROBE();
 
    virtual void ProbeTOExpired();
 
    virtual void state_POLL_tx();
 
    virtual void POLL_tx();
 
    virtual void state_wait_first_DATA();
 
    virtual void state_wait_other_DATA();
 
    virtual void DataTOExpired();
 
    virtual void DATA_rx();
 
    virtual void state_CBEACON_tx();
 
    virtual void CBEACON_tx();
 
    virtual void TRIGGER_rx();
 
    virtual void TRIGGER_rx_without();
 
    virtual void state_RTS_tx();
 
    virtual void RTS_tx();
 
    virtual void state_wait_CTS();
 
    virtual void CtsTOExpired();
 
    virtual void CTS_rx();
 
    virtual void state_DATA_HN_first_tx();
 
    virtual void state_DATA_HN_first_tx_without();
 
    virtual void state_DATA_HN_tx();
 
    virtual void state_DATA_HN_tx_without();
 
    virtual void state_DATA_HN_finish_tx();
 
    virtual void state_DATA_HN_finish_tx_without();
 
    virtual void DATA_HN_tx();
 
    virtual void DATA_HN_tx_without();
 
    virtual void BCKTOExpired_HN();
 
    virtual void BCKTOExpired_HN_without();
 
    virtual void DataBeforeTxTOExpired_HN();
 
    /******************************************************************************
     *                          METODI AUSILIARI *
     ******************************************************************************/
    virtual bool isHeadNode();
 
    virtual bool typeCommunication();
 
    virtual bool burstDATA();
 
    virtual double choiceBackOffTimer();
 
    virtual double choiceBackOffTimer_HN();
 
    virtual double getDataTimerValue();
 
    virtual void computeTxTime(UWUFETCH_NODE_PACKET_TYPE tp);
 
    virtual void computeTxTime_HN(UWUFETCH_NODE_PACKET_TYPE tp);
 
    virtual double getRTT();
 
    virtual void updateListProbbedNode();
 
    /******************************************************************************
     *                                          METODI get E incr *
     * ****************************************************************************/
 
    /**************************
     *          HEAD NODE     *
     **************************/
 
    void
    incrBeaconPckTx_by_HN()
    {
        n_BEACON_pck_tx_by_HN++;
    };
 
    int
    getBeaconTx_by_HN()
    {
        return n_BEACON_pck_tx_by_HN;
    };
 
    void
    incrTotalBeaconPckTx_by_HN()
    {
        n_tot_BEACON_pck_tx_by_HN++;
    };
 
    int
    getTotalBeaconTx_by_HN()
    {
        return n_tot_BEACON_pck_tx_by_HN;
    };
 
    void
    incrProbePckRx_HN()
    {
        n_PROBE_pck_rx_by_HN++;
    };
 
    int
    getProbePckRx_HN()
    {
        return n_PROBE_pck_rx_by_HN;
    };
 
    void
    incrTotalProbePckRx_HN()
    {
        n_tot_PROBE_pck_rx_by_HN++;
    };
 
    int
    getTotalProbePckRx_HN()
    {
        return n_tot_PROBE_pck_rx_by_HN;
    };
 
    void
    incrTotalProbePckRx_corrupted_HN()
    {
        n_tot_PROBE_pck_corr_rx_by_HN++;
    };
 
    int
    getTotalProbePckRx_corrupted_HN()
    {
        return n_tot_PROBE_pck_corr_rx_by_HN;
    };
 
    void
    incrPollPckTx_by_HN()
    {
        n_POLL_pck_tx_by_HN++;
    };
 
    int
    getPollPckTx_by_HN()
    {
        return n_POLL_pck_tx_by_HN;
    };
 
    void
    incrTotalPollPckTx_by_HN()
    {
        n_tot_POLL_pck_tx_by_HN++;
    };
 
    int
    getTotalPollPckTx_by_HN()
    {
        return n_tot_POLL_pck_tx_by_HN;
    };
 
    void
    incrDataPckRx_by_HN()
    {
        n_DATA_pck_rx_by_HN++;
    };
 
    int
    getDataPckRx_by_HN()
    {
        return n_DATA_pck_rx_by_HN;
    };
 
    void
    incrTotalDataPckRx_by_HN()
    {
        n_tot_DATA_pck_rx_by_HN++;
    };
 
    int
    getTotalDataPckRx_by_HN()
    {
        return n_tot_DATA_pck_rx_by_HN;
    };
 
    void
    incrTotalDataPckRx_corrupted_by_HN()
    {
        n_tot_DATA_pck_rx_corr_by_HN++;
    };
 
    int
    getTotalDataPckRx_corrupted_by_HN()
    {
        return n_tot_DATA_pck_rx_corr_by_HN;
    };
 
    void
    incrCBeaconPckTx_by_HN()
    {
        n_CBEACON_pck_tx_by_HN++;
    };
 
    int
    getCBeaconPckTx_by_HN()
    {
        return n_CBEACON_pck_tx_by_HN;
    };
 
    void
    incrTotalCBeaconPckTx_by_HN()
    {
        n_tot_CBEACON_pck_tx_by_HN++;
    };
 
    int
    getTotalCBeaconPckTx_by_HN()
    {
        return n_tot_CBEACON_pck_tx_by_HN;
    };
 
    void
    incrTriggerPckRx_HN()
    {
        n_TRIGGER_pck_rx_by_HN++;
    };
 
    int
    getTriggerPckRx_HN()
    {
        return n_TRIGGER_pck_rx_by_HN;
    };
 
    void
    incrTotalTriggerPckRx_HN()
    {
        n_tot_TRIGGER_pck_rx_by_HN++;
    };
 
    int
    getTotalTriggerPckRx_HN()
    {
        return n_tot_TRIGGER_pck_rx_by_HN;
    };
 
    void
    incrTotalTriggerPckRx_corrupted_HN()
    {
        n_tot_TRIGGER_pck_rx_corr_by_HN++;
    };
 
    int
    getTotalTriggerPckRx_corrupted_HN()
    {
        return n_tot_TRIGGER_pck_rx_corr_by_HN;
    };
 
    void
    incrRtsPckTx_by_HN()
    {
        n_RTS_pck_tx_by_HN++;
    };
 
    int
    getRtsPckTx_by_HN()
    {
        return n_RTS_pck_tx_by_HN;
    };
 
    void
    incrTotalRtsPckTx_by_HN()
    {
        n_tot_RTS_pck_tx_by_HN++;
    };
 
    int
    getTotalRtsPckTx_by_HN()
    {
        return n_tot_RTS_pck_tx_by_HN;
    };
 
    void
    incrCtsPckRx_HN()
    {
        n_CTS_pck_rx_by_HN++;
    };
 
    int
    getCtsPckRx_HN()
    {
        return n_CTS_pck_rx_by_HN;
    };
 
    void
    incrTotalCtsPckRx_HN()
    {
        n_tot_CTS_pck_rx_by_HN++;
    };
 
    int
    getTotalCtsPckRx_HN()
    {
        return n_tot_CTS_pck_rx_by_HN;
    };
 
    void
    incrTotalCtsPckRx_corrupted_HN()
    {
        n_tot_CTS_pck_rx_corr_by_HN++;
    };
 
    int
    getTotalCtsPckRx_corrupted_HN()
    {
        return n_tot_CTS_pck_rx_corr_by_HN;
    };
 
    void
    incrDataPckTx_by_HN()
    {
        n_DATA_pck_tx_by_HN++;
    };
 
    int
    getDataPckTx_by_HN()
    {
        return n_DATA_pck_tx_by_HN;
    };
 
    void
    incrTotalDataPckTx_by_HN()
    {
        n_tot_DATA_pck_tx_by_HN++;
    }
 
    int
    getTotalDataPckTx_by_HN()
    {
        return n_tot_DATA_pck_tx_by_HN;
    }
 
    /*********************************
     *          SENSOR NODE            *
     *********************************/
 
    void
    incrBeaconPckRx_by_NODE()
    {
        n_BEACON_pck_rx_by_NODE++;
    };
 
    int
    getBeaconPckRx_by_NODE()
    {
        return n_BEACON_pck_rx_by_NODE;
    };
 
    void
    incrTotalBeaconPckRx_by_NODE()
    {
        n_tot_BEACON_pck_rx_by_NODE++;
    };
 
    int
    getTotalBeaconPckRx_by_NODE()
    {
        return n_tot_BEACON_pck_rx_by_NODE;
    };
 
    void
    incrTotalBeaconPckRx_corrupted_by_NODE()
    {
        n_tot_BEACON_pck_rx_corr_by_NODE++;
    };
 
    int
    getTotalBeaconPckRx_corrupted_by_NODE()
    {
        return n_tot_BEACON_pck_rx_corr_by_NODE;
    };
 
    void
    incrProbePckTx_by_NODE()
    {
        n_PROBE_pck_tx_by_NODE++;
    };
 
    int
    getProbePckTx_by_NODE()
    {
        return n_PROBE_pck_tx_by_NODE;
    };
 
    void
    incrTotalProbePckTx_by_NODE()
    {
        n_tot_PROBE_pck_tx_by_NODE++;
    };
 
    int
    getTotalProbePckTx_by_NODE()
    {
        return n_tot_PROBE_pck_tx_by_NODE;
    };
 
    void
    incrPollPckRx_by_NODE()
    {
        n_POLL_pck_rx_by_NODE++;
    };
 
    int
    getPollPckRx_by_NODE()
    {
        return n_POLL_pck_rx_by_NODE;
    };
 
    void
    incrTotalPollPckRx_by_NODE()
    {
        n_tot_POLL_pck_rx_by_NODE++;
    };
 
    int
    getTotalPollPckRx_by_NODE()
    {
        return n_tot_POLL_pck_rx_by_NODE;
    };
 
    void
    incrTotalPollPckRx_corrupted_by_NODE()
    {
        n_tot_POLL_pck_rx_corr_by_NODE++;
    };
 
    int
    getTotalPollPckRx_corrupted_by_NODE()
    {
        return n_tot_POLL_pck_rx_corr_by_NODE;
    };
 
    void
    incrDataPckTx_by_NODE()
    {
        n_DATA_pck_tx_by_NODE++;
    };
 
    int
    getDataPckTx_by_NODE()
    {
        return n_DATA_pck_tx_by_NODE;
    };
 
    void
    incrTotalDataPckTx_by_NODE()
    {
        n_tot_DATA_pck_tx_by_NODE++;
    };
 
    int
    getTotalDataPckTx_by_NODE()
    {
        return n_tot_DATA_pck_tx_by_NODE;
    };
 
    void
    incrCBeaconPckRx_by_NODE()
    {
        n_CBEACON_pck_rx_by_NODE++;
    };
 
    int
    getCBeaconPckRx_by_NODE()
    {
        return n_CBEACON_pck_rx_by_NODE;
    };
 
    void
    incrTotalCBeaconPckRx_by_NODE()
    {
        n_tot_CBEACON_pck_rx_by_NODE++;
    };
 
    int
    getTotalCBeaconPckRx_by_NODE()
    {
        return n_tot_CBEACON_pck_rx_by_NODE;
    };
 
    void
    incrTotalCBeaconPckRx_corrupted_by_NODE()
    {
        n_tot_CBEACON_pck_rx_corr_by_NODE++;
    };
 
    int
    getTotalCBeaconPckRx_corrupted_by_NODE()
    {
        return n_tot_CBEACON_pck_rx_corr_by_NODE;
    };
 
    /****************************************************************************
     *                   SENSOR NODE VARIABLES *
     ****************************************************************************/
    // TCL variables
    int MAX_PAYLOAD; 
    double
            T_GUARD; 
    int MAXIMUM_BUFFER_DATA_PCK_NODE; 
    double T_POLL; 
    int debugMio_; 
    int N_RUN; 
    double TIME_BETWEEN_2_TX_DATA_NODE_HN; 
    int MODE_COMM_HN_AUV; 
    int
            MODE_BURST_DATA; 
    // Timers
    uwUFetch_BackOffTimer BCK_timer_probe; 
    uwUFetch_POLL_timer
            POLL_timer; 
    uwUFetch_DATA_BEFORE_TX_timer DATA_BEFORE_TX_timer; // Interval time after
                                                        // that the SN transmit
                                                        // the successive DATA
                                                        // pck to the HN */
    uwUFetch_CBeacon_timer CBEACON_timer; // Interval time in which SN is
                                          // enabled to receive CBEACON packet
                                          // from HN */
 
    // Global Variables that should be never reset
    double
            rx_BEACON_start_time; 
    double rx_BEACON_finish_time; 
    double tx_PROBE_start_time; 
    double tx_PROBE_finish_time; 
    double rx_POLL_start_time; 
    double
            rx_POLL_finish_time; 
    double tx_DATA_start_time; 
    double tx_DATA_finish_time; 
    double rx_CBEACON_start_time; 
    double
            rx_CBEACON_finish_time; 
    int n_tot_BEACON_pck_rx_by_NODE; 
    int n_tot_BEACON_pck_rx_corr_by_NODE; 
    int n_tot_PROBE_pck_tx_by_NODE; 
    int n_tot_POLL_pck_rx_by_NODE; 
    int n_tot_POLL_pck_rx_corr_by_NODE; 
    int n_tot_DATA_pck_tx_by_NODE; 
    int
            n_tot_CBEACON_pck_rx_by_NODE; 
    int n_tot_CBEACON_pck_rx_corr_by_NODE; 
    double T_min_bck_probe_node; 
    double T_max_bck_probe_node; 
    int
            num_cbeacon_node_rx; 
    int mac_addr_HN_in_beacon; 
    double bck_before_tx_probe; 
    double Tprobe; 
    double Tdata_NODE; 
    double RTT; 
    int
            mac_addr_HN_in_poll; 
    int
            num_pck_to_tx_by_NODE; 
    double Tdata_NODE_pck; 
    int num_cbeacon_at_now_HN_tx; 
    int mac_addr_HN_in_cbeacon; 
    double
            T_min_bck_DATA; 
    double
            T_max_bck_DATA; 
    double bck_before_tx_data; 
    // Variables that should be reseted when a cycle is end
    int
            n_BEACON_pck_rx_by_NODE; 
    int n_PROBE_pck_tx_by_NODE; 
    int n_POLL_pck_rx_by_NODE; 
    int
            n_DATA_pck_tx_by_NODE; 
    int n_CBEACON_pck_rx_by_NODE; 
    bool dataAlreadyTransmitted; 
    // Variables that enable or not an operation
    bool rxBEACONEnabled; 
    bool
            txPROBEEnabled; 
    bool rxPOLLEnabled; 
    bool txDATAEnabled; 
    bool rxCBEACONEnabled; 
    // PACKETS create
    Packet *curr_BEACON_NODE_pck_rx; 
    Packet *curr_PROBE_NODE_pck_tx; 
    Packet
            *curr_POLL_NODE_pck_rx; 
    Packet
            *curr_DATA_NODE_pck_tx; 
    Packet
            *curr_CBEACON_NODE_pck_rx; 
    // Queue
    std::queue<Packet *> Q_data; 
    /******************************************************************************
     *                          HEAD NODE VARIABLES *
     ******************************************************************************/
    // TCL variables
    double
            T_START_PROCEDURE_HN_NODE; 
    double T_MAX_BACKOFF_PROBE; 
    double T_MIN_BACKOFF_PROBE; 
    int PRINT_TRANSITIONS_INT; 
    double
            T_PROBE; 
    int MAX_ALLOWED_CBEACON_TX; // Maximum number of CBEACON cycles that HN can
                                // start after the transmission of a BEACON
                                // packet. */
    int MAX_PCK_HN_WANT_RX_FROM_NODE; // Maximum number of DATA packets that HN
                                      // want to receive from a single SN during
                                      // a cycle BEACON-PROBE-POLL-DATA-CBEACON
                                      // */
    double T_CTS; // Interval time in which HN is enabled to receive a CTS
                  // packet from AUV */
    int MAX_POLLED_NODE; 
    double
            TIME_BETWEEN_2_TX_DATA_HN_AUV; 
    // Timers
    uwUFetch_BEACON_timer
            BeaconBeforeTx_timer; 
    uwUFetch_PROBE_timer PROBE_timer; 
    uwUFetch_DATA_timer DATA_timer; 
    uwUFetch_BackOffTimer
            BCK_timer_rts; 
    uwUFetch_CTS_timer CTS_timer; 
    uwUFetch_BackOffTimer
            BCK_timer_data; 
    // Global Variables that should be never reset
    double tx_BEACON_start_HN_time; 
    double
            tx_BEACON_finish_HN_time; 
    double rx_PROBE_start_HN_time; 
    double rx_PROBE_finish_HN_time; 
    double tx_POLL_start_HN_time; 
    double tx_POLL_finish_HN_time; 
    double rx_DATA_start_HN_time; 
    double
            rx_DATA_finish_HN_time; 
    double tx_CBEACON_start_HN_time; 
    double tx_CBEACON_finish_HN_time; 
    double
            rx_TRIGGER_start_HN_time; 
    double rx_TRIGGER_finish_HN_time; 
    double
            tx_RTS_start_HN_time; 
    double tx_RTS_finish_HN_time; 
    double
            rx_CTS_start_HN_time; 
    double rx_CTS_finish_HN_time; 
    double tx_DATA_start_HN_time; 
    double tx_DATA_finish_HN_time; 
    int n_tot_BEACON_pck_tx_by_HN; 
    int
            n_tot_PROBE_pck_rx_by_HN; 
    int n_tot_PROBE_pck_corr_rx_by_HN; 
    int n_tot_POLL_pck_tx_by_HN; 
    int n_tot_DATA_pck_rx_by_HN; 
    int n_tot_DATA_pck_rx_corr_by_HN; 
    int n_tot_CBEACON_pck_tx_by_HN; 
    int n_tot_TRIGGER_pck_rx_by_HN; 
    int
            n_tot_TRIGGER_pck_rx_corr_by_HN; 
    int n_tot_RTS_pck_tx_by_HN; 
    int n_tot_CTS_pck_rx_by_HN; 
    int n_tot_CTS_pck_rx_corr_by_HN; 
    int n_tot_DATA_pck_tx_by_HN; 
    int mac_addr_NODE_polled; 
    int
            number_data_pck_HN_rx_exact; 
    int pck_number_id; 
    double data_timeout; 
    double Tbeacon; 
    double
            Tpoll; 
    double Trts; 
    double Tdata_HN; 
    int mac_addr_NODE_in_data; 
    double bck_before_tx_RTS; 
    double T_min_bck_RTS; 
    double T_max_bck_RTS; 
    int mac_addr_AUV_in_trigger; 
    int mac_addr_AUV_in_CTS; 
    int
            max_data_HN_can_tx; 
    int max_pck_HN_can_tx; 
    double Tdata_HN_pck; 
    bool CTSrx; 
    bool txRTSbeforeCBEACON; 
    bool sectionCBeacon; 
    // Variables that should be reseted when a cycle is end
    int n_BEACON_pck_tx_by_HN; 
    int n_PROBE_pck_rx_by_HN; 
    int
            n_POLL_pck_tx_by_HN; 
    int
            n_DATA_pck_rx_by_HN; 
    int n_CBEACON_pck_tx_by_HN; 
    int
            n_TRIGGER_pck_rx_by_HN; 
    int n_RTS_pck_tx_by_HN; 
    int n_CTS_pck_rx_by_HN; 
    int n_DATA_pck_tx_by_HN; 
    // Variables that enable or not an operation
    bool txBEACONEnabled; 
    bool
            rxPROBEEnabled; 
    bool txPOLLEnabled; 
    bool rxDATAEnabled; 
    bool txCBEACONEnabled; 
    bool rxTRIGGEREnabled; 
    bool txRTSEnabled; 
    bool rxCTSEnabled; 
    bool
            txDATAEnabledHN; 
    // PACKETS create
    Packet *curr_BEACON_HN_pck_tx; 
    Packet
            *curr_PROBE_HN_pck_rx; 
    Packet *curr_POLL_HN_pck_tx; 
    Packet *curr_DATA_HN_pck_rx; 
    Packet *curr_CBEACON_HN_pck_tx; 
    Packet *curr_TRIGGER_HN_pck_rx; 
    Packet *curr_RTS_HN_pck_tx; 
    Packet *curr_CTS_HN_pck_rx; 
    Packet *curr_DATA_HN_pck_tx; 
    Packet *curr_DATA_NODE_pck_tx_HN; 
    // QUEUE
    std::
            queue<Packet *>
                    Q_data_HN; 
    std::queue<int> Q_data_source_SN; 
    std::queue<int> Q_probbed_mac_HN; 
    std::queue<int>
            Q_probbed_n_pcks_NODE_want_tx_HN; 
    std::queue<double> Q_probbed_backoff_time; 
    // EXTRA
    UWUFETCH_NODE_STATUS_CHANGE last_reason; 
    UWUFETCH_NODE_STATUS
            curr_state; 
    UWUFETCH_NODE_STATUS prev_state; 
    static bool
            initialized; 
    bool
            print_transitions; 
    int HEADNODE; 
    // Mapping
    static std::
            map<UWUFETCH_NODE_STATUS, std::string>
                    statusInfo; 
    static std::map<UWUFETCH_NODE_STATUS_CHANGE, std::string>
            statusChange; 
    static std::map<UWUFETCH_NODE_PACKET_TYPE, std::string>
            packetType; 
    static std::map<UWUFETCH_TIMER_STATUS, std::string>
            statusTimer; 
    std::
            ofstream fout; 
    std::ofstream
            out_file_logging; 
};
#endif