A Discrete-Event Network Simulator
API
wifi-example-apps.cc
Go to the documentation of this file.
1/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 as
5 * published by the Free Software Foundation;
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 *
16 * Authors: Joe Kopena <tjkopena@cs.drexel.edu>
17 *
18 * These applications are used in the WiFi Distance Test experiment,
19 * described and implemented in test02.cc. That file should be in the
20 * same place as this file. The applications have two very simple
21 * jobs, they just generate and receive packets. We could use the
22 * standard Application classes included in the NS-3 distribution.
23 * These have been written just to change the behavior a little, and
24 * provide more examples.
25 *
26 */
27
28#include <ostream>
29
30#include "ns3/core-module.h"
31#include "ns3/network-module.h"
32#include "ns3/internet-module.h"
33
34#include "ns3/stats-module.h"
35
36#include "wifi-example-apps.h"
37
38using namespace ns3;
39
40NS_LOG_COMPONENT_DEFINE ("WiFiDistanceApps");
41
44{
45 static TypeId tid = TypeId ("Sender")
47 .AddConstructor<Sender> ()
48 .AddAttribute ("PacketSize", "The size of packets transmitted.",
49 UintegerValue (64),
51 MakeUintegerChecker<uint32_t>(1))
52 .AddAttribute ("Destination", "Target host address.",
53 Ipv4AddressValue ("255.255.255.255"),
54 MakeIpv4AddressAccessor (&Sender::m_destAddr),
55 MakeIpv4AddressChecker ())
56 .AddAttribute ("Port", "Destination app port.",
57 UintegerValue (1603),
59 MakeUintegerChecker<uint32_t>())
60 .AddAttribute ("NumPackets", "Total number of packets to send.",
61 UintegerValue (30),
63 MakeUintegerChecker<uint32_t>(1))
64 .AddAttribute ("Interval", "Delay between transmissions.",
65 StringValue ("ns3::ConstantRandomVariable[Constant=0.5]"),
67 MakePointerChecker <RandomVariableStream>())
68 .AddTraceSource ("Tx", "A new packet is created and is sent",
70 "ns3::Packet::TracedCallback")
71 ;
72 return tid;
73}
74
75
77{
79 m_interval = CreateObject<ConstantRandomVariable> ();
80 m_socket = 0;
81}
82
84{
86}
87
88void
90{
92
93 m_socket = 0;
94 // chain up
95 Application::DoDispose ();
96}
97
99{
101
102 if (!m_socket) {
104 (UdpSocketFactory::GetTypeId ());
105 m_socket = socketFactory->CreateSocket ();
106 m_socket->Bind ();
107 }
108
109 m_count = 0;
110
111 Simulator::Cancel (m_sendEvent);
112 m_sendEvent = Simulator::ScheduleNow (&Sender::SendPacket, this);
113
114 // end Sender::StartApplication
115}
116
118{
120 Simulator::Cancel (m_sendEvent);
121 // end Sender::StopApplication
122}
123
125{
126 // NS_LOG_FUNCTION_NOARGS ();
127 NS_LOG_INFO ("Sending packet at " << Simulator::Now () << " to " <<
128 m_destAddr);
129
130 Ptr<Packet> packet = Create<Packet>(m_pktSize);
131
132 TimestampTag timestamp;
133 timestamp.SetTimestamp (Simulator::Now ());
134 packet->AddByteTag (timestamp);
135
136 // Could connect the socket since the address never changes; using SendTo
137 // here simply because all of the standard apps do not.
139
140 // Report the event to the trace.
141 m_txTrace (packet);
142
143 if (++m_count < m_numPkts) {
144 m_sendEvent = Simulator::Schedule (Seconds (m_interval->GetValue ()),
145 &Sender::SendPacket, this);
146 }
147
148 // end Sender::SendPacket
149}
150
151
152
153
154//----------------------------------------------------------------------
155//-- Receiver
156//------------------------------------------------------
157TypeId
159{
160 static TypeId tid = TypeId ("Receiver")
162 .AddConstructor<Receiver> ()
163 .AddAttribute ("Port", "Listening port.",
164 UintegerValue (1603),
166 MakeUintegerChecker<uint32_t>())
167 ;
168 return tid;
169}
170
172 m_calc (0),
173 m_delay (0)
174{
176 m_socket = 0;
177}
178
180{
182}
183
184void
186{
188
189 m_socket = 0;
190 // chain up
191 Application::DoDispose ();
192}
193
194void
196{
198
199 if (!m_socket) {
201 (UdpSocketFactory::GetTypeId ());
202 m_socket = socketFactory->CreateSocket ();
203 InetSocketAddress local =
204 InetSocketAddress (Ipv4Address::GetAny (), m_port);
205 m_socket->Bind (local);
206 }
207
209
210 // end Receiver::StartApplication
211}
212
213void
215{
217
218 if (m_socket) {
220 }
221
222 // end Receiver::StopApplication
223}
224
225void
227{
228 m_calc = calc;
229 // end Receiver::SetCounter
230}
231void
233{
234 m_delay = delay;
235 // end Receiver::SetDelayTracker
236}
237
238void
240{
241 // NS_LOG_FUNCTION (this << socket << packet << from);
242
243 Ptr<Packet> packet;
244 Address from;
245 while ((packet = socket->RecvFrom (from))) {
246 if (InetSocketAddress::IsMatchingType (from)) {
247 NS_LOG_INFO ("Received " << packet->GetSize () << " bytes from " <<
248 InetSocketAddress::ConvertFrom (from).GetIpv4 ());
249 }
250
251 TimestampTag timestamp;
252 // Should never not be found since the sender is adding it, but
253 // you never know.
254 if (packet->FindFirstMatchingByteTag (timestamp)) {
255 Time tx = timestamp.GetTimestamp ();
256
257 if (m_delay) {
258 m_delay->Update (Simulator::Now () - tx);
259 }
260 }
261
262 if (m_calc) {
263 m_calc->Update ();
264 }
265
266 // end receiving packets
267 }
268
269 // end Receiver::Receive
270}
271
272
273
274
275//----------------------------------------------------------------------
276//-- TimestampTag
277//------------------------------------------------------
278TypeId
280{
281 static TypeId tid = TypeId ("TimestampTag")
282 .SetParent<Tag> ()
283 .AddConstructor<TimestampTag> ()
284 .AddAttribute ("Timestamp",
285 "Some momentous point in time!",
289 ;
290 return tid;
291}
292TypeId
294{
295 return GetTypeId ();
296}
297
300{
301 return 8;
302}
303void
305{
306 int64_t t = m_timestamp.GetNanoSeconds ();
307 i.Write ((const uint8_t *)&t, 8);
308}
309void
311{
312 int64_t t;
313 i.Read ((uint8_t *)&t, 8);
315}
316
317void
319{
320 m_timestamp = time;
321}
322Time
324{
325 return m_timestamp;
326}
327
328void
329TimestampTag::Print (std::ostream &os) const
330{
331 os << "t=" << m_timestamp;
332}
uint32_t m_port
Listening port.
virtual void StopApplication(void)
Application specific shutdown code.
virtual ~Receiver()
Ptr< Socket > m_socket
Receiving socket.
void SetDelayTracker(Ptr< TimeMinMaxAvgTotalCalculator > delay)
Set the delay tracker for received packets.
void Receive(Ptr< Socket > socket)
Receive a packet.
virtual void StartApplication(void)
Application specific startup code.
static TypeId GetTypeId(void)
Get the type ID.
Ptr< CounterCalculator<> > m_calc
Counter of the number of received packets.
void SetCounter(Ptr< CounterCalculator<> > calc)
Set the counter calculator for received packets.
Ptr< TimeMinMaxAvgTotalCalculator > m_delay
Delay calculator.
virtual void DoDispose(void)
Destructor implementation.
Ptr< Socket > m_socket
Sending socket.
void SendPacket()
Send a packet.
uint32_t m_count
Number of packets sent.
uint32_t m_destPort
Destination port.
Ptr< ConstantRandomVariable > m_interval
Rng for sending packets.
static TypeId GetTypeId(void)
Get the type ID.
Ipv4Address m_destAddr
Destination address.
virtual void StartApplication(void)
Application specific startup code.
EventId m_sendEvent
Send packet event.
uint32_t m_numPkts
Number of packets to send.
virtual ~Sender()
virtual void DoDispose(void)
Destructor implementation.
TracedCallback< Ptr< const Packet > > m_txTrace
Tx TracedCallback.
uint32_t m_pktSize
The packet size.
virtual void StopApplication(void)
Application specific shutdown code.
Timestamp tag - it carries when the packet has been sent.
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
void Print(std::ostream &os) const
static TypeId GetTypeId(void)
Get the type ID.
void SetTimestamp(Time time)
Set the timestamp.
virtual void Serialize(TagBuffer i) const
virtual uint32_t GetSerializedSize(void) const
virtual void Deserialize(TagBuffer i)
Time GetTimestamp(void) const
Get the timestamp.
Time m_timestamp
Timestamp.
a polymophic address class
Definition: address.h:91
The base class for all ns3 applications.
Definition: application.h:61
Ptr< Node > GetNode() const
Definition: application.cc:104
double GetValue(double constant)
Get the next random value, as a double equal to the argument.
Template class CounterCalculator.
A class for an empty attribute value.
Definition: attribute.h:233
an Inet address class
AttributeValue implementation for Ipv4Address.
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
bool FindFirstMatchingByteTag(Tag &tag) const
Finds the first tag matching the parameter Tag type.
Definition: packet.cc:939
void AddByteTag(const Tag &tag) const
Tag each byte included in this packet with a new byte tag.
Definition: packet.cc:912
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:856
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
Object to create transport layer instances that provide a socket API to applications.
virtual Ptr< Packet > RecvFrom(uint32_t maxSize, uint32_t flags, Address &fromAddress)=0
Read a single packet from the socket and retrieve the sender address.
void SetRecvCallback(Callback< void, Ptr< Socket > > receivedData)
Notify application when new data is available to be read.
Definition: socket.cc:128
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
virtual int SendTo(Ptr< Packet > p, uint32_t flags, const Address &toAddress)=0
Send data to a specified peer.
Hold variables of type string.
Definition: string.h:41
read and write tag data
Definition: tag-buffer.h:52
void Read(uint8_t *buffer, uint32_t size)
Definition: tag-buffer.cc:176
void Write(const uint8_t *buffer, uint32_t size)
Definition: tag-buffer.cc:125
tag a set of bytes in a packet
Definition: tag.h:37
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
int64_t GetNanoSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:392
void Update(const Time i)
Updates all variables of TimeMinMaxAvgTotalCalculator.
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
Hold an unsigned integer type.
Definition: uinteger.h:44
Ptr< const AttributeAccessor > MakePointerAccessor(T1 a1)
Definition: pointer.h:227
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition: nstime.h:1310
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:45
Callback< R, Args... > MakeNullCallback(void)
Definition: callback.h:697
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:206
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:282
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:287
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1269
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1245
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Create a TraceSourceAccessor which will control access to the underlying trace source.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:661
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:522