Arduino y sensores de temperatura

Esta parte es bastante sencilla y me he basado en este tutorial de AdaFruit (http://learn.adafruit.com/tmp36-temperature-sensor)

El cableado, sencillo donde los haya, es el siguiente.

Y el código para el Arduino. También bastante sencillo. Lo más complido aquí es calcular la temperatura en ºC, a partir del voltage que nos devuelve la patilla central. El datasheet del sensor y el tutorial de AdaFruit nos dan la siguiente fórmula.

Este es el enlace al código para el Arduino. A partir de ahora para comodidad y profesionalidad, lo voy a subir a una cuenta en github.

Explico a continuación las fórmulas.

Voltage en el pin en Mili Voltios = valor del pin Analógico de Arduino * 5000 / 1024

5000 es porque yo utilizo un Arduino UNO, que funciona a 5V. Si utilizara otro Arduino que funcione a 3.3V, hay que utilizar el valor 3300. O como se verá más adelante, una Raspberry Pi, que funciona a 3.3.

Lo que hace esta fórmula es normalizar el valor 0-1023 que devuelve el pin a un valor 0-5000 mV que son 5 V. Lo de convertir a mili Voltios es porque el datasheet del sensor nos da la relación entre miliVoltios y ºC mediante la siguiente fórmula.

Temperatura en ºC = (mili Voltios - 500) / 10

Disculpad si he cometido algún error con la nomenclatura de las magnitudes físicas. Estoy abierto a correcciones/sugerencias/comentarios.

Las lecturas no son del todo estables como he podido comprobar en esta salida del puerto serie. Sobre estabilizar las lecturas, hay cientos de cosas muy profesionales si se busca en google. Como no pretendo, de momento, controlar ningún proceso crítico con esto, quedo contento con el experimento.

------------------------------

Valor entrada analógica: 154

mV: 751.95
Grados ºC: 25.20
------------------------------
Valor entrada analógica: 157

mV: 766.60
Grados ºC: 26.66
------------------------------
Valor entrada analógica: 152
mV: 742.19
Grados ºC: 24.22
------------------------------
Valor entrada analógica: 156
mV: 761.72
Grados ºC: 26.17
------------------------------
Valor entrada analógica: 152
mV: 742.19
Grados ºC: 24.22
------------------------------

Emisor Receptor RF con Arduino (III): Conclusiones

Los tutoriales que encontré por internet trataban el tema a tan bajo nivel que se me hacía imposible seguirlos. Esta librería te abstrae completamente de todo y sólo te tienes que preocupar practicamente de la función enviar mensaje y recibir mensaje. Te lo dan todo hecho. Aunque esto, para gente que le guste trastear más, pueda ser un inconveniente. Yo, sólo puedo decir cosas buenas de VirtualDrive para Arduino.

He probado el alcance, y a unos tres metros, que es lo máximo que me dan los cables usb, funciona igual de bien. No estoy usando antenas de ningún tipo. Debería buscar como alimentar al Arduino con una base de pilas. De este modo no estaría limitado al cable conectado al ordenador.

Lo siguiente que voy a intentar hacer en esta línea, es conectar el Arduino emisor al ordenador que leerá órdenes de un joystick, y un Arduino receptor al Lego(C) Mindstorms y tratar de manejarlo remotamente, al más puro estilo coche teledirigido.

Emisor Receptor RF con Arduino (II): Primer intento

He estado buscando por internet tutoriales sobre el tema y de todo lo que he encontrado, lo que más esperanzas me ha generado, ha sido VirtualWire para Arduino.

Como dicen los creadores, y yo traduzco, "VirtualWire es una librería para Arduino que permite enviar mensajes cortos, sin direccionamiento, retransmisión o confirmación, como un UDP inalámbrico, utilizando ASK"

VirtualWire is an Arduino library that provides features to send short messages, without
addressing, retransmit or acknowledgment, a bit like UDP over wireless, using ASK
(amplitude shift keying).

El enlace anterior apunta a un documento donde está explicada perfectamente toda la librería. Lo cierto es que la API que proporcionan es bastante limpia y parece sencilla. Así que manos a la obra.

Lo primero que vamos a programar es la parte emisora y el código que he escrito es el siguiente. Es realmente sencillo. Lee cada medio segundo el estado de los botones y lo envía.

#include 

int pinRojo = 2;
int pinVerde = 3;
// me he dado cuenta de que no hace falta
// configurarlo para salida o entrada
int pinTx = 4;

void setup(){
  pinMode(pinRojo,INPUT);
  pinMode(pinVerde,INPUT);

  vw_set_tx_pin(pinTx);
  vw_setup(2000);

  Serial.begin(9600);
}//setup

void loop(){
  delay(500);

  int estadoRojo = digitalRead(pinRojo);
  int estadoVerde = digitalRead(pinVerde);

  char *mensaje = "VACIO";

  if ( (estadoRojo ==  HIGH ) && (estadoVerde == HIGH) ){
    mensaje = "A"; // rojo + verde = azul
  }else if ( (estadoRojo == LOW) && (estadoVerde == LOW) ){
    mensaje = "N"; // nada
  }else if ( (estadoRojo == HIGH) && (estadoVerde == LOW) ){
    mensaje = "R"; // rojo
  }else if ( (estadoRojo == LOW) && (estadoVerde == HIGH) ){
    mensaje = "V";      //verde
  }
  
  Serial.print("Enviado -> ");
  Serial.println( mensaje );

  vw_send( (uint8_t *) mensaje , strlen(mensaje) );   
}//loop

Y aquí se puede ver el circuito que he montado para el emisor. Está hecho con Fritzing. Como no tenía un componente para el emisor, he dejado el cableado suelto y he añadido las patillas.



Y ahora, vamos a por la parte receptora. También sencilla, cada vez que recibe un mensaje, lo compara y enciende el LED correspondiente.

#include 

int pinRojo = 2;
int pinVerde = 3;
int pinRx = 4;

void setup(){
  pinMode(pinRojo,OUTPUT);
  pinMode(pinVerde,OUTPUT);

  Serial.begin(9600);

  vw_set_rx_pin(pinRx);
  vw_setup(2000);
  vw_rx_start();
}//setup

void loop(){
  // esto es un poco engañoso porque sólo voy
  // a recibir cosas de tamaño 0
  uint8_t mensaje[VW_MAX_MESSAGE_LEN];
  uint8_t longitud = VW_MAX_MESSAGE_LEN;

  if (vw_get_message( mensaje , &longitud ) ){    
    Serial.print("Recibido -> ");
    Serial.println( mensaje[0] ); 
    
    if( mensaje[0] == 'A' ){
       digitalWrite( pinRojo , HIGH );
       digitalWrite( pinVerde , HIGH );       
    }else if( mensaje[0] == 'R' ){
       digitalWrite( pinRojo , HIGH );
       digitalWrite( pinVerde , LOW );             
    }else if( mensaje[0] == 'V' ){
       digitalWrite( pinRojo , LOW );
       digitalWrite( pinVerde , HIGH );             
    }else if( mensaje[0] == 'N' ){
       digitalWrite( pinRojo , LOW );
       digitalWrite( pinVerde , LOW );             
    }// if de caso de mensaje
  }//if de he recibido un mensaje 
}//loop

Y aquí se puede ver el circuito que he montado para el receptor. Está hecho con Fritzing. Como no tenía un componente para el receptor, he dejado el cableado suelto y he añadido las patillas.



Y me ha funcionado todo, más o menos a la primera, y no me lo creo todavía. He conseguido exactamente lo que pretendía en un principio. Aquí os dejo un video de esta maravilla funcionando.

Emisor Receptor RF con Arduino (I): Introducción

Durante un arrebato consumista estas navidades, hice un pedido a una tienda de electrónica de un montón de cachirulos. Una de las cosas que pedí, fueron un par de módulos emisor y receptor de radiofrecuencia.

Y como el pedido me vino muy bien, rápido y no tengo ninguna queja, os he enlazado los productos a la tienda.

Lo que pretendo conseguir es conectar un Arduino a un emisor, y otro Arduino al receptor, y tratar que se comuniquen entre si utilizando la magia de las ondas.

Aprovecho para contar, que en mi arrebato consumista navideño, cayó un Arduino Uno. Para que juege con el Arduino Duemilanove que ya tenía, que estaba muy sólo ultimamente.

¿Cómo voy a probar que mis dos Arduinos se llevan bien, y hablan entre si? El Arduino emisor leerá los valores de dos botones, y el Arduino receptor encenderá un par de leds según el botón pulsado.

Hola Mundo u Hola LED

Hoy voy a dar mi primer paso con Arduino. Al parecer para iniciarse en este mundo, tenemos un Hola mundo!, pero a lo Arduino, y con un diodo emisor de luz. Voy a seguir los pasos de este tutorial, que iré comentado con las cosas que me encuentre.

A mano todo lo importante

Lo primero que necesitamos es obviamente un Arduino, yo tengo un Duemilanove, así que a partir de ahora, mis referencias a Arduino, son en realidad a Arduino Duemilanove.

También hace falta un cable USB, de conector A a B. El que viene con nuestro Lego(c) MindStorms, sirve perfectamente. Esto es para conectar el Arduino con el ordenador.

Y por último hace falta el entorno de desarrollo de Arduino, que se puede descargar desde aquí. Sigo pendiente de volver a instalar mi distribución GNU/Linux favorita, Gentoo, así que voy a comentar todo sobre un Microsoft Windows XP SP3. Es un fichero zip, que descomprimimos donde queramos y hay que ejecugtar arduino.exe. Es una aplicación java, así que hay que darle tiempo. Ahora podemos ver una pantalla que tengo la impresión que se me va a hacer muy familiar dentro de poco.

Conectado Arduino a un ordenador por primera vez

Conectamos el Arduino con el cable USB y a Windows le da un jamacuco intentando reconocer el hardware, pero no hay problema. Le damos a buscar los controladores por nuestra cuenta y seleccionamos el directorio drivers del zip que hemos descomprimido en el paso anterior.

Ahora muy importante, que a mi no me funcionó nada la primera vez por esto, es configurar el puerto donde está escuchando el Arduino y que tipo es la placa.

Para ello nos vamos al menú TOOLS -> BOARD y seleccionamos la que tengamos.

Y ahora en el menú TOOLS -> SERIAL PORT. Ahora viene la gran pregunta ... ¿en qué puerto tengo conectado el Arduino?, truquele fácil, enchufamos el Arduino y vemos la lista de puertos disponibles, desenchufamos el Arduino y vemos cuál ha desaparecido ... ese será nuestro puerto.

Darle al play

Ahora viene la parte más fácil. En el menú seleccionamos FILE -> OPEN y buscamos en examples/digital/blink el fichero blink.pde. Vemos que un código se ha cargado en la pantalla principal del editor.

Ahora, con el Arduino conectado pinchamos en el botón de upload, que es como el de play y si todo ha ido bien ... veremos a nuestro Arduino haciendo lo siguiente.

Si algo ha fallado, nos toca buscar en este enlace.

Por hoy ya he tenido suficiente. Al próximo día más y mejor. Hay muchos tutoriales y vídeos por internet donde se pueden encontrar ideas interesantes. De momento no tengo nada definido de cual será mi siguiente paso

Arduino: entre mis manos

Hoy por fin he podido recoger mi Arduino Duemilanove. Una vez más el servicio de FunGizmos ha sido muy bueno, correcto embalaje y protección de todo lo pedido y en un tiempo más que razonable.

Aquí os dejo algunas fotos de mi nuevo juguetito y de cómo ha venido. Una vez más, un diez para FunGizmos

Podeis ver que a parte he pedido también algunas resistencias, unos interruptores y unos diodos emisores.




Tampoco tiene mucho sentido contar cosas de un Arduino en un blog sobre Lego(c) MindStorms, pero como el objetivo es que en un futuro, todo esté dentro del mismo saco ... Además así tiene más actividad el blog.

¡ El arduino ! ¡Qué viene!. Tenía que hacer la gracia, lo siento. En breve mi primera aventura y espero que no desventuras.