Laboratorio 13

Laboratorio 13 - Simulación de una red sensora

Hola a todos mis compañeros y gente que regularmente visita mi blog, esta entrada corresponde a la actividad número 13 del laboratorio de "Redes de telecomunicaciones". La actividad consiste en elaborar una simulación simple de una red sensora (ad hoc) pequeña con nodos estáticos en un terreno 3D. Donde la comunicación entre los nodos es con rangos ajustables y TTL (Time To Live).

Para estudiar una propiedad de mi interés decidí simular un escenario en el que se usen sensores ambientales, podrían entrar variables como temperatura, fuego, humedad, etc.

Podemos tomar cualquiera de estas 3 variables para simular el escenario (en realidad no importa cual de las 3 tomemos).

Bien, yo preparé un plano en 3D en el que desde cualquier nodo se envia la información hacia la estación base, que es la que procesa y toma medidas en función a los datos recibidos por los demás nodos sensores.

El plano se ve de la siguiente manera (dependiendo de los nodos que yo ponga, puedo pasar como parámetro el número de nodos que yo quiera):

Bien para comenzar, yo obtuve de manera aleatoria los rangos de alcance de cada nodo sensor (cobertura), donde todo los nodos tienen exactamente el mismo rango de alcance.
Seguido de esto, también establezco de manera aleatoria el TTL, que será nuestro indicador de por cuántos nodos puede pasar el paquete antes de ser descartado por la nuestra red. 

Luego de obtener estos valores lo que hice fue generar el plano en 3D, seguido de esto ingrese cada uno de los nodos en el mismo plano. El código que realiza este proceso es el siguiente (posicioné hasta el último la estación base):

def main():

 fig = plt.figure()
 ax = fig.add_subplot(111, projection='3d')

 propx = random.randint(0, 5) #Proporcion de crecimiento en el eje x
 ttl = random.randint(0, 4) # Cuantos nodos puede pasar un paquete antes de ser descartado por la red
 cober = random.randint(0, 5) #Cobertura de rango para cada nodo (todos los nodos tienen la misma cobertura)

 #ax.text2D(0.05, 0.95, "Terreno 3D", transform=ax.transAxes)

 ax.set_xlim3d(0, 10)
 ax.set_ylim3d(0, 10)
 ax.set_zlim3d(0, 10)

 c = 'r'
 m = 'o'

 coords = [] # Guardar las coordenadas de cada uno de los nodos en el plano (formato x, y, z)
 listacoords = [] # Guarda cada una de las coordenadas
 n = int(argv[1]) #Para agregar n nodos a la simulacion
 for i in range(n):
  if i == 0:
   coords = []
   xs = random.randint(0, 10)
   ys = random.randint(0, 10)
   zs = random.randint(0, 10)
   coords.append(i)
   coords.append(xs)
   coords.append(ys)
   coords.append(zs)
   ax.scatter(xs, ys, zs, c=c, marker=m)
   ax.text(xs, ys, zs, ("nodo: ", i), color='green')
   listacoords.append(coords)

  elif (i != 0) and (i != (n-1)):
   coords = []
   #xs = random.randint(xs+propx, 10)
   xs = xs + propx   
   ys = random.randint(0, 10)
   zs = random.randint(0, 10)
   coords.append(i)
   coords.append(xs)
   coords.append(ys)
   coords.append(zs)
   ax.scatter(xs, ys, zs, c=c, marker=m)
   ax.text(xs, ys, zs, ("nodo: ", i), color='green')
   listacoords.append(coords)
    elif i == (n-1):
   c = 'black'
   coords = []
   #xs = random.randint(0, 10)
   xs = xs + propx   
   ys = random.randint(0, 10)
   zs = random.randint(0, 10)
   coords.append(i)
   coords.append(xs)
   coords.append(ys)
   coords.append(zs)
   ax.scatter(xs, ys, zs, c=c, marker=m)
   ax.text(xs, ys, zs, ("Base"), color='green')
   listacoords.append(coords)
   print "\n", i, " es el ultimo elemento del for"
   print coords
 
 ax.set_xlabel('X Label')
 ax.set_ylabel('Y Label')
 ax.set_zlabel('Z Label')

Además en el punto donde posiciono a cada nodo, agrego una nota sobre el ID del nodo sensor (el último nodo tiene la etiqueta de "estación base").

Como ya lo comenté antes, obtendo primero el valor de rango que tiene cada nodo sensor, pero, ¿qué sucede si los valores de rango de cobertura no son de la magnitud suficiente como para comunicarse son su vecino?, es decir, si el rango de cobertura no abarca hasta su vecino, la transmisión no podrá efectuarse y la red queda incomunicada, impidiendo que todos los datos le lleguen a la estación base para su futuro procesamiento y toma de medidas.

Para esto calculé la distancia entre cada uno de los nodos próximos, con el fin de obtener un valor para comparar con el rango de cobertura. Si el rango de cobertura de nodo1 + rango de cobertura de nodo2 es mayor o igual a la distancia entre estos nodos, la comunicación puede efectuarse entre ellos, en caso contrario la comunicación no podría llevarse acabo, quedando incomunicada la red.

El código que implementé que realiza este proceso es el siguiente:

def getDistance(p1, p2):
     #p son listas de coordenadas, en formato [nodo, x, y, z]
     #p1 representa al punto inicial    
 x1 = p1[1] #Solo para darle claridad al codigo, aunque salgan mas lineas
 x2 = p2[1]

 y1 = p1[2] #Solo para darle claridad al codigo, aunque salgan mas lineas
 y2 = p2[2]
 
 z1 = p1[3]
 z2 = p2[3]

     c = (((x2 - x1)**2) + ((y2-y1)**2) + ((z2-z1)**2))
 distancia = math.sqrt(c)
 return distancia


 distancias = [] # Coleccionar las distancias entre los nodos 
 for j in range(len(listacoords)):
  if j != (len(listacoords)-1):
   print listacoords[j]
   d = getDistance(listacoords[j], listacoords[j+1])
   distancias.append(d)
  else:
   print "Este es el ultimo nodo, osea nodo = ", j
   print listacoords[j]
   
 print distancias

 print "Cobertura = ", cober

 for x in range(len(distancias)):
  if cober*2 >= distancias[x]:
   print "Existe comunicacion entre nodo ", x, " y nodo ", x+1
  if cober*2 < distancias[x]:
   print "No existe comunicacion por auscencia de cobertura entre nodo ", x, " y nodo ", x+1 
 #getDistance(listacoords)

 print ">>>\nAhora checando estructura del paquete IP, TTL = ", ttl
 if ttl > (n-1):
  print "!!!! El paquete de datos puede ser entregado a la estacion base..."
 else:
  print "**** El paquete no puede ser entregadoa a la estacion base porque su TTL no es suficiente..." 
 
 plt.show() #Al final para mostrar el plano

Luego de obtener las distancias y realizar las verificaciones de que existiera una correcta cobertura en la red sensora, el siguiente paso fue verificar si el valor aleatorio que generé de TTL era suficiente para la transmisión desde el nodo 0, hasta la estación de la base.
Recordemos que si el valor de TTL es 0, la red descarta ese paquete para que no esté creando un loop infinito en la misma (causa de congestión en una red). Las líneas finales del código anterior son las que realizan este proceso.

Al final imprimo todos los datos de las coberturas y las distancias entre los nodos, además, también imprimo un aviso si existen comunicación entre ciertos nodos, o si no existe la comunicación debido a las coberturas y TTL (esto con el fin de que se reubiquen los nodos en que no tengan la suficiente cobertura).

En conclusión, cuando mando el aviso de que existe comunicación por buena cobertura entre todos los nodos, y también que el valor de TTL (recuerden que lo genero aleatoriamente) es suficiente con respecto al valor de nodos presentes en la red sensora, el paquete puede ser entregado desde su origen hasta la "estación base" sin ningún problema.
A continuación les muestro un ejemplo de la simulación realizada con 8 nodos (plano 3D con los nodos + salida en terminal):

El código completo lo pueden encontrar en mi repositorio: https://github.com/eddypre/Telecomunicaciones

 
Bibliografía

- Tiempo de vida (informática), [Documento en línea]. <http://es.wikipedia.org/wiki/Tiempo_de_vida_%28inform%C3%A1tica%29>. [Consulta: 23-05-13].
- Distancia entre puntos en el espacio, [Documento en línea]. <http://distanciapuntosenelespacio.blogspot.mx/http://distanciapuntosenelespacio.blogspot.mx/>. [Consulta: 23-05-13].
- matplotlib, [Documento en línea]. <http://matplotlib.org/mpl_toolkits/mplot3d/tutorial.html>. [Consulta: 23-05-13]

Cualquier duda o aclaración que quieran hacer pueden dejarla en la caja de comentarios.

Saludos a todos!