Búsqueda personalizada

30 octubre 2006

Versión 1.0 Display en Router Linksys - Arduino

Mas proyectos en: http://eduardomarin.es/blog/tag/arduino

Introducción (Documentación actual en http://eduardomarin.es/blog/entry/version-1-0-display-en-router-linksys---arduino)


Bueno, pues empezamos este "tuto" para añadir al router Linksys WRT54GL un display 16x2 de Philips (documentacion) que nos ayudará a visualizar aquellos datos que creamos oportunos.

En mi caso, y de momento, puedo visualizar dos temperaturas (interna y externa), la hora GMT, las redes disponibles, y aquellos mensajes que yo edite.

Pero... cómo he realizado todo esto. Comencemos.

Antecedentes

Desde que adquirí el router y comencé a añadirle componentes (puerto serie, lector tarjeta SD, ...), visité muchas páginas, y en una de ellas, más concretamente en los Hacks de Openwrt, ví que añadían un display de un Nokia. Esa opción me alegró bastante y me amplió las miras hacia las posibilidades que ofrecía. El inconveniente es que, ni yo tenía ese tipo de display, ni lo iba a comprar, y además, la instalación se lleva a cabo a través de las señales GPIO, que no me gusta tocar mucho, además que ya las tengo ocupadas con el lector de SD.
Entonces... qué solución podía darle. Pues bien. En primer lugar, llegó a mis manos una impresora multifunción con escaner en donde venía el display que ahora porta el router.
Se trata del modelo de 16 x 2 de philips, en donde hay una muy buena documentación sobre su control en esta dirección.
Muy bien, ya tenemos el display, pero ahora... dónde lo enchufamos?
Aquí entra en juego el proyecto que desarrollan los chicos de Arduino. Como ya he hablado bastantes veces en posts anteriores, éste microcontrolador nos permite manejar una serie de señales digitales y analógicas, y, además, puede realizar una comunicación por puerto serie. Es este el punto fuerte del enlace.
Así pues, volvemos a la simbiosis Arduino - Linksys que me permiten ampliar el sistema linux que porta Linksys.

Componentes

Router Linksys WRT56GL
Microcontrolador Arduino
Placa microperforada PCB
Tira de conectores
Resistencias de 220 ohm
Cable

Manos a la obra

En primer lugar, buscamos un lugar donde colocar el display. En mi caso, lo centré sobre la parte superior del router, justo donde está perforada la tapa para que ventile. Las medidas del display me permitieron centrarlo perfectamente, con lo cual da un aspecto bastante aproximado a "de fábrica", XD.
El siguiente paso es realizar la conexión entre las 11 entradas del display a Arduino (vease que puede realizarse el control del display con tan sólo 4 bits sobre datos). Así pues, de las 14 salidas digitales de las que dispone Arduino, tan sólo usamos 11. Dos de ellas están reservadas para el puerto serie.
Hay que pensar, además, que Arduino debe ser alimentado de alguna forma. También tenemos que pensar en qué uso le vamos a dar. En mi caso, además de controlar el display, realizará lecturas de diversos sensores, aprovechando las 5 entradas analógicas de las que dispone.
Por lo tanto, el cableado hacia Arduino va a ser algo complejo, y sería conveniente montar una PCB con conectores para facilitar la conexión y desconexión en caso de que se necesite.
Para ello, se monta una tira de conectores para que encaje perfectamente a Arduino. Esta tira irá soldada a cada una de las entradas al display, convenientemente dirigida, y soldada.
Para graduar el contraste del display hacemos uso de una resistencia variable de 10 k. Para la adquisición de datos para los dos termómetros, realizamos un divisor de voltaje mediante dos resistencias de 220 ohmios. Finalmente, la alimentación de Arduino se lleva a cabo directamente de la alimentación del router. Sin embargo, ésta alimentación devuelve unos 20 - 25 voltios que podrían no sentar muy bien a Arduino, pues éste trabaja en un rango de 5 a 12 voltios. Para ello se usa un regulador de tensión, en mi caso, aprovechado de la impresora que recibí.
Una vez establecida la conexión entre Arduino y el display, tan sólo queda realizar la conexión con el router. Esta conexión se lleva a cabo a través del puerto serie que ya buscamos en un post anterior.
Si todo ha salido bien, ahora quedaría meterse con el soft.

-- Software --

A la hora de crear los scripts y código necesario debemos tener en cuenta los siguientes aspectos.
Por un lado, estamos trabajando con Arduino y con Linksys.
Vamos a comenzar hablando del código que correrá en Arduino.
En posts anteriores hablé de la comunicación que podía llevarse a cabo entre Linksys y Arduino. Pues bien, mantendremos esa comunicación tal cual. Esto es, Linksys tendrá que ser capaz de activar y desactivar las señales suficientes para que arduino responda como si las señales las estuviese originando él. Así, de las 13 salidas digitales (mejor dicho, 11, pues dos de ellas son para comunicación serie), el router Linksys debe poder activarlas, tan sólo indicando las salidas que desea activar. Lo mismo ocurre con la entrada analógica. Así pues, si revisáis el post donde se indica veréis cómo para activar la salida 10 y 8 digitales, tan sólo habia que enviar sobre el puerto serie el comando H10H08, esto es echo H10H08 > /dev/cua/1. Una vez llevada a cabo la configuración de Arduino, y dispuesto para funcionar como un "interfaz" de cara al lcd, podemos comenzar con el código del router.

Por un lado tenemos el script que controla el lcd, y por otro el código que nos hace de lanzador de la "aplicación", es decir, la que recoge la información de la temperatura, de la hora, recoge información sobre la ssid actual, recoge los mensajes a imprimir...

Empecemos por el nivel más bajo, esto es, el control del lcd.

Veamos, en primer lugar, el código de ese controlador

#!/bin/ash

iniciar_lcd()
{
echo L06L07H08H09L10L11L12L13L04L03H05D00020L05D00020 > /dev/cua/1
echo H06L07L08L09L10L11L12L13L04L03H05D00020L05D00020 > /dev/cua/1
echo L06L07L08H09H10H11L12L13L04L03H05D00020L05D00020 > /dev/cua/1
}

desplazar_display()
{
L=1
while test $L -le $1
do
echo L06L07L08H09H10L11L12L13L04L03H05D00020L05D00020 > /dev/cua/1
L=`expr $L + 1`
done
}

posicionar_cursor()
{
COCIENTE=$1
COCIENTE=`expr $COCIENTE - 1`
K=6
if test $1 -ge 1
then
if test $1 -le 80
then
while test $K -le 12
do
MOD=`expr $COCIENTE % 2`
COCIENTE=`expr $COCIENTE / 2`
if test $K -le 9
then
case $MOD in
0) echo L0$K >> auxiliar
;;
1) echo H0$K >> auxiliar
;;
esac
else
case $MOD in
0) echo L$K >> auxiliar
;;
1) echo H$K >> auxiliar
;;
esac
fi
K=`expr $K + 1`
done
echo H13L04L03H05D00020L05D00020 >> auxiliar
SALIDA=`sed 's/\n//g' auxiliar`
SALIDA=`echo $SALIDA | sed 's/ //g'`
rm auxiliar
fi
fi
echo $SALIDA > /dev/cua/1
}

imprimir_caracter()
{
CARACTER=$1
case $CARACTER in
0)echo L06L07L08L09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
1)echo H06L07L08L09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
2)echo L06H07L08L09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
3)echo H06H07L08L09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
4)echo L06L07H08L09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
5)echo H06L07H08L09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
6)echo L06H07H08L09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
7)echo H06H07H08L09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
8)echo L06L07L08H09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
9)echo H06L07L08H09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
:)echo L06H07L08H09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
=)echo H06L07H08H09H10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
A)echo H06L07L08L09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
B)echo L06H07L08L09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
C)echo H06H07L08L09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
D)echo L06L07H08L09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
E)echo H06L07H08L09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
F)echo L06H07H08L09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
G)echo H06H07H08L09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
H)echo L06L07L08H09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
I)echo H06L07L08H09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
J)echo L06H07L08H09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
K)echo H06H07L08H09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
L)echo L06L07H08H09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
M)echo H06L07H08H09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
N)echo L06H07H08H09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
O)echo H06H07H08H09L10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
P)echo L06L07L08L09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
Q)echo H06L07L08L09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
R)echo L06H07L08L09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
S)echo H06H07L08L09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
T)echo L06L07H08L09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
U)echo H06L07H08L09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
V)echo L06H07H08L09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
W)echo H06H07H08L09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
X)echo L06L07L08H09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
Y)echo H06L07L08H09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
Z)echo L06H07L08H09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
Z)echo H06H07L08H09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
Z)echo H06H07L08H09H10L11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
a)echo H06L07L08L09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
b)echo L06H07L08L09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
c)echo H06H07L08L09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
d)echo L06L07H08L09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
e)echo H06L07H08L09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
f)echo L06H07H08L09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
g)echo H06H07H08L09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
h)echo L06L07L08H09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
i)echo H06L07L08H09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
j)echo L06H07L08H09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
k)echo H06H07L08H09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
l)echo L06L07H08H09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
m)echo H06L07H08H09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
n)echo L06H07H08H09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
o)echo H06H07H08H09L10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
p)echo L06L07L08L09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
q)echo H06L07L08L09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
r)echo L06H07L08L09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
s)echo H06H07L08L09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
t)echo L06L07H08L09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
u)echo H06L07H08L09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
v)echo L06H07H08L09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
w)echo H06H07H08L09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
x)echo L06L07L08H09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
y)echo H06L07L08H09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
z)echo L06H07L08H09H10H11H12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
�)echo L06H07L08H09H10H11L12H13L04H03H05D00020L05D00020 > /dev/cua/1
;;
_)echo L06L07L08L09L10H11L12L13L04H03H05D00020L05D00020 > /dev/cua/1
;;
esac
}

imprimir_cadena()
{
# Elimino todos los espacios en blanco de la cadena, para que
# no entre en conflicto con los espacios que no se escriben
# y el n�mero de car�cter que lleva en bucle
# Despu�s, si no hay nada que escribir , no hago nada, en caso
# contrario, distingo entre mensajes que entran en display y
# los que no. Los primeros los escribo a dos renglones.
# Los segundos, mediante desplazamiento de display (tipo banner).
# Finalmente, para cada car�cter, llamo a la funci�n imprimir_caracter.


CADENA=`echo $* | sed 's/ //g' | cat`
LONGITUD_CADENA=`echo $CADENA | wc -c`
LONGITUD_CADENA=`expr $LONGITUD_CADENA - 1`
if test $LONGITUD_CADENA -ne 0
then
I=1
while test $I -le $LONGITUD_CADENA
do
if test $I -ge 17
then
if test $LONGITUD_CADENA -le 32
then
if test $I -eq 17
then
posicionar_cursor 41
fi
else
if test $I -eq 41
then
posicionar_cursor 1
else
desplazar_display 1
II=`expr $I + 1`
if test $II -eq $LONGITUD_CADENA
then
desplazar_display 1
fi
fi
fi
fi
CARACTER=`echo $CADENA | cut -c $I`
imprimir_caracter $CARACTER
I=`expr $I + 1`
done
fi
}

imprimir_cadena $*


Pues bien, comenzamos haciendo que el script pueda ser interpretado por ash. A continuación creamos una serie de funciones que nos ayudarán a modularizar la aplicación y a reutilizar el código. En primer luga r, debemos mandar a Arduino la secuencia de bits necesaria para que éste, a su vez, lo envíe al lcd. Si miramos la documentación del lcd vemos cómo se lleva a cabo esa inicialización, dependiendo de si deseamos mostrar el cursor, en modo parpadeo, en formato 16 x 2 o 16 x 1...
La siguiente función nos realiza el desplazamiento del display teniendo en cuenta que sólo puede mostrar 16 de los 40 caracteres disponibles. Vuelvo a instar a que se lea con detenimiento la documentación del display. Ahí veremos cómo el display dispone de una zona de memoria de 40 posiciones por 2 filas. Al poder mostrar tan sólo 16 x 2 de esas 80 posiciones, es útil tener una función que nos permita mover esa pequeña "ventana" sobre toda la zona de memoria. Para ello, lo único que hacemos es pasarle como parámetro el número de desplazamientos (en este caso he optado hacia la derecha, por ser más útil) a la función desplazar_display y realizar mediante un bucle la iteración de desplazamientos individuales mediante la correspondiente serie de bits. No he dicho que el envío de esos bits en alta o baja sólo corresponden a una decisión propia. Todo depende de a qué pines hemos conectado el lcd a Arduino.
Otra función de movimiento en el lcd afecta esta vez al cursor. Imaginemos que tenemos una palabra de 16 letras. En este caso, esa palabra entra exáctamente en la primera fila del lcd, y, por tanto, no va a haber problemas, pero... qué ocurre si la palabra es de 17. En ese caso, no puede escribirse en la posición 18 de la primera fila, pues no aparecería en la "ventana" del lcd. Para ello, tendría que posicionarse en la posición 1 de la 2ª fila. Bien, esto parece bastante sencillo, pero ¿qué ocurre si tenemos en cuenta que el cursor se desplaza de forma secuencial (ya sea escribiendo carácteres o espacios en blanco), y tendrá que recorrer 40-16 posiciones hasta "bajar" a la segunda fila?, pues que a la vista de alguien, queda bastante mal que transcurra un tiempo notable sin que se escriba nada en el lcd. Para ello debe implementarse la función que posiciona automáticamente el cursor en la posición. Para ello se revisa de nuevo la documentación del lcd y se comprueba cómo el lcd dispone de una zona de memoria, correspondiente con cada posición de carácter a escribir, a la que se puede acceder mediante un comando donde se le indica tal posición (jo ke lío). El problema es que, cuando llamamos a la función posicionar_cursor con un entero, por ejemplo, el 42, la función tiene que comprobar, en primer lugar, que se encuentra entre el 1 y el 80, para, después, indicar en los 7 bits de datos, el entero 42. Para ello debe convertirse el 42 a binario, operación que se lleva a cabo en las líneas sucesivas. En ellas, se va insertando temporalmente cada uno de los bits de datos (del 06 al 12 para Arduino) en su formato en alta o baja (H06H07L08 ...). Finalmente se añade a ese archivo los bits en alta y baja correspondientes a la configuración de la señal que se envía, correspondiente al desplazamiento en el lcd (H13L04L03H05D00020L05D00020 >> auxiliar . ¿y... qué significa esas líneas siguientes? (SALIDA=`sed 's/\n//g' auxiliar` SALIDA=`echo $SALIDA | sed 's/ //g'`) Tan sólo eliminan los saltos de línea que hemos ido creando al añadir elementos al archivo auxiliar, además de los espacios en blanco, para que puedan ser interpretados correctamante al hacer echo. Finalmente enviamos los bits a Arduino.

Otro paso importante es la propia escritura de un carácter. Cuando llamemos finalmente a la función lcd mi_nombre_es_edu tenemos que ser capaces de escribir cada uno de esos carácteres. Para ello necesitamos hacer algo tan tedioso como representar el abecedario más básico con el que podemos trabajar asociándolo a su código binario en "pseudoASCII" (ver códigos del lcd) junto a los bits de control para enviarlo por el puerto serie a Arduino. La función consiste en un simple case sobre todo el conjunto de valores.

Finalmente nos queda tratar la cadena tal cual nos la dan a la función principal. Pero, un problema grave es cómo poder escribir espacios en blanco, y tratar además posibles variables a la entrada de la función. Es decir, imaginemos que tenemos la cadena "Tengo 20 monedas". Si pasamos la cadena en cuestión a la función, tenemos ./lcd Tengo 20 monedas entonces estaríamos dando por parámetros a $1 = Tengo, a $2 = 20 y a $3= monedas. Tratarlas por separados cada uno de los parámetros es difícil. Para ello debemos reunir todos los parámetros. Además, necesitamos contar cuantos caracteres tiene la cadena. Para ello eliminamos los posibles espacios en blanco que haya y guardamos la cadena en la variable CADENA (CADENA=`echo $* | sed 's/ //g' | cat`), y después contamos los carácteres que tiene la cadena (eliminando el salto de línea). Finalmente, y tras comprobar que la cadena tiene al menos 1 carácter, vemos cuál sería la mejor representación de la cadena. Esto es, ya vimos qué ocurriría si la cadena tenía 17 caracteres. Tan sólo había que posicionarse en la posicion 1 de la 2ª fila. pero ¿Qué ocurriría si la palabra tuviese (2 x 16) + 1 carácteres? En ese caso, ni aún pasando por la segunda fila entraría la palabra. En este último caso es mejor dejar la palabra en la primera fila y desplazar toda la "ventana" haciendo "banner" a la derecha, siempre y cuando no supere la longitud de (2x40). De esto es, esencialmente, de lo que se encarga la última parte, de comprobar qué representación y qué movimientos debe hacer la función para que quede "más bonito". Por último, se imprime la cadena.

Una vez "creado" el controlador del lcd, nos queda bastante simplificada la representación de información en el lcd. Tan sólo tenemos que aplicar la expresión ./lcd La_cadena_que_quiero_escribir, para que me muestre la información de la forma más conveniente para que entre en el lcd.

Ahora crearemos la aplicación para monitorear la temperatura exterior, interior, la hora y diversos mensajes útiles que nos permiten sacar la funcionalidad al lcd.

Veamos el código:

#!/bin/ash

imprimir_temperatura()
{
/www/arduino/adquisitor $1 &
sleep 1
ps > procesos
cat procesos | grep adquisitor | cut -b 1,2,3,4,5 > proceso
PROCESO=`cat proceso`
kill -9 $PROCESO
VARIABLE=`cat nivel | cut -b 1,2,3,4`
AUX=`expr 870 - $VARIABLE`
TEMPERATURA=`expr $AUX / 5`
if test $1 -eq 0
then
TEMPERATURA=`expr $TEMPERATURA - 7`
else
if test $1 -eq 2
then
TEMPERATURA=`expr $TEMPERATURA + 2`
fi
fi
echo $TEMPERATURA
}

imprimir_temperaturas()
{
TEMPERATURA0=`imprimir_temperatura 0`
TEMPERATURA1=`imprimir_temperatura 2`
/tmp/mmc/Display/iniciar_lcd
/tmp/mmc/Display/lcd Temp._Int:_ $TEMPERATURA0 _C
/tmp/mmc/Display/posicionar 41
/tmp/mmc/Display/lcd Temp._Ext:_ $TEMPERATURA1 _C
}


J=1
while test $J -le 2
do
imprimir_temperaturas
sleep 3
/tmp/mmc/Display/iniciar_lcd
/tmp/mmc/Display/lcd ==_ROUTER_FON_==
sleep 3
imprimir_temperaturas
sleep 3
/tmp/mmc/Display/iniciar_lcd
/tmp/mmc/Display/lcd By_Eduardo_Marin
sleep 3
imprimir_temperaturas
sleep 3
/tmp/mmc/Display/iniciar_lcd
HORA=`date |cut -c 12-19`
/tmp/mmc/Display/lcd  ===_ $HORA _===
sleep 3
#/tmp/mmc/wifi_sd/escaner
done


Habíamos visto en otro post anterior cómo adquirir un valor numérico que nos daba la temperatura de un sensor conectado a una de las entradas analógicas.
Pues bien, en la aplicación descrita mostraremos 2 temperaturas, la hora local, y mensajes escritos en el lcd.
Las primeras líneas, correspondientes a la función imprimir_temperatura llaman al script adquisitor en modo background. Para terminar el proceso, pues hace uso de la función cat sobre la entrada serie, y ésta no muere a no ser que se la mate, se lleva a cabo esa operación. Para ello se caza su id de ejecución haciendo uso de ps para más tarde, matarlo.
Una vez matado, leemos la información que ha volcado la aplicación anterior sobre el archivo nivel. Después se hace una conversión de los 1024 niveles disponibles a la temperatura adecuada (para ello se hace un "calibrado" manual). Esta parte se aplica a las dos temperaturas. La siguiente función, imprimir_temperaturas lleva a cabo la impresión sobre el lcd, mostrando un mensaje de indicación Temp. Int. Cabe destacar cómo se lleva a cabo el posicionamiento del cursor para imprimir la siguiente línea (posicionar), que, aunque no corresponde a la función interna del script lcd, se trata de la misma idea, pues está en otra función llamada así.

Por último, quedaría la parte principal (main) del script. Esta parte se ejecuta indefinidamente, de ahí el while infinito, en el que se imprimen las temperaturas, se muestra mensaje de FON, se vuelven a imprimir temperaturas...

Para que éste script se lance de forma automática hay que insertar un enlace a éste en /etc/init.d/.

Pues bien, ya sé que pueden quedar bastante confusas algunas ideas. Puede que algunos puntos no estén lo suficientemente desarrollados o que, simplemente, haya cosas que no tengan sentido, pero tampoque tenía la necesidad de crear este tutorial si no fuese porque, de no ser así, a mí se me olvidaría todo el proceso (de hecho ya hay cosas que no recuerdo muy bien porqué las hice), y sería una lástima para mí.

De todas formas, espero que le pueda servir a alguno.

Byes byes.




4 comentarios:

spam dijo...

muy buenas,
he leido este topic y también el que comentas (GUÍA: CONTROL ARDUINO - LINKSYS WRT45GL), pero no me queda algo claro.

yo tengo hecha la modificación de la SD, y entonces la conexión de sacar el puerto serie que comentas en el otro post ya esta ocupada (los diez pines)...
...sin embargo, en este post veo que tienes la tarjeta de memoria y aún así tienes conectado el arduíno (supongo que a los doce pines!) ¿me puedes aclarar ese punto?

mi idea es conectar un rele para encencer y apagar un disco duro mandando una orden al arduino, pero no quiero perder el mod de la tarjeta :S

gracias

kayak dijo...

Buenas Spam,

nononooo! No necesitas conectar los 12 pines entre el Linksys y Arduino, basta con usar los dos pines de arduino de su puerto serie y los 4 que dispone Linksys (+v, rx, tx, -v). Así tienes libres un montón de pines en arduino y mantienes, por otra parte, intacto tu mod SD.

Si necesitaras más info avisa.

Un saludo!

Jesus Trenado dijo...

hola maquina!

Se te ocurre como mostrar por ese display las peticiones http de la red?

Yo tambien hago cosillas con el arduino, echale un vistazo a

http://cacharreototal.blogspot.com/2009/08/como-hice-la-alarma-que-te-avisa-por.html

Un saludo, y felicitaciones por tu trabajo.

Jesus Trenado dijo...

me autorespondo:

ya lo consegui.

http://cacharreototal.blogspot.com.es/2012/04/router-wifi-linksys-con-pantalla.html


Saludos.