/home/ltracy/workspace/NSUAN/uan/uan-phy.h

#ifndef PHYUAN_H_
#define PHYUAN_H_

//Doxygen add on to create a main page comment
#include "phy.h"
#include "modulation.h"
#include "uan-mac.h"
#include "uan-tools.h"
#include "propagation.h"

#include <list>

#define PHY_DEBUGF

#define UAN_PHY_PTDEF  10
#define UAN_PHY_FDEF   24000

#define UAN_PHY_RXTDEF  10
#define UAN_PHY_CSTDEF  10
#define UAN_PHY_DEFCOLTIME  0.5

struct PacketInfo;
struct PktHandler;
class UanMac;



class UanPhy : public Phy {
        friend class PktHandler;
public:
        UanPhy(void);
        ~UanPhy();
        
        enum TransState {IDLE, RX, TX, CHIDLE, CHBUSY};
        
        enum TransEvent {ECOLL, EERR, ENORX, EOK};
        
        
        virtual void recv(Packet *p, Handler *h); //Receive packet from channel or MAC
        
        virtual void sendDown(Packet *p);  //Propagate packet on channel
        
        virtual int sendUp(Packet *p);
        
        virtual int command(int argc, const char*const* argv);
        
        bool initialized();
        
        bool isIdle(bool cs=false);
        
        void setMac(UanMac *m);
        
        double txtime(Packet *p);
        double txtime(int bytes);
        
        //There is no doubt.  This is a stupid hack.  This is an effort to fit into the mobile node model.
        //Don't really want an antenna underwater.
        inline double getAntennaZ() { return ant_->getZ(); }
        
        bool csIdle();
        
        double getFreq() {return txFreq;}
        double getTxPower() {return txPower;}
        
        
        //Stuff from Transducer
        
        virtual TransEvent rx(Packet *p);  //Log an incoming packet
        virtual TransEvent tx(Packet *p);  //TX packet
        
        virtual double pktNoise(void); //Combined noise from passing
                                                                   //Packets
                
        inline TransState getState(void) {return state;}
        
        inline double getColTime(void) {return colTime;}
        
        inline void setColTime(double c) {assert(c >= 0); colTime = c;}
        
        
protected:
        UanMac *mac;
        
        Modulation *modulation;
        
        virtual void debugf(char *fmt, ...);
        
        virtual void powerTrace(void);
        
        virtual void updatePower(void);
        
        void trace(char *fmt, ...);
        
        //Propagation *propagation;
        Antenna *ant_;
        
        double txPower;
        double txFreq;
        double rxThresh;
        double csThresh;
        
        
        //power info
        
        double txConsume;
        double rxConsume;
        double idleConsume;
        double powerTime;
        double joulesUsed;
        int tracePower;
        
        Trace *et;
        
        
        //From Transducer
        
        double colTime;
        bool collision;
        
        UanEventTimer *rxTimer;
        UanEventTimer *txTimer;
        
        
        Packet *pktRx;

        
        TransState state;       
        
        std::list<PacketInfo *> pktList;
        
        void setState(TransState newState);
        static void rxHandler(void *t);
        static void txHandler(void *t);
        
        PktHandler *pktHandler;
        
        double getChBusyTime(void);     
        
};

struct PacketInfo : public Event {
        double rxPwr;
        double txPwr;
        int size;
        int sourceAddr;
        double time;
        double x;
        double y;
        double z;
        
        bool operator ==(PacketInfo &other) {
                return (rxPwr == other.rxPwr)&&(txPwr == other.txPwr)
                           &&(sourceAddr == other.sourceAddr)&&(size = other.size)
                           &&(time == other.time);
        }
        bool operator !=(PacketInfo &other) {
                return (rxPwr != other.rxPwr) || (txPwr != other.txPwr) 
                || (sourceAddr != other.sourceAddr) || 
                (size != other.size) || (time != other.time);
        }
        bool operator <(PacketInfo &other) {
                return rxPwr < other.rxPwr;
        }
        PacketInfo() : rxPwr(-1), txPwr(-1), size(-1), sourceAddr(-1), time(-1) {}
        
        PacketInfo(const Packet &p) { setinfo(p); }
        
        void setinfo(const Packet &p) {
                PacketStamp ps = p.txinfo_;
                rxPwr = ps.RxPr;
                txPwr = ps.getTxPr();
                sourceAddr = ps.getNode()->address();
                size=HDR_CMN(&p)->size();
                time = Scheduler::instance().clock();
                x = ps.getNode()->X();
                y = ps.getNode()->Y();
                z = ps.getNode()->Z();
        }
        
};

class PktHandler : public Handler {
public:
        PktHandler(UanPhy *p) : Handler(),phy(p) {}
        void handle(Event *e);
protected:
        UanPhy *phy;
};


#endif /*PHYUAN_H_*/

---