/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#ifndef AUV_H

#define AUV_H

/**

 * \defgroup auv Autonomous Underwater Vehicle

 *

 * This section documents the API of the ns-3 AUV module. For a generic functional description, please refer to the ns-3 manual.

 */

#endif /* AUV_H */

An autonomous underwater vehicle (AUV) is a robot which travels underwater

without requiring input from an operator.

The NS-3 AUV module simulates the below AUVs:

Seaglider

REMUS 100

SAUV II

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#include "ns3/glider-energy-model.h"

using namespace ns3;

/**

 * In this example we show the basic usage of an AUV energy model.

 * Specifically, we show how to create a generic node, adding to it a

 * basic energy source and consuming energy from the energy source.

 *

 * The Seaglider AUV power consumption depends on buoyancy and vertical

 * speed values, so we simulate a 20 seconds movement at 0.3 m/s of vertical

 * speed and 138g of buoyancy. Then a 20 seconds movement at 0.2 m/s

 * of vertical speed and 138g of buoyancy and then a stop of 5 seconds.

 *

 * The required energy will be drained by the model basing on the

 * given buoyancy/speed values, from the energy source installed onto

 * the node.

 *

 * We register a callback to the TotalEnergyConsumption traced value.

 */

void

DoubleTrace (double oldValue, double newValue)

{

  std::cout << "Energy changed from " << oldValue << "J to " << newValue << "J" << std::endl;

}

int

main (int argc, char **argv)

{

  // uncomment to see energy consumption details

  // LogComponentEnable ("GliderEnergyModel", LOG_LEVEL_ALL);

  // create node

  Ptr<Node> node = CreateObject<Node> ();

  // create energy source

  ObjectFactory m_energySource;

  m_energySource.SetTypeId ("ns3::BasicEnergySource");

  m_energySource.Set ("BasicEnergySourceInitialEnergyJ",

                      DoubleValue (10000000));

  Ptr<EnergySource> source = m_energySource.Create<EnergySource> ();

  source->SetNode (node);

  Ptr<EnergySourceContainer> sourceCont = CreateObject<EnergySourceContainer> ();

  sourceCont->Add (source);

  // aggregate energy source to node

  node->AggregateObject (sourceCont);

  // create device energy model

  Ptr<GliderEnergyModel> model = CreateObject<GliderEnergyModel> ();

  // set energy source pointer

  model->SetEnergySource (source);

  model->SetNode (node);

  // add device energy model to model list in energy source

  source->AppendDeviceEnergyModel (model);

  // register a callback to the total consumption value

  model->TraceConnectWithoutContext ("TotalEnergyConsumption", MakeCallback (&DoubleTrace));

  // retrieve device energy model from energy source

  DeviceEnergyModelContainer modelCont =

    source->FindDeviceEnergyModels ("ns3::GliderEnergyModel");

  NS_ASSERT (modelCont.GetN () != 0);

  // get pointer

  Ptr<GliderEnergyModel> devModel = DynamicCast<GliderEnergyModel> (modelCont.Get (0));

  // simulate 20 seconds of movement with 138g buoyancy and 0.3 m/s of W

  devModel->ChangeEnergyConsumption (138, 0.3);

  // simulate 20 seconds of movement with 138g buoyancy and 0.2 m/s of W

  Simulator::Schedule (Seconds (20),

                       &GliderEnergyModel::ChangeEnergyConsumption,

                       devModel,

                       138,

                       0.2);

  // simulate a stop of the vehicle for the remaining 5 seconds

  Simulator::Schedule (Seconds (40),

                       &GliderEnergyModel::ChangeEnergyConsumption,

                       devModel,

                       0,

                       0);

  // run simulation

  Simulator::Stop (Seconds (45));

  Simulator::Run ();

  Simulator::Destroy ();

  std::cout << "Remaining energy: " << source->GetRemainingEnergy () << std::endl;

  return 0;

}

/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#include "ns3/glider-mobility-model.h"

#include "ns3/gnuplot.h"

#include "ns3/auv-mobility-helper.h"

#include <fstream>

using namespace ns3;

/**

 * We show how to use the AuvMobilityHelper to install an auv mobility model

 * into a (set of) node.

 *

 * Then we make the AUV to submerge to a depth of 1000 meters.

 * We also set a callback function called on reaching of the target depth.

 *

 * The callback then makes the AUV to emerge to water surface (0 meters).

 * We set a callback function called on reaching of the target depth.

 * The emerge callback then, stops the AUV.

 *

 * During the whole navigation process, the AUV's position is tracked by the

 * TracePos function and plotted into a Gnuplot graph.

 */

void Emerge (Ptr<GliderMobilityModel> mob);

static void

SubmergeCb (Ptr<MobilityModel> mob)

{

  // reached the target, makes the vehicle emerge

  Emerge (mob->GetObject<GliderMobilityModel> ());

}

static void

EmergeCb (Ptr<MobilityModel> mob)

{

  // stop the vehicle

  mob->GetObject<GliderMobilityModel> ()->Stop ();

}

void

Submerge (Ptr<GliderMobilityModel> mob)

{

  // set the submerge callback

  mob->SetSubmergeCallback (MakeCallback (&SubmergeCb));

  // makes the vehicle submerge to 1000m

  mob->Submerge (-1000);

}

void

Emerge (Ptr<GliderMobilityModel> mob)

{

  // set the emerge callback

  mob->SetEmergeCallback (MakeCallback (&EmergeCb));

  // makes the vehicle emerge to water surface

  mob->Emerge (0);

}

static void

TracePos (Gnuplot3dDataset* ds, Ptr<const GliderMobilityModel> mob)

{

  Vector curPos = mob->GetPosition ();

  ds->Add (curPos.x, curPos.y, curPos.z);

  Simulator::Schedule (Seconds (10),

                       &TracePos,

                       ds,

                       mob);

}

void

GeneratePlot (const GnuplotDataset& ds)

{

  Gnuplot gp;

  gp.SetTitle ("3D view");

  gp.SetExtra ("set multiplot");

  gp.AppendExtra ("set size 0.5,0.5");

  gp.AppendExtra ("set origin 0.0,0.0");

  gp.AppendExtra ("set view 60,30");

  gp.AddDataset (ds);

  Gnuplot gp1;

  gp1.SetTitle ("X-Y view");

  gp1.SetExtra ("set view 0,0");

  gp1.AppendExtra ("set origin 0.0,0.5");

  gp1.AddDataset (ds);

  Gnuplot gp2;

  gp2.SetTitle ("X-Z view");

  gp2.SetExtra ("set view 90,0");

  gp2.AppendExtra ("set origin 0.5,0.0");

  gp2.AddDataset (ds);

  Gnuplot gp3;

  gp3.SetTitle ("Y-Z view");

  gp3.SetExtra ("set view 0,90");

  gp3.AppendExtra ("set origin 0.5,0.5");

  gp3.AddDataset (ds);

  GnuplotCollection gpc ("seaglider-navigation-trace.eps");

  gpc.AddPlot (gp);

  gpc.AddPlot (gp1);

  gpc.AddPlot (gp2);

  gpc.AddPlot (gp3);

  gpc.SetTerminal ("postscript eps enhanced color \"Helvetica\" 10");

  std::ofstream of ("seaglider-navigation-trace.gpl");

  if (!of.is_open ())

    {

      NS_FATAL_ERROR ("Can not open GNU Plot outfile: seaglider-navigation-trace.gpl");

    }

  gpc.GenerateOutput (of);

  of.close ();

  std::cout << "Seaglider navigation trace successfully created!" << std::endl;

}

int

main (int argc, char **argv)

{

  NodeContainer node;

  node.Create (1);

  // install the glider mobility model

  AuvMobilityHelper rmh;

  rmh.SetType ("ns3::GliderMobilityModel");

  rmh.Install (node);

  Ptr<GliderMobilityModel> glider = DynamicCast<GliderMobilityModel> (node.Get (0)->GetObject<AuvMobilityModel> ());

  NS_ASSERT (glider != NULL);

  // set the initial position of the AUV

  glider->SetPosition (Vector (0.,0.,0.));

  // trace the position

  Gnuplot3dDataset ds ("Navigation Trace");

  TracePos (&ds, glider);

  // submerge

  Submerge (glider);

  // run simulation

  Simulator::Stop (Seconds (4001));

  Simulator::Run ();

  Simulator::Destroy ();

  // generate the navigation trace

  GeneratePlot (ds);

  return 0;

}

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#include "ns3/remus-mobility-model.h"

#include "ns3/auv-waypoint-mobility-model.h"

#include "ns3/glider-mobility-model.h"

using namespace ns3;

/**

 * We show how to use the AuvWaypointMobilityModel with a non-standard

 * ConstantVelocityMobilityModel.

 *

 * We first create a waypoint model with an underlying RemusMobilityModel

 * setting the mobility trace with two waypoints.

 *

 * We then create a waypoint model with an underlying GliderMobilityModel

 * setting the waypoints separately with the AddWaypoint method.

 *

 * We start the simulation.

 *

 * The AUV's position is printed out every seconds.

 */

static void

TracePos (Ptr<const AuvWaypointMobilityModel> mob)

{

  Vector curPos = mob->GetPosition ();

  std::cout << "At " << Simulator::Now ().GetSeconds () << ": " <<

    curPos.x << " " << curPos.y << " " << curPos.z << std::endl;

  Simulator::Schedule (Seconds (1),

                       &TracePos,

                       mob);

}

int

main (int argc, char **argv)

{

  Ptr<Node> node1 = CreateObject<Node> ();

  // create the waypoint model

  Ptr<AuvWaypointMobilityModel> mm = CreateObject<AuvWaypointMobilityModel> ();

  Ptr<RemusMobilityModel> remus = CreateObject<RemusMobilityModel> ();

  remus->SetNode (node1);

  // set the RemusMobilityModel as the underlying model

  mm->SetValidatorMobilityModel (remus);

  node1->AggregateObject (mm);

  // set some waypoints

  mm->AddWaypoint (Waypoint (Seconds (0), Vector (0, 0, 0)));

  mm->AddWaypoint (Waypoint (Seconds (10), Vector (20, 0, 0)));

  std::cout << "Remus simulation" << std::endl;

  // trace the position

  TracePos (mm);

  // run the simulation

  Simulator::Stop (Seconds (15));

  Simulator::Run ();

  Simulator::Destroy ();

  // create another waypoint model with an underlying GliderMobilityModel

  Ptr<Node> node2 = CreateObject<Node> ();

  Ptr<GliderMobilityModel> gmm = CreateObject<GliderMobilityModel> ();

  gmm->SetNode (node2);

  Ptr<AuvWaypointMobilityModel> wpmm = CreateObject<AuvWaypointMobilityModel> ();

  wpmm->SetValidatorMobilityModel (gmm);

  node2->AggregateObject (wpmm);

  // set some waypoints

  wpmm->AddWaypoint (Waypoint (Seconds (0), Vector (0,0,0)));

  wpmm->AddWaypoint (Waypoint (Seconds (60), Vector (10,0,-20)));

  std::cout << std::endl << "Seaglider simulation" << std::endl;

  // trace the position

  TracePos (wpmm);

  // run the simulation

  Simulator::Stop (Seconds (62));

  Simulator::Run ();

  Simulator::Destroy ();

  return 0;

}

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#include "ns3/core-module.h"

#include "uan-energy-auv.h"

#include "ns3/auv-glider-helper.h"

#include "ns3/auv-waypoint-mobility-model.h"

#include "ns3/basic-energy-source-helper.h"

#include "ns3/constant-position-mobility-model.h"

#include "ns3/uan-channel.h"

#include "ns3/uan-noise-model-default.h"

#include "ns3/uan-prop-model-ideal.h"

#include "ns3/acoustic-modem-energy-model-helper.h"

#include "ns3/energy-model-helper.h"

using namespace ns3;

UanEnergyAuv::UanEnergyAuv ()

  : m_bytesRx (0),

  m_sentPackets (0)

{

}

UanEnergyAuv::~UanEnergyAuv ()

{

  m_auv = NULL;

  m_gateway = NULL;

}

void

UanEnergyAuv::SendOnePacket (Ptr<Node> node)

{

  // create an empty 17 bytes packet

  Ptr<Packet> pkt = Create<Packet> (17);

  // send the packet in broadcast

  Ptr<UanNetDevice> dev = node->GetDevice (0)->GetObject<UanNetDevice> ();

  dev->Send (pkt, dev->GetBroadcast (), 0);

  // increase the sent packets number

  ++m_sentPackets;

  Simulator::Schedule (Seconds (10),

                       &UanEnergyAuv::SendOnePacket,

                       this,

                       node);

}

bool

UanEnergyAuv::RxPacket (Ptr<NetDevice> dev, Ptr<const Packet> pkt, uint16_t mode, const Address &sender)

{

  // increase the total bytes received

  m_bytesRx += pkt->GetSize ();

  return true;

}

void

UanEnergyAuv::PrintStats ()

{

  Ptr<EnergySource> source;

  std::cout << "AUV: sent " << m_sentPackets << " packets" << std::endl;

  std::cout << "Gateway: received " << m_bytesRx << " bytes" << std::endl;

  source = m_gateway->GetObject<EnergySourceContainer> ()->Get (0);

  std::cout << "Gateway energy consumption: " << 100 - (source->GetEnergyFraction () * 100) << " %" << std::endl;

  source = m_auv->GetObject<EnergySourceContainer> ()->Get (0);

  std::cout << "AUV energy consumption (nav): " << 100 - (source->GetEnergyFraction () * 100) << " %" << std::endl;

  source = m_auv->GetObject<EnergySourceContainer> ()->Get (1);

  std::cout << "AUV energy consumption (comms): " << 100 - (source->GetEnergyFraction () * 100) << " %" << std::endl;

}

bool

UanEnergyAuv::Run ()

{

  UanHelper uan;

  AcousticModemEnergyModelHelper umem;

  // create a generic node

  m_auv = CreateObject<Node> ();

  // create a gateway node

  m_gateway = CreateObject<Node> ();

  // install the glider components

  AuvGliderHelper gh;

  gh.Install (m_auv);

  // move the vehicle somewhere

  Ptr<AuvWaypointMobilityModel> mob = m_auv->GetObject<AuvWaypointMobilityModel> ();

  mob->AddWaypoint (Waypoint (Seconds (0), Vector (500,0,0)));

  mob->AddWaypoint (Waypoint (Seconds (3000), Vector (0, 500,-1000)));

  mob->AddWaypoint (Waypoint (Seconds (6000), Vector (-500, 0, 0)));

  mob->AddWaypoint (Waypoint (Seconds (9000), Vector (0, 500,-1000)));

  mob->AddWaypoint (Waypoint (Seconds (12000), Vector (500, 0, 0)));

  // set the gateway mobility model

  Ptr<ConstantPositionMobilityModel> mobility = CreateObject<ConstantPositionMobilityModel> ();

  mobility->SetPosition (Vector (0, 0, 0));

  m_gateway->AggregateObject (mobility);

  // create a default underwater channel

  Ptr<UanChannel> channel = CreateObject<UanChannel> ();

  Ptr<UanNoiseModelDefault> noise = CreateObject<UanNoiseModelDefault> ();

  channel->SetPropagationModel (CreateObject<UanPropModelIdeal> ());

  channel->SetNoiseModel (noise);

  // install the underwater communication stack on AUV and gateway

  uan.Install (m_auv, channel);

  uan.Install (m_gateway, channel);

  // setup the energy sources for AUV and gateway

  BasicEnergySourceHelper eh;

  eh.Set ("BasicEnergySourceInitialEnergyJ", DoubleValue (3888000.0));

  eh.Install (m_gateway);

  // Check nodes setup

  Ptr<EnergySource> gatewayEnergySource = m_gateway->GetObject<EnergySourceContainer> ()->Get (0);

  NS_ASSERT (gatewayEnergySource != NULL);

  Ptr<EnergySource> auvEnergySource = m_auv->GetObject<EnergySourceContainer> ()->Get (1);

  NS_ASSERT (auvEnergySource != NULL);

  Ptr<NetDevice> gatewayDevice = m_gateway->GetDevice (0);

  NS_ASSERT (gatewayDevice != NULL);

  Ptr<NetDevice> auvDevice = m_auv->GetDevice (0);

  NS_ASSERT (auvDevice != NULL);

  // micro modem energy model

  umem.Install (gatewayDevice, gatewayEnergySource);

  umem.Install (auvDevice, auvEnergySource);

  // Animate with a packet every 10 seconds

  Simulator::ScheduleNow (&UanEnergyAuv::SendOnePacket,

                          this,

                          m_auv);

  // set the receive callback

  gatewayDevice->SetReceiveCallback (MakeCallback (&UanEnergyAuv::RxPacket,

                                                   this));

  // run the simulation

  Simulator::Stop (Hours (3));

  Simulator::Run ();

  // print the simulation's statistics

  PrintStats ();

  Simulator::Destroy ();

  return false;

}

int

main (int argc, char **argv)

{

  CommandLine cmd;

  UanEnergyAuv uan;

  cmd.Parse (argc, argv);

  // uncomment to see models log

  // LogComponentEnable("GliderEnergyModel", LOG_LEVEL_ALL);

  // LogComponentEnable("BasicEnergySource", LOG_LEVEL_ALL);

  // LogComponentEnable("AcousticModemEnergyModel", LOG_LEVEL_ALL);

  uan.Run ();

  return 0;

}

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#ifndef UAN_ENERGY_AUV_H

#define UAN_ENERGY_AUV_H

/**

 * This is a comprehensive example where all the project's components are used.

 * We setup two nodes, one fixed surface gateway and a moving Seaglider AUV,

 * both equipped with an acoustic modem.

 *

 * Using the waypoint mobility model with an underlying GliderMobilityModel,

 * we make the glider descend to -1000 meters and then emerge to the water surface.

 *

 * The AUV sends a generic 17-bytes packet every 10 seconds during the navigation

 * process.

 * The gateway receives the packets and stores the total bytes amount.

 *

 * During the simulation the AUV consumes energy for navigation and packets sending.

 * The energy drained is subtracted from the main energy source.

 * The surface gateway instead consumes energy only receiving packets.

 *

 * At the end of the simulation are printed out the energy consumptions of the two

 * nodes and the networking stats.

 */

#include "ns3/packet.h"

#include "ns3/uan-helper.h"

using namespace ns3;

class UanEnergyAuv

{

public:

  UanEnergyAuv ();

  ~UanEnergyAuv ();

  bool RxPacket (Ptr<NetDevice> dev, Ptr<const Packet> pkt, uint16_t mode, const Address &sender);

  void SendOnePacket (Ptr<Node> node);

  void PrintStats ();

  bool Run (void);

  uint32_t m_bytesRx;

  uint32_t m_sentPackets;

  Ptr<Node> m_auv;

  Ptr<Node> m_gateway;

};

#endif /* UAN_ENERGY_AUV_H */

# -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-

def build(bld):

    obj = bld.create_ns3_program('uan-energy-auv', ['internet', 'uan', 'mobility', 'auv', 'energy'])

    obj.source = 'uan-energy-auv.cc'

    obj = bld.create_ns3_program('auv-energy-model', ['internet', 'mobility', 'auv', 'energy'])

    obj.source = 'auv-energy-model.cc'

    obj = bld.create_ns3_program('auv-waypoint-mobility', ['internet', 'mobility', 'auv'])

    obj.source = 'auv-waypoint-mobility.cc'

    obj = bld.create_ns3_program('auv-mobility', ['internet', 'mobility', 'auv'])

    obj.source = 'auv-mobility.cc'

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#include "auv-glider-helper.h"

#include "ns3/net-device-container.h"

#include "ns3/auv-mobility-helper.h"

#include "ns3/li-ion-energy-source.h"

#include "ns3/glider-energy-model.h"

#include "ns3/glider-mobility-model.h"

#include "ns3/auv-waypoint-mobility-model.h"

#include "ns3/energy-source-container.h"

#include "ns3/acoustic-modem-energy-model-helper.h"

#include "ns3/uan-channel.h"

#include "ns3/uan-net-device.h"

#include "ns3/uan-helper.h"

namespace ns3 {

AuvGliderHelper::AuvGliderHelper ()

{

}

void

AuvGliderHelper::Install (NodeContainer c) const

{

  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)

    {

      Install (*i);

    }

}

void

AuvGliderHelper::Install (std::string nodeName) const

{

  Ptr<Node> node = Names::Find<Node> (nodeName);

  Install (node);

}

void

AuvGliderHelper::Install (Ptr<Node> node) const

{

  // waypoint mobility model with underlying glider mobility model

  Ptr<GliderMobilityModel> gmm = CreateObject<GliderMobilityModel> ();

  gmm->SetNode (node);

  Ptr<AuvWaypointMobilityModel> wpmm = CreateObject<AuvWaypointMobilityModel> ();

  wpmm->SetValidatorMobilityModel (gmm);

  node->AggregateObject (wpmm);

  // Motor battery pack. 7 in-series string x 6 strings = 42 cells

  // Capacity 18.1 MJ @ 24 V

  //

  //     +--C-C-C-C-C-C-C--+

  //     +--C-C-C-C-C-C-C--+

  //  ---+--C-C-C-C-C-C-C--+---

  //     +--C-C-C-C-C-C-C--+

  //     +--C-C-C-C-C-C-C--+

  //     +--C-C-C-C-C-C-C--+

  //

  Ptr<EnergySourceContainer> esContainer = CreateObject<EnergySourceContainer> ();

  Ptr<EnergySourceContainer> cont = node->GetObject<EnergySourceContainer> ();

  NS_ASSERT_MSG (cont == 0, "Energy source already installed!");

  ObjectFactory fact;

  fact.SetTypeId (LiIonEnergySource::GetTypeId ());

  fact.Set ("LiIonEnergySourceInitialEnergyJ", DoubleValue (13608000.0));

  fact.Set ("InitialCellVoltage", DoubleValue (3.45 * 7));

  fact.Set ("NominalCellVoltage", DoubleValue (3.3 * 7));

  fact.Set ("ExpCellVoltage", DoubleValue (3.55 * 7));

  fact.Set ("RatedCapacity", DoubleValue (30.0 * 6));

  fact.Set ("NomCapacity", DoubleValue (27.0 * 6));

  fact.Set ("ExpCapacity", DoubleValue (15.0 * 6));

  // 0.145 ohm per cell, 7 in series and 6 string in parallel

  // Gstring = 1 / (0.145 * 7)

  // Rint = 1 / (Gstring * 6)

  fact.Set ("InternalResistance", DoubleValue (0.16917));

  fact.Set ("TypCurrent", DoubleValue (1.0 * 6));

  fact.Set ("ThresholdVoltage", DoubleValue (3.0 * 6));

  Ptr<LiIonEnergySource> devSource = fact.Create ()->GetObject<LiIonEnergySource> ();

  devSource->SetNode (node);

  esContainer->Add (devSource);

  // Analogic/digital power battery pack. 3 in-series string x 4 strings = 12 cells

  // Capacity 18.1 MJ @ 10 V

  //

  //     +--C-C-C--+

  //     +--C-C-C--+

  //  ---+--C-C-C--+---

  //     +--C-C-C--+

  //

  fact.SetTypeId (LiIonEnergySource::GetTypeId ());

  fact.Set ("LiIonEnergySourceInitialEnergyJ", DoubleValue (3888000.0));

  fact.Set ("InitialCellVoltage", DoubleValue (3.45 * 3));

  fact.Set ("NominalCellVoltage", DoubleValue (3.3 * 3));

  fact.Set ("ExpCellVoltage", DoubleValue (3.55 * 3));

  fact.Set ("RatedCapacity", DoubleValue (30.0 * 4));

  fact.Set ("NomCapacity", DoubleValue (27.0 * 4));

  fact.Set ("ExpCapacity", DoubleValue (15.0 * 4));

  // 0.145 ohm per cell, 3 in series and 4 string in parallel

  // Gstring = 1 / (0.145 * 3)

  // Rint = 1 / (Gstring * 4)

  fact.Set ("InternalResistance", DoubleValue (0.10875));

  fact.Set ("TypCurrent", DoubleValue (1.0 * 4));

  fact.Set ("ThresholdVoltage", DoubleValue (3.0 * 4));

  Ptr<LiIonEnergySource> devSource1 = fact.Create ()->GetObject<LiIonEnergySource> ();

  devSource1->SetNode (node);

  esContainer->Add (devSource1);

  node->AggregateObject (esContainer);

  // get the installed energy source container

  cont = node->GetObject<EnergySourceContainer> ();

  NS_ASSERT (cont != NULL);

  // glider energy model

  Ptr<GliderEnergyModel> gem = CreateObject<GliderEnergyModel> ();

  gem->SetEnergySource (devSource);

  gem->SetNode (node);

  devSource->AppendDeviceEnergyModel (gem);

  gem->SetEnergyDepletionCallback (MakeCallback (&AuvWaypointMobilityModel::HandleEnergyDepletion, wpmm));

  gem->SetEnergyRechargedCallback (MakeCallback (&AuvWaypointMobilityModel::HandleEnergyRecharged, wpmm));

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#ifndef AUV_GLIDER_HELPER_H

#define AUV_GLIDER_HELPER_H

#include "ns3/node-container.h"

#include "ns3/object-factory.h"

#include "ns3/names.h"

namespace ns3 {

/**

 * \ingroup auv

 * Install into a node (or set of nodes) the Seaglider's features:

 * - waypoint model with underlying glider mobility model

 * - glider energy model

 * - glider energy source

 * - micro modem energy model

 *

 * The glider mobility model is the GliderMobilityModel with default parameters.

 *

 * The glider energy model is the GliderEnergyModel with default parameters.

 *

 * Regarding the energy source, the Seaglider features two battery packs, one

 * for motor power and one for digital-analog power.

 * Each pack is composed of 12 (10V) and 42 (24V) lithium chloride DD-cell batteries,

 * respectively [1]. The total power capacity is around 17.5 MJ (3.9 MJ + 13.6 MJ).

 * In the original version of the Seaglider there was 18 + 63 D-cell with a total

 * power capacity of 10MJ.

 *

 * The packs design is as follows:

 * 10V - 3 in-series string x 4 strings = 12 cells - typical capacity ~100 Ah

 * 24V - 7 in-series-strings x 6 strings = 42 cells - typical capacity ~150 Ah

 *

 * Battery cells are Electrochem 3B36, with 3.6 V nominal voltage and 30.0 Ah

 * nominal capacity.

 *

 * The 10V battery pack is associated with the electronic devices, while the 24V one

 * is associated with the pump motor.

 *

 * The micro modem energy model is the AcousticModemEnergyModel with default parameters.

 *

 * References:

 * [1] Eriksen et al, "Seaglider: A Long-Range Autonomous Underwater Vehicle for Oceanographic Research"

 *     URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=972073&userType=inst

 */

class AuvGliderHelper

{

public:

  AuvGliderHelper ();

  /**

   * Install the Glider features into a set of nodes.

   *

   * \param c NodeContainer where to install the features

   */

  void Install (NodeContainer c) const;

  /**

   * Install the Glider features into a single node.

   *

   * \param nodeName Name of the node where to install the features.

   */

  void Install (std::string nodeName) const;

  /**

   * Install the Glider features into a single node.

   *

   * \param node Pointer of the node where to install the features.

   */

  void Install (Ptr<Node> node) const;

};

} // namespace ns3

#endif /* AUV_GLIDER_HELPER_H */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#include "auv-mobility-helper.h"

#include "ns3/remus-mobility-model.h"

#include "ns3/string.h"

namespace ns3 {

AuvMobilityHelper::AuvMobilityHelper ()

{

  m_factory.SetTypeId ("ns3::RemusMobilityModel");

  m_allocator = CreateObjectWithAttributes<RandomBoxPositionAllocator>

      ("X", StringValue ("ns3::ConstantRandomVariable[Constant=0.0]"),

      "Y", StringValue ("ns3::ConstantRandomVariable[Constant=0.0]"),

      "Z", StringValue ("ns3::ConstantRandomVariable[Constant=0.0]"));

}

void

AuvMobilityHelper::SetType (std::string type)

{

  m_factory.SetTypeId (type);

}

void AuvMobilityHelper::SetAttribute (std::string name,

                                      const AttributeValue &value)

{

  m_factory.Set (name,

                 value);

}

void

AuvMobilityHelper::SetPositionAllocator (Ptr<PositionAllocator> allocator)

{

  m_allocator = allocator;

}

void

AuvMobilityHelper::SetPositionAllocator (std::string type,

                                         std::string n1, const AttributeValue &v1,

                                         std::string n2, const AttributeValue &v2,

                                         std::string n3, const AttributeValue &v3,

                                         std::string n4, const AttributeValue &v4,

                                         std::string n5, const AttributeValue &v5,

                                         std::string n6, const AttributeValue &v6,

                                         std::string n7, const AttributeValue &v7,

                                         std::string n8, const AttributeValue &v8,

                                         std::string n9, const AttributeValue &v9)

{

  ObjectFactory pos;

  pos.SetTypeId (type);

  pos.Set (n1, v1);

  pos.Set (n2, v2);

  pos.Set (n3, v3);

  pos.Set (n4, v4);

  pos.Set (n5, v5);

  pos.Set (n6, v6);

  pos.Set (n7, v7);

  pos.Set (n8, v8);

  pos.Set (n9, v9);

  m_allocator = pos.Create ()->GetObject<PositionAllocator> ();

}

void

AuvMobilityHelper::Install (NodeContainer c) const

{

  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)

    {

      Install (*i);

    }

}

void

AuvMobilityHelper::Install (std::string nodeName) const

{

  Ptr<Node> node = Names::Find<Node> (nodeName);

  Install (node);

}

void

AuvMobilityHelper::Install (Ptr<Node> node) const

{

  Ptr<AuvMobilityModel> model = m_factory.Create ()->GetObject<AuvMobilityModel> ();

  NS_ASSERT_MSG (model != NULL,

                 "The requested mobility model is not an auv mobility model: \"" <<

                 m_factory.GetTypeId ().GetName () << "\"");

  Vector pos = m_allocator->GetNext ();

  model->SetPosition (pos);

  model->SetNode (node);

  node->AggregateObject (model);

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#ifndef AUV_MOBILITY_HELPER_H

#define AUV_MOBILITY_HELPER_H

#include "ns3/node-container.h"

#include "ns3/object-factory.h"

#include "ns3/position-allocator.h"

#include "ns3/names.h"

namespace ns3 {

/**

 * \ingroup auv

 * \brief Install into a set of nodes an AuvMobilityModel

 *

 * Install into a set of nodes (or single node) the specified AuvMobilityModel.

 * The specific AuvMobilityModel can be specified with the SetType method.

 *

 * The helper also uses a PositionAllocator to set the nodes positions.

 *

 * By default the mobility model is the RemusMobilityModel and the position

 * allocator is a RandomBoxPositionAllocator with X, Y and Z variables set to

 * constant zero.

 */

class AuvMobilityHelper

{

public:

  /**

   * Set the default mobility model (RemusMobilityModel) and the

   * default position allocator (RandomBoxPositionAllocator with

   * constant position in 0,0,0)

   */

  AuvMobilityHelper ();

  /**

   * \param type the AUV mobility model TypeId

   */

  void SetType (std::string type);

  /**

   * Set an attribute of the specified auv mobility model

   *

   * \param name name of the parameter

   * \param value value of the parameter

   */

  void SetAttribute (std::string name, const AttributeValue &value);

  /**

   * Set the position allocator to be used during the install process

   * to give each node an initial position

   *

   * \param allocator the position allocator to be set

   */

  void SetPositionAllocator (Ptr<PositionAllocator> allocator);

  /**

   * Set the position allocator to be used during the install process

   * to give each node an initial position

   *

   * \param type the position allocator TypeId

   * \param n1 the name of the attribute to set

   * \param v1 the value of the attribute to set

   * \param n2 the name of the attribute to set

   * \param v2 the value of the attribute to set

   * \param n3 the name of the attribute to set

   * \param v3 the value of the attribute to set

   * \param n4 the name of the attribute to set

   * \param v4 the value of the attribute to set

   * \param n5 the name of the attribute to set

   * \param v5 the value of the attribute to set

   * \param n6 the name of the attribute to set

   * \param v6 the value of the attribute to set

   * \param n7 the name of the attribute to set

   * \param v7 the value of the attribute to set

   * \param n8 the name of the attribute to set

   * \param v8 the value of the attribute to set

   * \param n9 the name of the attribute to set

   * \param v9 the value of the attribute to set

   */

  void SetPositionAllocator (std::string type,

                             std::string n1, const AttributeValue &v1,

                             std::string n2, const AttributeValue &v2,

                             std::string n3, const AttributeValue &v3,

                             std::string n4, const AttributeValue &v4,

                             std::string n5, const AttributeValue &v5,

                             std::string n6, const AttributeValue &v6,

                             std::string n7, const AttributeValue &v7,

                             std::string n8, const AttributeValue &v8,

                             std::string n9, const AttributeValue &v9);

  /**

   * For each of the input nodes a new mobility model of the specified type

   * is created and attached to the node.

   *

   * \param c a set of nodes

   */

  void Install (NodeContainer c) const;

  /**

   * Install the specified auv mobility model into the node with the specified

   * name.

   *

   * \param nodeName name of the node

   */

  void Install (std::string nodeName) const;

  /**

   * Install the specified auv mobility model into the specified node

   *

   * \param node Pointer of the node where to install the mobility model

   */

  void Install (Ptr<Node> node) const;

  ObjectFactory m_factory;

  Ptr<PositionAllocator> m_allocator;

};

} // namespace ns3

#endif /* AUV_MOBILITY_HELPER_H */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#include "auv-remus-helper.h"

#include "ns3/auv-mobility-helper.h"

#include "ns3/basic-energy-source-helper.h"

#include "ns3/remus-energy-model.h"

#include "ns3/remus-mobility-model.h"

#include "ns3/auv-waypoint-mobility-model.h"

#include "ns3/acoustic-modem-energy-model-helper.h"

#include "ns3/uan-channel.h"

#include "ns3/uan-net-device.h"

#include "ns3/uan-helper.h"

#include "ns3/net-device-container.h"

#include "ns3/net-device-container.h"

namespace ns3 {

AuvRemusHelper::AuvRemusHelper ()

{

}

void

AuvRemusHelper::Install (NodeContainer c) const

{

  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)

    {

      Install (*i);

    }

}

void

AuvRemusHelper::Install (std::string nodeName) const

{

  Ptr<Node> node = Names::Find<Node> (nodeName);

  Install (node);

}

void

AuvRemusHelper::Install (Ptr<Node> node) const

{

  // waypoint mobility model with underlying remus mobility model

  Ptr<RemusMobilityModel> rmm = CreateObject<RemusMobilityModel> ();

  rmm->SetNode (node);

  Ptr<AuvWaypointMobilityModel> wpmm = CreateObject<AuvWaypointMobilityModel> ();

  wpmm->SetValidatorMobilityModel (rmm);

  node->AggregateObject (wpmm);

  // 1.1 kWh -> 1.1 * 1000 * 3600 = 3960000J

  // remus energy source

  BasicEnergySourceHelper eh;

  eh.Set ("BasicEnergySourceInitialEnergyJ", DoubleValue (3960000.0));

  eh.Install (node);

  // remus energy model

  Ptr<RemusEnergyModel> rem = CreateObject<RemusEnergyModel> ();

  Ptr<EnergySource> source = node->GetObject<EnergySourceContainer> ()->Get (0);

  NS_ASSERT (source != NULL);

  rem->SetEnergySource (source);

  source->AppendDeviceEnergyModel (rem);

  source->SetNode (node);

  rem->SetNode (node);

  rem->SetEnergyDepletionCallback (MakeCallback (&AuvWaypointMobilityModel::HandleEnergyDepletion, wpmm));

  rem->SetEnergyRechargedCallback (MakeCallback (&AuvWaypointMobilityModel::HandleEnergyRecharged, wpmm));

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#ifndef AUV_REMUS_HELPER_H

#define AUV_REMUS_HELPER_H

#include "ns3/node.h"

#include "ns3/node-container.h"

#include "ns3/object-factory.h"

#include "ns3/names.h"

namespace ns3 {

/**

 * \ingroup auv

 * Install into a node (or set of nodes) the REMUS features:

 * - waypoint model with REMUS mobility model validation

 * - REMUS energy model

 * - REMUS energy source

 * - micro modem energy model

 *

 * The REMUS mobility model is the RemusMobilityModel with default parameters.

 *

 * The REMUS energy model is the RemusEnergyModel with default parameters.

 *

 * Regarding the energy source, the REMUS features a rechargeable lithium ion

 * battery pack rated 1.1 kWh @ 27 V (40 Ah) in operating conditions (specifications

 * from [1] and Hydroinc European salesman).

 * Since more detailed information about battery pack were not publicly available,

 * the energy source used is a BasicEnergySource.

 *

 * The micro modem energy model is the AcousticModemEnergyModel with default parameters.

 *

 * References:

 *

 * [1] Hydroinc Products; http://www.hydroidinc.com/products.html

 */

class AuvRemusHelper

{

public:

  AuvRemusHelper ();

  /**

   * Install the REMUS features into a set of nodes

   *

   * \param c NodeContainer where to install the features

   */

  void Install (NodeContainer c) const;

  /**

   * Install the REMUS features into a single node

   *

   * \param nodeName Name of the node where to install the features

   */

  void Install (std::string nodeName) const;

  /**

   * Install the REMUS features into a single node

   *

   * \param node Pointer of the node where to install the features

   */

  void Install (Ptr<Node> node) const;

};

} // namespace ns3

#endif /* AUV_REMUS_HELPER_H */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#include "auv-mobility-model.h"

namespace ns3 {

TypeId

AuvMobilityModel::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::AuvMobilityModel")

    .SetParent (MobilityModel::GetTypeId ())

  ;

  return tid;

}

AuvMobilityModel::AuvMobilityModel ()

{

}

AuvMobilityModel::~AuvMobilityModel ()

{

}

void

AuvMobilityModel::Move (void)

{

  return DoMove ();

}

void

AuvMobilityModel::Stop (void)

{

  return DoStop ();

}

void

AuvMobilityModel::Emerge (double depth)

{

  return DoEmerge (depth);

}

void

AuvMobilityModel::Submerge (double depth)

{

  return DoSubmerge (depth);

}

double

AuvMobilityModel::GetPitch () const

{

  return DoGetPitch ();

}

void

AuvMobilityModel::SetPitch (double pitch)

{

  return DoSetPitch (pitch);

}

double

AuvMobilityModel::GetDepth (void)

{

  return DoGetDepth ();

}

double

AuvMobilityModel::GetDirection (void) const

{

  return DoGetDirection ();

}

void

AuvMobilityModel::SetDirection (double dir)

{

  return DoSetDirection (dir);

}

double

AuvMobilityModel::GetSpeed () const

{

  return DoGetSpeed ();

}

void

AuvMobilityModel::SetSpeed (double speed)

{

  return DoSetSpeed (speed);

}

void

AuvMobilityModel::SetVelocity (const Vector &velocity)

{

  return DoSetVelocity (velocity);

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Andrea Sacco

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#ifndef AUV_MOBILITY_MODEL_H_

#define AUV_MOBILITY_MODEL_H_

#include "ns3/constant-velocity-mobility-model.h"

#include "ns3/node.h"

namespace ns3 {

/**

 * \ingroup auv

 * \brief keep track of the current position of an Autonomous Underwater Vehicle (AUV)

 *

 * Define an interface for AUV mobility models. Every AUV mobility model should derive

 * from this interface, and implements all the pure virtual methods.

 *

 * The interface allow the client to move/stop the vehicle's movement, makes it submerge

 * or emerge to a target depth, and getting and setting the main navigation's parameter

 * like pitch, direction, speed.

 *

 * The emerge and submerge callback are called when the vehicle reach the target depth.

 */

class AuvMobilityModel : public MobilityModel

{

public:

  static TypeId GetTypeId (void);

  AuvMobilityModel ();

  virtual ~AuvMobilityModel () = 0;

  /**

   * Makes the AUV to move along the given direction

   */

  void Move (void);

  /**

   * Makes the AUV to stop

   */

  void Stop (void);

  /**

   * Makes the AUV to emerge at the maximum velocity

   * to the given depth

   * \param depth the depth to which emerge to, in m (negative)

   */

  void Emerge (double depth);

  /**

   * Makes the AUV to submerge at the maximum velocity

   * to the given depth

   * \param depth the depth to which submerge to, in m (negative)

   */

  void Submerge (double depth);

  /**

   * \returns the current pitch in degrees

   */

  double GetPitch () const;

  /**

   * \param pitch the pitch to set in degrees

   */

  void SetPitch (double pitch);

  /**

   * \returns the current depth

   */

  double GetDepth (void);

  /**

   * \returns the current direction in degrees

   */

  double GetDirection (void) const;

  /**

   * \param dir the heading direction in degrees

   */

  void SetDirection (double dir);

  /**

   * \returns the current speed in m/s

   */

  double GetSpeed () const;

  /**

   * \param speed the speed to set in m/s

   */

  void SetSpeed (double speed);

  /**

   * \param velocity the velocity vector to set

   */

  void SetVelocity (const Vector &velocity);

  /**

   * \param node the node associated with the mobility model

   */

  virtual void SetNode (const Ptr<Node> node) = 0;

  /**

   * \returns the associated node

   */

  virtual Ptr<Node> GetNode (void) const = 0;

  /**

   * \param cb the callback being called at the end of the emerging process

   */

  virtual void SetEmergeCallback (Callback<void, Ptr<MobilityModel> > cb) = 0;

  /**

   ** \param cb the callback being called at the end of the submerging process

   */

  virtual void SetSubmergeCallback (Callback<void, Ptr<MobilityModel> > cb) = 0;

private:

  /**

   * Concrete subclasses of this base class must

   * implement this methods.

   */

  /**

   * Makes the AUV to move along the given direction

   */

  virtual void DoMove (void) = 0;

  /**

   * Makes the AUV to stop

   */

  virtual void DoStop (void) = 0;

  /**

   * Makes the AUV to emerge at the maximum velocity

   * to the given depth. When reaching the target depth, it

   * will be called the EmergeCallback, if set.

   * \param depth the depth to which emerge to, in m (negative)

   */

  virtual void DoEmerge (double depth) = 0;

  /**

   * Makes the AUV to submerge at the maximum velocity

   * to the given depth. When reaching the target depth, it

   * will be called the SubmergeCallback, if set.

   * \param depth the depth to which submerge to, in m (negative)

   */

  virtual void DoSubmerge (double depth) = 0;

  /**

   * \returns the current pitch in degrees

   */

  virtual double DoGetPitch () const = 0;

  /**

   * \param pitch the pitch to set in degrees

   */

  virtual void DoSetPitch (double pitch) = 0;

  /**

   * \returns the current depth

   */

  virtual double DoGetDepth (void) = 0;

  /**

   * \returns the current direction in degrees

   */

  virtual double DoGetDirection (void) const = 0;

  /**

   * \param direction the heading direction in degrees

   */

  virtual void DoSetDirection (double dir) = 0;

  /**

   * \returns the current speed in m/s

   */

  virtual double DoGetSpeed () const = 0;

  /**

   * \param speed the speed to set in m/s

   */

  virtual void DoSetSpeed (double speed) = 0;

  /**

   * \param velocity the velocity vector to set

   */

  virtual void DoSetVelocity (const Vector &velocity) = 0;

  // inherited from MobilityModel

  /**

   * \returns the current position

   */

  virtual Vector DoGetPosition (void) const = 0;

  /**

   * \param position the position to set

   */

  virtual void DoSetPosition (const Vector &position) = 0;

  /**

   * \returns the current velocity vector

   */

  virtual Vector DoGetVelocity (void) const = 0;

};

}   // namespace ns3

#endif /* AUV_MOBILITY_MODEL_H_ */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Andrea Sacco <andrea.sacco85@gmail.com>

 */

#include "auv-waypoint-mobility-model.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("AuvWaypointMobilityModel");

NS_OBJECT_ENSURE_REGISTERED (AuvWaypointMobilityModel);

TypeId

AuvWaypointMobilityModel::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::AuvWaypointMobilityModel")

    .SetParent<WaypointMobilityModel> ()

    .SetGroupName ("AUV")

    .AddConstructor<AuvWaypointMobilityModel> ()

    .AddAttribute ("ValidatorMobilityModel", "The MobilityModel going to be used for the position's validation, must be a constant velocity model",

                   PointerValue (),

                   MakePointerAccessor (&AuvWaypointMobilityModel::m_auvMobilityModel),

                   MakePointerChecker<ConstantVelocityMobilityModel> ())

  ;

  return tid;

}

AuvWaypointMobilityModel::AuvWaypointMobilityModel ()

  : m_lazyNotify (false),

  m_initialPositionIsWaypoint (true),

  m_auvMobilityModel (NULL),

  m_energyDepleted (false),

  m_lastUpdate (Seconds (-1)),

  m_callbackDone (false)

{

  m_waypointReachedCallback.Nullify ();

}

AuvWaypointMobilityModel::~AuvWaypointMobilityModel ()

{

  m_auvMobilityModel = NULL;

  m_waypointReachedCallback.Nullify ();

}

void

AuvWaypointMobilityModel::SetValidatorMobilityModel (Ptr<AuvMobilityModel> auvMobilityModel)

{

  m_auvMobilityModel = auvMobilityModel;

}

Ptr<AuvMobilityModel>

AuvWaypointMobilityModel::GetValidatorMobilityModel (void) const

{

  return m_auvMobilityModel;

}

void

AuvWaypointMobilityModel::DoDispose (void)

{

  MobilityModel::DoDispose ();

}

void

AuvWaypointMobilityModel::Update (void) const

{

  const Time now = Simulator::Now ();

  bool newWaypoint = false;

  if ( now == m_lastUpdate )

    {

      return;

    }

  if ( now < m_current.time )

    {

      return;

    }

  while ( now >= m_next.time  )

    {

      if ( m_waypoints.empty () &&  m_waypointReachedCallback.IsNull () )

        {

          if ( m_current.time <= m_next.time )

            {

              /*

                Set m_next.time = -1 to make sure this doesn't happen more than once.

                The comparison here still needs to be '<=' in the case of mobility with one waypoint.

              */

              m_next.time = Seconds (-1.0);

              m_current.position = m_next.position;

              m_current.time = now;

              m_velocity = Vector (0,0,0);

              m_auvMobilityModel->SetVelocity (m_velocity);

              NotifyCourseChange ();

            }

          else

            {

              m_current.time = now;

            }

          return;

        }

      if ( m_energyDepleted )

        {

          return;

        }

      if ( !m_waypoints.empty () )

        {

          m_current = m_next;

          m_next = m_waypoints.front ();

          m_waypoints.pop_front ();

          newWaypoint = true;

        }

      const double t_span = (m_next.time - m_current.time).GetSeconds ();

      if (t_span > 0)

        {

          m_velocity.x = (m_next.position.x - m_current.position.x) / t_span;

          m_velocity.y = (m_next.position.y - m_current.position.y) / t_span;

          m_velocity.z = (m_next.position.z - m_current.position.z) / t_span;

        }

      else

        {

          m_velocity = Vector (0,0,0);

        }

      m_auvMobilityModel->SetVelocity (m_velocity);

      if ( now > m_lastUpdate )

        {

          m_callbackDone = false;

        }

      m_lastUpdate = now;

      if ( !m_waypointReachedCallback.IsNull ()  && (!m_callbackDone) )

        {

          m_callbackDone = true;

          // if the callback causes a call to AddWaypoint()

          // this will prevent it from overriding m_current and m_next

          bool waypointsEmpty = m_waypoints.empty ();

          if (waypointsEmpty)

            {

              m_waypoints.push_back (Waypoint (Seconds (0), Vector (0,0,0)));

            }

          m_waypointReachedCallback ();

          if (waypointsEmpty)

            {

              m_waypoints.pop_front ();

            }

        }

      if ( m_waypoints.empty () && !m_waypointReachedCallback.IsNull () )

        {

          break;

        }

    }

  if ( now > m_current.time ) // Won't ever be less, but may be equal

    {

      const double t_diff = (now - m_current.time).GetSeconds ();

      m_current.position.x += m_velocity.x * t_diff;

      m_current.position.y += m_velocity.y * t_diff;

      m_current.position.z += m_velocity.z * t_diff;

      m_current.time = now;

    }

  if ( newWaypoint )

    {

      NotifyCourseChange ();

    }

  else if ( !m_waypointReachedCallback.IsNull () && m_current.time == m_next.time )

    {

      m_velocity = Vector (0,0,0);

      m_auvMobilityModel->SetVelocity (m_velocity);

      NotifyCourseChange ();

    }

}

void

AuvWaypointMobilityModel::DoSetPosition (const Vector &position)

{

  const Time now = Simulator::Now ();

  if ( m_initialPositionIsWaypoint )

    {

      AddWaypoint (Waypoint (now, position));

      return;

    }

  Update ();

  m_current.time = std::max (now, m_next.time);

  m_current.position = position;

  m_velocity = Vector (0,0,0);

  m_auvMobilityModel->SetVelocity (m_velocity);

  if ( now >= m_current.time )

    {

      // This is only a course change if the node is actually moving

      NotifyCourseChange ();

    }

}

Vector

AuvWaypointMobilityModel::DoGetPosition (void) const

{

  AuvWaypointMobilityModel::Update ();

  return m_current.position;

}