#include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); float temp; int tempPin = 0; void setup() { lcd.begin(16, 2); lcd.

print("Temperature:"); } void loop() { temp = analogRead(tempPin); temp = temp * 0.48828125; lcd.setCursor(0, 1); lcd.print(temp); delay(1000); }

Midiendo temperatura con LM35 y Pingino (o Arduino)

febrero 12, 2012

Interactuar con el mundo real es una de los puntos fuertes de los microcontroladores. Una de las maneras de hacerlo es tomando una medida analgica que represente una magnitud real. En este caso, mediremos temperatura usando un pequeo integrado, el famoso LM35 (datasheet). Es el mismo que utilic en mi proyecto Templogger. La conexin con nuestra placa es muy sencilla, pero hay un pequeo detalle importante. Veamos cmo se ve en una protoboard:

Ese detalle importante del que hablo es la resistencia. Conecta el pin Vout del LM35 (el que da la tensin de salida) con GND (masa). Su funcin es estabilizar la seal, y sus valores pueden estar entre 10 y 100 k. Este circuito en particular funcionar nicamente con temperaturas sobre 0, por lo que sirve para proyectos en un interior (o en exterior en zonas clidas). Si queris poder medir temperaturas bajo 0, hay circuitos en su hoja de datos. Para leer los datos, tanto Pingino como Arduino tienen una orden muy simple:
1 analogRead(pin);

que nos devolver un valor entre 0 y 1024 directamente proporcional a la tensin recibida. Mirando la hoja de datos del sensor, vemos que por cada C, la tensin en el pin Vout aumenta 10mV, por lo que para dar los 5V mximos (que corresponderan a una lectura de 1024) necesitaramos 500C, lo que no vamos a alcanzar (el sensor se fundira antes ). Por tanto, mediante una regla de 3, calculamos la operacin de conversin desde el valor que leemos en el pin, hasta la temperatura real, y tenemos:
1 temperatura = lectura * 500/1024

Pero queremos un nmero con decimales (flotante), por lo que aadimos esa peticin al cdigo:

1 temperatura = (float) lectura * 500/1024

Si quisiramos conseguir mayor precisin, podramos utilizar voltajes de referencia, lo que nos ayudara a tener un rango de temperatura menor ganando en calidad de lectura. Pero para una aplicacin usual no es necesario tanto (con el mtodo utilizado tenemos una precisin aproximada de ~0.5C). Por ltimo, utilizamos una pantalla lcd para mostrar los resultados, quedando el circuito completo as:

Y ahora escribimos todo el cdigo, lo compilamos, lo cargamos en nuestro micro, y listo!

01 int lectura; 02 float temperatura; 03 void setup() 04 { 05 06 07 08 09 10 11 12 lcd(9,8,0,1,2,3,0,0,0,0); // RS, E, D4 ~ D8 for (i=0;i { char i=0; pinMode(13,INPUT); //Usaremos el pin 13 como entrada analgica

pinMode(i,OUTPUT); }

13 14 15 16 17 18 19 } 20

lcd.begin(2, 0); lcd.clear(); lcd.print("Lector LM35"); lcd.setCursor(0,1); lcd.print("elelectronlibre"); delay(1000);

21 void loop() 22 { 23 24 25 26 27 28 29 30 31 32 33 34 35 36 } char i=0; temperatura =0; lectura =0; for(i=0;i {

lectura = lectura + analogRead(13); delay(100); } lectura = lectura / 5; temperatura = (float) lectura * 500 / 1024; lcd.clear(); lcd.printf("T = %f.2",temperatura); lcd.printf("Lectura: %d",lectura); delay(500);

Hoy la entrada va a ser un 2x1, aprenderemos a usar dos cosas en una misma entrada, veremos como funciona el sensor de temperatura LM35 y tambin una pantalla LCD en la que visualizaremos la temperatura.

El componente que vemos en la imagen es el sensor LM35 el cual nos mide una temperatura de -55C a 150C y una precisin de 0.5C a 25C, que es muy buena y suficiente para pequeos inventos que podamos hacer en casa. Si miris la imagen veris que tiene tres patillas. La primera empezando por la izquierda es la de entrada de tensin, la segunda es por donde nos dara la seal y la tercera el negativo. Pantallas LCD hay de muchos tipos yo usare esta de dos lneas porque para esto es suficiente y adems es la que me venia en el kit arduino que compre. Para usar esta pantalla bastara con hacer unas pocas conexiones, un par de lneas de cdigo y ya tendremos funcionando nuestra pantalla.

Como veis el tercer pin tiene la salida de un potencimetro. Con el potencimetro lo que haremos ser regular el contraste. El pin de retroiluminacin no lleva resistencia porque cogemos directamente del pin 13 de arduino que ya la lleva incorporada.

//www.playingwitharduino.blogspot.com #include <LiquidCrystal.h> //Incluir esta libreria para poder usar el lcd

int Ana1 = A0; //Entrada analogica de LM35 LiquidCrystal lcd(12,11,5,4,3,2); //Definimos la pantalla LCD int Temp = 0; char Grados = ''; void setup(){ Serial.begin(9600); lcd.begin(16,2); pinMode(13,OUTPUT); digitalWrite(13, HIGH); }

//Activamos la retroiluminacion

void loop(){ Temp = analogRead(Ana1); //Leemos el valor de la entrada analogica Temp = map(Temp,0,1024,-55,150); //Escalamos la seal a grados centigrados

//Mostramos los grados en el serial Serial.print("Grados: "); Serial.print(Temp); Serial.print(Grados); Serial.println("C");

//Mostramos los grados en la pantalla LCD lcd.setCursor(0,0); //Con este comando decimos en que linea queremos escribir lcd.print("Temperatura: "); lcd.setCursor(0,1); lcd.print(Temp);

delay(10000); }

//Al ser temperatura no hace falta leerlo tan seguido

Termmetro graficador con LM35 y display HD44780 compatible

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

En la documentacin figuran varios circuitos de aplicacin pero para este experimento vamos a hacerlo lo ms bsico posible. Lo conectaremos as:

Para la medicin, lo nico que tenemos que hacer es leer la entrada analgica y calcular cuantos milivolts son. Lo dividimos por 10 y listo. Un detalle con respecto al montaje fsico 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 ms de 100 grados, o sea que rara vez tendremos ms de 1 volt en la salida. As que para obtener mejor precisin en la medida podramos usar como referencia del conversor analgico digital, la tensin 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 precisin en la medida. Aunque tampoco sera tan importante ya que el LM35 tampoco es super exacto. Puede tener un error de medio grado, lo cual parece mucho pero en comparacin con otras alternativas est muy bien. Otros tienen tolerancias de un grado o ms. El conversor analgico digital mide con una precisin de 10 bits, o sea que la funcin analogRead nos devuelve un valor entre 0 y 1023. Dado que 1023 corresponde a 1.1 volt, lo que son 110 grados, la frmula para convertir la informacin 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 mltiples interferencias externas, el valor de entrada no es totalmente estable. Entonces, para conseguir una medicin ms exacta lo que vamos a hacer es promediar todos los valores medidos durante una fraccin 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 podramos 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 analgico-digital, la grfica, la medicin de temperatura, y el tiempo transcurrido. Una vez conformes con el resultado los datos se pueden reubicar. Recordemos que la grfica 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); } }