uw-csma-ca.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 CSMA_CA_H
#define CSMA_CA_H
 
#include <mmac.h>
#include <queue>
#include <sstream>
#include <fstream>
#include <unistd.h>
#include <iostream>
#include <time.h>
 
#include "uw-csma-ca-hdrs.h"
 
#define DROP_REASON_SNR "SNR"
#define DROP_REASON_NOTFORME "NFM"
#define DROP_REASON_NOTRIGHTSTATE "NRS"
#define DROP_REASON_GENERICERROR "ERR"
 
typedef enum CSMA_CA_TIMERS {
    CSMA_CA_DATA_TIMER,
    CSMA_CA_BACKOFF_TIMER,
    CSMA_CA_CTS_TIMER,
    CSMA_CA_ACK_TIMER
} csma_ca_timers_t;
 
enum CSMA_CA_ACK_MODES { CSMA_CA_NO_ACK_MODE = 0, CSMA_CA_ACK_MODE };
 
typedef enum CSMA_CA_ACK_MODES ack_modes_t;
 
enum CSMA_CA_STATES {
    CSMA_CA_IDLE = 0,
    CSMA_CA_BACKOFF,
    CSMA_CA_TX_RTS,
    CSMA_CA_TX_CTS,
    CSMA_CA_TX_DATA,
    CSMA_CA_WAIT_CTS,
    CSMA_CA_WAIT_DATA,
    CSMA_CA_WAIT_ACK,
    CSMA_CA_TX_ACK,
};
 
enum CSMA_CA_PKT_TYPE { CSMA_CA_RTS, CSMA_CA_CTS, CSMA_CA_ACK, CSMA_CA_DATA };
 
typedef enum CSMA_CA_PKT_TYPE csma_ca_pkt_type_t;
 
typedef enum CSMA_CA_STATES csma_ca_states_t;
 
enum log_level { CSMA_CA_ERROR = 0, CSMA_CA_WARN, CSMA_CA_INFO, CSMA_CA_DEBUG };
 
typedef enum log_level csma_ca_log_level_t;
 
 
 
string log_level_string[] = {"ERROR", "WARNING", "INFO", "DEBUG"};
class CsmaCa : public MMac
{
public:
    class CsmaCaTimer : public TimerHandler
    {
    public:
        CsmaCaTimer(CsmaCa *m, csma_ca_timers_t tt)
            : TimerHandler()
        {
            module = m;
            timer_type = tt;
        }
 
    protected:
        virtual void expire(Event *e);
        CsmaCa *module;
        csma_ca_timers_t timer_type;
    };
 
    CsmaCa();
    virtual ~CsmaCa();
    virtual int command(int argc, const char *const *argv);
 
protected:
    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 dropPacket(Packet *p, csma_ca_pkt_type_t type, char *reason);
    inline csma_ca_states_t
    getState()
    {
        return state;
    }
    inline void
    updateState(csma_ca_states_t s)
    {
        previous_state = state;
        state = s;
    }
    inline csma_ca_log_level_t
    getLogLevel()
    {
        return log_level;
    }
    inline int
    getQueueSize()
    {
        return data_q.size();
    }
    inline time_t
    getEpoch()
    {
        return time(NULL);
    }
    inline string
    getLogFile()
    {
        return logfile;
    }
    virtual void state_Wait_CTS();
    virtual void state_Wait_Data();
    virtual void state_Idle();
    virtual void state_Backoff(int tx_time);
    virtual int stateRxData(Packet *p);
    virtual int stateRxRTS(hdr_ca_RTS *rts, int mac_src, int mac_dst);
    virtual int stateRxCTS(hdr_ca_CTS *cts, int mac_src, int mac_dst);
    virtual int stateRxACK(Packet *ack);
    virtual void stateTxCTS();
    virtual int stateTxData();
    virtual void state_Wait_ACK();
    virtual void stateTxAck(int mac_dst);
    virtual void initializeLog();
 
    CsmaCaTimer backoff_timer; 
    CsmaCaTimer cts_timer; 
    CsmaCaTimer data_timer; 
    CsmaCaTimer ack_timer; 
private:
/* Log Macros */
#define LOGERR(log) printonLog(CSMA_CA_ERROR, log);
#define LOGDBG(log) printonLog(CSMA_CA_DEBUG, log);
#define LOGWRN(log) printonLog(CSMA_CA_WARN, log);
#define LOGINFO(log) printonLog(CSMA_CA_INFO, log);
    void printonLog(csma_ca_log_level_t level, string log);
 
    /* Private Methods */
    void extractDataPacket();
    int txData();
    int txRTS(int mac_dest);
    int txCTS(int mac_dest);
    int txAck();
    void data_timer_fired();
    void backoff_timer_fired();
    void cts_timer_fired();
    void ack_timer_fired();
    inline int
    computeTxTime()
    {
        return (int) ((data_size * 8) / bitrate);
    }
 
    /* Header build Methods */
    void buildRTShdr(hdr_ca_RTS **rts, uint8_t tx_time);
    void buildCTShdr(hdr_ca_CTS **cts, uint8_t tx_time);
    Packet *buildPacket(int mac_dest, csma_ca_pkt_type_t type, uint8_t tx_time);
 
    /* config from tcl */
    int max_queue_size; 
    int data_size; 
    int bitrate; 
    int backoff_delta; 
    int backoff_max; 
    int cts_wait_val; 
    int data_wait_val; 
    int ack_wait_val; 
    /* status variables */
    int actual_mac_data_src; 
    int actual_expected_tx_time; 
    Packet *actual_data_packet; 
    std::queue<Packet *> data_q; 
    ack_modes_t ack_mode; 
    csma_ca_states_t state; 
    csma_ca_states_t previous_state; 
    /* log */
    std::ofstream outLog; 
    csma_ca_log_level_t log_level; 
    string logfile; 
    /* statistics*/
    int n_rts_rx; 
    int n_cts_rx; 
    int data_pkt_dropped; 
    int cts_pkt_dropped; 
    int rts_pkt_dropped; 
    int ack_pkt_dropped; 
};
 
#endif /* CSMA_CA_H */