uwpolling_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 UWPOLLING_HDR_AUV_H
#define UWPOLLING_HDR_AUV_H
 
#include "uwpolling_cmn_hdr.h"
 
#include "uwsmposition.h"
#include <chrono>
#include <clmessage.h>
#include <fstream>
#include <iostream>
#include <map>
#include <mmac.h>
#include <mphy.h>
#include <ostream>
#include <queue>
#include <set>
#include <string>
 
#define UWPOLLING_AUV_DROP_REASON_ERROR "DERR" 
#define UWPOLLING_AUV_DROP_REASON_UNKNOWN_TYPE \
    "DUT" 
#define UWPOLLING_AUV_DROP_REASON_WRONG_RECEIVER \
    "DWR" 
#define UWPOLLING_AUV_DROP_REASON_WRONG_STATE \
    "DWS" 
#define UWPOLLING_AUV_DROP_REASON_BUFFER_FULL "ADBF"
 
#define ENTRY_MAX_SIZE 256
 
typedef struct probe_cicle_counters {
    uint n_probe_detected; 
    uint n_probe_received; 
    inline void
    incrementCounters()
    {
        n_probe_detected++;
        n_probe_received++;
    }
    inline void
    resetCounters()
    {
        n_probe_detected = 0;
        n_probe_received = 0;
    }
    inline uint
    getNumberOfNeighbors()
    {
        return n_probe_detected + (n_probe_detected - n_probe_received);
    }
};
 
typedef struct probbed_node {
    uint id_node; 
    int n_pkts; 
    int mac_address; 
    double time_stamp; 
    // double backoff_time; /**< Backoff time chosen by the node before
    //  transmitting the PROBE */
    double Tmeasured; 
    bool is_sink_; 
    uint16_t id_ack; 
    double policy_weight; 
    inline double &
    get_time_stamp()
    {
        return (time_stamp);
    }
 
    inline uint &
    get_id_node()
    {
        return (id_node);
    }
 
    inline int &
    get_n_pkts()
    {
        return (n_pkts);
    }
 
    inline int &
    get_mac_address()
    {
        return (mac_address);
    }
 
    inline bool &
    is_sink()
    {
        return is_sink_;
    }
 
    inline uint16_t &
    get_id_ack()
    {
        return id_ack;
    }
 
    inline double &
    get_weight()
    {
        return policy_weight;
    }
 
} probbed_node;
 
class Uwpolling_AUV : public MMac
{
public:
    Uwpolling_AUV();
    virtual ~Uwpolling_AUV();
 
    virtual int command(int argc, const char *const *argv);
    virtual int crLayCommand(ClMessage *m);
 
protected:
    /***********************************
     | Internal variable and functions |
     ***********************************/
 
    enum UWPOLLING_AUV_STATUS {
        UWPOLLING_AUV_STATUS_IDLE = 1,
        UWPOLLING_AUV_STATUS_TX_TRIGGER,
        UWPOLLING_AUV_STATUS_RX_PROBES,
        UWPOLLING_AUV_STATUS_RX_DATA,
        UWPOLLING_AUV_STATUS_RX_ACK,
        UWPOLLING_AUV_STATUS_TX_POLL,
        UWPOLLING_AUV_STATUS_TX_DATA,
        UWPOLLING_AUV_STATUS_WAIT_PROBE,
        UWPOLLING_AUV_STATUS_WAIT_DATA,
        UWPOLLING_AUV_STATUS_WAIT_ACK
    };
 
    enum UWPOLLING_AUV_REASON {
        UWPOLLING_AUV_REASON_DATA_RX = 1,
        UWPOLLING_AUV_REASON_TX_TRIGGER,
        UWPOLLING_AUV_REASON_TX_POLL,
        UWPOLLING_AUV_REASON_PROBE_RECEIVED,
        UWPOLLING_AUV_REASON_RX_DATA_TO,
        UWPOLLING_AUV_REASON_PACKET_ERROR,
        UWPOLLING_AUV_REASON_LAST_PACKET_RECEIVED,
        UWPOLLING_AUV_REASON_MAX_PROBE_RECEIVED,
        UWPOLLING_AUV_REASON_LAST_POLLED_NODE,
        UWPOLLING_AUV_REASON_PROBE_TO_EXPIRED
    };
 
    enum UWPOLLING_PKT_TYPE {
        UWPOLLING_DATA_PKT = 1,
        UWPOLLING_POLL_PKT,
        UWPOLLING_TRIGGER_PKT,
        UWPOLLING_PROBE_PKT
    };
 
    enum UWPOLLING_TIMER_STATUS {
        UWPOLLING_IDLE = 1,
        UWPOLLING_RUNNING,
        UWPOLLING_FROZEN,
        UWPOLLING_EXPIRED
    };
 
    class Uwpolling_AUV_Timer : public TimerHandler
    {
    public:
        Uwpolling_AUV_Timer(Uwpolling_AUV *m)
            : TimerHandler()
            , start_time(0.0)
            , left_duration(0.0)
            , counter(0)
            , module(m)
            , timer_status(UWPOLLING_IDLE)
        {
            assert(m != NULL);
        }
 
        virtual ~Uwpolling_AUV_Timer()
        {
        }
 
        virtual void
        freeze()
        {
            assert(timer_status == UWPOLLING_RUNNING);
            left_duration -= (NOW - start_time);
            if (left_duration <= 0.0) {
                left_duration = module->mac2phy_delay_;
            }
            force_cancel();
            timer_status = UWPOLLING_FROZEN;
        }
 
        virtual void
        unFreeze()
        {
            assert(timer_status == UWPOLLING_FROZEN);
            start_time = NOW;
            assert(left_duration > 0);
            sched(left_duration);
            timer_status = UWPOLLING_RUNNING;
        }
 
        virtual void
        stop()
        {
            timer_status = UWPOLLING_IDLE;
            force_cancel();
        }
 
        virtual void
        schedule(double val)
        {
            start_time = NOW;
            left_duration = val;
            timer_status = UWPOLLING_RUNNING;
            resched(val);
        }
 
        bool
        isIdle()
        {
            return (timer_status == UWPOLLING_IDLE);
        }
 
        bool
        isRunning()
        {
            return (timer_status == UWPOLLING_RUNNING);
        }
 
        bool
        isExpired()
        {
            return (timer_status == UWPOLLING_EXPIRED);
        }
 
        bool
        isFrozen()
        {
            return (timer_status == UWPOLLING_FROZEN);
        }
 
        bool
        isActive()
        {
            return (timer_status == UWPOLLING_FROZEN ||
                    timer_status == UWPOLLING_RUNNING);
        }
 
        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; 
        Uwpolling_AUV
                *module; 
        UWPOLLING_TIMER_STATUS timer_status; 
    };
 
    class DataTimer : public Uwpolling_AUV_Timer
    {
    public:
        DataTimer(Uwpolling_AUV *m)
            : Uwpolling_AUV_Timer(m)
        {
        }
 
        virtual ~DataTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class ProbeTimer : public Uwpolling_AUV_Timer
    {
    public:
        ProbeTimer(Uwpolling_AUV *m)
            : Uwpolling_AUV_Timer(m)
        {
        }
 
        virtual ~ProbeTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class PollTimer : public Uwpolling_AUV_Timer
    {
    public:
        PollTimer(Uwpolling_AUV *m)
            : Uwpolling_AUV_Timer(m)
        {
        }
 
        virtual ~PollTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    class AckTimer : public Uwpolling_AUV_Timer
    {
    public:
        AckTimer(Uwpolling_AUV *m)
            : Uwpolling_AUV_Timer(m)
        {
        }
 
        virtual ~AckTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
 
    double getMaxBackoffTime();
 
    virtual double linearInterpolator(
            double x, double x1, double x2, double y1, double y2);
 
    virtual void Mac2PhyStartTx(Packet *p);
 
    virtual void Phy2MacEndTx(const Packet *p);
    virtual void Phy2MacStartRx(const Packet *p);
    virtual void Phy2MacEndRx(Packet *p);
 
    inline void
    incrTriggerTx()
    {
        n_trigger_tx++;
    }
 
    inline void
    incrProbeRx()
    {
        n_probe_rx++;
    }
 
    inline void
    incrAckRx()
    {
        n_ack_rx++;
    }
 
    inline void
    incrWrongNodeDataSent()
    {
        wrong_node_data_sent++;
    }
 
    inline void
    incrDroppedProbePkts()
    {
        N_dropped_probe_pkts++;
    }
 
    inline void
    incrDroppedAckPkts()
    {
        n_dropped_ack_pkts++;
    }
 
    inline void
    incrDroppedProbeWrongState()
    {
        N_dropped_probe_wrong_state++;
    }
 
    inline void
    incrPollTx()
    {
        n_poll_tx++;
    }
 
    inline int
    getTriggerTx()
    {
        return n_trigger_tx;
    }
 
    inline int
    getProbeRx()
    {
        return n_probe_rx;
    }
 
    inline int
    getAckRx()
    {
        return n_ack_rx;
    }
 
    inline int
    getWrongNodeDataSent()
    {
        return wrong_node_data_sent;
    }
 
    inline int
    getPollSent()
    {
        return n_poll_tx;
    }
 
    inline int
    getDroppedProbePkts()
    {
        return N_dropped_probe_pkts;
    }
 
    inline int
    getDroppedAckPkts()
    {
        return n_dropped_ack_pkts;
    }
 
    inline int
    getDroppedProbeWrongState()
    {
        return N_dropped_probe_wrong_state;
    }
 
    virtual void
    refreshReason(UWPOLLING_AUV_REASON reason)
    {
        last_reason = reason;
    }
 
    virtual void
    refreshState(UWPOLLING_AUV_STATUS state)
    {
        prev_state = curr_state;
        curr_state = state;
    }
    virtual void stateRxProbe();
    virtual void stateRxData();
    virtual void stateWaitProbe();
    virtual void stateWaitData();
    virtual void stateIdle();
    virtual void stateTxTrigger();
    virtual void stateTxPoll();
 
    virtual void DataTOExpired();
    virtual void ProbeTOExpired();
    // virtual void printStateInfo(double delay = 0);
    virtual void initInfo();
    virtual void TxTrigger();
    virtual void TxPoll();
    virtual void SortNode2Poll();
    virtual void ChangeNodePolled();
    virtual double GetDataTimerValue();
    virtual void computeTxTime(UWPOLLING_PKT_TYPE pkt);
    virtual void UpdateRTT();
    virtual void stop_count_time();
 
    inline double
    GetTotalReceivingTime()
    {
        return total_time;
    }
    virtual void waitForUser();
    inline unsigned long int
    getEpoch()
    {
        unsigned long int timestamp =
                (unsigned long int) (std::chrono::duration_cast<
                        std::chrono::milliseconds>(
                        std::chrono::system_clock::now().time_since_epoch())
                                .count());
        return timestamp;
    }
 
    virtual void recvFromUpperLayers(Packet *p);
 
    virtual void stateTx();
 
    virtual void stateTxData();
 
    virtual void txData();
 
    virtual void stateWaitAck();
 
    virtual void ackTOExpired();
 
    virtual void stateAckRx();
 
    virtual void handleAck();
 
    virtual void handleNoAck();
 
    virtual void handleProbeAck();
 
    virtual void addNode2List();
 
    virtual void addSink2List();
 
    virtual uint16_t getPollTime();
 
    virtual uint getRxPkts(int mac_addr);
 
    bool initBackoffLUT();
 
    // timers
    DataTimer data_timer; 
    ProbeTimer probe_timer; 
    PollTimer poll_timer; 
    AckTimer ack_timer; 
    // internal AUV structure for list of polled node
    std::vector<probbed_node> list_probbed_node; 
    probbed_node probbed_sink; 
    int polling_index; 
    bool sink_inserted; 
    // pointer to packets
    Packet *curr_trigger_packet; 
    Packet *curr_poll_packet; 
    Packet *curr_data_packet; 
    Packet *curr_probe_packet; 
    Packet *curr_tx_data_packet; 
    Packet *curr_ack_packet; 
    // input parameters via TCL
    double T_probe; 
    double T_probe_guard; 
    double T_ack_timer; 
    int max_payload; 
    double T_min; 
    double T_max; 
    double T_guard; 
    int max_polled_node; 
    int sea_trial_; 
    int print_stats_; 
    int modem_data_bit_rate; 
    int DATA_POLL_guard_time_; 
    int n_run; /*< ID of the experiments (used during sea trial) */
 
    // states of protocol and reasons
    UWPOLLING_AUV_STATUS curr_state,
            prev_state; 
    UWPOLLING_AUV_REASON reason, last_reason; 
    // mapping
    static std::map<UWPOLLING_PKT_TYPE, std::string>
            pkt_type_info; 
    static std::map<UWPOLLING_AUV_STATUS, std::string>
            status_info; 
    static std::map<UWPOLLING_AUV_REASON, std::string>
            reason_info; 
    static bool initialized; 
    bool RxDataEnabled; 
    bool RxProbeEnabled; 
    bool TxEnabled; 
    double distance; 
    int N_expected_pkt; 
    int packet_index; 
    int curr_polled_node_address; 
    uint curr_node_id; 
    // statistics
 
    // double curr_backoff_time; /**< backoff time of the node polled */
    double curr_RTT; 
    double curr_Tmeasured; 
    double probe_rtt; 
    int wrong_node_data_sent; 
    double initial_time; 
    int n_trigger_tx; 
    uint n_probe_rx; 
    int n_ack_rx; 
    int n_poll_tx; 
    bool begin; 
    double stop_time; 
    double pkt_time; 
    double total_time; 
    double Tdata; 
    double Tprobe; 
    double Ttrigger; 
    double Tpoll; 
    uint TRIGGER_uid; 
    uint POLL_uid; 
    int N_dropped_probe_pkts; 
    int n_dropped_ack_pkts; 
    int N_dropped_probe_wrong_state; 
    std::ofstream fout; 
    std::ofstream out_file_stats; 
    std::deque<Packet *> tx_buffer; 
    std::deque<Packet *> temp_buffer; 
    uint max_buffer_size; 
    uint16_t uid_tx_pkt; 
    bool curr_is_sink; 
    uint max_tx_pkts; 
    uint n_pkts_to_tx; 
    uint n_tx_pkts; 
    uint16_t last_pkt_uid; 
    bool enableAckRx; 
    bool acked; 
    int ack_enabled; 
    std::map<int, uint> rx_pkts_map; 
    bool enable_adaptive_backoff; 
    std::string backoff_LUT_file; 
    char lut_token_separator; 
    std::map<double, double> backoff_LUT; 
    probe_cicle_counters probe_counters; 
    int full_knowledge; 
    int last_probe_lost; 
};
#endif