Entrada # 9 - Laboratorio

Laboratorio de 

Redes de Telecomunicaciones

Energy-Aware Routing in Cluster-Based 

Sensor Networks

Mohamed Younis

Moustafa Youssef

Khaled Arisha

En este artículo nos presenta un enfoque novedoso para el enrutamiento consciente de energía y consciente del contexto de los sensores de datos.

Este enfoque consiste en llamar a la red de agrupamiento y le asigna al nodo del gateway menos energía para que actué como un gestor de red centralizada.

Este enfoque basa en el uso de energía en cada nodo sensor y los cambios en el medio ambiente y en la misión para que el gateway establezca las rutas de datos de los sensores, controlar la latencia en todo el cluster y arbitrar el acceso entre los sensores.

La imagen siguiente nos explica el proceso aplicándolo cuando fuera :

Para una red de un solo cluster cuando alguien desee comunicarse a un nodo este debe de solicitárselo al gateway el cuál establece la ruta para llegar al nodo (como va a pasar por varios puntos alimentaria la perdida de energía sería proporcional), en lugar de la manera tradicional (hacer un recorrido directo de un punto a otro lo que ocasionaría perdida de energía o que se consuma mas energía de la que requiera).


Su fuera una red de varios clusters, cada uno de estos tendrían su propio gateway y estos a su vez estarían comunicados y la forma de trabajar sería la misma que con un solo cluster solo que cuando se requiera comunicar con un nodo de otro cluster el gateway se conecta con el otro a fin de evitar que la persona tenga que desconectarse de este y entrar al correcto.

El problema de los sensores utilizados es que ya que son desechables (dejan de funcionar cuando se quedan sin energía), se tiene que administrar la energía de estos a fin de que duren el mayor tiempo posible y evitar el tener que cambiar un sensor por otro.

Critica Constructiva

Esta manera me parece muy buena ya que trabajando mediante cluster nos permitiría que la distribución de la energía de cada sensor sea equitativa.

En lugar de la forma común que sería comunicar de un punto a otro haciendo que estos tengan un consumo mayor a los demás nodos que están en el cluster.

Referencia

http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=1167069

Entrada # 5 - Materia

Redes de Telecomunicaciones

Control de Congestión con ns2

Código Utilizado

	puts "Ejecutando el Simulador"
	#Creando el simulador
	set ns [new Simulator]
	set sal1 [open sal1.tr w]
	set sal2 [open sal2.tr w]
	set n0 [$ns node]
	set n1 [$ns node]
	set n2 [$ns node]
	set n3 [$ns node]
	$ns duplex-link $n0 $n2 2Mb 100ms DropTail
	$ns duplex-link $n1 $n2 2Mb 100ms DropTail
	$ns duplex-link $n2 $n3 1Mb 200ms DropTail
	#Procedure "finish"
	proc finish {} {
	global sal1 sal2
	close $sal1
	close $sal2
	exec xgraph sal1.tr sal2.tr -geometry 800x400 &
	exit 0
	}
	#Se crea una funcion la cuál regresa el trafico del nodo y el sink que esta conectado asi como otras variables
	proc proctrafico { nodo sink tamano burst idle laten } {
	#Obtener la instancia del simulador
	set ns [Simulator instance]
	set source [new Agent/UDP]
	$ns attach-agent $nodo $source
	set trafico [new Application/Traffic/Exponential]
	$trafico set packetSise_ $tamano
	$trafico set burst_time_ $burst
	$trafico set idle_time_ $idle
	$trafico set rate_ $laten
	$trafico attach-agent $source
	$ns connect $source $sink
	return $trafico
	}
	proc monitoreo {} {
	global sinks1 sinks2 sal1 sal2
	set ns [Simulator instance]
	set time 0.5
	set OK [$sinks1 set bytes_]
	set Lost [$sinks2 set nlost_]
	set var1 [expr $OK/$time*8/1000000]
	#Tiempo actual del simulador
	set tactual [$ns now]
	puts $sal1 "$tactual $OK"
	puts $sal2 "$tactual $Lost"
	puts "Bytes $var1"
	#Si se va a sobrepasar el ancho de banda seteamos la cantidad de datos a enviar
	if {$var1>1} {
	$sinks1 set bytes_ 0
	}
	if {$var1<0.5} {
	$sinks2 set packetSise 100
	}
	#Se vuelve a llamar al proceso 0.5s despues de la ejecucion que acaba de terminar
	$ns at [expr $tactual+$time] "monitoreo"
	}
	set sinks1 [new Agent/LossMonitor]
	set sinks2 [new Agent/LossMonitor]
	$ns attach-agent $n3 $sinks1
	$ns attach-agent $n3 $sinks2
	set source1 [proctrafico $n0 $sinks1 200 2s 1s 100k]
	set source2 [proctrafico $n1 $sinks2 200 2s 1s 100k]
	$ns at 0.0 "monitoreo"
	$ns at 1.0 "$source1 start"
	$ns at 1.0 "$source2 start"
	$ns at 8.0 "$source1 stop"
	$ns at 8.0 "$source2 stop"
	$ns at 9.0 "finish"
	$ns run

view raw Tarea5.tcl hosted with ❤ by GitHub

Graficas

En la gráfica siguiente la franja roja son la cantidad de paquetes enviados y la línea verde es la cantidad de paquetes perdidos.

Como ven no existe perdida de paquetes.

Entrada # 8 - Laboratorio

Laboratorio de 

Redes de Telecomunicaciones

A Survey on TCP-Friendly Congestion Control

Joerg Widmer, Robert Denda, and Martin Mauve

En este articulo nos muestra un estudio acerca de la clasificación de los protocolos TCP-Friendly incluyendo los tipos de congestiones en los que se puede dividir así como la clasificación de cada uno y los protocolos que están en cada lista.

En la siguiente imagen nos muestra todo la clasificación.

Por consiguiente comenzare a explicar cada punto de la clasificación, iniciando desde lo que es el TCP-Friendly hasta los protocolos.

Comenzando

Primeramente el protocolo TCP es utilizado transferencia de datos mediante una conexión unicast (envío de información desde un emisor único a un receptor único).

TCP-Friendly.- Se les conoce al flujo de las conexiones No-TCP, cuando el rendimiento a largo plazo de estas no supere el rendimiento de una conexión TCP estando en las mismas condiciones.

La congestión que pueden tener el TCP-Friendly se divide en dos tipos:

TCP Friendliness para Unicast (Single-Rate).- Son cuando se tiene un flujo unicast (envío de un emisor a un receptor) y el rendimiento a largo plazo de este no reduce el de otro TCP que coexista al mismo en tiempo en comparación a si se tiene un flujo TCP que tiene en el mismo camino otro TCP que haría que el rendimiento de la segundo disminuya.

TCP Friendliness para Multicast (Multirate).- Se les conoce así a los flujos multicast (un emisor y múltiples destinatarios) cuando para cada par de receptor-emisor, el flujo multicast tiene la propiedad de ser TCP-Friendly unicast.

En el articulo menciona que los dos tipos de congestión anteriores se pueden clasificar según su carga de red basándose en:

Window-Based (Ventana de Congestión).- Utilizan una ventana de congestión que puede ir en el emisor o en el receptor con el fin de garantizar que se cumpla el TCP-Friendly. En estos cada paquete a transmitir ocupa una ranura en esta ventana la cuál se liberara hasta que se haya recibido la notificación de que el paquete haya llegado al receptor (Este proceso es parecido al TCP).

El emisor esta autorizado para transmitir paquetes cuando cuente con una ranura libre.

Rate-Based (Velocidad de Transmisión) .- En estos para que se cumpla el TCP-Friendly la velocidad de transmisión se adapta gracias a algún mecanismo de red que indique si exista alguna congestión.

Los anteriores aplican tanto para TCP Friendly Unicast y Multicast.

Protocolos del TCP Friendly Unicast basados en la Velocidad de Transmisión:

En este apartado están los siguientes protocolos:

RAP (Rate Adaption Protocol - Protocolo de Adaptación de Velocidad).- En este cada paquete es reconocido por el receptor. Utiliza los ACK (informa cuando se envío un paquete) para detectar si hubo perdida de paquetes. En este protocolo cuando ocurre la congestión la tasa de envío se reduce a la mitad, en caso contrario la tasa se incrementa en 1 paquete.

LDA+.- Se basa en el Protocolo de control de transporte en Tiempo Real (RTCP) usando los mensajes del Protocolo de Transporte en Tiempo Real (RTP) para controlar la tasa de envío de paquetes.

El control de la congestión se basa usando las condiciones de la red.

TFRC (TCP-Friendly Rate Control Protocol).- Es la evolución del TFRCP. Su taza de envío de basa de la ecuación del TCP complejo pero utilizando métodos mas sofisticados para reunir la información que requiera la ecuación.

TEAR (Emulation at Receivers - Emulación de Receptores).- Protocolo híbrido ya que combina la congestión mediante ventanas y de velocidad de recepción.

En estos el tamaño de la ventana aumenta o disminuye dependiendo la cantidad de paquetes que llegan.

Protocolos del TCP Friendly Unicast basados en Ventanas de Congestión:

RLA (Random Listening Algorithm) y LPR (Linear Proportional Response) .- Estos combinados logran un buen TCP Friendly.

MTCP (Multicast TCP).- La estructura de este protocolo es como un árbol lógico teniendo como raíz del árbol el remitente de los datos y en las ramas del árbol irían los destinatarios.

El padre viene siendo el nodo anterior y el envió de información es unicast.

NCA (Nominee-Based Congestion Avoidance) y pgmmc (pragmatic general multicast congestion control).- Estos dos protocolos que aunque son distintas ventanas de congestión tienen la misma idea (Seleccionar como grupo representativo del receptor aquel que cuente con la peor conexión de red).

Protocolos del TCP Friendly Multicast basados en la Velocidad de Transmisión:

RLC (Receiver-Driven Layered Congestion Control).- El proceso que el control de la congestión sea por capaz de modo que el ancho de banda consumido por cada nueva capa que se genere aumente de forma exponencial.

FLID-DL.- En este el remitente codifica los datos de origen y la información importante de modo que los que reciban la información decodifiquen los datos originales una vez que se haya recibido una cantidad definida de distintos paquetes.

LTS (Layered Transmission Scheme) y TFRP (TCP-Friendly Transport Protocol).- Protocolos similares para el envío de streams de vídeo.

MLDA (Multicast Loss-Delay Based Adaption Algorithm).- Protocolo basado en el LDA+ usando los reportes que genera el RTCP para señalizar entre el emisor y los receptores.

El MLDA conserva el aumento y disminución que hace el LDA+ pero el calculo lo hace con la velocidad de envío (El LDA+ lo hace dependiendo las condiciones de la red), este dato lo tomar el receptor el cuál se lo envía al remitente el cuál ajusta continuamente el ancho de la banda de las capas.

Protocolos del TCP Friendly Multicast basados en Ventanas de Congestión:

Rainbow.- Sistema de congestión usado para la transferencia por lotes.

Critica Constructiva

Lo aprendido de este articulo es el que existe no todo es TCP, ya que existen los No-TCP.

Y existen también los TCP-Friendly el cuál se puede utilizar tanto en Multicast como Unicast  y se apoyan en la Velocidad de Transferencia y en las Ventanas de congestión para el envió de paquetes.

También de que existen una gran cantidad de paquetes dentro de estas categorías y cada uno tiene se utiliza dependiendo la ocasión.

Referencia:

http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=923938

Entrada # 7 - Laboratorio

Laboratorio de Redes de Telecomunicaciones

La topología diseñada para esta ocasión consiste en 3 computadoras que desean enviar paquetes UDP a una sola maquina pero antes tienen que pasar por un servidor el cuál recibe los paquetes y se los envía a la computadora destino.

El proceso de ejecución fue el siguiente se corre el simulador y todo el trafico se guarda en un archivo, el cuál es tratado por dos archivos AWK para obtener dos archivos los cuales serán graficados para obtener la gráfica de latencia y Throughput.

Vídeo de la Simulación

A continuación muestro el código de la simulación:

	puts "Corriendo Simulación"
	#Creamos el simulador a usar
	set ns [new Simulator]
	#Colores
	$ns color 0 Green
	$ns color 1 Yellow
	$ns color 2 Red
	#Enrutamiento Distance Vector
	$ns rtproto DV
	#$ns mrtproto DM
	#Abrimos un archivo .nam el cual almacenara el trafico producido por el simulador
	set nf [open out.nam w]
	$ns namtrace-all $nf
	set trafico [open salida.puddi w]
	$ns trace-all $trafico
	#Se define el proceso que tendra la simulacion
	proc finish {} {
	#Se definen las variables ns y nf
	global ns nf
	#Se guarda en la variable nf el trafico lo que a su vez se guarda en el archivo .nam
	$ns flush-trace
	#Se cierra la variable nf para que no almacene mas información
	close $nf
	#Se ejecuta el archivo .nam
	exec nam out.nam &
	exit 0
	}
	#Creamos los nodos a utilizar
	for {set i 0} {$i < 5} {incr i} {
	set n($i) [$ns node]
	$n($i) label "Nodo $i"
	$n($i) color Blue
	#puts "Nodo $i"
	}
	#Conectamos los nodos
	$ns duplex-link $n(0) $n(3) 10Mb 10ms DropTail
	$ns duplex-link $n(1) $n(3) 10Mb 10ms DropTail
	$ns duplex-link $n(2) $n(3) 10Mb 10ms DropTail
	$ns duplex-link $n(3) $n(4) 5Mb 5ms DropTail
	#Se acomodan los nodos en la simulacion
	$ns duplex-link-op $n(0) $n(3) orient right-down
	$ns duplex-link-op $n(1) $n(3) orient right
	$ns duplex-link-op $n(2) $n(3) orient right-up
	$ns duplex-link-op $n(3) $n(4) orient right
	#Se crea el agente udp junto con su agente CBR y null para que cada nodo pueda enviarle info al nodo final
	for {set i 0} {$i < 3} {incr i} {
	set udp($i) [new Agent/UDP]
	$ns attach-agent $n($i) $udp($i)
	set null($i) [new Agent/Null]
	$ns attach-agent $n(4) $null($i)
	$ns connect $udp($i) $null($i)
	$udp($i) set fid_ $i
	#puts "$udp($i) set fid_ $i"
	set cbr($i) [new Application/Traffic/CBR]
	$cbr($i) attach-agent $udp($i)
	$cbr($i) set type_ CBR
	$cbr($i) set packet_size_ 1000
	$cbr($i) set rate_ 1mb
	$cbr($i) set random_ false
	}
	$ns at 0.1 "$cbr(0) start"
	$ns at 0.2 "$cbr(1) start"
	$ns at 0.3 "$cbr(2) start"
	$ns at 1.7 "$cbr(0) stop"
	$ns at 1.8 "$cbr(1) stop"
	$ns at 1.9 "$cbr(2) stop"
	$ns at 2.0 "finish"
	#Corremos la simulacion
	$ns run

view raw Tarea7.tcl hosted with ❤ by GitHub

Código Bash

El bash en el cuál se generan las imágenes.

	for Tamano in "Resultado0_Resultado3.puddi" "Resultado1_Resultado3.puddi" "Resultado2_Resultado3.puddi" "Resultado4_Resultado3.puddi";do
	rm Graficador.plot
	touch Graficador.plot
	echo "set term png" >> Graficador.plot
	echo "set output '$Tamano.png'" >> Graficador.plot
	echo "set xlabel \"Tiempo Total\"" >> Graficador.plot
	echo "set ylabel \"Tiempo Espera\"" >> Graficador.plot
	echo "plot '$Tamano' using (\$1):(\$2)" >> Graficador.plot
	gnuplot Graficador.plot
	done

view raw Correr.sh hosted with ❤ by GitHub

Código AWK

Para los Retardos

	BEGIN {
	Inicial0 = 0.0;
	Final0 = 0.0;
	Inicial1 = 0.0;
	Final1 = 0.0;
	Inicial2 = 0.0;
	Final2 = 0.0;
	Inicial3 = 0.0;
	Final3 = 0.0;
	}
	{
	Final0 = $2;
	Final1 = $2;
	Final2 = $2;
	Final3 = $2;
	if($1 == "r")
	{
	if($3==0)
	{
	printf("%f %f\n", Inicial0, Final0) > "Resultado0_Resultado3.puddi";
	Inicial0 += $2;
	}
	else
	{
	if($3==1){
	printf("%f %f\n", Inicial1, Final1) > "Resultado1_Resultado3.puddi";
	Inicial1 += $2;
	}
	else
	{
	if($3==2)
	{
	printf("%f %f\n", Inicial2, Final2) > "Resultado2_Resultado3.puddi";
	Inicial2 += $2;
	}
	else
	{
	if($3==4)
	{
	printf("%f %f\n", Inicial3, Final3) > "Resultado4_Resultado3.puddi";
	Inicial3 += $2;
	}
	}
	}
	}
	}
	}
	END {
	Inicial1 = 0
	}

view raw Retardo.awk hosted with ❤ by GitHub

Para los Throughput's

Imágenes de las graficas de Latencia

Entrada # 3

Teoría de la Información y 

Métodos de Codificación

Algoritmo de Huffman

Para esta ocasión haremos uso del algoritmo de huffman para realizar la compresión en forma binaria de una frase.

Primeramente que es Algoritmo de Huffman

Este algoritmo fue creado por David A. Huffman con el propósito de la compresión de frases demasiado grandes.

El propósito de algoritmo es crear un árbol binario, a fin de obtener un código, la gran ayuda del árbol es que al seguir la raíz de arriba hacia abajo se obtiene el código de una manera fácil y gráfica.

Los pasos del Algoritmo:

• Se crean varios arboles uno por cada letra de la frase, a estas se le coloca su letra respectiva y la cantidad de veces que aparece.

• Se eligen los dos que tengan la menor frecuencia, estos se unen para crear un nuevo árbol (nodo) y los dos arboles que se unieron se unen mediante ramas (líneas) para indicar que son raíces del árbol que se acaba de crear. A este árbol que se creo, al igual que los anteriores, debe de tener su letra y la cantidad de repeticiones ... Estas se obtienen uniendo las dos letras  y se suman la frecuencia de estas letras.

• Se repite el paso anterior hasta que solo quede un solo árbol el cuál contendrá todas las letras y el tamaño de la frase (o la suma de las frecuencias de los arboles).

El proceso del programa es el siguiente:

• Te pide la frase a la que se le aplicara el algoritmo

• Se obtiene la cantidad de veces que se encuentra un carácter en la frase, por ejemplo: en la frase 'perro' nos detectaría 1 p, 1 e, 2 r, 1 o

• Después se ordena de menor a mayor en base a la cantidad de veces que esta cada carácter.

• La parte siguiente seria aplicar el Algoritmo.

• Teniendo lo que vale cada letra solo se sustituye el binario con la palabra y se obtendría la frase.

• Para regresar la frase solo se lee cada parte del binario y se compara si esta existe en la lista, si no existe se incrementa lo que va ahorita con el siguiente y se vuelve a aplicar el proceso

Código Realizado en Python

	import networkx as netx
	import matplotlib.pyplot as grafica #Con este se genera la grafica \o/
	def arbol(Lista):
	G = netx.Graph()
	lista1 = list(Lista)
	lista2 = list()
	i = 1
	for i in range(len(Lista) - 1):
	pu = list([lista1.pop(0)])
	var1, var2 = pu[0][0], pu[0][1]
	pu = list([lista1.pop(0)])
	var3, var4 = pu[0][0], pu[0][1]
	d1 = 0
	d2 = 0
	if var2 > var4: #Si el primer valor es mayor
	d1 = 1
	d2 = 0
	else: #Si el segundo valor es mayor
	d1 = 0
	d2 = 1
	lista2.append((var1, d1))
	lista2.append((var3, d2))
	c = var1+''+var3
	d = var2 + var4
	G.add_node(var1)
	G.add_node(var3)
	G.add_node(c)
	G.add_edge(c, var1, color='blue')
	G.add_edge(c, var3, color='blue')
	puddi = lista1
	lista1 = list([(c, d)])
	for i in puddi:
	lista1.append(i)
	lista1 = ordenar2(lista1)
	netx.draw(G)
	#grafica.show() #Con este muestro en pantalla
	grafica.savefig("Hola.png") #Con este genero el grafo en una imagen
	return lista1, lista2
	def ordenar2(lista):
	dicc = ({})
	for i, j in lista:
	dicc[i] = j
	lista1 = sorted(dicc.items(), key=lambda x: x[1])
	return lista1
	def final(elementos, palabras):
	lisfi = ({})
	lista = elementos
	for i in range(len(elementos)):
	s = list(lista.pop(-1))
	var1, var2 = s[0], s[1] #Var1 es la palabra, y var2 es el valor (0 o 1)
	for j in palabras:
	if var1.find(j) != -1:
	if lisfi.has_key(j) == True: #Si la letra ya esta en el diccionario
	valor = lisfi[j]
	valor = str(valor)+str(var2)
	lisfi[j] = valor
	else:
	lisfi[j] = str(var2)
	return lisfi
	def atras(lista, comprimido):
	var1 = ''
	var2 = 0
	palabra = ''
	for i in comprimido:
	if var2 == 0:
	var1 = var1 + i
	for l in lista.keys():
	j = lista[l]
	if var1 == j:
	var1 = ''
	palabra = palabra + l
	var2 == 1
	else:
	var2 == 0
	return palabra
	def datos(lista):
	lista1 = list()
	for i, j in lista:
	lista1.append(i)
	return lista1
	def ordenar(dicc):
	dicc2 = sorted(dicc.items(), key=lambda x: x[1]) #Le los elementos del diccionario y los ordena de menor a mayor segun el valor de las claves
	return dicc2
	def contador(frase):
	lista = list(frase)
	lista2 = lista
	dicc = ({})
	for i in range(len(lista2)):
	a = lista.pop(0)
	if dicc.has_key(a) == True:
	valor = dicc[a]
	dicc[a] = valor + 1
	else:
	dicc[a] = 1
	return dicc
	def main():
	frase = raw_input('Frase a comprimir: ')
	diccionario = contador(frase)
	print 'Cantidad de letras en la frase: '+str(diccionario)
	diccionario = ordenar(diccionario)
	print 'Lista de Letras Ordenadas: '+str(diccionario)
	diccionario = list(diccionario)
	d, a = arbol(diccionario) #Se manda llamar el metodo arbol y recibe dos variables ...
	print '\nResultado del Arbol: '+str(a)
	palabras = datos(diccionario) #Este metodo separa el diccionario en una lista
	ListaFinal = final(a, palabras)
	print 'Binario: '+str(ListaFinal)
	compri = ''
	Lista = list(frase) #Se separa la frase en una lista
	for i in Lista:
	compri = compri+ListaFinal[i] #Se obtiene el binario del diccionario utilizando la letra de la frase y se almacena a compri
	compri = compri.replace(' ', '')
	print 'Comprimido : '+str(compri)
	desprin = atras(ListaFinal, compri)
	print 'Descomprimido: '+str(desprin)
	main()

view raw Compresor.py hosted with ❤ by GitHub

Imágenes del Resultado

Como ven en la imagen, nos pide la frase a comprimir; después obtiene la cantidad de veces que aparece cada letra y las ordena en base de menor a mayor según la cantidad de veces que aparece.

Una vez aplica el proceso del árbol y obtenemos una lista la cuál se barrera para obtener el binario de cada letra y para obtener el grafo.

Se obtiene la frase en binario y después se descomprime.

Imagen del grafo:

Corriendo con otra frase:

El único problema que tuve fue que no encontré el como acomodar la imagen a fin de que tenga una mejor presentación ya que mientras existían mas letras la imagen se veía mas horrible.

Referencias

http://networkx.github.io/documentation/latest/tutorial/tutorial.html
http://networkx.lanl.gov/pygraphviz/tutorial.html
http://www.danielmunoz.com.ar/blog/2010/07/07/el-algoritmo-de-huffman/
http://es.wikipedia.org/wiki/Algoritmo_de_Huffman

Entrada # 6 - Laboratorio

Laboratorio de

Redes de Telecomunicaciones

Ruteo en Simulador NS2

El Ruteo es el encargado de dirigirnos de un origen a un destino; este camino debe de ser el mejor (el que nos genere la menor distancia y tiempo), para lograrlo se hacen uso de los protocolos de ruteo.

Los Protocolo de Ruteo

Estos nos permite la comunicación de un router con otro.

Algunos ejemplos de protocolos:

• Protocolo de Gateway fronterizo (BGP)
• Protocolo "Primero la ruta más corta" (OSPF)
• Protocolo de información de enrutamiento (RIP)
• Protocolo de enrutamiento de gateway interior (IGRP)

Topologías de Red

Es la forma en la que se acomodan las computadoras (nodos) para poder enviar información.

https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg4bDBK1IAOI-mtf9cxGJtrVu6KoXOp1Ul6TFIXYzOhp81dP7AP-vvM4j6UAg0kwAkwjXVr2G2lkz0qjALJhnl30IxjmOei4Zq-69Hbr-lbjouMbMa_QKZoTWq7v-v52vvXb5Mfs2wYUwyM/s1600/TIPOS+REDES.png

Código Utilizado

	puts "Corriendo Simulación de Topología de Anillo"
	#Creamos el simulador a usar
	set ns [new Simulator]
	#Enrutamiento Distance Vector
	$ns rtproto DV
	#Abrimos un archivo .nam el cual almacenara el trafico producido por el simulador
	set nf [open out.nam w]
	$ns namtrace-all $nf
	#Se define el proceso que tendra la simulacion
	proc finish {} {
	#Se definen las variables ns y nf
	global ns nf
	#Se guarda en la variable nf el trafico lo que a su vez se guarda en el archivo .nam
	$ns flush-trace
	#Se cierra la variable nf para que no almacene mas información
	close $nf
	#Se ejecuta el archivo .nam
	exec nam out.nam &
	exit 0
	}
	#Creamos los nodos a utilizar
	set n0 [$ns node]
	set n1 [$ns node]
	set n2 [$ns node]
	set n3 [$ns node]
	set n4 [$ns node]
	set n5 [$ns node]
	#Conectamos los nodos a una velocidad de 2Mb con un tiempo de envio de 10ms
	$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
	#Se acomodan los nodos en la simulacion
	$ns duplex-link-op $n0 $n1 orient left-up
	$ns duplex-link-op $n1 $n2 orient left
	$ns duplex-link-op $n2 $n3 orient left-down
	$ns duplex-link-op $n3 $n4 orient right-down
	$ns duplex-link-op $n4 $n5 orient right
	$ns duplex-link-op $n5 $n0 orient right-up
	#Se crea una conexion UDP y esta comenzara en el nodo n0
	set udp [new Agent/UDP]
	$ns attach-agent $n0 $udp
	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
	set null [new Agent/Null]
	$ns attach-agent $n3 $null
	$ns connect $udp $null
	$ns at 0.1 "$cbr start"
	$ns at 2.5 "$cbr stop"
	$ns at 3.0 "finish"
	#Corremos la simulacion
	$ns run

view raw Tarea6.tcl hosted with ❤ by GitHub

Vídeo donde se Muestra la Simulación

Referencias:

http://www.slideshare.net/code453/ns2-tutorial
http://es.wikipedia.org/wiki/Encaminamiento
http://www.scribd.com/doc/22508801/Tarea-5-Teleco2-Protocolos-de-Ruteo