uw-csma-aloha-trigger-sink.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 UW_CSMA_UW_CS_ALOHA_TRIG_SINK_TRIGGER_SINK_H
#define UW_CSMA_UW_CS_ALOHA_TRIG_SINK_TRIGGER_SINK_H
 
#include "mmac.h"
#include "mphy.h"
#include "mac.h"
 
#include <iostream>
 
#define UW_CS_ALOHA_TRIG_SINK_DROP_REASON_WRONG_RECEIVER \
    "WRCV" 
#define UW_CS_ALOHA_TRIG_SINK_DROP_REASON_UNKNOWN_TYPE \
    "UPT" 
#define UW_CS_ALOHA_TRIG_SINK_DROP_REASON_ERROR "ERR" 
#define UW_CS_ALOHA_TRIG_SINK_DROP_REASON_RECEIVING_NOT_ENABLED \
    "RNE" 
extern packet_t PT_MMAC_TRIGGER;
 
class UwCsmaAloha_Trigger_SINK : public MMac
{
public:
    UwCsmaAloha_Trigger_SINK();
    virtual ~UwCsmaAloha_Trigger_SINK();
    virtual int command(int argc, const char *const *argv);
    virtual int crLayCommand(ClMessage *m);
 
protected:
    enum UW_CS_ALOHA_TRIG_SINK_STATUS {
        UW_CS_ALOHA_TRIG_SINK_STATE_IDLE = 1,
        UW_CS_ALOHA_TRIG_SINK_STATE_NOT_SET,
        UW_CS_ALOHA_TRIG_SINK_STATE_TX_TRIGGER,
        UW_CS_ALOHA_TRIG_SINK_STATE_ENABLE_RX,
        UW_CS_ALOHA_TRIG_SINK_STATE_DISABLE_RX,
        UW_CS_ALOHA_TRIG_SINK_STATE_DATA_RX
    };
 
    enum UW_CS_ALOHA_TRIG_SINK_REASON_STATUS {
        UW_CS_ALOHA_TRIG_SINK_REASON_DATA_RX = 1,
        UW_CS_ALOHA_TRIG_SINK_REASON_NOT_SET,
        UW_CS_ALOHA_TRIG_SINK_REASON_START_RX,
        UW_CS_ALOHA_TRIG_SINK_REASON_PKT_NOT_FOR_ME,
        UW_CS_ALOHA_TRIG_SINK_REASON_PKT_ERROR,
        UW_CS_ALOHA_TRIG_SINK_REASON_TX_TRIGGER
    };
 
    enum UW_CS_ALOHA_TRIG_SINK_TIMER_STATUS {
        UW_CS_ALOHA_TRIG_SINK_IDLE = 1,
        UW_CS_ALOHA_TRIG_SINK_RUNNING,
        UW_CS_ALOHA_TRIG_SINK_FROZEN,
        UW_CS_ALOHA_TRIG_SINK_EXPIRED
    };
 
    class GenericTimer : public TimerHandler
    {
    public:
        GenericTimer(UwCsmaAloha_Trigger_SINK *m)
            : TimerHandler()
            , start_time(0.0)
            , left_duration(0.0)
            , counter(0)
            , module(m)
            , timer_status(UW_CS_ALOHA_TRIG_SINK_IDLE)
        {
            assert(m != NULL);
        }
 
        virtual ~GenericTimer()
        {
        }
 
        virtual void
        freeze()
        {
            assert(timer_status == UW_CS_ALOHA_TRIG_SINK_RUNNING);
            left_duration -= (NOW - start_time);
            if (left_duration <= 0.0)
                left_duration = module->mac2phy_delay_;
            force_cancel();
            timer_status = UW_CS_ALOHA_TRIG_SINK_FROZEN;
        }
 
        virtual void
        unFreeze()
        {
            assert(timer_status == UW_CS_ALOHA_TRIG_SINK_FROZEN);
            start_time = NOW;
            assert(left_duration > 0);
            sched(left_duration);
            timer_status = UW_CS_ALOHA_TRIG_SINK_RUNNING;
        }
 
        virtual void
        stop()
        {
            timer_status = UW_CS_ALOHA_TRIG_SINK_IDLE;
            force_cancel();
        }
 
        virtual void
        schedule(double val)
        {
            start_time = NOW;
            left_duration = val;
            timer_status = UW_CS_ALOHA_TRIG_SINK_RUNNING;
            resched(val);
        }
 
        bool
        isIdle()
        {
            return (timer_status == UW_CS_ALOHA_TRIG_SINK_IDLE);
        }
 
        bool
        isRunning()
        {
            return (timer_status == UW_CS_ALOHA_TRIG_SINK_RUNNING);
        }
 
        bool
        isExpired()
        {
            return (timer_status == UW_CS_ALOHA_TRIG_SINK_EXPIRED);
        }
 
        bool
        isFrozen()
        {
            return (timer_status == UW_CS_ALOHA_TRIG_SINK_FROZEN);
        }
 
        bool
        isActive()
        {
            return (timer_status == UW_CS_ALOHA_TRIG_SINK_FROZEN ||
                    timer_status == UW_CS_ALOHA_TRIG_SINK_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; 
        UwCsmaAloha_Trigger_SINK
                *module; 
        UW_CS_ALOHA_TRIG_SINK_TIMER_STATUS timer_status; 
    };
 
    class ReceiveTimer : public GenericTimer
    {
    public:
        ReceiveTimer(UwCsmaAloha_Trigger_SINK *m)
            : GenericTimer(m)
        {
        }
 
        virtual ~ReceiveTimer()
        {
        }
 
    protected:
        virtual void expire(Event *e);
    };
    virtual void recvFromUpperLayers(Packet *p);
    virtual void Mac2PhyStartTx(Packet *p);
    virtual void Phy2MacEndTx(const Packet *p);
    virtual void Phy2MacStartRx(const Packet *p);
    virtual void Phy2MacEndRx(Packet *p);
    virtual void initPkt(Packet *p, int dest_addr = 0);
 
    virtual void stateIdle();
    virtual void stateEnableRx();
    virtual void stateDisableRx();
 
    virtual void stateTxTRIGGER();
    virtual void txTRIGGER(Packet *p);
    virtual void stateRxData(Packet *p);
    virtual void stateRxPacketNotForMe(Packet *p);
    inline void
    refreshState(UW_CS_ALOHA_TRIG_SINK_STATUS state)
    {
        curr_state = state;
    }
 
    inline void
    refreshReason(UW_CS_ALOHA_TRIG_SINK_REASON_STATUS reason)
    {
        last_reason = reason;
    }
 
    inline int
    getTriggerMsgSent()
    {
        return trigger_pkts_tx;
    }
 
    virtual void waitForUser();
 
    virtual void
    incrUpperDataRx()
    {
        up_data_pkts_rx++;
    }
 
    inline void
    incrTRIGGERPacketTx()
    {
        trigger_pkts_tx++;
    }
 
    int TRIGGER_size; 
    int buffer_pkts; 
    double tx_timer_duration; 
    bool receiving_state_active; 
    UW_CS_ALOHA_TRIG_SINK_STATUS
            curr_state; 
    UW_CS_ALOHA_TRIG_SINK_STATUS
            prev_state; 
    UW_CS_ALOHA_TRIG_SINK_REASON_STATUS
            last_reason; 
    ReceiveTimer receive_timer; 
    int trigger_pkts_tx; 
};
 
#endif