• Sensor de humedad y temperatura con Arduino. Primera parte: El hardware.
• Sensor de humedad y temperatura con Arduino. Segunda parte: firmware.
• Sensor de humedad y temperatura con Arduino. Tercera parte: HttpRelay.

Utilizando la base desarrollada en artículos anteriores, se construyó un gadget para el escritorio de Windows 7 que nos muestra información sobre la temperatura y la humedad y cuyo aspecto se puede ver en la figura siguiente.

Además del manifiesto que le define, el gadget está compuesto de Html/CSS, JavaScript e imágenes que definen su background. El siguiente artículo que explica como desarrollar un gadget para Windows resultó muy útil.

Toda la lógica ha sido implementada en JavaScript utilizando Jquery y las APIs de visualización de Google.

El gadget establece un timer que ejecutará una medición de forma periódica cada minuto utilizando ajax. Si la petición tiene éxito se ejecutará la función measureReceived.

En la función measureReceived, ejecutada después de cada medición, se actualizarán los valores de las medidas, así como del gráfico que representa su historia. También se calcularán y actualizarán los estadísticos valor medio, mínimo y máximo de la humedad y temperatura.

El código fuente se adjunta al artículo.

• Sensor de humedad y temperatura con Arduino. Primera parte: El hardware.
• Sensor de humedad y temperatura con Arduino. Segunda parte: firmware.

El acceso a través del puerto serie resulta inconveniente para el propósito de crear un gadget para el escritorio de Windows 7, por lo que se hace necesario escribir un pequeño programa que nos permita trasladar peticiones HTTP convencionales a peticiones a través del puerto serie. Se ha escrito dicho programa y se ha denominado HttpRelay.

Dicho programa se queda residente como un icono en la barra de notificaciones encargándose de trasladar las peticiones HTTP GET a comandos a través del puerto serie que se haya configurado. De esta forma, podemos comunicarnos con el Arduino a través de HTTP.

El programa se configura a través de un archivo xml que indica la URI en la que se debe escuchar y el puerto serie COM al que se delegará la respuesta, así como, la velocidad en bits por segundo a la que se debe utilizar el puerto.

El programa traslada al puerto serie el parámetro de query llamado ‘q’ por lo que si deseamos obtener mediciones de temperatura y humedad con la configuración anterior, utilizando el comando ‘g’ definido en el firmware, deberemos utilizar la URL: ‘http://localhost:8080/?q=g’

El programa HttpRelay, escrito en c#, utiliza la clase HttpListener para realizar la escucha en una URL determinada. Su código fuente se adjunta en este artículo.

El programa de Arduino que utilizaremos para obtener la medición de temperatura y humedad del sensor SHT15 proporcionará un sencillo interface a través del puerto serie. Dicho programa está basado en el código de Hobby robotics, aunque ha sido fuertemente modificado para adaptarse a nuestras necesidades.

En el principio del programa se definen las constantes que representan a cada uno de los comandos que utilizaremos del sensor, así como a los pines a los que están conectadas las líneas DATA y SCK del sensor. La función shiftIn nos permite leer un numero arbitrario de bits del sensor.

La función sendCommand contiene toda la lógica que envía un comando al sensor SHT15 siguiendo el protocolo descrito en el artículo anterior.

Después de enviar un comando es necesario esperar unas cuantas decenas de milisegundos a que se realice la medida. Una vez que la medida se ha completado, el sensor avisará poniendo la línea DATA a 0. El esperar el resultado de la medida, es el objetivo de la siguiente función.

Por último, la función getResult obtiene el resultado de la medida del sensor siguiendo el protocolo descrito en el artículo anterior. Dicha medida se obtiene como un entero de 16 bits que será necesario procesar para obtener la medida en las unidades de humedad y temperatura.

Ese es el objetivo de las siguientes funciones printTemperature y printHumidity; envían el comando correspondiente al sensor obteniendo el resultado como un entero de 16 bits, convierten dicho entero a un valor de temperatura en grados centígrados y a un valor de humedad relativa, imprimiendo dichos valores a través del puerto serie.

La última parte del sketch de arduino es la configuración que simplemente establecerá el pin SCK como de salida y configurará el puerto serie a 9600 bps.

y el bucle principal que define una serie de comandos para obtener la medición de la temperatura y la humedad. El comando que utilizaremos en artículos posteriores es el comando ‘g’. Al recibir una ‘g’ en ASCII por el puerto serie, el programa realizara mediciones de la temperatura y de la humedad y las imprimirá por el puerto serie separadas por el carácter ‘|’ y finalizadas por ‘\r\n’.

La implementación de dicho programa en el Arduino ya nos permite obtener los valores de temperatura y humedad utilizando un programa de terminal tal y como se muestra en la figura siguiente.

En un artículo posterior utilizaremos esta base para construir un gadget para el escritorio de Windows 7.

El interface con el sensor consiste de lógica estática y por lo tanto no existe una frecuencia de reloj mínima. El pin de datos triestado es utilizado para escribir y leer datos del sensor. Los datos se validan en el pulso de subida del reloj y deben permanecer estables mientras el reloj esté en estado alto.

En el datasheet del sensor se muestran las frecuencias máximas de operación que soporta el sensor, sin embargo, los comandos para modificar los pins del arduino imponen la suficiente sobrecarga para que en este caso no nos tengamos que preocupar de sobrepasarlas, y por lo tanto, no es necesario introducir ningún retraso a la hora de modificar los pins del interface para operar con el sensor.

En las siguientes figuras se muestra una traza del comando para medir la temperatura. El trazo superior de la figura representa el reloj (SCK) y el inferior los datos (DATA). El comando para medir la humedad es muy parecido por lo que solo se ilustrará el de temperatura.

La secuencia para enviar un comando consiste en poner DATA a 0 mientras SCK es 1, seguido por un pulso de reloj de 1 a 0 y de 0 a 1 para a continuación poner de nuevo DATA a 1 con SCK aún a 1.

Posteriormente a la secuencia de inicio de comando se envían 3 bits de dirección (que deben ser 000) y 5 bits de comando, que en el caso del comando para medir la temperatura son 00011.

El sensor indica la correcta recepción del comando estableciendo DATA a 0 durante la parte activa del siguiente pulso del reloj y liberando la línea en la caída de dicho pulso lo cual hace que DATA quede a 1 después del noveno pulso de reloj. A partir de ese momento el sensor realiza la medida, que tardara unas decenas de milisegundos. El sensor avisará de que ha completado la medida estableciendo DATA a 0.

En el momento que DATA vale 0 podemos proceder a leer los datos de la medida realizada por el sensor.

Se lee el primer byte, que en el caso anterior corresponde a 00011000 = 0x18 y se envía un ACK poniendo la línea de datos a cero durante el siguiente pulso de reloj. A continuación se lee el segundo byte correspondiente a 00011010 = 0x1A y en este caso no enviamos un ACK debido a que no vamos a utilizar el CRC que nos podría enviar el sensor como un tercer byte si le diéramos un ACK. El mantener DATA activo después de leer el segundo byte indica al sensor que hemos terminado y le permite pasar a modo SLEEP.

Después de leer el valor hexadecimal 0x181A que equivale a 6170 obtenemos la temperatura mediante la siguiente fórmula: T= –40.1 + 6170 * 0.01 = 21.6ºC

El circuito controlador elegido es el chip ULN2003AN que utilizamos a modo de relé para encender y apagar cada led.

El led tiene cuatro puertos, un ánodo común y un cátodo para cada uno de los colores: rojo, verde y azul. Al combinarse estos colores en distintas proporciones podemos crear la sensación de estar viendo casi cualquier color.

El esquema de circuito se muestra en la siguiente figura:

El sketch Arduino le programa para recibir mensajes de cambio de color del led vía el puerto serie en un formato ‘COLOR R G B’. Una vez recibido el mensaje utiliza la función analogWrite para controlar la corriente que circulara cada led vía modulación de anchura de pulso (PWM).

Posteriormente se realizo un programa en .NET que permite especificar el color del led de una forma amigable. El siguiente video muestra el resultado:

Se adjunta un archivo con el código del sketch arduino y el programa de .NET.

Constan de tres señales de entrada: alimentación, referencia, y señal de control. Utilizando la señal de control se puede posicionar el motor dentro del rango. El control se realiza a través de pulsos de duración determinada de la señal de control. Por ejemplo, para posicionar un servomotor controlado con pulsos de 1msg a 2msg de rango 0-180 grados a 90 grados necesitaríamos suministrar a la señal de control un pulso de 1.5msg de duración.

Se conecta el control del servomotor a la salida digital número 9 del Arduino que programaremos para recibir mensajes de posicionamiento a través del puerto serie, interpretarles y posicionar el servomotor. Para ello utilizaremos las librerías de control de servos (Servo) y de delimitación de mensajes del puerto serie (Messenger).

La inicialización del programa del Arduino se muestra en la siguiente figura donde simplemente indicamos a la librería de control de servos que se utilizará el pin 9 para el control, inicializamos el puerto serie a 115200 baudios e inicializamos la librería de procesado de mensajes.

Dentro del bucle principal simplemente se leerá el puerto serie esperando mensajes de la forma ‘SERVO n’ donde n es un número de 0 a 178 que indica el ángulo en grados donde se desea posicionar el motor. Una vez interpretado el mensaje satisfactoriamente se posicionara el servomotor y se añadirá un pequeño retraso de 15msg que permita al servomotor posicionarse antes de recibir otra orden.

Para la aplicación WPF diseñaremos una clase con una única propiedad que permita establecer la posición del servo. Haremos que dicha propiedad sea ‘Bindable’ para poderla enlazar de forma natural con los controles de interface gráfico.

La parte principal de dicha clase se muestra en la figura siguiente:

y se creará un interface gráfico para el control en XAML enlazando a dicha propiedad de la siguiente manera:

El resultado se puede ver en el siguiente video. El código fuente de ambos programas se adjunta en el artículo:

El circuito es extremadamente sencillo, basta conectar los pins de alimentación y referencia del sensor para alimentarle, y que de esta forma nos proporcione en su otro pin un voltaje proporcional a la temperatura, el cual leeremos a través de la entrada analógica número 0 del Arduino, cuyo ADC nos proporciona una resolución de 10 bits.

El programa cargado en el Arduino es simplemente un bucle que cada segundo lee el voltaje de la entrada analógica y le convierte en un valor de temperatura utilizando las indicaciones de la hoja de características del sensor, enviando posteriormente este valor por el puerto serie.

El programa de PC leerá de forma continua los valores de temperatura que le vayan llegando por el puerto serie virtual (USB) y representándoles en pantalla. Su código principal es el siguiente (Aplicacion WPF en C#):

Con lo cual podremos leer en la pantalla del PC el valor de temperatura procedente del sensor, el cual se actualizará cada segundo.

World Science Festival 2009: Bobby McFerrin Demonstrates the Power of the Pentatonic Scale from World Science Festival on Vimeo.

Para ello se definirá un parámetro t, que representa el progreso de la transición y cuyo rango es de 0 a 1. Un valor de cero significa que la transición aún no ha comenzado, es decir, aún se muestra completamente la imagen de origen, mientras que un valor de 1 significa que se ha completado el 100% de la transición, es decir, se mostrará la imagen de destino. Un valor de 0.5 significaría que la transición está al 50% por lo que se mostraría una mezcla a partes iguales de la imagen de origen y la imagen de destino.

Para su implementación se utilizará un WriteableBitmap. Los pixeles de un WriteableBitmap en Silverlight se representan como valores pargb lo que implica que el canal alpha, encargado de representar el nivel de opacidad, debe ir premultiplicado por lo que para representar un color rojo 50% transparente el pixel debería contener los valores [0.5,0.5,0,0]. De todas formas, para el caso que nos ocupa simplemente realizaremos la interpolación entre cada uno de los componentes de cada pixel de la imagen.

Si representamos cada pixel como un vector de cuatro componentes, siendo tr el vector que representa a un pixel de la transición, o a uno de la imagen de origen y d a uno de la imagen de destino el calculo de cada uno de los pixeles de la transición para un t dado se realiza mediante la siguiente expresión:

siendo x,y las coordenadas del pixel.

El siguiente programa en Silverlight muestra el efecto de transición con dos imagenes predefinidas.

El código fuente del programa se encuentra adjunto al artículo.

Su funcionamiento es muy sencillo, basta con pasar en el constructor el número de pixels de ancho y de alto que queremos que tenga la imagen para generarla y una vez generada podemos acceder a su contenido a través de la propiedad Pixels.

En el siguiente fragmento de código se construye un bitmap de 320x200 pixels y se establece el pixel en la posición (x, y) al color (r,g,b). Una vez modificado el bitmap se debe llamar a la función Invalidate para actualizar su contenido.

   1: var bitmap = new WriteableBitmap(320,200);

   2: var pixelColor = BitConverter.ToInt32(new byte[] { (byte)b, (byte)g, (byte)r, 255 }, 0)

   3: bitmap.Pixels[x + y * bitmap.PixelWidth] = pixelColor;

   4: bitmap.Invalidate();

Por supuesto es necesario asignar el bitmap a la propiedad Source de un control Image para representarle en pantalla.

Una funcionalidad interesante añadida es el método Render que permite representar en el bitmap un control gráfico descendiente de UIElement después de aplicarle una transformación (rotación,escala,posición) lo que abre la puerta a la generación de interesantes efectos.

La siguiente ilustración muestra la generación dinámica de bitmaps. Si posa el cursor sobre la imagen podrá ver una representación de metaballs construida sobre un WriteableBitmap.