BasePhyLayer.h

#ifndef BASEPHYLAYER_
#define BASEPHYLAYER_

#include "ChannelAccess.h"
#include "DeciderToPhyInterface.h"
#include "MacToPhyInterface.h"

#include "AnalogueModel.h"

#include "Decider.h"
#include "ChannelInfo.h"
#include "BaseWorldUtility.h"

#include "MacPkt_m.h"

#include <cxmlelement.h>
#include <map>
#include <vector>
#include <iostream>


class BasePhyLayer: public ChannelAccess,
          public DeciderToPhyInterface,
          public MacToPhyInterface {

protected:

  enum ProtocolIds {
    GENERIC = 0,
  };

  int protocolId;

  static short airFramePriority;

  ConstantSimpleConstMapping* thermalNoise;

  double maxTXPower;

  double sensitivity;

  bool recordStats;

  ChannelInfo channelInfo;

  Radio* radio;

  Decider* decider;

  typedef std::vector<AnalogueModel*> AnalogueModelList;

  AnalogueModelList analogueModels;

  typedef std::map<std::string, cMsgPar> ParameterMap;

  int upperGateIn;
  int upperGateOut;
  int upperControlOut;
  int upperControlIn;

  cMessage* radioSwitchingOverTimer;

  cMessage* txOverTimer;

  enum AirFrameStates {
    START_RECEIVE = 1,
    RECEIVING,
    END_RECEIVE
  };

  int headerLength;

  BaseWorldUtility* world;

public:


private:

  void getParametersFromXML(cXMLElement* xmlData, ParameterMap& outputMap);

  void initializeAnalogueModels(cXMLElement* xmlConfig);

  void initializeDecider(cXMLElement* xmlConfig);



protected:

  template<class T> T readPar(const char* parName, const T defaultValue);

  virtual void initialize(int stage);

  virtual void handleMessage(cMessage* msg);

  virtual Radio* initializeRadio();

  virtual AnalogueModel* getAnalogueModelFromName(std::string name, ParameterMap& params);

  virtual Decider* getDeciderFromName(std::string name, ParameterMap& params);


  virtual void handleAirFrame(cMessage* msg);

  virtual void handleUpperMessage(cMessage* msg);

  virtual void handleUpperControlMessage(cMessage* msg);

  virtual void handleSelfMessage(cMessage* msg);

  virtual void handleChannelSenseRequest(cMessage* msg);

  void handleAirFrameFirstReceive(AirFrame* msg);

  virtual void handleAirFrameStartReceive(AirFrame* msg);

  virtual void handleAirFrameReceiving(AirFrame* msg);

  virtual void handleAirFrameEndReceive(AirFrame* msg);


  void sendControlMessageUp(cMessage* msg);

  void sendMacPktUp(cMessage* pkt);

  void sendMessageDown(AirFrame* pkt);

  void sendSelfMessage(cMessage* msg, simtime_t time);

  virtual AirFrame *encapsMsg(cPacket *msg);

  virtual void filterSignal(Signal& s);

  virtual void finishRadioSwitching();

  virtual int myProtocolId() { return protocolId; }

  virtual bool isKnownProtocolId(int id) { return id == myProtocolId(); }

public:
  BasePhyLayer();

  virtual ~BasePhyLayer();

  virtual void finish();

  //---------MacToPhyInterface implementation-----------

  virtual int getRadioState();

  virtual simtime_t setRadioState(int rs);

  virtual ChannelState getChannelState();

  virtual int getPhyHeaderLength();

  virtual void setCurrentRadioChannel(int newRadioChannel);

  virtual int getCurrentRadioChannel();

  virtual int getNbRadioChannels();

  //---------DeciderToPhyInterface implementation-----------

  virtual void getChannelInfo(simtime_t from, simtime_t to, AirFrameVector& out);

  virtual ConstMapping* getThermalNoise(simtime_t from, simtime_t to);

  virtual void sendControlMsg(cMessage* msg);

  virtual void sendUp(AirFrame* packet, DeciderResult* result);

  virtual simtime_t getSimTime();

  virtual void cancelScheduledMessage(cMessage* msg);

  virtual void rescheduleMessage(cMessage* msg, simtime_t t);

  virtual void drawCurrent(double amount, int activity);

  virtual BaseUtility* getUtility();

  virtual BaseWorldUtility* getWorldUtility();

  void recordScalar(const char *name, double value, const char *unit=NULL);

};

#endif /*BASEPHYLAYER_*/