uwUFetch_AUV.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_AUV_H_
#define UWUFETCH_AUV_H_
 
#include <mmac.h>
#include <iostream>
#include <clmessage.h>
#include <mphy.h>
#include <string>
#include <fstream>
#include <ostream>
#include <cassert>
#include <map>
#include <queue>
 
#define UWFETCH_AUV_DROP_REASON_ERROR \
    "DERR" 
#define UWFETCH_AUV_DROP_REASON_UNKNOWN_TYPE \
    "DUT" 
#define UWFETCH_AUV_DROP_REASON_WRONG_RECEIVER \
    "DWR" 
#define UWFETCH_AUV_DROP_REASON_WRONG_STATE                                   \
    "DWS" 
#define UWFETCH_AUV_DROP_PHY_CAN_NOT_TX \
    "PNT" 
#define UWFETCH_AUV_DROP_REASON_ALREADY_ONE_RTS_RX \
    "DAORR" 
#define UUFETCH_AUV_DROP_REASON_NOT_ENABLE                                     \
    "PDNE" 
#define UWUFETCH_AUV_DROP_CAN_NOT_RX_THIS_PCK                               \
    "DCNR" 
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; 
class uwUFetch_AUV : public MMac
{
public:
    uwUFetch_AUV();
 
    virtual ~uwUFetch_AUV();
 
    virtual int command(int argc, const char *const *argv);
 
    virtual int crLayCommand(ClMessage *m);
 
protected:
    enum UWUFETCH_AUV_STATUS {
        UWUFETCH_AUV_STATUS_IDLE,
        UWUFETCH_AUV_STATUS_TRANSMIT_TRIGGER,
        UWUFETCH_AUV_STATUS_WAIT_RTS_PACKET,
        UWUFETCH_AUV_STATUS_RECEIVE_RTS_PACKET,
        UWUFETCH_AUV_STATUS_TRANSMIT_CTS_PACKET,
        UWUFETCH_AUV_STATUS_WAIT_DATA_HN,
        UWUFETCH_AUV_STATUS_RECEIVE_DATA_PACKET
    };
 
    enum UWUFETCH_AUV_STATUS_CHANGE {
        UWUFETCH_AUV_STATUS_CHANGE_TRIGGER_TX,
        UWUFETCH_AUV_STATUS_CHANGE_PHY_CAN_NOT_TX,
        UWUFETCH_AUV_STATUS_CHANGE_TO_WAIT_RTS_EXPIRED,
        UWUFETCH_AUV_STATUS_CHANGE_PACKET_IS_IN_ERROR,
        UWUFETCH_AUV_STATUS_CHANGE_RTS_RX,
        UWUFETCH_AUV_STATUS_CHANGE_CTS_TX,
        UWUFETCH_AUV_STATUS_CHANGE_DATA_PCK_RX,
        UWFETCH_AUV_STATUS_CHANGE_PACKET_FOR_ANOTHER_NODE,
        UWFETCH_AUV_STATUS_CHANGE_PACKET_ERROR,
        UWUFETCH_AUV_STATUS_CHANGE_TRIGGER_TX_WAIT_RTS,
        UWUFETCH_AUV_STATUS_CHANGE_CTS_TX_WAIT_DATA,
        UWUFETCH_AUV_STATUS_CHANGE_RTS_FINISHED_TO_RX,
        UWUFETCH_AUV_STATUS_CHANGE_DATA_PCK_FINISHED_TO_RX,
        UWUFETCH_AUV_STATUS_CHANGE_PACKET_FOR_ANOTHER_NODE,
        UWUFETCH_AUV_STATUS_CHANGE_LAST_DATA_PCK_RX,
        UWUFETCH_AUV_STATUS_CHANGE_ANOTHER_DATA_PCK_RX,
        UWUFETCH_AUV_STATUS_CHANGE_TRIGGER_TO_EXPIRED,
        UWUFETCH_AUV_STATUS_CHANGE_TRIGGER_INITIALIZE_TX_TRIGGER,
        UWUFETCH_AUV_STATUS_CHANGE_RTS_FINSHED_TO_STORE,
        UWUFETCH_AUV_STATUS_CHANGE_RTS_TO_EXPIRED_AT_LEAST_ONE_RTS_RX,
        UWUFETCH_AUV_STATUS_CHANGE_RTS_TO_EXPIRED_0_RTS_RX,
        UWUFETCH_AUV_STATUS_CHANGE_CTS_INITIALIZED_TX_CTS,
        UWUFETCH_AUV_STATUS_CHANGE_TO_WAIT_DATA_EXPIRED
    };
 
    enum UWUFETCH_AUV_PACKET_TYPE {
        UWUFETCH_AUV_PACKET_TYPE_DATA,
        UWUFETCH_AUV_PACKET_TYPE_TRIGGER,
        UWUFETCH_AUV_PACKET_TYPE_RTS,
        UWUFETCH_AUV_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_timer : public TimerHandler
    {
    public:
        uwUFetch_timer(uwUFetch_AUV *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_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_AUV *module; 
        UWUFETCH_TIMER_STATUS timer_status; 
    }; // END class uwUFetch_timer
 
    class uwUFetch_TRIGGER_timer : public uwUFetch_timer
    {
    public:
        uwUFetch_TRIGGER_timer(uwUFetch_AUV *m)
            : uwUFetch_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_TRIGGER_timer
         */
        virtual ~uwUFetch_TRIGGER_timer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    }; // END class uwUFetch_TRIGGER_timer
 
    class uwUFetch_RTS_timer : public uwUFetch_timer
    {
    public:
        uwUFetch_RTS_timer(uwUFetch_AUV *m)
            : uwUFetch_timer(m)
        {
        }
 
        /*
         * Destructor of  uwUFetch_RTS_timer
         */
        virtual ~uwUFetch_RTS_timer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    }; // END class UWUFetch_RTS_timer
 
    class uwUFetch_DATA_timer : public uwUFetch_timer
    {
    public:
        uwUFetch_DATA_timer(uwUFetch_AUV *m)
            : uwUFetch_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_DATA_timer
         */
        virtual ~uwUFetch_DATA_timer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    }; // END class UWUFetch_DATA_timer   uwUFetch_FIRST_DATA_timer
 
    class uwUFetch_FIRST_DATA_timer : public uwUFetch_timer
    {
    public:
        uwUFetch_FIRST_DATA_timer(uwUFetch_AUV *m)
            : uwUFetch_timer(m)
        {
        }
 
        /*
         * Destructor of uwUFetch_FIRST_DATA_timer
         */
        virtual ~uwUFetch_FIRST_DATA_timer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    }; // END class uwUFetch_FIRST_DATA_timer
 
    /****************************************************************************
     *                        GENERAL METHODS *
     ****************************************************************************/
    virtual void Phy2MacStartRx(const Packet *p);
 
    virtual void Phy2MacStartRx_without(const Packet *p);
 
    virtual void Phy2MacEndRx(Packet *p);
 
    virtual void Phy2MacEndRx_without(Packet *p);
 
    virtual void Mac2PhyStartTx(Packet *p);
 
    virtual void Mac2PhyStartTx_without(Packet *p);
 
    virtual void Phy2MacEndTx(const Packet *p);
 
    virtual void Phy2MacEndTx_without(const Packet *p);
 
    virtual void printStateInfo(double delay = 0);
 
    virtual void initInfo();
 
    virtual void waitForUser();
 
    virtual void
    refreshReason(UWUFETCH_AUV_STATUS_CHANGE reason)
    {
        last_reason = reason;
    }
 
    virtual void
    refreshState(UWUFETCH_AUV_STATUS state)
    {
        prev_state = curr_state;
        curr_state = state;
    }
 
    /*****************************************************************************
     *                             AUV METHODS *
     *****************************************************************************/
    virtual void stateIdle_AUV();
 
    virtual void TriggerTOExpired();
 
    virtual void state_TRIGGER_tx();
 
    virtual void state_TRIGGER_tx_without();
 
    virtual void TRIGGER_tx();
 
    virtual void state_wait_RTS();
 
    virtual void RTS_rx();
 
    virtual void RtsTOExpired();
 
    virtual void state_CTS_tx();
 
    virtual void CTS_tx();
 
    virtual void state_wait_first_DATA();
 
    virtual void state_wait_first_DATA_without();
 
    virtual void DATA_rx();
 
    virtual void state_wait_DATA();
 
    virtual void DataTOExpired();
 
    virtual void DataTOExpired_first();
 
    virtual void updateQueueRTS();
 
    /*****************************************************************************
     *                             METODI AUSILIARI *
     *****************************************************************************/
    virtual bool typeCommunication();
 
    virtual double getDataTimerValue();
 
    virtual void computeTxTime(UWUFETCH_AUV_PACKET_TYPE tp);
 
    virtual double getRTT();
 
    virtual void another_DATA_received();
 
    /*****************************************************************************
     *                           Metodi get & incr *
     *****************************************************************************/
 
    void
    incrTrigger_Tx_by_AUV()
    {
        n_TRIGGER_tx_by_AUV++;
    }
 
    int
    getTrigger_Tx_by_AUV()
    {
        return n_TRIGGER_tx_by_AUV;
    }
 
    void
    incrTotalTrigger_Tx_by_AUV()
    {
        n_tot_TRIGGER_tx_by_AUV++;
    }
 
    int
    getTotalTrigger_Tx_by_AUV()
    {
        return n_tot_TRIGGER_tx_by_AUV;
    }
 
    void
    incrRts_Rx_by_AUV()
    {
        n_RTS_rx_by_AUV++;
    }
 
    int
    getRts_Rx_by_AUV()
    {
        return n_RTS_rx_by_AUV;
    }
 
    void
    incrTotalRts_Rx_by_AUV()
    {
        n_tot_RTS_rx_by_AUV++;
    }
 
    int
    getTotalRts_Rx_by_AUV()
    {
        return n_tot_RTS_rx_by_AUV;
    }
 
    void
    incrTotalRts_Rx_corrupted_by_AUV()
    {
        n_tot_RTS_rx_corr_by_AUV++;
    }
 
    int
    getTotalRts_Rx_corrupted_by_AUV()
    {
        return n_tot_RTS_rx_corr_by_AUV;
    }
 
    void
    incrCts_Tx_by_AUV()
    {
        n_CTS_tx_by_AUV++;
    }
 
    int
    getCts_Tx_by_AUV()
    {
        return n_CTS_tx_by_AUV;
    }
 
    void
    incrTotalCts_Tx_by_AUV()
    {
        n_tot_CTS_tx_by_AUV++;
    }
 
    int
    getTotalCts_Tx_by_AUV()
    {
        return n_tot_CTS_tx_by_AUV;
    }
 
    void
    incrData_Rx_by_AUV()
    {
        n_DATA_rx_by_AUV++;
    }
 
    int
    getData_Rx_by_AUV()
    {
        return n_DATA_rx_by_AUV;
    }
 
    void
    incrTotal_Data_Rx_by_AUV()
    {
        n_tot_DATA_rx_by_AUV++;
    }
 
    int
    getTotal_Data_Rx_by_AUV()
    {
        return n_tot_DATA_rx_by_AUV;
    }
 
    void
    incrTotal_Data_Rx_corrupted_by_AUV()
    {
        n_tot_DATA_rx_corr_by_AUV++;
    }
 
    int
    getTotal_Data_Rx_corrupted_by_AUV()
    {
        return n_tot_DATA_rx_corr_by_AUV;
    }
 
    /*****************************************************************************
     *                         VARIABLES OF AUV NODE *
     *****************************************************************************/
    // TCL VARIABLES
    double T_MIN_RTS; 
    double T_MAX_RTS; 
    double T_GUARD; 
    double T_RTS; 
    int mode_comm_hn_auv; 
    int NUM_HN_NET; 
    // TIMERS
    uwUFetch_TRIGGER_timer
            Trigger_timer; 
    uwUFetch_RTS_timer
            RTS_timer; 
    uwUFetch_DATA_timer DATA_timer; 
    uwUFetch_FIRST_DATA_timer
            DATA_timer_first_pck; 
    // GLOBAL VARIABLES THAT SHOULD BE NEVER RESET
    double MAX_PAYLOAD; 
    int NUM_MAX_DATA_AUV_WANT_RX; 
    double T_START_PROC_TRIGGER; 
    int debugMio_; 
    int N_RUN; 
    int HEAD_NODE_1; 
    int HEAD_NODE_2; 
    int HEAD_NODE_3; 
    int HEAD_NODE_4; 
    double tx_TRIGGER_start_time; 
    double tx_TRIGGER_finish_time; 
    double
            rx_RTS_start_time; 
    double rx_RTS_finish_time; 
    double tx_CTS_start_time; 
    double tx_CTS_finish_time; 
    double rx_DATA_start_time; 
    double rx_DATA_finish_time; 
    int
            n_tot_TRIGGER_tx_by_AUV; 
    int n_tot_RTS_rx_by_AUV; 
    int n_tot_RTS_rx_corr_by_AUV; 
    int n_tot_CTS_tx_by_AUV; 
    int n_tot_DATA_rx_by_AUV; 
    int
            n_tot_DATA_rx_corr_by_AUV; 
    int
            number_data_pck_AUV_rx_exact; 
    int
            mac_addr_HN_ctsed; 
    double data_timeout; 
    double T_tx_TRIGGER; 
    double Trts; 
    double Tcts; 
    double
            Tdata; 
    double RTT; 
    int mac_addr_HN_in_data; 
    int last_hn_triggered; 
    int hn_trigg; 
    int index; 
    int
            mac_addr_hn_triggered; 
    int
            num_pck_hn_1; 
    int
            num_pck_hn_2; 
    int
            num_pck_hn_3; 
    int
            num_pck_hn_4; 
    // VARIABLES THAT ENABLES OR NOT AN OPERATION
    bool txTRIGGEREnabled; 
    bool rxRTSEnabled; 
    bool txCTSEnabled; 
    bool rxDATAEnabled; 
    // VARIABLES THAT SHOULD BE RESETED WHEN A CYCLE IS ENDED
    int n_TRIGGER_tx_by_AUV; 
    int n_RTS_rx_by_AUV; 
    int n_CTS_tx_by_AUV; 
    int
            n_DATA_rx_by_AUV; 
    // PACKETS CREATED
    Packet *curr_TRIGGER_pck_tx; 
    Packet *curr_RTS_pck_rx; 
    Packet *curr_CTS_pck_tx; 
    Packet *curr_DATA_pck_rx; 
    // STRUCTURES USED
    std::queue<Packet *> Q_data_AUV; 
    std::queue<int> Q_rts_mac_HN; 
    std::queue<int> Q_rts_n_pcks_HN_want_tx_AUV; 
    std::queue<double> Q_rts_backoff_time; 
    // VARIABLES THAT INDICATE IN WHICH STATE THE NODE IS IN THAT MOMENT AND THE
    // REASON BECAUSE THE NODE PASS FROM A STATE TO ANOTHER ONE
    UWUFETCH_AUV_STATUS_CHANGE
            last_reason; 
    UWUFETCH_AUV_STATUS
            curr_state; 
    UWUFETCH_AUV_STATUS
            prev_state; 
    static std::map<UWUFETCH_AUV_STATUS, std::string>
            statusInfo; 
    static std::map<UWUFETCH_AUV_STATUS_CHANGE, std::string>
            statusChange; 
    static std::
            map<UWUFETCH_AUV_PACKET_TYPE, std::string>
                    packetType; 
    static std::map<UWUFETCH_TIMER_STATUS, std::string>
            statusTimer; 
    // VARIABLES FOR DEBUG
    std::
            ofstream fout; 
    std::ofstream
            out_file_logging; 
    static bool
            initialized; 
    bool
            print_transitions; 
    static const int MAX_RTS_RX =
            100; 
}; // END class UWUFetch_AUV
 
#endif