Enrutamiento avanzado automático en Linux.

Una situación que se va volviendo más común es tener más de una conexión a internet en los servidores. El problema que se presenta, entonces, es que cuando nos llega un paquete proveniente de internet por una conexión, éste debe ser contestado por la misma por donde llegó y no simplemente por la ruta por defecto.

El comportamiento normal sería el siguiente:

Red local, eth0
ip 192.168.1.1
mascara 255.255.255.0

Primera salida a internet, eth1
ip 1.2.3.4
mascara 255.255.255.0
ruta por defecto 1.2.3.254

Primera salida a internet, eth2
ip2.3.4.5
mascara 255.255.255.0
ruta por defecto 2.3.4.254

Segun este esquema, las tablas de ruteo quedarían así:

Destination     Gateway         Genmask         Flags   MSS Window  irtt Iface

192.168.1.0     0.0.0.0         255.255.255.0   U         0 0          0 eth0

1.2.3.0         0.0.0.0         255.255.255.0   U         0 0          0 eth1

2.3.4.0         0.0.0.0         255.255.255.0   U         0 0          0 eth2

0.0.0.0         1.2.3.254       0.0.0.0         UG        0 0          0 eth1

0.0.0.0         2.3.4.254       0.0.0.0         UG        0 0          0 eth2 

Como se puede ver, aparecen dos rutas por defecto. Sin embargo el sistema utilizará siempre la primera que haya a no ser que la interfaz esté caída, o sea que falte la letra "U" (de up).

En qué nos afecta esto? Supongamos que nos viene un paquete destinado a la ip 1.2.3.4 proveniente de algún lugar de internet, digamos 5.5.5.5. Cuando el sistema mande la respuesta, esta saldrá por la placa eth1, porque es la primera ruta que sirve para alcanzar la ip 5.5.5.5 y todo funciona bien.

Pero qué pasa si viene un paquete proveniente, digamos, de 6.6.6.6, destinado a 2.3.4.5. El paquete llegará sin problemas pero cuando haya que enviar la respuesta, esta saldrá, de nuevo, por la eth1. Pero resulta que la IP de origen del paquete de respueta tiene que ser, obviamente, 2.3.4.5 y el proveedor de internet al que llegamos por la eth1 no querrá rutear paquetes con esa ip de origen. El paquete debería haber salido por la eth2, dirigido a su router correspondiente, el 2.3.4.254.

Lo que necesitamos, es alguna manera de decirle al sistema qué hacer en esta situación, y ahí es donde aparece la capacidad de ruteo avanzado que tiene Linux.

El documento  Linux Advanced Routing and Traffic Control how-to
 explica claramente este problema y la manera de solucionarlo. Lo que yo les presento ahora es un script que se encarga de hacer todo automáticamente.


La situación es  que tenemos dos rutas por defecto y debemos utilizar cada una según corresponda.

ATENCION: esto no se trata de balancear cargas por las dos conexiones. Se trata simplemente de que ambas sean utilizables desde internet.




Para solucionar esta situación, lo que hace es crear una tabla para cada placa de red que haya. En cada una tiene rutas para llegar a las demás redes, y la ruta por defecto que corresponda a esa placa. De esa forma, se puede configurar en cada placa de red una ruta por defecto diferente.

Para seleccionar cuál de todas estas tablas de ruteo es la que debemos utilizar en cada momento, se debe crear reglas que seleccionan la tabla correspondiente en función de la IP de origen del paquete. La IP de origen es lo que distingue una placa de red de otra, así que nos sirve para saber por qué placa está saliendo el paquete.


Para su funcinamiento, el script utiliza la información de los archivos de configuración de la red, que se encuentran en /etc/sysconfig/network-scripts. Al menos en los sistemas que siguen la Linux Standard Base, este directorio contiene archivos con el nombre ifcfg-<nombre de la placa de red>. Por ejemplo /etc/sysconfig/network-scripts/ifcfg-eth1 contendría:

DEVICE=eth

BOOTPROTO=static

IPADDR=1.2.3.4

NETMASK=255.255.255.0

GATEWAY=1.2.3.254

ONBOOT=yes

METRIC=10

MII_NOT_SUPPORTED=no

USERCTL=no

DNS1=127.0.0.1

RESOLV_MODS=no

IPV6INIT=no

IPV6TO4INIT=no

ACCOUNTING=no

Lo que nos interesa de este archivo son la IPADDR, NETMASK y GATEWAY. Con estos datos podemos generar automáticamente lo que necesitamos.

A continuación el script:

#limpiar reglas anteriores por si lo ejecutamos de nuevo

ip rule show | awk 'BEGIN{FS=":"}{if(index($2,"lookup main")==0 && index($2,"lookup default")==0 && index($2,"lookup local")==0) system ("ip rule del " $2) }'

#recorrer las intefaces de red
#para cada una crear una tabla

cuenta=0
for ifcfg in /etc/sysconfig/network-scripts/ifcfg-*
do
      cuenta=$(( cuenta + 1 ))
      TABLE=100$cuenta

      . $ifcfg
      echo "DEVICE=$DEVICE"

      export `ipcalc -n $IPADDR $NETMASK`
      NET=$NETWORK/$NETMASK

      ip route flush table $TABLE

      ip route add $NET dev $DEVICE src $IPADDR table $TABLE
      if [ "$GATEWAY" != "" ]
      then
         ip route add default via $GATEWAY table $TABLE
      fi

      ip route add $NETWORK dev $DEVICE src $IPADDR


      ip rule add from $IPADDR table $TABLE
      ip rule add fwmark $TABLE table $TABLE



      tables="$tables $TABLE"
      if [ "$GATEWAY" != "" ]
      then
         ip route add default via $GATEWAY table $TABLE
      fi

      echo 
      echo 
      echo 
      echo 
done



for TABLE in $tables 
do
   for ifcfg in /etc/sysconfig/network-scripts/ifcfg-*
   do
      . $ifcfg
      export `ipcalc -n $IPADDR $NETMASK`
      NET=$NETWORK/$NETMASK

      ip route add $NET dev $DEVICE table $TABLE
   done

done


echo 0 > /proc/sys/net/ipv4/conf/eth1/rp_filter
ip route flush cache

Termómetro graficador con LM35 y display HD44780 compatible

El circuito integrado LM35 es muy interesante. Se comporta como un regulador de tensión controlado por temperatura. El resultado es que por su salida entrega 10 milivolts por grado celsius.

En la documentación figuran varios circuitos de aplicación pero para este experimento vamos a hacerlo lo más básico posible. Lo conectaremos así:

Para la medición, lo único que tenemos que hacer es leer la entrada analógica y calcular cuantos milivolts son. Lo dividimos por 10 y listo.

Un detalle con respecto al montaje físico del LM35: no conviene conectarlo directamente sobre el Arduino. Aunque no lo parezca la placa genera bastante calor como para aumentar la temperatura un par de grados. Es mejor ponerle un calbe y que esté lejos.

Con temperaturas normales, rara vez mediremos más de 100 grados, o sea que rara vez tendremos más de 1 volt en la salida. Así que para obtener mejor precisión en la medida podríamos usar como referencia del conversor analógico digital, la tensión interna de 1,1 Volt.

  analogReference(INTERNAL); //referencia de 1.1V 

¿Por qué usar una referencia de 1,1V en lugar de dejarlo en la normal que son 5V?  Para tener mejor precisión en la medida. Aunque tampoco sería tan importante ya que el LM35 tampoco es super exacto. Puede tener un error de medio grado, lo cual parece mucho pero en comparación con otras alternativas está muy bien. Otros tienen tolerancias de un grado o más.

El conversor analógico digital mide con una precisión de 10 bits, o sea que la función analogRead nos devuelve un valor entre 0 y 1023. Dado que 1023 corresponde a 1.1 volt, lo que son 110 grados, la fórmula para convertir la información en grados es sencilla. Si a es el valor medido, la temperatura es:

t=a*110/1023.0;

Dado que la entrada está sujeta a múltiples interferencias externas, el valor de entrada no es totalmente estable. Entonces, para conseguir una medición más exacta lo que vamos a hacer es promediar todos los valores medidos durante una fracción de segundo. Los vamos sumando en la variable s y contando con c. Al final dividimos s por c y tenemos la temperatura (variable a):

m=millis();
s=0;
c=0;
while(millis()-m <300) {
     s+=analogRead(A1);
     c++;
     } 

a=s/c;

Ahora bien. Usando la rutina del post anterior, tenemos 24 barritas para mostrar datos. Así que podríamos mostrar una barrita por hora y así graficar las últimas 24 horas. Crearemos una variable llamada m10m donde guardaremos los milisegundos de la última barra mostrada, y lo compararemos con los milisegundos actuales. Eso nos dará los milisegundos que han transcurrido. Si lo dividimos por 1000 lo tendremos en segundos, y cuando esto de 3600 será que ha pasado una hora. Algo así:

dif=(millis()-m10m)/1000;
if (dif>3600){....

Para ver que tal funcionan las cosas en la pantalla mostraremos el valor devuelto por el conversor analógico-digital, la gráfica, la medición de temperatura, y el tiempo transcurrido.

Una vez conformes con el resultado los datos se pueden reubicar. Recordemos que la gráfica sale donde pongamos los caracteres 0 a 7.

Al final a mi me ha quedado así:

Y el programa que lo hace es este:

#include <LiquidCrystal.h>

LiquidCrystal lcd(8,9,4,5,6,7);



byte grafica[24]; //valores entre 0 y 8

void setup(){
  lcd.begin(16, 2);

  Serial.begin(9600);

  analogReference(INTERNAL); //referencia de 1.1V
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("OK");

  lcd.setCursor(8,0);
  lcd.print('\0');
  lcd.print('\1');
  lcd.print('\2');
  lcd.print('\3');
  lcd.print('\4');
  lcd.print('\5');
  lcd.print('\6');
  lcd.print('\7');

  memset(grafica,(byte)9,sizeof(grafica));  

  mostrar_grafica();  
  }

/////////////////////////////////////////////////////////////


long a;
float t;
long m,s,c;

long s10m=0;
long c10m=0;
long m10m=millis();
int i,indice_registro=0;
long dif;
int k;
/////////////////////////////////////////////////////////////

void loop(){

m=millis();
s=0;
c=0;
while(millis()-m <300) {
     s+=analogRead(A1);
     c++;
     }

a=s/c;

lcd.setCursor(0,0);
lcd.print(a);
lcd.print("  ");

t=a*110/1023.0;
lcd.setCursor(0,1);
lcd.print(t);

//cada 10 minutos guardar el promedio

s10m+=a;
c10m++;;

dif=(millis()-m10m)/1000;
lcd.setCursor(8,1);
lcd.print(dif);
lcd.print("       ");
if (dif>3600){ 
   //guradar valor
   
   a=s10m/c10m;
   memcpy(grafica,grafica+1,23); //desplazar hacia la izquierda   
   grafica[23]=8 * (1.0*t-10.0)/12;

   s10m=0;
   c10m=0;
   m10m=millis();
   mostrar_grafica();
   }

}


//////////////////////////////////////////////////////

void mostrar_grafica(){
int d,dp;
byte bm[8];
int c,columna,fila,posicion,x;
int i;
for ( c=0;c<8;c++){ 
    memset(bm,0,8);//llenamos el caracter con ceros
    
    // cada caracter representa 3 datos, que comienzan por el...
    
    //poner puntitos en la primera columna (entre 0 y 8)
    x=0;
    dp=c * 3;

    for (columna=0;columna<5;columna+=2){
        i=dp + 2-( columna/2 );
        d=grafica[i];
                   
        for (fila=0;fila<8;fila++){
            
            if (d>8) // dato invalido
              bm[fila] |= (fila & 1) <<columna;
            else 
              if (fila>=9-d) bm[fila] |= 1<<columna;
                 
            
            }//for fila
        x++;
        }//for columna
    lcd.createChar(c,bm);  
    }

} 

Graficos en display HD44780 (1602)

Existen en el mercado montones de displays compatibles con HD44780. Yo tengo este: http://www.yerobot.com/arduino-lcd-shield.html.

El display es de 16 columnas por dos filas y puede mostrar una amplia variedad de caracteres, pero tiene un inconveniente: no puede mostrar gráficos... pero podemos hacer alguna trampa para conseguir algo útil.

Para empezar, manejamos bien el display con la biblioteca standard incluída con el entorno Arduino: http://www.arduino.cc/en/Reference/LiquidCrystal. No hace falta utilizar la que provee el fabricante. De hecho, es poco aconsejable usarla porque es más lenta y no funciona bien con las versiones nuevas.

El controlador HD44780 muestra caracteres en una matriz de puntos, así que nada impediría que pudiera dibujar cualquier cosa sobre ella. Sin embargo no está pensado para eso. No tiene comandos que permitan enviar pixels individuales sino sólo caracteres alfanuméricos.

El truco que usaré para hacer algunos gráficos consiste en aprovechar la capacidad del HD44780 para mostrar hasta ocho caracteres definidos por el usuario. De esa forma, en principio, en la zona que ocuparían ocho letras podemos poner lo que nos de la gana. Simplemente escribiríamos el carácter 0, el 1, el 2 y así hasta el 8 y luego los redefinimos para que tengan los pixels que nos haga falta.

Sólo hay un inconveniente: que el display LCD no tiene todos los pixels sino que deja una separación entre los caracteres. La cosa se ve más o menos así:

Físicamente no existen los pixels necesarios para dibujar un gráfico completo. Así que tendremos que conformarnos con otro tipo de gráficos. Tenemos 8 cuadros de 8x5 pixels separados por 1 pixel, para hacer lo que queramos. Así que voy a hacer una rutina para dibujar histogramas.

Podemos suponer que cada carácter tiene seix pixels, uno de los cuales siempre tendrá que estar apagado. Así que tendremos que adaptarnos a eso y tratar de que no se note. Para eso dibujaremos barras verticales pero separadas por un píxel entre ellas. De esa forma parecerá que la separación fue dejada a propósito. 

De esta forma, hay 24 columnas disponibles para mostrar información. La rutina utilizará, entonces, un vector con 24 bytes. En ellos se usarán valores entre 0 y 8 para indicar la altura de la barra a mostrar. 

byte grafica[24];

La gráfica se podrá ubicar en cualquier parte de la pantalla, simplemente escribiendo los caracteres del 0 al 7, que son los que se pueden redefinir. Por ejemplo una manera sencilla de hacerlo sería esta:

void setup(){
  lcd.begin(16, 2);

  lcd.clear();

  lcd.setCursor(8,0);
  lcd.print('\0');
  lcd.print('\1');
  lcd.print('\2');
  lcd.print('\3');
  lcd.print('\4');
  lcd.print('\5');
  lcd.print('\6');
  lcd.print('\7');
  }

Por supuesto, también hace falta información para mostrar. Esta deberá ser generada por cualquier programa que hagamos. Después daré un ejemplo práctico. Por ahora llenemos el vector con algo de información para probar.

for (a=0;a<9;a++) grafica[a]=a;

for (a=8;a<16;a++) grafica[a]=8;

Y ahora la rutina que convierte el contenido del vector "gráfica" componiendo los caracteres que se ven en la pantalla.

void mostrar_grafica(){
int d,dp;
byte bm[8];
int c,columna,fila,posicion,x;
int i;
for ( c=0;c<8;c++){ 
    memset(bm,0,8); //llenamos el caracter con ceros
    
    // cada caracter representa 3 datos
    
    //poner puntitos en la primera columna (entre 0 y 8)
    x=0;
    dp=c * 3;

    for (columna=0;columna<5;columna+=2){
        i=dp + 2-( columna/2 );
        d=grafica[i];
                   
        for (fila=0;fila<8;fila++){
            
            if (d>8) // dato invalido
              bm[fila] |= (fila & 1) <<columna;
            else 
              if (fila>=9-d) bm[fila] |= 1<<columna;
                 
            
            }//for fila
        x++;
        }//for columna
    lcd.createChar(c,bm);  
    }

}

Nótese que no es necesario volver a escribir los caracteres en la pantalla cuando se modifica la gráfica. El controlador se encargará de irlos modificando cuando se hace el lcd.createChar.

Finalmente, al usar la rutina el resultado queda así:

En el siguiente artículo, un ejemplo práctico de uso de esta rutina.