1

Topologas almbricas e
inalmbricas en NS2
Silva Gmez Ral Giovanni, Miembro Estudiantil, UAM

ResumenEn esta prctica utilizamos el simulador NS2

para construir diferentes topologas de red (anillo, bus, estrella y
malla), y se trat de entender ampliamente como implementar
los cdigos para cada topologa.
ndice de Trminos Nodo, NS2, OTcl, Topologa.
I. INTRODUCCIN

NS
Es un simulador de redes basado en eventos discretos, se usa
principalmente en ambientes educativos y de investigacin.
Permite simular tanto protocolos unicast como multicast y se
utiliza intensamente en la investigacin de redes mviles ad-hoc.
Implementa una amplia gama de protocolos tanto de redes
cableadas como de redes inalmbricas. La versin actual, ns-3,
est diseada para soportar todo el flujo de trabajo de la
simulacin desde la configuracin hasta la recoleccin y anlisis
de tramas.
Ns-2 [1] fue desarrollado en C++ y provee una interfaz de
simulacin a travs de OTcl, una variante Orientada a Objetos
de Tcl. El usuario describe una topologa de red por medio de
scripts OTcl, y luego el programa principal de ns-2 simular dicha
topologa utilizando los parmetros definidos. ns -2 esta diseado
para sistemas operativos Linux, FreeBSD,Solaris, Mac OS X.

servidores. El establecimiento de una red de malla es una manera

de encaminar datos, voz e instrucciones entre los nodos. Las
redes de malla se diferencian de otras redes en que los elementos
de la red (nodo) estn conectados todos con todos, mediante
cables separados. Esta configuracin ofrece caminos redundantes
por toda la red de modo que, si falla un cable, otro se har cargo
del trfico. Esta topologa, a diferencia de otras (como la
topologa en rbol y la topologa en estrella), no requiere de un
servidor o nodo central, con lo que se reduce el mantenimiento
(un error en un nodo, sea importante o no, no implica la cada de
toda la red). Las redes de malla son auto ruteables. La red puede
funcionar, incluso cuando un nodo desaparece o la conexin
falla, ya que el resto de los nodos evitan el paso por ese punto.
En consecuencia, la red malla, se transforma en una red muy
confiable. Una red con topologa en malla ofrece una
redundancia y fiabilidad superiores.

Topologa de Red
La topologa de red [2] se define como el mapa fsico o lgico
de una red para intercambiar datos. Es la forma en que est
diseada la red, sea en el plano fsico o lgico. El concepto de red
puede definirse como "conjunto de nodos interconectados". Un
nodo es el punto en el que una curva se intercepta a s misma. Lo
que un nodo es concretamente, depende del tipo de redes a que
nos refiramos.
La topologa de red la determina nicamente la configuracin
de las conexiones entre nodos. La distancia entre los nodos, las
interconexiones fsicas, las tasas de transmisin y los tipos de
seales no pertenecen a la topologa de la red, aunque pueden
verse afectados por la misma.
Topologa de Malla
La topologa en malla es una topologa de red en la que cada
nodo est conectado a todos los nodos. De esta manera es posible
llevar los mensajes de un nodo a otro por diferentes caminos. Si la
red de malla est completamente conectada, no puede existir
absolutamente ninguna interrupcin en las comunicaciones. Cada
servidor tiene sus propias conexiones con todos los dems

Figura 1. Topologa de malla.

Topologa de anillo
Topologa de red en la que cada estacin est conectada a la
siguiente y la ltima est conectada a la primera. Cada estacin
tiene un receptor y un transmisor que hace la funcin de
repetidor, pasando la seal a la siguiente estacin. En este tipo de
red la comunicacin se da por el paso de un token o testigo, que
se puede conceptualizar como un cartero que pasa recogiendo y
entregando paquetes de informacin, de esta manera se evitan
eventuales prdidas de informacin debidas a colisiones. Cabe
mencionar que si algn nodo de la red deja de funcionar, la
comunicacin en todo el anillo se pierde. En un anillo doble, dos
anillos permiten que los datos se enven en ambas direcciones.
Esta configuracin crea redundancia (tolerancia a fallos), lo que
significa que si uno de los anillos falla, los datos pueden
transmitirse por el otro.
Ventajas:
-Simplicidad de arquitectura. Facilidad de crecimiento.
Desventajas:
-Longitudes de canales limitadas.
-El canal usualmente degradar a medida que la red crece.

2
central activo que normalmente tiene los medios para prevenir
problemas relacionados con el eco. Se utiliza sobre todo para
redes locales. La mayora de las redes de rea local que tienen un
enrutador (router), un conmutador (switch) o un concentrador
(hub) siguen esta topologa. El nodo central en estas sera el
enrutador, el conmutador o el concentrador, por el que pasan
todos los paquetes.
Ventajas:
-Tiene dos medios para prevenir problemas.
-Permite que todos los nodos se comuniquen entre s.

Figura 2. Topologa de anillo.

Topologa de bus

Desventajas:
-Si el nodo central falla, toda la red se desconecta.
-Es costosa, ya que requiere ms cable que la topologa Bus
-El cable viaja por separado del hub.

Red cuya topologa se caracteriza por tener un nico canal de

comunicaciones (denominado bus o troncal) al cual se conectan
los diferentes dispositivos. De esta forma todos los dispositivos
comparten el mismo canal para comunicarse entre s. La
topologa de bus tiene todos sus nodos conectados directamente a
un enlace y no tiene ninguna otra conexin entre si. Fsicamente
cada host est conectado a un cable comn, por lo que se pueden
comunicar directamente. La ruptura del cable hace que los hosts
queden desconectados. Es la tercera de las topologas principales.
Las estaciones estn conectadas por un nico segmento de cable.
A diferencia de una red en anillo, el bus es pasivo, no se produce
generacin de seales en cada nodo.
Ventajas:
-Facilidad de implementacin y crecimiento.
-Econmica.
-Simplicidad en la arquitectura.
Desventajas:
-Longitudes de canal limitadas.
-Un problema en el canal usualmente degrada toda la red.
-El desempeo se disminuye a medida que la red crece.
-El canal requiere ser correctamente cerrado.
-Prdidas en la transmisin debido a colisiones entre mensajes.

Figura 4. Topologa de estrella

II. DESARROLLO
Material
1 PCs (Laptops)
Software NS2
Abrimos un editor de texto e introducimos el cdigo
correspondiente a cada topologa, despus ejecutamos lo
siguiente en la lnea de comandos:
ns topologia.tcl
A. Se crea la topologa anillo
#Create a simulator object
set ns [new Simulator]

Figura 3. Topologa de bus.

Topologa de estrella.
Una topologa en estrella es una red en la cual las estaciones
estn conectadas directamente a un punto central y todas las
comunicaciones que han de hacer necesariamente a travs de este.
Dado su transmisin, una red en estrella activa tiene un nodo

#Define different colors for data flows (for NAM)

$ns color 1 Blue
$ns color 2 Red
#Open the NAM trace file set nf [open out.nam w]
$ns namtrace-all $nf
#Define a 'finish' procedure
proc finish {} {

3
global ns nf
$ns flush-trace
#Close the NAM trace file
close $nf
#Execute NAM on the trace file
exec nam out.nam &
exit 0
}
#Create four nodes
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
#Create links between the nodes
$ns duplex-link $n0 $n1 2Mb 10ms DropTail
$ns duplex-link $n1 $n2 2Mb 10ms DropTail
$ns duplex-link $n2 $n3 2Mb 10ms DropTail
$ns duplex-link $n3 $n4 2Mb 10ms DropTail
$ns duplex-link $n4 $n5 2Mb 10ms DropTail
$ns duplex-link $n5 $n0 2Mb 10ms DropTail
#Set Queue Size of link to 10
$ns queue-limit $n0 $n1 10
$ns queue-limit $n1 $n2 10
$ns queue-limit $n2 $n3 10
$ns queue-limit $n3 $n4 10
$ns queue-limit $n4 $n5 10
$ns queue-limit $n5 $n0 10
#Give node position (for NAM)
$ns duplex-link-op $n0 $n1 orient left-down
$ns duplex-link-op $n1 $n2 orient right-down
$ns duplex-link-op $n2 $n3 orient right
$ns duplex-link-op $n3 $n4 orient right-up
$ns duplex-link-op $n4 $n5 orient left-up
$ns duplex-link-op $n5 $n0 orient left

$ftp set type_ FTP

#Setup a UDP connection
set udp [new Agent/UDP]
$ns attach-agent $n4 $udp
set null [new Agent/Null]
$ns attach-agent $n0 $null
$ns connect $udp $null
$udp set fid_ 2
#Setup a CBR over UDP connection
set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set type_ CBR
$cbr set packet_size_ 1000
$cbr set rate_ 1mb
$cbr set random_ false
#Schedule events for the CBR and FTP agents
$ns at 0.1 "$cbr start"
$ns at 1.0 "$ftp start"
$ns at 4.0 "$ftp stop"
$ns at 4.5 "$cbr stop"
#Detach tcp and sink agents (not really necessary)
$ns at 4.5 "$ns detach-agent $n0 $tcp ; $ns detach-agent $n3
$sink"

#Call the finish procedure after 5 seconds of simulation time

$ns at 5.0 "finish"
#Print CBR packet size and interval
puts "CBR packet size = [$cbr set packet_size_]"
puts "CBR interval = [$cbr set interval_]"
#Run the simulation
$ns run

#Monitor the queue for link . (for NAM)

$ns duplex-link-op $n0 $n1 queuePos 0.5
$ns duplex-link-op $n1 $n2 queuePos 0.5
$ns duplex-link-op $n2 $n3 queuePos 0.5
$ns duplex-link-op $n3 $n4 queuePos 0.5
$ns duplex-link-op $n4 $n5 queuePos 0.5
$ns duplex-link-op $n5 $n0 queuePos 0.5
#Setup a TCP connection
set tcp [new Agent/TCP]
$tcp set class_ 2
$ns attach-agent $n0 $tcp
set sink [new Agent/TCPSink]
$ns attach-agent $n3 $sink
$ns connect $tcp $sink
$tcp set fid_ 1
#Setup a FTP over TCP connection
set ftp [new Application/FTP]
$ftp attach-agent $tcp

Figura 5. Topologa de anillo en ns2.

B. Se crea la topologa estrella

#Creamos el objeto
set ns [new Simulator]
#Abrimos Xgraph
set nr [open tr1.tr w] $ns trace-all $nr

4
#Enrutamiento
$ns rtproto DV
#Abrimos el archivo nam
set nf [open tr1.nam w]
$ns namtrace-all $nf
#Definimos proceso "finish"
proc finish { } {
global ns nr nf
$ns flush-trace
close $nf
close $nr
exec nam tr1.nam &
exit 0
}
#Creamos nodos set
n0 [$ns node] set
n1 [$ns node] set
n2 [$ns node] set
n3 [$ns node] set
n4 [$ns node] set
n5 [$ns node] set
n6 [$ns node]
#Creamos conexiones:
$ns duplex-link $n0 $n2 1Mb 10ms DropTail
$ns duplex-link $n5 $n2 1Mb 10ms DropTail
$ns duplex-link $n1 $n2 1Mb 10ms DropTail
$ns duplex-link $n2 $n4 2Mb 10ms DropTail
$ns duplex-link $n2 $n6 2Mb 10ms DropTail
$ns duplex-link $n2 $n3 2Mb 10ms DropTail

$ns attach-agent $n4 $sink4

set sink6 [new Agent/TCPSink]
$ns attach-agent $n6 $sink6
set null3 [new Agent/Null]
$ns attach-agent $n3 $null3
$ns connect $tcp0 $sink4
$ns connect $udp1 $null3
$ns connect $tcp5 $sink6
#Colores de nodos
$tcp0 set fid_ 2
$ns color 2 Red
$tcp5 set fid_ 1
$ns color 1 Green
$udp1 set fid_ 3 $ns color 3 Blue
$ns at 0.5 "$cb1start"
$ns rtmodel-at 1.0 down $n0 $n2
$ns rtmodel-at 2.0 up $n5 $n2
$ns rtmodel-at 3.0 down $n1 $n2
$ns at 4.5 "$cb1 stop"
#Eventos programados
$ns at 1.0 "$ftp start"
$ns at 4.0 "$ftp stop"
$ns at 1.5 "$ftp5 start"
$ns at 4.2 "$ftp5 stop"
$ns at 0.1 "$cb1 start"
$ns at 4.5 "$cb1 stop"
$ns at 5.0 "finish"
$ns run

#Orientacion de nodos
$ns duplex-link-op $n0 $n2 orient right-down
$ns duplex-link-op $n5 $n2 orient right
$ns duplex-link-op $n1 $n2 orient right-up
$ns duplex-link-op $n2 $n4 orient right-up
$ns duplex-link-op $n2 $n6 orient right
$ns duplex-link-op $n2 $n3 orient right-down
#Conexiones
set tcp0 [new Agent/TCP]
$ns attach-agent $n0 $tcp0
set ftp [new Application/FTP]
$ftp attach-agent $tcp0

Figura 6. Topologa de estrella en ns2

B. Se crea la topologa malla

set tcp5 [new Agent/TCP]
$ns attach-agent $n5 $tcp5
set ftp5 [new Application/FTP]
$ftp5 attach-agent $tcp5
set udp1 [new Agent/UDP]
$ns attach-agent $n1 $udp1
set cb1 [new Application/Traffic/CBR]
$cb1 attach-agent $udp1
set sink4 [new Agent/TCPSink]

#Create a simulator object

set ns [new Simulator]
#Define different colors for data flows (for NAM)
$ns color 1 Blue
$ns color 2 Red
#Open the NAM trace file set nf [open out.nam w]
$ns namtrace-all $nf

#Define a 'finish' procedure

proc finish {} {
global ns nf
$ns flush-trace
#Close the NAM trace file
close $nf
#Execute NAM on the trace file
exec nam out.nam &
exit 0
}
#Create eight nodes
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
set n6 [$ns node]
set n7 [$ns node]
set n8 [$ns node]
#Create links between the nodes
$ns duplex-link $n0 $n1 2Mb 10ms DropTail
$ns duplex-link $n0 $n3 2Mb 10ms DropTail
$ns duplex-link $n1 $n2 2Mb 10ms DropTail
$ns duplex-link $n1 $n3 2Mb 10ms DropTail
$ns duplex-link $n1 $n4 2Mb 10ms DropTail
$ns duplex-link $n2 $n4 2Mb 10ms DropTail
$ns duplex-link $n2 $n5 2Mb 10ms DropTail
$ns duplex-link $n3 $n4 2Mb 10ms DropTail
$ns duplex-link $n3 $n6 2Mb 10ms DropTail
$ns duplex-link $n4 $n5 2Mb 10ms DropTail
$ns duplex-link $n4 $n6 2Mb 10ms DropTail
$ns duplex-link $n4 $n7 2Mb 10ms DropTail
$ns duplex-link $n5 $n8 2Mb 10ms DropTail
$ns duplex-link $n5 $n7 2Mb 10ms DropTail
$ns duplex-link $n6 $n7 2Mb 10ms DropTail
$ns duplex-link $n7 $n8 2Mb 10ms DropTail
#Set Queue Size of link to 10
$ns queue-limit $n0 $n1 10
$ns queue-limit $n0 $n3 10
$ns queue-limit $n1 $n2 10
$ns queue-limit $n1 $n3 10
$ns queue-limit $n1 $n4 10
$ns queue-limit $n2 $n4 10
$ns queue-limit $n2 $n5 10
$ns queue-limit $n3 $n4 10
$ns queue-limit $n3 $n6 10
$ns queue-limit $n4 $n5 10
$ns queue-limit $n4 $n6 10
$ns queue-limit $n4 $n7 10
$ns queue-limit $n5 $n8 10
$ns queue-limit $n5 $n7 10
$ns queue-limit $n6 $n7 10
$ns queue-limit $n7 $n8 10
#Give node position (for NAM)
$ns duplex-link-op $n0 $n1 orient right

$ns duplex-link-op $n1 $n2 orient right

$ns duplex-link-op $n0 $n3 orient down
$ns duplex-link-op $n1 $n4 orient down
$ns duplex-link-op $n2 $n5 orient down
$ns duplex-link-op $n3 $n6 orient down
$ns duplex-link-op $n4 $n7 orient down
$ns duplex-link-op $n5 $n8 orient down
#Monitor the queue for link . (for NAM)
$ns duplex-link-op $n0 $n1 queuePos 0.5
$ns duplex-link-op $n0 $n3 queuePos 0.5
$ns duplex-link-op $n1 $n2 queuePos 0.5
$ns duplex-link-op $n1 $n3 queuePos 0.5
$ns duplex-link-op $n1 $n4 queuePos 0.5
$ns duplex-link-op $n2 $n4 queuePos 0.5
$ns duplex-link-op $n2 $n5 queuePos 0.5
$ns duplex-link-op $n3 $n4 queuePos 0.5
$ns duplex-link-op $n3 $n6 queuePos 0.5
$ns duplex-link-op $n4 $n5 queuePos 0.5
$ns duplex-link-op $n4 $n6 queuePos 0.5
$ns duplex-link-op $n4 $n7 queuePos 0.5
$ns duplex-link-op $n5 $n8 queuePos 0.5
$ns duplex-link-op $n5 $n7 queuePos 0.5
$ns duplex-link-op $n6 $n7 queuePos 0.5
$ns duplex-link-op $n7 $n8 queuePos 0.5
#Setup a TCP connection
set tcp [new Agent/TCP]
$tcp set class_ 2
$ns attach-agent $n0 $tcp
set sink [new Agent/TCPSink]
$ns attach-agent $n5 $sink
$ns connect $tcp
$sink $tcp set fid_ 1
#Setup a FTP over TCP connection
set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ftp set type_ FTP
#Setup a UDP connection
set udp [new Agent/UDP]
$ns attach-agent $n3 $udp
set null [new Agent/Null]
$ns attach-agent $n8 $null
$ns connect $udp $null
$udp set fid_ 2
#Setup a CBR over UDP connection
set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set type_ CBR
$cbr set packet_size_ 1000
$cbr set rate_ 1mb
$cbr set random_ false
#Schedule events for the CBR and FTP agents
$ns at 0.1 "$cbr start"
$ns at 1.0 "$ftp start"
$ns at 4.0 "$ftp stop"
$ns at 4.5 "$cbr stop

6
#Detach tcp and sink agents (not really necessary)
$ns at 4.5 "$ns detach-agent $n0 $tcp ; $ns detach-agent $n3
$sink"
#Call the finish procedure after 5 seconds of simulation time
$ns at 5.0 "finish"
#Print CBR packet size and interval
puts "CBR packet size = [$cbr set packet_size_]"
puts "CBR interval = [$cbr set interval_]"
#Run the simulation
$ns run

Figura 7. Topologa de malla en ns2

III. CONCLUSION
Esta prctica comprendimos como trabajar con el simulador NS2
para crear redes de comunicaciones en sus distintos tipos de
topologas.
Este simulador ayuda a ver el comportamiento de una red, el
trfico que se puede ocasionar en diferentes nodos, el tipo de
conexin, el orden de como de se pueden comunicar los nodos, el
tamao y velocidad de conexin de la red, etc.
En el simulador NS2, y la herramienta MAP, nos ayuda a
visualizar la red, con scripts que uno puede generar.

IV. REFERENCIAS
[1]
[2]

https://www.tlm.unavarra.es/
http://es.wikipedia.org/wiki/Telnet