Estoy seguro de que acierto si digo que, en algún momento de tu vida, te enseñaron un campo que te gustó pero en el que por una cosa u otra no pudiste profundizar. Algo que te llamó la atención, que te interesó, que te motivó, que te gustó aprender, pero que finalmente tuviste que dejar de lado para dedicar tu tiempo a otras cosas quizá menos estimulantes aunque más prioritarias.

A mí, en mi caso, me pasó con la electrónica. Me llamó la atención desde siempre, disfruté aprendiendo algo de ella y ahora, varios años después, me he animado a retomarla y a volver a disfrutar pelando cables y juntando unos componentes con otros para hacer cosas que se mueven, suenan, se encienden y funcionan en el mundo real. Paralelamente, aprender algo que habia olvidado me ha ayudado a tener una nueva perspectiva del conocimiento que ahora mismo tengo.

El caso es que estoy dando mis primeros pasos con Arduino montando algunas cosas sencillitas. Hay muchísima información acerca de Arduino en la red, os recomiendo que visiteis su web y la entrada en la wikipedia. También hay un documental en castellano sobre Arduino que, aunque es un poco aburrido, dice algo con lo que yo también estoy de acuerdo: es una herramienta interesantísima para utilizar en los institutos ya que permite fomentar la imaginación de los adolescentes, independientemente de que éstos estudien letras o ciencias. Lo importante es utilizar la parte derecha del cerebro.

En esta entrada voy a explicar un pequeño montaje que hemos hecho entre Carlos Javier Prados, mi jefe, y yo, utilizando Arduino. Como ambos nos dedicamos al M2M, y a los dos nos gusta programar, la electrónica y el cacharrear, no ha sido muy difícil que nos pusieramos de acuerdo para hacer un pequeño prototipo conjunto y que disfrutásemos a medida que éste iba progresando y tomaba forma.

El funcionamiento del prototipo es muy sencillo y nos permitirá poder ver desde nuestro teléfono la temperatura que hace en un lugar que queramos. La idea es que dejes un pequeño sistema funcionando, por ejemplo, en el salón de tu casa y, ya en el trabajo, en la calle, en el cine, o en cualquier sitio con conexión a internet puedas ver qué temperatura hace en ese momento en el salón.

Los elementos que van a entrar en juego son tres:

• El primero de ellos es un pequeño circuito que va a medir la temperatura que hay en el ambiente. Esta temperatura le llegará en forma de voltaje a una placa Arduino, la cual programaremos para convertir ese voltaje en grados centígrados.
• El segundo es un ordenador que reciba la información directamente desde la placa Arduino y la suba a internet.
• El tercero es un dispositivo cualquiera con acceso a internet que nos permita conocer la temperatura medida en cualquier momento y en cualquier lugar.

En cuanto a los componentes que vamos a necesitar para cada uno de los elementos, son los siguientes:

1. Para poder medir la temperatura:

• Una placa Arduino. En este caso vamos a utilizar una placa Arduino UNO.
• Una placa de experimentación.
• Un sensor de temperatura.
• Cables

2. Para poder enviarla:

• Un ordenador con un puerto USB y conexión a internet.
• Una cuenta en http://pachube.com/
• Python y pyserial instalados.

3. Para poder leerla:

• Un dispositivo con conexión a internet y un navegador.

1. Cómo medir la temperatura

Si sabes algo de electrónica verás que el circuito es muy sencillo: dos cables se encargan de alimentar una resistencia cuya impedancia varía en función de la temperatura y un tercer cable devuelve el voltaje que no se ha consumido en dicha resistencia. Dicha resistencia, por tanto, actúa como un sensor de temperatura.

Los cables encargados de la alimentación son el rojo y el negro y el que devuelve el voltaje en función a la temperatura es el amarillo. Fijaros en que el cable amarillo se conecta en la entrada analógica 0 de la placa Arduino.

Una vez lo tengamos montado programamos la placa Arduino para que, en función al voltaje recibido por la resistencia, esta haga una conversión y envíe la temperatura ambiente en grados centígrados a través del puerto USB con el que se conecta la placa Arduino con el ordenador. El lenguaje, aunque parezca C, es Processing.

int PIN_SENSOR = 0;
int TIEMPO_ENTRE_MEDICIONES = 5 * 60 * 1000;  // 5 minutos
float MARGEN = .5;

float temperaturaAnterior = -100;

// ---------------------------------------------------
// procedimiento de iniciacion
// ---------------------------------------------------

void setup()
{
  Serial.begin(9600);
}

// ---------------------------------------------------
// procedimiento que se ejecuta permanentemente
// ---------------------------------------------------

void loop()
{
  float temperaturaActual = getTemperature(PIN_SENSOR);
  if (isInRange(temperaturaActual)) {
    temperaturaAnterior = temperaturaActual;
    Serial.println(temperaturaActual);
  }

  delay(TIEMPO_ENTRE_MEDICIONES);
}

/**
 * Metodo que devuelve la temperatura que mide el sensor conectado al pin
 * recibido por parametro
 */
float getTemperature(int pin)
{
  // recupera el voltaje leido por el sensor de temperatura
  // teniendo en cuenta que devuelve 10 mv por cada centesima de grado centigrado
  // con un offset de 500 mV para poder medir temperaturas por debajo
  // de cero grados
  return (getVoltage(pin) - .5) * 100;
}

/**
 * Metodo que devuelve el voltaje que mide el sensor conectado al pin
 * recibido por parametro
 */
float getVoltage(int pin)
{
  // el sensor devuelve como maximo 5 voltios
  // y la pata de arduino tiene una resolucion de 0 a 1023
  // de tal modo que 5 / 1024 = .004882814
  return (analogRead(pin) * .0048828125);
}

/**
 * Metodo que indica si la temperatura medida esta dentro de los margenes
 * en los cuales consideramos que no es necesario actualizar la informacion
 */
boolean isInRange (float temperatura)
{ 
  return ((temperatura + MARGEN) <= temperaturaAnterior || (temperatura - MARGEN) >= temperaturaAnterior);
}

El código, como veis, está muy explicado. Lee la temperatura del sensor desde la entrada analógica 0 cada 5 minutos, y si ésta ha variado en más de medio grado por encima o por debajo la envía a través del cable USB.

Poder programar en la placa Arduino y poder hacer pruebas leyendo del puerto USB es muy sencillo gracias a Arduino IDE, por lo que no entraré en detalles.

El sensor que hemos utilizado es el TMP36GZ, de tal modo que el programa funciona bien con ese sensor pero, para otro sensor diferente, será necesario hacer un programa distinto.

2. Cómo enviar la temperatura

De momento tenemos un pequeño circuito que cada 5 minutos comprueba la temperatura y, si ésta ha cambiado en más de medio grado por encima o por debajo, nos la devuelve. Ahora debemos leer esa temperatura y publicarla en internet para poder verla cuando estemos en otro sitio.

Para publicarla barajamos varias opciones, como por ejemplo hacer una pequeña aplicación y dejarla en Google App Engine, pero no nos aportaba mucho y nos hacía trabajar más. Otra opción era crearle una cuenta de twitter al sensor y que fuese publicando la tempertura, lo cual aunque nos pareció gracioso no terminó de cuajar. Finalmente decidimos que la mejor opción era utilizar pachube, que es un servicio cuya función es precisamente la de poder enviar y recibir información leida desde sensores que tienen los propios usuarios, así que creamos una cuenta gratuita en pachube y le dimos uso.

Pero claro, la placa Arduino por sí sola no envia la información a pachube, simplemente la envía por el puerto USB. Es por ello que hicimos un pequeño script en Python que lee desde el puerto USB y, cuando hay una nueva lectura, genera un objeto JSON y lo envía a pachube:

#!/usr/bin/env python

import httplib
import serial
from string import Template

ser = serial.Serial('/dev/tty.usbmodem1a21', 9600)

while 1:

#       LEEMOS LA TEMPERATURA ENVIADA POR ARDUINO
#       le quitamos los dos ultimos caracteres

        readedTemperature = ser.readline()[:-2]
        print "The new temperature is :", readedTemperature

#       CREAMOS EL OBJETO JSON
#       reemplazamos los valores en una plantilla

        bodyTemplate = '''{
        "version":"1.0.0",
        "datastreams":[
                {"id":"0", "current_value":"$temperature"}
        ]
        }'''
        template= Template(bodyTemplate)
        bodyContent = template.substitute(temperature=readedTemperature)

#       LO ENVIAMOS A PACHUBE
#       aqui es necesario poner la key del usuario que tengais en pachube
#       y subir los datos a vuestro datastream

        headers={"X-PachubeApiKey":"VUESTRA KEY DE PACHUBE"}

        connection =  httplib.HTTPConnection('api.pachube.com')
        connection.request('PUT', '/v2/feeds/ID DATASTREAM', bodyContent, headers)
        response = connection.getresponse()
        print response.status, response.reason

Como veis, este código también está muy comentado. Tan sólo mencionar que pachube os crea una key y un datastream cuando os registrais y que debeis modificar este script en Python para rellenarlo con vuestros datos.

3. Cómo leer la temperatura

Bueno, dejamos el sistema funcionando y nos vamos. Cuando queramos saber qué temperatura hace en el lugar donde hayamos dejado el invento nos vamos a nuestra cuenta de pachube y lo consultamos. Veremos una gráfica como la siguiente:

4. Conclusiones

Pues como veis ha sido todo muy sencillo. La electrónica es muy simple y los dos programas hacen mucho con muy poco código. Lo bueno de utilizar estas herramientas para hacer estos prototipos es que se pueden hacer infinidad de cambios y, de este modo:

• enviar la temperatura, la humedad, la cantidad de luz y prácticamente cualquier magnitud física que se pueda medir.
• crear un sistema de alarmas que avise cuando la temperatura sea mayor o menor a cierta medida.
• que nos mandase correos electrónicos.
• que dejase mensajes en nuestro muro de Facebook.
• etc.

Me gustaría terminar esta entrada con una cita que, aunque no se de quién es, me viene en este caso como anillo al dedo:

“La diferencia entre los niños y los adultos está en el precio de sus juguetes.”