ChannelControl Class Reference

#include <ChannelControl.h>

List of all members.


Detailed Description

Monitors which hosts are "in range". Supports multiple channels.

See also:
ChannelAccess


Public Types

typedef HostEntryHostRef
typedef std::vector< cModule * > ModuleList
typedef std::list< AirFrame * > TransmissionList

Public Member Functions

 ChannelControl ()
 ~ChannelControl ()
HostRef registerHost (cModule *host, const Coord &initialPos)
 Registers the given host.
HostRef lookupHost (cModule *host)
 Returns the "handle" of a previously registered host.
void updateHostPosition (HostRef h, const Coord &pos)
 To be called when the host moved; updates proximity info.
void updateHostChannel (HostRef h, const int channel)
 Called when host switches channel.
const TransmissionListgetOngoingTransmissions (const int channel)
 Provides a list of transmissions currently on the air.
void addOngoingTransmission (HostRef h, AirFrame *frame)
 Notifies the channel control with an ongoing transmission.
const CoordgetHostPosition (HostRef h)
 Returns the host's position.
const ModuleListgetNeighbors (HostRef h)
 Get the list of modules in range of the given host.
double getCommunicationRange (HostRef h)
 Reads init parameters and calculates a maximal interference distance.
const CoordgetPgs ()
 Returns the playground size.
const int getNumChannels ()
 Returns the number of radio channels (frequencies) simulated.

Protected Types

typedef std::list< HostEntryHostList
typedef std::vector< TransmissionListChannelTransmissionLists
 keeps track of ongoing transmissions; this is needed when a host switches to another channel (then it needs to know whether the target channel is empty or busy)

Protected Member Functions

void updateConnections (HostRef h)
virtual double calcInterfDist ()
 Calculate interference distance.
void updateDisplayString (cModule *playgroundMod)
 Set up playground module's display string.
virtual void initialize ()
 Reads init parameters and calculates a maximal interference distance.
void purgeOngoingTransmissions ()
 Throws away expired transmissions.
void checkChannel (const int channel)
 Validate the channel identifier.

Protected Attributes

HostList hosts
ChannelTransmissionLists transmissions
double lastOngoingTransmissionsUpdate
 used to clear the transmission list from time to time
bool coreDebug
 Set debugging for the basic module.
Coord playgroundSize
 x and y size of the area the nodes are in (in meters)
double maxInterferenceDistance
 the biggest interference distance in the network.
int numChannels
 the number of controlled channels

Friends

std::ostream & operator<< (std::ostream &, const HostEntry &)
std::ostream & operator<< (std::ostream &, const TransmissionList &)

Classes

struct  HostEntry


Member Typedef Documentation

typedef std::vector<TransmissionList> ChannelControl::ChannelTransmissionLists [protected]

keeps track of ongoing transmissions; this is needed when a host switches to another channel (then it needs to know whether the target channel is empty or busy)

typedef std::list<HostEntry> ChannelControl::HostList [protected]

typedef HostEntry* ChannelControl::HostRef

typedef std::vector<cModule*> ChannelControl::ModuleList

typedef std::list<AirFrame*> ChannelControl::TransmissionList


Constructor & Destructor Documentation

ChannelControl::ChannelControl (  ) 

00043 {
00044 }

ChannelControl::~ChannelControl (  ) 

00047 {
00048     for (unsigned int i = 0; i < transmissions.size(); i++)
00049         for (TransmissionList::iterator it = transmissions[i].begin(); it != transmissions[i].end(); it++)
00050             delete *it;
00051 }


Member Function Documentation

void ChannelControl::addOngoingTransmission ( HostRef  h,
AirFrame frame 
)

Notifies the channel control with an ongoing transmission.

00234 {
00235     Enter_Method_Silent();
00236 
00237     // we only keep track of ongoing transmissions so that we can support
00238     // NICs switching channels -- so there's no point doing it if there's only
00239     // one channel
00240     if (numChannels==1)
00241     {
00242         delete frame;
00243         return;
00244     }
00245 
00246     // purge old transmissions from time to time
00247     if (simTime() - lastOngoingTransmissionsUpdate > TRANSMISSION_PURGE_INTERVAL)
00248     {
00249         purgeOngoingTransmissions();
00250         lastOngoingTransmissionsUpdate = simTime();
00251     }
00252 
00253     // register ongoing transmission
00254     take(frame);
00255     frame->setTimestamp(); // store time of transmission start
00256     transmissions[frame->getChannelNumber()].push_back(frame);
00257 }

double ChannelControl::calcInterfDist (  )  [protected, virtual]

Calculate interference distance.

Calculation of the interference distance based on the transmitter power, wavelength, pathloss coefficient and a threshold for the minimal receive Power

You may want to overwrite this function in order to do your own interference calculation

00104 {
00105     double SPEED_OF_LIGHT = 300000000.0;
00106     double interfDistance;
00107 
00108     //the carrier frequency used
00109     double carrierFrequency = par("carrierFrequency");
00110     //maximum transmission power possible
00111     double pMax = par("pMax");
00112     //signal attenuation threshold
00113     double sat = par("sat");
00114     //path loss coefficient
00115     double alpha = par("alpha");
00116 
00117     double waveLength = (SPEED_OF_LIGHT / carrierFrequency);
00118     //minimum power level to be able to physically receive a signal
00119     double minReceivePower = pow(10.0, sat / 10.0);
00120 
00121     interfDistance = pow(waveLength * waveLength * pMax /
00122                          (16.0 * M_PI * M_PI * minReceivePower), 1.0 / alpha);
00123 
00124     coreEV << "max interference distance:" << interfDistance << endl;
00125 
00126     return interfDistance;
00127 }

void ChannelControl::checkChannel ( const int  channel  )  [protected]

Validate the channel identifier.

00204 {
00205     if (channel >= numChannels || channel < 0)
00206         error("Invalid channel, must be between 0 and %d", numChannels);
00207 }

double ChannelControl::getCommunicationRange ( HostRef  h  )  [inline]

Reads init parameters and calculates a maximal interference distance.

00140                                             {
00141         return maxInterferenceDistance;
00142     }

const Coord& ChannelControl::getHostPosition ( HostRef  h  )  [inline]

Returns the host's position.

00134 {return h->pos;}

const ChannelControl::ModuleList & ChannelControl::getNeighbors ( HostRef  h  ) 

Get the list of modules in range of the given host.

00156 {
00157     Enter_Method_Silent();
00158     if (!h->isModuleListValid)
00159     {
00160         h->neighborModules.clear();
00161         for (std::set<HostRef>::const_iterator it = h->neighbors.begin(); it != h->neighbors.end(); it++)
00162             h->neighborModules.push_back((*it)->host);
00163         h->isModuleListValid = true;
00164     }
00165     return h->neighborModules;
00166 }

const int ChannelControl::getNumChannels (  )  [inline]

Returns the number of radio channels (frequencies) simulated.

00148 {return numChannels;}

const ChannelControl::TransmissionList & ChannelControl::getOngoingTransmissions ( const int  channel  ) 

Provides a list of transmissions currently on the air.

00225 {
00226     Enter_Method_Silent();
00227 
00228     checkChannel(channel);
00229     purgeOngoingTransmissions();
00230     return transmissions[channel];
00231 }

const Coord* ChannelControl::getPgs (  )  [inline]

Returns the playground size.

00145 {return &playgroundSize;}

void ChannelControl::initialize (  )  [protected, virtual]

Reads init parameters and calculates a maximal interference distance.

Sets up the playgroundSize and calculates the maxInterferenceDistance

calcInterfDist

00060 {
00061     coreDebug = hasPar("coreDebug") ? (bool) par("coreDebug") : false;
00062 
00063     coreEV << "initializing ChannelControl\n";
00064 
00065     playgroundSize.x = par("playgroundSizeX");
00066     playgroundSize.y = par("playgroundSizeY");
00067 
00068     numChannels = par("numChannels");
00069     transmissions.resize(numChannels);
00070 
00071     lastOngoingTransmissionsUpdate = 0;
00072 
00073     maxInterferenceDistance = calcInterfDist();
00074 
00075     WATCH(maxInterferenceDistance);
00076     WATCH_LIST(hosts);
00077     WATCH_VECTOR(transmissions);
00078 
00079     updateDisplayString(parentModule());
00080 }

ChannelControl::HostRef ChannelControl::lookupHost ( cModule *  host  ) 

Returns the "handle" of a previously registered host.

00147 {
00148     Enter_Method_Silent();
00149     for (HostList::iterator it = hosts.begin(); it != hosts.end(); it++)
00150         if (it->host == host)
00151             return &(*it);
00152     return 0;
00153 }

void ChannelControl::purgeOngoingTransmissions (  )  [protected]

Throws away expired transmissions.

00260 {
00261     for (int i = 0; i < numChannels; i++)
00262     {
00263         for (TransmissionList::iterator it = transmissions[i].begin(); it != transmissions[i].end();)
00264         {
00265             TransmissionList::iterator curr = it;
00266             AirFrame *frame = *it;
00267             it++;
00268 
00269             if (frame->timestamp() + frame->getDuration() + TRANSMISSION_PURGE_INTERVAL < simTime())
00270             {
00271                 delete frame;
00272                 transmissions[i].erase(curr);
00273             }
00274         }
00275     }
00276 }

ChannelControl::HostRef ChannelControl::registerHost ( cModule *  host,
const Coord initialPos 
)

Registers the given host.

00130 {
00131     Enter_Method_Silent();
00132     if (lookupHost(host) != NULL)
00133         error("ChannelControl::registerHost(): host (%s)%s already registered",
00134               host->className(), host->fullPath().c_str());
00135 
00136     HostEntry he;
00137     he.host = host;
00138     he.pos = initialPos;
00139     he.isModuleListValid = false;
00140     // TODO: get it from caller
00141     he.channel = 0;
00142     hosts.push_back(he);
00143     return &hosts.back(); // last element
00144 }

void ChannelControl::updateConnections ( HostRef  h  )  [protected]

00169 {
00170     Coord& hpos = h->pos;
00171     double maxDistSquared = maxInterferenceDistance * maxInterferenceDistance;
00172     for (HostList::iterator it = hosts.begin(); it != hosts.end(); ++it)
00173     {
00174         HostEntry *hi = &(*it);
00175         if (hi == h)
00176             continue;
00177 
00178         // get the distance between the two hosts.
00179         // (omitting the square root (calling sqrdist() instead of distance()) saves about 5% CPU)
00180         bool inRange = hpos.sqrdist(hi->pos) < maxDistSquared;
00181 
00182         if (inRange)
00183         {
00184             // nodes within communication range: connect
00185             if (h->neighbors.insert(hi).second == true)
00186             {
00187                 hi->neighbors.insert(h);
00188                 h->isModuleListValid = hi->isModuleListValid = false;
00189             }
00190         }
00191         else
00192         {
00193             // out of range: disconnect
00194             if (h->neighbors.erase(hi))
00195             {
00196                 hi->neighbors.erase(h);
00197                 h->isModuleListValid = hi->isModuleListValid = false;
00198             }
00199         }
00200     }
00201 }

void ChannelControl::updateDisplayString ( cModule *  playgroundMod  )  [protected]

Set up playground module's display string.

Sets up background size by adding the following tags: "p=0,0;b=$playgroundSizeX,$playgroundSizeY"

00087 {
00088     cDisplayString& d = playgroundMod->backgroundDisplayString();
00089     d.setTagArg("p", 0, 0L);
00090     d.setTagArg("p", 1, 0L);
00091     d.setTagArg("b", 0, (long) playgroundSize.x);
00092     d.setTagArg("b", 1, (long) playgroundSize.y);
00093 }

void ChannelControl::updateHostChannel ( HostRef  h,
const int  channel 
)

Called when host switches channel.

00217 {
00218     Enter_Method_Silent();
00219     checkChannel(channel);
00220 
00221     h->channel = channel;
00222 }

void ChannelControl::updateHostPosition ( HostRef  h,
const Coord pos 
)

To be called when the host moved; updates proximity info.

00210 {
00211     Enter_Method_Silent();
00212     h->pos = pos;
00213     updateConnections(h);
00214 }


Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const TransmissionList tl 
) [friend]

00036 {
00037     for (ChannelControl::TransmissionList::const_iterator it = tl.begin(); it != tl.end(); ++it)
00038         os << endl << *it;
00039     return os;
00040 }

std::ostream& operator<< ( std::ostream &  os,
const HostEntry h 
) [friend]

00029 {
00030     os << h.host->fullPath() << " (x=" << h.pos.x << ",y=" << h.pos.y << "), "
00031        << h.neighbors.size() << " neighbor(s)";
00032     return os;
00033 }


Member Data Documentation

bool ChannelControl::coreDebug [protected]

Set debugging for the basic module.

HostList ChannelControl::hosts [protected]

double ChannelControl::lastOngoingTransmissionsUpdate [protected]

used to clear the transmission list from time to time

double ChannelControl::maxInterferenceDistance [protected]

the biggest interference distance in the network.

int ChannelControl::numChannels [protected]

the number of controlled channels

Coord ChannelControl::playgroundSize [protected]

x and y size of the area the nodes are in (in meters)

ChannelTransmissionLists ChannelControl::transmissions [protected]


The documentation for this class was generated from the following files:
Generated on Wed Apr 4 13:20:19 2007 for INET Framework for OMNeT++/OMNEST by  doxygen 1.4.7