Indicador de temperatura con LED

Texto completo

(1)

Indicador de temperatura con LED

Vamos a usar un sensor de temperatura (TMP36) para medir la temperatura de la piel. Este componente varía su tensión de salida dependiendo de la temperatura que detecta. Dispone de tres terminales: uno se conecta a masa, otro se conecta a la alimentación y el tercero produce una tensión de salida variable que se aplica a Arduino. En el sketch de este proyecto, se va a leer la tensión de salida del sensor y usarla para encender o apagar unos diodos LED, como indicadores de la temperatura de su piel. Existen varios modelos de sensores de temperatura. Este modelo, el TMP36, es utilizado por que los cambios de la tensión de salida son directamente proporcionales a la temperatura en grados Celsius.

Funciona entre -50º C y 125º C .

No es especialmente preciso, ya que tiene ± 1º C de

incertidumbre, pero normalmente nos sobra para proyectos sencillos y es muy barato.

El encapsulado es similar al de un transistor y también tiene tres patas, así que mucho cuidado con confundirlos.

Las constantes son similares a las variables (guardan información) las cuales permiten usar un único nombre con los datos del programa, pero a diferencia de las variables su contenido no se puede cambiar.

Vamos a definir una constante de tipo entera (int) para la entrada analógica cuyo nombre haga referencia al tipo de pin que se trata (Pin_del_Sensor), y otra constante de tipo decimal (float) para la temperatura de referencia (Temperatura_de_Referencia). Acordaros que este tipo float tiene un punto decimal en los valores que toma.

Para cada dos grados sobre esta temperatura de referencia un led se enciende, por ejemplo, si la temperatura de referencia es de 20 grados, con 22 grados se enciende el primer led, con 24 grados el segundo y así sucesivamente.

const int Pin_del_Sensor=A0;

const float Temperatura_de_Referencia=20.0;

void setup() {

Serial.begin(9600); //Abrir el puerto serie

for(int Pin=2; Pin<5; Pin ++) // Configuración de pines

{

(2)

pinMode(Pin,OUTPUT);

digitalWrite(Pin,LOW);

} }

void loop() {

int Valor_del_Sensor=analogRead(Pin_del_Sensor);

Serial.print("Valor del sensor:");

Serial.print(Valor_del_Sensor);

……….. hasta aquí 1ª prueba del programa float Tension=(Valor_del_Sensor/1024.0)*5.0; //cálculo del valor de tensión que introduce el sensor Serial.print(",Voltios:");

Serial.print(Tension);

Serial.print(",grados C:");

float Temperatura=Tension*100 - 50; // convertimos la tensión en temperatura en ºC Serial.println(Temperatura);

Si examinamos la hoja de datos del sensor, se muestra información sobre el rango de la tensión de salida. Las hojas de datos son como los manuales de los componentes electrónicos. Son escritas por ingenieros, para otros ingenieros. En la hoja de datos de este sensor se indica que por cada 10 milivoltios de cambio en la tensión del sensor equivale a un cambio de 1 grado Celsius de temperatura(

entonces cada voltio suponen 100º C ya que 1V / 10mv = 100). También indica que el sensor puede leer temperaturas por debajo de los 0 grados. Debido a esto, es necesario crear un offset de 50 ya que si tenemos 0v la temperatura será de -50º C. Se almacena este valor dentro de una variable con coma flotante llamada Temperatura.

………hasta aquí 2ª prueba del programa

if(Temperatura < Temperatura_de_Referencia) {

digitalWrite(2,LOW);

digitalWrite(3,LOW);

digitalWrite(4,LOW);

}else if(Temperatura >= Temperatura_de_Referencia+2 &&

Temperatura < Temperatura_de_Referencia+4) {

digitalWrite(2,HIGH);

digitalWrite(3,LOW);

digitalWrite(4,LOW);

}else if(Temperatura >= Temperatura_de_Referencia+4 &&

Temperatura < Temperatura_de_Referencia+6) {

digitalWrite(2,HIGH);

digitalWrite(3,HIGH);

digitalWrite(4,LOW);

}else if(Temperatura >= Temperatura_de_Referencia+6) {

digitalWrite(2,HIGH);

digitalWrite(3,HIGH);

digitalWrite(4,HIGH);

}

delay(100);

}

El convertidor analógico digital puede leer demasiado rápido, así que hay que introducir una pequeña pausa al final del programa (lazo loop()). Si no existiese esta pausa se producirán errores en los valores que se leen.

(3)

THEREMIN CON LDR Y ZUMBADOR (BUZZER)

Las fotorresistencias, también conocidas por sus siglas en inglés (LDR o Light Dependant Resistor), son resistencias variables que modifican su número de Ohmios por la cantidad de luz que incide sobre ellas. Resulta obvio que son o elemento clave de circuitos de control donde el comportamiento del mismo viene dado por la cantidad de luz del entorno.

El ejemplo mas claro es en los circuitos de encendido y apagado automático de lámparas en función de la luminosidad presente, por ejemplo en los coches actuales o en alumbrado público.

Matemáticamente en su comportamiento tenemos una relación inversa entre cantidad de luz y resistencia ofrecida

Un zumbador es un tipo de componente electrónico que permite la conversión de energía eléctrica en energía mecánica en forma de ondas sonoras. Se construyen a partir de una lámina metálica de acero que se hace vibrar para que produzca sonido. Esta vibración se puede conseguir o bien a partir de un electroimán o bien de un disco piezoeléctrico, los cuales accionan la lámina de acero al pasar la corriente por ellos.

Para su correcto funcionamiento debemos respectar su polaridad, siendo los habituales en montajes electrónicas los que funcionan a 5V. Su símbolo es:

Son muy habituales en aparatos electrónicos donde se quiere producir algún tipo de señal acústico.

Aunque físicamente son idénticos existen dos tipos:

Zumbadores activos: que generan un sonido a una frecuencia determinada y fija, por lo que no podremos variar el tono de dicho sonido.

Zumbadores pasivos: que si permiten variar el tono de sonido, por lo que con ellos podremos reproducir melodías.

Montaremos un circuito con un LDR y un zumbador para construir un theremin rudimentario.

Un theremin es un sintetizador rudimentario que genera sonido variable mediante el movimiento de las manos de un músico alrededor de este instrumento. El circuito utiliza un LDR como señal de control ,al mover las manos se variará la cantidad de luz que llega a la superficie de la LDR. El cambio de tensión

(4)

en el pin de una entrada analógica de Arduino (A0) determinará la frecuencia de la nota que se va a escuchar.

Recordad que los convertidores ADC como los de Arduino no pueden leer resistencia sino tensión.

Fíjate que el LDR R1, junto con R2 forma un divisor de tensión. La lectura de A0 dependerá de la luz que incida en el LDR. El esquema de protoboard es igual de fácil:

El programa es muy sencillo. Leemos la caída de tensión en A0 y lo usamos para mapear una

frecuencia entre 20 y 5.000 Hz para llamar a la función tone() que genera un sonido en el zumbador de la frecuencia indicada.

const int pinZumbador = 13;

int frecuencia;

void setup() {

pinMode (pinZumbador,OUTPUT);

}

void loop() {

int p = analogRead(A0); //leemos la tensión de entrada

frecuencia = map (p,0,1024,20,5000); //mapea a frecuencia entre 20Hz y 5KHz

tone (pinZumbador,frecuencia); //envia al zumbador el valor de la frecuencia }

(5)

MEJORANDO EL SKETCH

Vamos a mejorar nuestro instrumento musical y así aprenderemos a ajustar automáticamente las condiciones iniciales de un sensor si pueden variar de una hora a otra. Por ejemplo, en nuestro caso las condiciones de iluminación son distintas dependiendo de la hora y del día. Eso hace que el rango de valores en que se mueve la entrada que leemos de la LDR sea distinta y por tanto las frecuencias generadas serán distintas en la función map().

Vamos a conectar un LED a la salida 10 que nos indica el período de test de condiciones iniciales.

Usaremos la función millis() que informa del tiempo que Arduino lleva funcionando desde que se ha sido encendido o desde que se hizo un reset.

La función while() ejecuta las instrucciones que contiene hasta que ciertas condiciones se cumplen.

Combinando while() y millis() hacemos que el test dure 5 segundos.

int ValordelSensor; // variable donde leemos el valor de luz const int pinZumbador = 13;

int ValorminimoSensor=1023; // variable que guardará el valor mínimo de luz int ValorMaximoSensor=0; // variable que guardará el valor máximo de luz

const int PinLed=10;

int frecuencia;

void setup() // en el setup realizamos el test de condiciones iniciales {

pinMode(PinLed, OUTPUT);

pinMode (pinZumbador,OUTPUT);

digitalWrite(PinLed, HIGH); //encendemos led de aviso de test

while( millis()<5000 ) //repite el test durante 5 segundos moviendo mano {

ValordelSensor = analogRead(A0); //vamos ajustando máx y mín If (ValordelSensor > ValorMaximoSensor) {

ValorMaximoSensor=ValordelSensor;

}

If(ValordelSensor < ValorMinimoSensor) { ValorMinimoSensor=ValordelSensor;

} }

digitalWrite(PinLed, LOW); // apagamos led de aviso de test }

void loop() {

ValordelSensor = analogRead(A0);

frecuencia=map(ValordelSensor, ValorMinimoSensor, ValorMaximoSensor, 50, 4000);

tone(PinZumbador, frecuencia, 20); //ahora le ponemos una duración de 20 ms

delay(10); //detenemos 10 ms para dar tiempo a Arduino

}

(6)

MEDIR DISTANCIA CON SENSOR DE ULTRASONIDOS

Un sensor de ultra sonidos es un dispositivo para medir distancias. Su funcionamiento se basa en el envío de un pulso de alta frecuencia, no audible por el ser humano. Este pulso rebota en los objetos cercanos y es reflejado hacia el sensor, que dispone de un micrófono adecuado para esa frecuencia.

Midiendo el tiempo entre pulsos, conociendo la velocidad del sonido, podemos estimar la distancia del objeto contra cuya superficie impacto el impulso de ultrasonidos.

Sabemos que la velocidad del sonido es 343 m/s en condiciones de temperatura 20 ºC, 50% de humedad, presión atmosférica a nivel del mar. Transformando unidades resulta

Es decir, el sonido tarda 29,2 microsegundos en recorrer un centímetro. Por tanto, podemos obtener la distancia a partir del tiempo entre la emisión y recepción del pulso mediante la siguiente ecuación.

El motivo de dividir por dos el tiempo (además de la velociad del sonido en las unidades apropiadas, que hemos calculado antes) es porque hemos medido el tiempo que tarda el pulso en ir y volver, por lo que la distancia recorrida por el pulso es el doble de la que queremos medir.

Vamos a utilizar un sensor de distancia sencillo HC-SR04 (muy parecido a los sensores de aparcamiento de los coches modernos), que nos permite enviar estos pulsos ultrasónicos y escuchar el eco de retorno. El rango de medición teórico del sensor HC-SR04 es de 2cm a 4m, con una resolución de 0.3cm. No son perfectos, les influye la temperatura ambiente, la humedad y los materiales en los que reflejan, lo que genera una cierta incertidumbre. Pero a cambio son baratos y efectivos desde 20cm a 2 metros.

Los sensores de ultrasonidos son sensores de baja precisión. No resultan adecuados en entornos con gran número de objetos, dado que el sonido rebota en las superficies generando ecos y falsas mediciones. Tampoco son apropiados para el funcionamiento en el exterior y al aire libre.

En aplicaciones en que se requiera una precisión superior en la medición de la distancia, suelen acompañarse de medidores de distancia por infrarrojos y sensores ópticos.

Para activar el sensor necesitamos generar un pulso eléctrico en el pin Trigger (disparador) de al menos 10us. Previamente, pondremos el pin a Low durante 4us para asegurar un disparo limpio.

Posteriormente usamos la función “pulseIn” para obtener el tiempo requerido por el pulso para volver al sensor. Finalmente, convertimos el tiempo en distancia mediante la ecuación correspondiente.

Observar que intentamos emplear siempre aritmética de enteros, evitando usar números en coma flotante. Esto es debido a que las operaciones en coma flotante ralentizan mucho el procesador, y suponen cargar un gran número de librerías en memoria.

(7)

const int EchoPin = 5;

const int TriggerPin = 6;

const int LedPin = 13;

void setup() {

Serial.begin(9600);

pinMode(LedPin, OUTPUT);

pinMode(TriggerPin, OUTPUT);

pinMode(EchoPin, INPUT);

}

Ya estamos más que habituados a la función delay (milis), pero el reloj interno de Arduino mide en microsegundos y tenemos otra función parecida delayMicroseconds(µs) que detiene el programa el número especificado de microsegundos.

Para dar un pulso ultrasónico lo que hacemos es activar el pin Trigger durante unos microsegundos y para ello lo ponemos en HIGH, antes de escuchar el eco:

void loop() {

digitalWrite(triggerPin, LOW); // Nos aseguramos de que el trigger está desactivado delayMicroseconds(2); // Para estar seguros de que el trigger ya está LOW digitalWrite(triggerPin, HIGH); // Activamos el pulso de salida

delayMicroseconds(10); // Esperamos 10µs. El pulso sigue active este tiempo digitalWrite(triggerPin, LOW); // Cortamos el pulso y a esperar el echo

(8)

Para escuchar el pulso vamos a usar otra función, pulseIn()

Básicamente lo que hace es escuchar el pin que le pasamos, buscando una señal que pase de LOW a HIGH ( si le pasamos HIGH como parámetro) y cuenta el tiempo que tarda en volver a bajar desde que sube.

long duracion, distancia ; //estas variables tendrían que ir al ppio duracion = pulseIn(echoPin, HIGH) ;

distancia = duracion / 2 / 29.2 ;

Serial.println(String(distancia) + " cm.") ;

int Limite = 200 ; // Medida en vacío del sensor if ( distancia < Limite){

digitalWrite ( led , HIGH) ; } else{

digitalWrite( led , LOW) ;

delay (500) ; // Para limitar el número de mediciones }

}

(9)

PANTALLA LCD

La pantalla LCD se puede usar para mostrar caracteres alfanuméricos. La que usaremos dispone de 16 columnas y de 2 filas, para un total de 32 caracteres. Su montaje sobre la placa de circuito impreso incluye un gran número de conexiones. Estos terminales se utilizan para la alimentación y comunicación, además de indicar lo que tiene que escribir sobre la pantalla, pero no es necesario conectar todos sus terminales, algunos los dejaremos sin conectar.

VSS que es el pin de negativo, masa, 0 volts o GND.

VDD es la alimentación principal de la pantalla y el chip, lleva 5 voltios (recomendable ponerle en serie una resistencia para evitar daños, con una de 220 ohmios es suficiente).

VO es el contraste de la pantalla, debe conectarse con un potenciómetro de unos 10k o una resistencia fija una vez que encontremos el valor deseado de contraste. Si no conectan, no se verá nada.

RS es el selector de registro (Arduino le comunica a la LCD si quiere mostrar caracteres o si lo que quiere es enviar comandos de control, como cambiar posición del cursor o borrar la pantalla, por ejemplo).

RW es el pin que ordena la lectura/escritura. En nuestro caso siempre estará en 0 (conectado a GND) para que escriba en todo momento.

E es enable, habilita la pantalla para recibir información.

D0 ~ D3 no los vamos a utilizar. Como pueden ver la pantalla tiene un bus de datos de 8 bits, de D0 a D7. Nosotros solamente utilizaremos 4 bits, de D4 a D7, que nos servirán para establecer las líneas de comunicación por donde se transfieren los datos.

A (LED+) y K(LED-) son los pines del led de la luz de fondo de la pantalla. Se conectarán a 5 volts (con R de 220Ω) y a GND respectivamente.

Veamos las conexiones del circuito que vamos a montar:

(10)

Veamos el montaje de los terminales paso a paso:

En primer lugar procederemos a la preparación del contraste de la pantalla LCD. Para ello haremos las siguientes conexiones mediante cables:

Conexión: GND --> pin 1 de la LCD (VSS) Conexión: 5V --> pin 2 de la LCD (VDD)

Conexión: 5V --> pin 15 de la LCD (Ánodo) a través de una resistencia serie de 220Ω Conexión: GND --> pin 16 de la LCD (K)

Para probar la correcta conexión, encenderemos la placa Arduino UNO mediante el cable USB al ordenador y veremos que la pantalla LCD se ilumina.

El siguiente paso es la introducción del potenciómetro de 10K, para ajustar el contraste de la pantalla.

Lo conectaremos a la izquierda de la pantalla LCD y procederemos al cableado para la conexión de sus tres pines.

Conexión: primer pin del potenciómetro---> GND

Conexión: pin de en medio potenciómetro --> pin 3 de la pantalla LCD (VO) Conexión: tercer pin del potenciómetro---> 5V

Cuando la placa Arduino esté alimentada (conexión USB-PC), se verá por pantalla caracteres en forma de cuadrado en la fila de arriba. Prueba a ajustar con el potenciómetro y verificar que todo funciona correctamente.

En el próximo paso, vamos a conectar la pantalla LCD a la placa Arduino UNO para que se pueda mostrar el mensaje de texto que queramos.

Conexión: pin 4 de la LCD (RS) ---> pin 12 del arduino Conexión: pin 5 de la LCD (RW) --> GND

Conexión: pin 6 de la LCD (E)--> pin 11 de la placa Arduino Conexión: pin 11 de la LCD (D4)--> pin 5 de la placa Arduino Conexión: pin 12 de la LCD (D5)--> pin 4 de la placa Arduino Conexión: pin 13 de la LCD (D6)--> pin 3 de la placa Arduino Conexión: pin 14 de la LCD (D7)--> pin 2 de la placa Arduino

Ahora vamos a escribir el siguiente programa y transmitirlo a la placa Arduino UNO.

(11)

#include <LiquidCrystal.h> // Importamos la librería de la pantalla LCD

LiquidCrystal lcd(12, 11, 5, 4, 3 , 2); // Indicamos a Arduino los terminales que usaremos

void setup() {

lcd.begin(16, 2); // Indicamos el nº de columnas y filas de la pantalla LCD lcd.print("Tecnopondal "); // aquí escribe en la columna 0 y fila 0

lcd.setCursor(0,1); // situamos el cursor en la columna 0 y en la fila 1 lcd.print(“ROBÓTICA”);

}

void loop() { }

Cuando el código esté cargado y ejecutándose, la pantalla LCD mostrará el texto.

La librería de la pantalla LCD que se incluye con el software de Arduino maneja toda la información de estos terminales y simplifica el proceso de escribir software para mostrar los caracteres.

Primero, es necesario importar la librería LiquidCrystal. A continuación, se inicializa esta librería, de la misma forma que se hizo con la librería del servomotor, indicando en el programa que terminales se van a usar para la comunicación con Arduino.

Iniciar la librería LCD e indicarle el tamaño de la pantalla (16 columnas por 2 filas).

Con el fin de escribir en la siguiente línea, hay que indicarle a la pantalla donde se debe de colocar el cursor (setCursor(0,1)). Las coordenadas de la primera columna y de la segunda línea son 0,1 . Usar la función lcd.setCursor() para mover el cursor a la primera columna de la segunda fila y a continuación le decimos que escriba “ROBÓTICA”.

ACABAR EL LOOP DEL SKETCH PARA QUE AL CABO DE 5 SEGUNDOS SE BORRE LA PANTALLA Y APAREZCA VUESTRO NOMBRE

Limpiar la pantalla con la función lcd.clear(). Estas instrucciones también mueven el cursor a la posición inicial 0,0; la primera columna de la primera fila del LCD. Escribir el texto “Mi nombre es:” en pantalla y mover el cursor a la siguiente linea donde aparece tu nombre.

EJERCICIO: Añade al montaje el sensor de utrasonidos y modifica el código para que aparezca en la pantalla LCD la distancia medida.

Figure

Actualización...

Referencias

Actualización...

Related subjects :