RFLink.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// pydtn is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "simlpy/interpreter_defs.h"
#include "simlpy/interpreter_hooks.h"

#include "RFLink.h"

#include "pydtn/BundleEvent.h"
#include "mobility/MobileNode.h"
#include "simlpy/Clock.h"
#include "simlpy/SimulationException.h"

#include <math.h>
#include <iostream>

using namespace RF;

RFLink::NodeList RFLink::listeners;

RFLink::RFLink()
{
}

RFLink::~RFLink()
{
}

Entity*
RFLink::create() const
{
   return new RFLink;
}

void
RFLink::configure( const ArgList& args )
{
   unsigned int nargs = args.size();
   if ( 0 == nargs )
   {
      std::cerr << "no configuration options were passed" << std::endl;
      throw SimulationException( __FILE__ , __LINE__ );
   }
   std::string command = parse_string(args[0]);
   if ( "connect" == command )
   {
      // base class does the parsing
      WirelessLink::configure(args);
      if ( 0 != m_node )
      {
         listeners.push_back( m_node );
      }
      return;
   }
   if ( "range" == command )
   {
      if ( nargs < 2 )
      {
         std::cerr << "config('range') requires two arguments"
                   << std::endl;
         throw SimulationException( __FILE__ , __LINE__ );
      }
      m_range = parse_double(args[1]);
      return;
   }
   WirelessLink::configure(args);
}

InterpreterItem
RFLink::get( const ArgList& args )
{
   unsigned int nargs = args.size();
   if ( 0 == nargs )
   {
      std::cerr << "No attribute specified" << std::endl;
      throw SimulationException( __FILE__ , __LINE__ );
   }

   std::string attr = parse_string(args[0]);

   if ( "range" == attr )
   {
      return construct_double( m_range );
   }
   if ( "visible" == attr )
   {
      ArgList alist;
      Mobility::Position  pos = m_node->position();
      double rnorm = m_range * m_range;
      NodeList::iterator  itr = listeners.begin();
      NodeList::iterator  end = listeners.end();
      for ( ; itr != end ; ++itr )
      {
         // make sure it's not a NULL pointer
         if ( 0 == *itr ) continue;

         // we don't send messages to ourself
         if ( m_node == *itr ) continue;

         // compute the vector from us to the potential recipient
         Mobility::Position  rcvrPos = (*itr)->position() - pos;

         // quick rectangular comparisons
         if ( fabs( rcvrPos.x() ) > m_range ) continue;
         if ( fabs( rcvrPos.y() ) > m_range ) continue;
         if ( fabs( rcvrPos.z() ) > m_range ) continue;

         // we're within the cube, but what about the sphere?
         double norm = rcvrPos.x() * rcvrPos.x()
            + rcvrPos.y() * rcvrPos.y()
            + rcvrPos.z() * rcvrPos.z();
         if ( norm > rnorm ) continue;

         alist.push_back( construct_string( (*itr)->addrString() ) );
      }

      return construct_list(alist);
   }

   return WirelessLink::get(args);
}

bool
RFLink::handler( BundleEvent& event )
{
   bool sent = false;

   if ( m_link.up() )
   {
      if ( event.sentAt() >= m_link.upSince() )
      {
         Mobility::Position  pos = m_node->position();
         double rnorm = m_range * m_range;
         NodeList::iterator  itr = listeners.begin();
         NodeList::iterator  end = listeners.end();
         for ( ; itr != end ; ++itr )
         {
            // make sure it's not a NULL pointer
            if ( 0 == *itr ) continue;

            // we don't send messages to ourself
            if ( m_node == *itr ) continue;

            // compute the vector from us to the potential recipient
            Mobility::Position  rcvrPos = (*itr)->position() - pos;

            // quick rectangular comparisons
            if ( fabs( rcvrPos.x() ) > m_range ) continue;
            if ( fabs( rcvrPos.y() ) > m_range ) continue;
            if ( fabs( rcvrPos.z() ) > m_range ) continue;

            // we're within the cube, but what about the sphere?
            double norm = rcvrPos.x() * rcvrPos.x()
               + rcvrPos.y() * rcvrPos.y()
               + rcvrPos.z() * rcvrPos.z();
            if ( norm > rnorm ) continue;

            // everything checks out -- send this node the bundle
            DTN::Bundle* b = event.data().clone();
            Clock::schedule( new BundleEvent( this,
                                              *itr,
                                              event.sentAt(),
                                              Clock::time(),
                                              b ) );
            sent = true;
         }
      }
   }

   // If we get here, the Bundle is going to disappear.
   if ( 0 == m_source )
   {
      throw SimulationException( __FILE__ , __LINE__ );
   }

   // If the bundle was sent, the BundleEvent will still own its data,
   // and will clean it up when its destructor is invoked.
   return sent;
}

---