rv-battery-model.cc

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2010 Network Security Lab, University of Washington, Seattle.
 *
 * 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
 *
 * Authors: Sidharth Nabar <snabar@uw.edu>, He Wu <mdzz@u.washington.edu>
 */

#include "rv-battery-model.h"
#include "ns3/log.h"
#include "ns3/assert.h"
#include "ns3/double.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/simulator.h"
#include <cmath>

NS_LOG_COMPONENT_DEFINE ("RvBatteryModel");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (RvBatteryModel);

TypeId
RvBatteryModel::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::RvBatteryModel")
    .SetParent<EnergySource> ()
    .AddConstructor<RvBatteryModel> ()
    .AddAttribute ("RvBatteryModelPeriodicEnergyUpdateInterval",
                   "RV battery model sampling interval.",
                   TimeValue (Seconds (1.0)),
                   MakeTimeAccessor (&RvBatteryModel::SetSamplingInterval,
                                     &RvBatteryModel::GetSamplingInterval),
                   MakeTimeChecker ())
    .AddAttribute ("RvBatteryModelOpenCircuitVoltage",
                   "RV battery model open circuit voltage.",
                   DoubleValue (4.1),
                   MakeDoubleAccessor (&RvBatteryModel::SetOpenCircuitVoltage,
                                       &RvBatteryModel::GetOpenCircuitVoltage),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("RvBatteryModelCutoffVoltage",
                   "RV battery model cutoff voltage.",
                   DoubleValue (3.0),
                   MakeDoubleAccessor (&RvBatteryModel::SetCutoffVoltage,
                                       &RvBatteryModel::GetCutoffVoltage),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("RvBatteryModelAlphaValue",
                   "RV battery model alpha value.",
                   DoubleValue (35220.0),
                   MakeDoubleAccessor (&RvBatteryModel::SetAlpha,
                                       &RvBatteryModel::GetAlpha),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("RvBatteryModelBetaValue",
                   "RV battery model beta value.",
                   DoubleValue (0.637),
                   MakeDoubleAccessor (&RvBatteryModel::SetBeta,
                                       &RvBatteryModel::GetBeta),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("RvBatteryModelNumOfTerms",
                   "The number of terms of the infinite sum for estimating battery level.",
                   IntegerValue (10),   // value used in paper
                   MakeIntegerAccessor (&RvBatteryModel::SetNumOfTerms,
                                        &RvBatteryModel::GetNumOfTerms),
                   MakeIntegerChecker<int> ())
    .AddTraceSource ("RvBatteryModelBatteryLevel",
                     "RV battery model battery level.",
                     MakeTraceSourceAccessor (&RvBatteryModel::m_batteryLevel))
    .AddTraceSource ("RvBatteryModelBatteryLifetime",
                     "RV battery model battery lifetime.",
                     MakeTraceSourceAccessor (&RvBatteryModel::m_lifetime))
  ;
  return tid;
}

RvBatteryModel::RvBatteryModel ()
{
  m_lastSampleTime = Seconds (0.0);
  m_previousLoad = 0.0;
  m_batteryLevel = 1; // fully charged
  m_lifetime = Seconds (0.0);
}

RvBatteryModel::~RvBatteryModel ()
{
}

double
RvBatteryModel::GetInitialEnergy (void) const
{
  return m_alpha * GetSupplyVoltage ();
}

double
RvBatteryModel::GetSupplyVoltage (void) const
{
  // average of Voc and Vcutoff
  return (m_openCircuitVoltage - m_cutoffVoltage) / 2 + m_cutoffVoltage;
}

double
RvBatteryModel::GetRemainingEnergy (void)
{
  NS_LOG_FUNCTION (this);
  UpdateEnergySource ();
  return m_alpha * GetSupplyVoltage () * m_batteryLevel;
}

double
RvBatteryModel::GetEnergyFraction (void)
{
  return GetBatteryLevel ();
}

void
RvBatteryModel::UpdateEnergySource (void)
{
  NS_LOG_FUNCTION (this);

  // do not update if battery is already dead
  if (m_batteryLevel <= 0)
    {
      NS_LOG_DEBUG ("RvBatteryModel:Battery is dead!");
      return;
    }

  // do not update if simulation has finished
  if (Simulator::IsFinished ())
    {
      return;
    }

  NS_LOG_DEBUG ("RvBatteryModel:Updating remaining energy!");

  m_currentSampleEvent.Cancel ();

  double currentLoad = CalculateTotalCurrent () * 1000; // must be in mA
  double calculatedAlpha = Discharge (currentLoad, Simulator::Now ());

  NS_LOG_DEBUG ("RvBatteryModel:Calculated alpha = " << calculatedAlpha <<
                " time = " << Simulator::Now ().GetSeconds ());

  // calculate battery level
  m_batteryLevel = 1 - (calculatedAlpha / m_alpha);
  if (m_batteryLevel < 0)
    {
      m_batteryLevel = 0;
    }

  // check if battery is dead.
  if (calculatedAlpha >= m_alpha)
    {
      m_lifetime = Simulator::Now ();
      NS_LOG_DEBUG ("RvBatteryModel:Battery is dead!");
      HandleEnergyDrainedEvent ();
      return; // stop periodic sampling
    }

  m_previousLoad = currentLoad;
  m_lastSampleTime = Simulator::Now ();
  m_currentSampleEvent = Simulator::Schedule (m_samplingInterval,
                                              &RvBatteryModel::UpdateEnergySource,
                                              this);
}

void
RvBatteryModel::SetSamplingInterval (Time interval)
{
  NS_LOG_FUNCTION (this << interval);
  m_samplingInterval = interval;
}

Time
RvBatteryModel::GetSamplingInterval (void) const
{
  return m_samplingInterval;
}

void
RvBatteryModel::SetOpenCircuitVoltage (double voltage)
{
  NS_LOG_FUNCTION (this << voltage);
  NS_ASSERT (voltage >= 0);
  m_openCircuitVoltage = voltage;
}

double
RvBatteryModel::GetOpenCircuitVoltage (void) const
{
  return m_openCircuitVoltage;
}

void
RvBatteryModel::SetCutoffVoltage (double voltage)
{
  NS_LOG_FUNCTION (this << voltage);
  NS_ASSERT (voltage <= m_openCircuitVoltage);
  m_cutoffVoltage = voltage;
}

double
RvBatteryModel::GetCutoffVoltage (void) const
{
  return m_cutoffVoltage;
}

void
RvBatteryModel::SetAlpha (double alpha)
{
  NS_LOG_FUNCTION (this << alpha);
  NS_ASSERT (alpha >= 0);
  m_alpha = alpha;
}

double
RvBatteryModel::GetAlpha (void) const
{
  return m_alpha;
}

void
RvBatteryModel::SetBeta (double beta)
{
  NS_LOG_FUNCTION (this << beta);
  NS_ASSERT (beta >= 0);
  m_beta = beta;
}

double
RvBatteryModel::GetBeta (void) const
{
  return m_beta;
}

double
RvBatteryModel::GetBatteryLevel (void)
{
  NS_LOG_FUNCTION (this);
  UpdateEnergySource ();
  return m_batteryLevel;
}

Time
RvBatteryModel::GetLifetime (void) const
{
  return m_lifetime;
}

void
RvBatteryModel::SetNumOfTerms (int num)
{
  NS_LOG_FUNCTION (this << num);
  m_numOfTerms = num;
}

int
RvBatteryModel::GetNumOfTerms (void) const
{
  return m_numOfTerms;
}

/*
 * Private functions start here.
 */

void
RvBatteryModel::DoStart (void)
{
  NS_LOG_DEBUG ("RvBatteryModel:Starting battery level update!");
  UpdateEnergySource ();  // start periodic sampling of load (total current)
}

void
RvBatteryModel::DoDispose (void)
{
  BreakDeviceEnergyModelRefCycle ();  // break reference cycle
}

void
RvBatteryModel::HandleEnergyDrainedEvent (void)
{
  NS_LOG_FUNCTION (this);
  NS_LOG_DEBUG ("RvBatteryModel:Energy depleted!");
  NotifyEnergyDrained (); // notify DeviceEnergyModel objects
}

double
RvBatteryModel::Discharge (double load, Time t)
{
  NS_LOG_FUNCTION (this << load << t);

  // record only when load changes
  if (load != m_previousLoad)
    {
      m_load.push_back (load);
      m_previousLoad = load;
      if (t != Seconds (0.0))
        {
          m_timeStamps[m_timeStamps.size () - 1] = m_lastSampleTime;
        }
      else
        {
          m_timeStamps.push_back (Seconds (0.0));
        }
      m_timeStamps.push_back (t);
    }
  else
    {
      m_timeStamps[m_timeStamps.size () - 1] = t;
    }

  m_lastSampleTime = t;

  // calculate alpha for new t
  NS_ASSERT (m_load.size () == m_timeStamps.size () - 1); // size must be equal
  double calculatedAlpha = 0.0;
  if (m_timeStamps.size () == 1)
    {
      // constant load
      calculatedAlpha = m_load[0] * RvModelAFunction (t, t, Seconds (0.0),
                                                      m_beta);
    }
  else
    {
      // changing load
      for (uint64_t i = 1; i < m_timeStamps.size (); i++)
        {
          calculatedAlpha += m_load[i - 1] * RvModelAFunction (t, m_timeStamps[i],
                                                               m_timeStamps[i - 1],
                                                               m_beta);
        }
    }

  return calculatedAlpha;
}

double
RvBatteryModel::RvModelAFunction (Time t, Time sk, Time sk_1, double beta)
{
  NS_LOG_FUNCTION (this << t << sk << sk_1 << beta);

  // everything is in minutes
  double firstDelta = (t.GetSeconds () - sk.GetSeconds ()) / 60;
  double secondDelta = (t.GetSeconds () - sk_1.GetSeconds ()) / 60;
  double delta = (sk.GetSeconds () - sk_1.GetSeconds ()) / 60;

  double sum = 0.0;
  for (int m = 1; m <= m_numOfTerms; m++)
    {
      double square = beta * beta * m * m;
      sum += (std::exp (-square * (firstDelta)) - std::exp (-square * (secondDelta))) / square;
    }
  return delta + 2 * sum;
}

} // namespace ns3