Attachment #2160 for bug #2190

View | Details | Raw Unified | Return to bug 2190
Collapse All | Expand All

(-)a/src/lr-wpan/model/lr-wpan-phy.cc (-3 / +4 lines)

Lines 546-551	Link Here

546

          LrWpanLqiTag lqiTag;

546

          LrWpanLqiTag lqiTag;

547

          p->RemovePacketTag (lqiTag);

547

          p->RemovePacketTag (lqiTag);

548

549

          m_phyTxBeginTrace (p);

550

          m_currentTxPacket.first = p;

551

          m_currentTxPacket.second = false;

552

549

          Ptr<LrWpanSpectrumSignalParameters> txParams = Create<LrWpanSpectrumSignalParameters> ();

553

          Ptr<LrWpanSpectrumSignalParameters> txParams = Create<LrWpanSpectrumSignalParameters> ();

550

          txParams->duration = CalculateTxTime (p);

554

          txParams->duration = CalculateTxTime (p);

551

          txParams->txPhy = GetObject<SpectrumPhy> ();

555

          txParams->txPhy = GetObject<SpectrumPhy> ();

Lines 557-565	Link Here

557

          m_channel->StartTx (txParams);

561

          m_channel->StartTx (txParams);

558

          m_pdDataRequest = Simulator::Schedule (txParams->duration, &LrWpanPhy::EndTx, this);

562

          m_pdDataRequest = Simulator::Schedule (txParams->duration, &LrWpanPhy::EndTx, this);

559

          ChangeTrxState (IEEE_802_15_4_PHY_BUSY_TX);

563

          ChangeTrxState (IEEE_802_15_4_PHY_BUSY_TX);

560

          m_phyTxBeginTrace (p);

561

          m_currentTxPacket.first = p;

562

          m_currentTxPacket.second = false;

563

          return;

564

          return;

564

565

      else if ((m_trxState == IEEE_802_15_4_PHY_RX_ON)

566

      else if ((m_trxState == IEEE_802_15_4_PHY_RX_ON)




#include "ns3/simulator.h"
#include "ns3/wifi-mac-header.h"
#include "ns3/wimax-mac-header.h"
#include "ns3/lr-wpan-mac-header.h"
#include "ns3/wifi-net-device.h"
#include "ns3/wifi-mac.h"
#include "ns3/constant-position-mobility-model.h"

#include "ns3/ipv4.h"
#include "ns3/ipv4-routing-protocol.h"
#include "ns3/energy-source-container.h"
#include "ns3/lr-wpan-net-device.h"

namespace ns3 {


      PurgePendingPackets (AnimationInterface::WIMAX);
      PurgePendingPackets (AnimationInterface::LTE);
      PurgePendingPackets (AnimationInterface::CSMA);
      PurgePendingPackets (AnimationInterface::LRWPAN);
      Simulator::Schedule (m_mobilityPollInterval, &AnimationInterface::MobilityAutoCheck, this);
    }
}

    }
  else
    {
      NS_ASSERT_MSG (0, "No AnimUid found");
      return 0;
    }
}

}

void
AnimationInterface::LrWpanMacTxTrace (std::string context, Ptr<const Packet> p)
{
  const Ptr <const Node> node = GetNodeFromContext (context);
  ++m_nodeLrWpanMacTx[node->GetId ()];
}

void
AnimationInterface::LrWpanMacTxDropTrace (std::string context, Ptr<const Packet> p)
{
  const Ptr <const Node> node = GetNodeFromContext (context);
  ++m_nodeLrWpanMacTxDrop[node->GetId ()];
}

void
AnimationInterface::LrWpanMacRxTrace (std::string context, Ptr<const Packet> p)
{
  const Ptr <const Node> node = GetNodeFromContext (context);
  ++m_nodeLrWpanMacRx[node->GetId ()];
}

void
AnimationInterface::LrWpanMacRxDropTrace (std::string context, Ptr<const Packet> p)
{
  const Ptr <const Node> node = GetNodeFromContext (context);
  ++m_nodeLrWpanMacRxDrop[node->GetId ()];
}

void
AnimationInterface::Ipv4TxTrace (std::string context, Ptr<const Packet> p, Ptr<Ipv4> ipv4, uint32_t interfaceIndex)
{
  const Ptr <const Node> node = GetNodeFromContext (context);

}

void 
AnimationInterface::LrWpanPhyTxBeginTrace (std::string context,
                                           Ptr<const Packet> p)
{
  if (!m_started || !IsInTimeWindow () || !m_trackPackets)
    return;

  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
  NS_ASSERT (ndev);
  Ptr<LrWpanNetDevice> netDevice = DynamicCast<LrWpanNetDevice> (ndev);

  Ptr <Node> n = ndev->GetNode ();
  NS_ASSERT (n);

  UpdatePosition (n);

  LrWpanMacHeader hdr;
  if (!p->PeekHeader (hdr))
  {
    NS_LOG_WARN ("LrWpanMacHeader not present");
    return;
  }

  std::ostringstream oss;
  if (hdr.GetSrcAddrMode () == 2)
    {
      Mac16Address nodeAddr = netDevice->GetMac ()->GetShortAddress ();
      oss << nodeAddr;
    }
  else if (hdr.GetSrcAddrMode () == 3)
    {
      Mac64Address nodeAddr = netDevice->GetMac ()->GetExtendedAddress ();
      oss << nodeAddr;
    }
  else
    {
      NS_LOG_WARN ("LrWpanMacHeader without source address");
      return;
    }
  m_macToNodeIdMap[oss.str ()] = n->GetId ();
  NS_LOG_INFO ("Added Mac" << oss.str () << " node:" <<m_macToNodeIdMap[oss.str ()]);

  ++gAnimUid;
  NS_LOG_INFO ("LrWpan TxBeginTrace for packet:" << gAnimUid);
  AddByteTag (gAnimUid, p);

  AnimPacketInfo pktInfo (ndev, Simulator::Now ());
  AddPendingPacket (AnimationInterface::LRWPAN, gAnimUid, pktInfo);

  OutputWirelessPacketTxInfo (p, m_pendingLrWpanPackets[gAnimUid], gAnimUid);
}

void
AnimationInterface::LrWpanPhyRxBeginTrace (std::string context,
                                           Ptr<const Packet> p)
{
  if (!m_started || !IsInTimeWindow () || !m_trackPackets)
    return;
  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
  NS_ASSERT (ndev);
  Ptr <Node> n = ndev->GetNode ();
  NS_ASSERT (n);

  AnimByteTag tag;
  if (!p->FindFirstMatchingByteTag (tag))
    {
      return;
    }

  uint64_t animUid = GetAnimUidFromPacket (p);
  NS_LOG_INFO ("LrWpan RxBeginTrace for packet:" << animUid);
  if (!IsPacketPending (animUid, AnimationInterface::LRWPAN))
    {
      NS_LOG_WARN ("LrWpanPhyRxBeginTrace: unknown Uid - most probably it's an ACK.");
    }

  UpdatePosition (n);
  m_pendingLrWpanPackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ());
  OutputWirelessPacketRxInfo (p, m_pendingLrWpanPackets[animUid], animUid);
}

void
AnimationInterface::WimaxTxTrace (std::string context, Ptr<const Packet> p, const Mac48Address & m)
{
  if (!m_started || !IsInTimeWindow () || !m_trackPackets)

          pendingPackets = &m_pendingLtePackets;
          break;
        }
      case AnimationInterface::LRWPAN:
        {
          pendingPackets = &m_pendingLrWpanPackets;
          break;
        }
    }
  return pendingPackets;


                   MakeCallback (&AnimationInterface::WifiPhyTxDropTrace, this));
  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxDrop",
                   MakeCallback (&AnimationInterface::WifiPhyRxDropTrace, this));

  // LrWpan
  Config::Connect ("NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Phy/PhyTxBegin",
                   MakeCallback (&AnimationInterface::LrWpanPhyTxBeginTrace, this));
  Config::Connect ("NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Phy/PhyRxBegin",
                   MakeCallback (&AnimationInterface::LrWpanPhyRxBeginTrace, this));
  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacTx",
                   MakeCallback (&AnimationInterface::LrWpanMacTxTrace, this));
  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacTxDrop",
                   MakeCallback (&AnimationInterface::LrWpanMacTxDropTrace, this));
  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacRx",
                   MakeCallback (&AnimationInterface::LrWpanMacRxTrace, this));
  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacRxDrop",
                   MakeCallback (&AnimationInterface::LrWpanMacRxDropTrace, this));
}

Vector 

(-)a/src/netanim/model/animation-interface.h (-3 / +21 lines)

Lines 495-501	Link Here

495

      LTE,

495

      LTE,

496

      WIFI,

496

      WIFI,

497

      WIMAX,

497

      WIMAX,

498

      CSMA

498

      CSMA,

499

      LRWPAN

499

    } ProtocolType;

500

    } ProtocolType;

500

501

  typedef struct

502

  typedef struct

Lines 588-593	Link Here

588

  AnimUidPacketInfoMap m_pendingLtePackets;

589

  AnimUidPacketInfoMap m_pendingLtePackets;

589

  AnimUidPacketInfoMap m_pendingCsmaPackets;

590

  AnimUidPacketInfoMap m_pendingCsmaPackets;

590

  AnimUidPacketInfoMap m_pendingUanPackets;

591

  AnimUidPacketInfoMap m_pendingUanPackets;

592

  AnimUidPacketInfoMap m_pendingLrWpanPackets;

591

  std::map <uint32_t, Vector> m_nodeLocation;

593

  std::map <uint32_t, Vector> m_nodeLocation;

592

  std::map <std::string, uint32_t> m_macToNodeIdMap;

594

  std::map <std::string, uint32_t> m_macToNodeIdMap;

593

  std::map <std::string, uint32_t> m_ipv4ToNodeIdMap;

595

  std::map <std::string, uint32_t> m_ipv4ToNodeIdMap;

Lines 614-619	Link Here

614

  NodeCounterMap64 m_nodeWifiMacRxDrop;

616

  NodeCounterMap64 m_nodeWifiMacRxDrop;

615

  NodeCounterMap64 m_nodeWifiPhyTxDrop;

617

  NodeCounterMap64 m_nodeWifiPhyTxDrop;

616

  NodeCounterMap64 m_nodeWifiPhyRxDrop;

618

  NodeCounterMap64 m_nodeWifiPhyRxDrop;

619

  NodeCounterMap64 m_nodeLrWpanMacTx;

620

  NodeCounterMap64 m_nodeLrWpanMacTxDrop;

621

  NodeCounterMap64 m_nodeLrWpanMacRx;

622

  NodeCounterMap64 m_nodeLrWpanMacRxDrop;

617

623

618

  const std::vector<std::string> GetElementsFromContext (const std::string& context) const;

624

  const std::vector<std::string> GetElementsFromContext (const std::string& context) const;

619

  Ptr <Node> GetNodeFromContext (const std::string& context) const;

625

  Ptr <Node> GetNodeFromContext (const std::string& context) const;

Lines 681-689	Link Here

681

  void WifiMacRxDropTrace (std::string context,

687

  void WifiMacRxDropTrace (std::string context,

682

                           Ptr<const Packet>);

688

                           Ptr<const Packet>);

683

  void WifiPhyTxDropTrace (std::string context,

689

  void WifiPhyTxDropTrace (std::string context,

684

                       Ptr<const Packet>);

690

                           Ptr<const Packet>);

685

  void WifiPhyRxDropTrace (std::string context,

691

  void WifiPhyRxDropTrace (std::string context,

686

                       Ptr<const Packet>);

692

                           Ptr<const Packet>);

693

  void LrWpanMacTxTrace (std::string context,

694

                         Ptr<const Packet>);

695

  void LrWpanMacTxDropTrace (std::string context,

696

                             Ptr<const Packet>);

697

  void LrWpanMacRxTrace (std::string context,

698

                         Ptr<const Packet>);

699

  void LrWpanMacRxDropTrace (std::string context,

700

                             Ptr<const Packet>);

687

  void DevTxTrace (std::string context,

701

  void DevTxTrace (std::string context,

688

                   Ptr<const Packet> p,

702

                   Ptr<const Packet> p,

689

                   Ptr<NetDevice> tx,

703

                   Ptr<NetDevice> tx,

Lines 694-699	Link Here

694

                            Ptr<const Packet> p);

708

                            Ptr<const Packet> p);

695

  void WifiPhyRxBeginTrace (std::string context,

709

  void WifiPhyRxBeginTrace (std::string context,

696

                            Ptr<const Packet> p);

710

                            Ptr<const Packet> p);

711

  void LrWpanPhyTxBeginTrace (std::string context,

712

                              Ptr<const Packet> p);

713

  void LrWpanPhyRxBeginTrace (std::string context,

714

                              Ptr<const Packet> p);

697

  void WimaxTxTrace (std::string context,

715

  void WimaxTxTrace (std::string context,

698

                     Ptr<const Packet> p,

716

                     Ptr<const Packet> p,

699

		     const Mac48Address &);

717

		     const Mac48Address &);

(-)a/src/netanim/wscript (-1 / +1 lines)

Lines 6-12	Link Here

NETANIM_RELEASE_NAME = "netanim-3.106"

NETANIM_RELEASE_NAME = "netanim-3.106"

def build (bld) :

def build (bld) :

    module = bld.create_ns3_module ('netanim', ['internet', 'mobility', 'wimax', 'wifi', 'csma', 'lte', 'uan', 'energy'])

    module = bld.create_ns3_module ('netanim', ['internet', 'mobility', 'wimax', 'wifi', 'csma', 'lte', 'uan', 'energy', 'lr-wpan'])

    module.includes = '.'

    module.includes = '.'

    module.source = [ 'model/animation-interface.cc', ]

    module.source = [ 'model/animation-interface.cc', ]

    netanim_test = bld.create_ns3_module_test_library('netanim')

    netanim_test = bld.create_ns3_module_test_library('netanim')

Return to bug 2190