Temporizador: Arduino + LCD

Hoy quiero hablar de los displays LCD y su control y uso mediante una placa Arduino.
El proceso de control de un LCD con Arduino nos abre un frente de interacción visual de la electrónica de un modo rápido, sencillo y eficaz.

¿Qué es un display LCD?
De un modo muy resumido, las siglas LCD significan “Liquid Cristal Display” o en español “Pantalla de cristal líquido“, y es una pantalla delgada y plana, formada por un número de píxeles en color o monocromos colocados delante de una fuente de luz o reflectora. (Wikipedia).

El uso de estas pantallas, está tan extendido hoy en día, que prácticamente todos los aparatos electrónicos suelen llevarlas, para mejor uso y facilidad de interacción.
Existen muchos tipos de LCD, variando en forma y tamaño, número de píxeles, color, y la gran mayoría tienen un coste de unos pocos €uros en cualquier tienda de electrónica.

El que voy a utilizar yo, es del tipo más sencillo de controlar, y son los displays LCD diseñados para interactuar con circuitos integrados, de entrada de 4/8 bits en paralelo, basados en el controlador Hitachi HD44780.
Estos se caracterizan principalmente por el número de caracteres que son capaces de representar, que viene dado en su datasheet generalmente por unos números del tipo “8×1”, “16×2”, “20×4”, que significan “Número de caracteres x Número de filas“, así pues, un display LCD 16×2, es capaz de representar 2 filas de 16 caracteres.

El display LCD que utilizaré yo (Gracias a Dani), es de 16×2 caracteres, de fondo verde y caracteres negros con retroiluminación led de color verde:



Sigue leyendo!


Estos displays se controlan muy facilmente con una placa Arduino o un PIC y muy pocas lineas de código. Para ello veamos sus pines para saber como se conectan:

– Pin 1 – Vss: GND o tierra.

– Pin 2 – Vdd: Alimentación Vcc o +5V.
(Algunos pueden alimentarse a 3 Vcc)

– Pin 3 – V0: Control del contraste del display, conectamos este pin al terminal variable de un potenciómetro conectado a Vcc y Masa en sus terminales extremos.

– Pin 4 – RS: Selección de Registro.
0 lógico: Registro de comandos (escritura),
1 lógico: Registro de datos (escritura, lectura)

– Pin 5 – R/W:
0 lógico: Escritura del LCD.
1 Lógico: Lectura del LCD.

– Pin 6 – Enable: El famoso Enable de casi todos los componentes de la electrónica digital. Un 1 lógico señala el inicio de escritura o lectura del LCD, un 0 lógico, desactiva todas las funciones.

– Pin 7-10 – D0/D3: Pines correspondientes al bus de datos.
D0 corresponde al bit menos significativo.
Estos pines no se utilizan si realizamos operaciones sobre el LCD de 4 bits.

– Pin 11-14 – D4/D7: Pines correspondientes al bus de datos.
D7 corresponde al bit más significativo y puede utilizarse como “Busy Flag”,
si leemos sobre este pin, un 1 lógico nos indicará que el LCD se encuentra ocupado,
no permitiendonos realizar ninguna operación hasta que se deshabilite.

En la tabla no aparecen, ya que no todos los displays disponen de los pines 15 y 16, yo he modificado la imagen para añadirlos, y son simplemente:
– Pin 15 – Ánodo de la retroiluminación : R + 5V.
– Pin 16 – Cátodo de la retroiluminación: GND.

Ahora si, podemos meternos de lleno en el control del LCD.
En la web de Arduino, vienen muchos ejemplos con sus correspondientes imágenes de conexión del LCD con la placa en cuestión, además del código para ponerlo en funcionamiento en pocos clicks.

El código para poner en funcionamiento un LCD es muy sencillo, y se trata simplemente de declarar los pines a utilizar por el LCD, situar el cursor en el caracter que deseemos escribir (Nº caracter, Fila) y escribir sobre el LCD.
Arduino simplifica el trabajo de escribir sobre un LCD hasta un punto que resulta muy fácil. Aqui un ejemplo de código para escribir una frase sobre un LCD.

//Ejemplo Frase "Hello World" en LCD con Arduino

#include <LiquidCrystal.h> //Incluimos la libreria de control del LCD

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Inicializamos la libreria con los pines a utilizar

void setup() {
lcd.begin(16, 2);   //Configuramos el numero de caracteres y filas a utilizar
}

void loop() {
lcd.setCursor(0, 0); //Situamos el cursor en el caracter 0, fila 0
lcd.print("Hello World") //Escribimos sobre el LCD
}

Yo he preferido hacer algo más interesante que los ejemplos que vienen en dicha web, asi que me he puesto a programar un temporizador.

Empezando por la conexión del circuito, la siguiente imagen creada con Fritzing
(Fántastico programa freeware y multiplataforma para crear esquemas) nos muestra como conectar el LCD con Arduino y algunos componentes más necesarios para este proyectillo, como son pulsadores, led o un buzzer.

El esquema consta de un Arduino UNO, un display LCD 16×2, un potenciómetro para el control de contraste del LCD, un led de señal de fin de temporización, y 4 pulsadores con su resistencia Pull-down de 10kΩ, los 3 pulsadores cuyos cables son naranja son los que permitirán la elección del tiempo (Horas, Minutos y Segundos) mientras que el 4to pulsador, el del cable azul, es que que dará la señal de inicio del temporizador.

Una vez conectado todo, solo queda la programación y ponerlo en funcionamiento.
Mi código es algo largo asi que dejaré el archivo Temporizador.pde de Arduino para el que quiera descargarlo y echarle un vistazo.

Y a funcionar!

😀

Anuncios

174 comentarios en “Temporizador: Arduino + LCD

  1. Hola Buenas tardes, Ya no aparece el código para descargar me manda a otra pagina serias tan amable de enviarmelo. Gracias

    • Olá.
      Circuito correto esta nesta imagem.

      Código é.

      //TEMPORIZADOR ARDUINO + LCD

      #include //Libreria del display LCD

      LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Inicializamos la libreria con el numero de los pines a utilizar

      int buzzer = 13; //Alarma
      int ahoras = 0; //Variable a mostrar por LCD de las horas
      int aminutos = 0; //Variable a mostrar por LCD de los minutos
      int asegundos = 0; //Variable a mostrar por LCD de los segundos
      int segundostotal = 0; //Tiempo total
      int msg= 0; //Barrera para el mensaje de bienvenida

      int start = A1; //Pulsador de arranque
      int empieza = 1024; // Variable para almacenaje del pulsador de arranque

      int buth = A5; //Pulsador de Horas
      int butm = A4; //Pulsador de Minutos
      int buts = A3; //Pulsador de segundos

      int varbuth = 0; //Variable para almacenar el valor del pulsador de horas
      int varbutm = 0; //Variable para almacenar el valor del pulsador de minutos
      int varbuts = 0; //Variable para almacenar el valor del pulsador de segundos

      void setup()
      {
      lcd.begin(16, 2); // Configuramos el numero de columnas y filas del LCD.

      pinMode(buzzer, OUTPUT); //Pin de alarma –> Salida
      pinMode(buth, INPUT); //Pin de pulsador de horas –> Entrada
      pinMode(butm, INPUT); //Pin de pulsador de minutos –> Entrada
      pinMode(buts, INPUT); //Pin de pulsador de segundos –> Entrada
      pinMode(start, INPUT); //Pin de pulsador de arranque –> Entrada

      msg = 0; //Barrera del mensaje de bienvenida
      empieza = 1024; //Barrera de arranque

      varbuth = 1; //Barrera de horas
      varbutm = 1; //Barrera de minutos
      varbuts = 1; //Barrera de segundos
      }

      void loop()
      {
      if(msg==0) //Mostramos el mensaje de bienvenida solo una vez
      {
      lcd.setCursor(0,0);
      lcd.print(“Temporizador com”);
      lcd.setCursor(1,1);
      lcd.print(“Arduino + LCD”);
      delay(2500);
      msg = 1;
      lcd.clear();
      }

      //————————————————————————————————-
      // LECTURA DE LOS BOTONES Y ELECCIÓN DEL TIEMPO, NO SALE DEL BUCLE HASTA PULSAR
      // EL BOTON DE ARRANQUE
      //————————————————————————————————-

      do
      {

      varbuth = analogRead(buth); //Leemos boton de horas
      varbutm = analogRead(butm); //Leemos boton de minutos
      varbuts = analogRead(buts); //Leemos boton de segundos

      if(varbuth == 0) //Si el boton ha sido pulsado, aumentamos las horas en una unidad
      {
      ahoras = ahoras + 1 ;
      delay(250);
      }

      if(varbutm == 0) //Si el boton ha sido pulsado, aumentamos los minutos en una unidad
      {
      aminutos = aminutos + 1;
      delay(250);
      }

      if(varbuts == 0) //Si el boton ha sido pulsado, aumentamos los segundos en una unidad
      {
      asegundos = asegundos + 1;
      delay(250);
      }

      lcd.setCursor(0,0);
      lcd.print(” Digite o Tempo”); //Muestra mensaje y las HH:MM:SS que vayamos aumentando

      lcd.setCursor(4,1);

      if (ahoras < 10) lcd.print("0"); // Si las horas son menor que 10, pone un "0" delante.
      lcd.print(ahoras); // Sin este codigo, se muestra asi: H:M:S (1:M:S)
      lcd.print(":");

      if (aminutos < 10) lcd.print("0"); // Si los minutos son menor que 10, pone un "0" delante.
      lcd.print(aminutos); // Sin este codigo, se muestra asi: H:M:S (H:1:S)

      lcd.print(":");
      if (asegundos 0)
      {
      delay (1000); //Descontamos en periodos de 1 segundo
      segundostotal–;

      ahoras = ((segundostotal / 60)/ 60); //Convertimos los segundos totales en horas
      aminutos = (segundostotal / 60) % 60; //Convertimos los segundos totales en minutos
      asegundos = segundostotal % 60; //Convertimos los segundos totales en periodos de 60 segundos

      lcd.setCursor(0,0);
      lcd.print(“Tempo restante”); //Mostramos mensaje de tiempo restante

      lcd.setCursor(4,1);
      if (ahoras < 10) lcd.print("0"); // Si las horas son menor que 10, pone un "0" delante.
      lcd.print(ahoras); // Sin este codigo, se muestra asi: H:M:S (1:M:S)
      lcd.print(":");

      if (aminutos < 10) lcd.print("0"); // Si los minutos son menor que 10, pone un "0" delante.
      lcd.print(aminutos); // Sin este codigo, se muestra asi: H:M:S (H:1:S)

      lcd.print(":");
      if (asegundos < 10) lcd.print("0"); // si el valor de segundo esta por debajo de 9 (unidad) antepone un cero
      lcd.print(asegundos); // Sin este codigo, se muestra asi: H:M:S (H:M:1)

      if (segundostotal == 0) //Si finaliza el tiempo
      {
      while(1) //Bucle infinito mostrando mensaje y haciendo parpadear un led
      {
      lcd.clear();
      lcd.setCursor(5,0);
      lcd.print("Tempo");
      lcd.setCursor(3,1);
      lcd.print("Finalizado");

      digitalWrite(buzzer, HIGH);
      delay(200);
      digitalWrite(buzzer, LOW);
      delay(200);
      }
      }
      }

      }

  2. Amigo muchas gracias por compartir tus diseños con nosotros, pero por alguna razon no he conseguido bajar el codigo te agradeceria si me lo puedes enviar al correo

    • Primero para programar deben estudiar el codigo en base a ejemplos. Estos los consiguen en la pagina ofician de arduino o en la Gui de ejemplos del compilaror . Hay que tener logica del codigo y saber que hace cada linea. No es satisfactorio para ningun aprendiz solo pedir codigo, copiar y pegar.

  3. amigo por favor me podrias hacer llgear el codigo, es que lo necesito pronto y el limnk envia a otra pagina …..

    • #include
      #include
      #define TONO_ERROR 600
      #define TIME_INTERVAL 3000

      LiquidCrystal lcd(8, 7, 9, 10, 11, 12); //Inicializar a biblioteca com o número de pinos utilizados

      /* // Pinos do UNO
      #define Linha1 A0 // Linha 1 do teclado no pino 4
      #define Linha2 A1 // Linha 2 do teclado no pino 5
      #define Linha3 A2 // Linha 3 do teclado no pino 6
      #define Linha4 A3 // Linha 4 do teclado no pino 7

      #define Row1 3 // Coluna 1 do teclado no pino 8
      #define Row2 4 // Coluna 2 do teclado no pino 9
      #define Row3 13 // Coluna 3 do teclado no pino 10
      */
      // Pinos do Mega
      #define Linha1 34 // Linha 1 do teclado no pino 34
      #define Linha2 35 // Linha 2 do teclado no pino 35
      #define Linha3 36 // Linha 3 do teclado no pino 36
      #define Linha4 37 // Linha 4 do teclado no pino 37

      #define Row1 38 // Coluna 1 do teclado no pino 38
      #define Row2 39 // Coluna 2 do teclado no pino 39
      #define Row3 40 // Coluna 3 do teclado no pino 40

      byte Digito = 0 ; // Variavel Digito digitado
      byte i = 0;
      byte contagem = 0; // Numero de digitos digitados
      unsigned long Acumulado = 0; // Variavel Digitos acumulados
      unsigned long Tempo = 0; // variavel Tempo de atraso = Digito Acumulado

      unsigned Inicio = 0;
      unsigned int horas = 0; // Variável para mostar no LCD as Horas
      unsigned int minutos = 0; // Variável para mostar no LCD as Minutos
      unsigned int segundos = 0; // Variável para mostar no LCD as segundos
      unsigned int segundostotal = 0; //Tempo Total

      int rele = 5; //Rele
      int buzzer = 6; //Alarme
      int msg= 0; //Barreira para mensagem de boas vindas

      // ———————————————————————
      void setup()
      {
      lcd.begin(16, 2); // Defini o numero de colunas e linhas do LCD 16×2

      pinMode(rele, OUTPUT); //Define o pino como saida
      pinMode(buzzer, OUTPUT); //Pino de alarme –> Salida

      msg = 0; //Barreira para mensagem de boas vindas

      Serial.begin(9600);
      }
      // ————————————————————————
      void loop()
      {
      if(msg==0) //Mostrar a mesnsagem de boas vindas apenas uma vez
      {
      lcd.setCursor(0,0);
      lcd.print(“Peneirador PVE-I”);
      lcd.setCursor(1,1);
      lcd.print(” Temporizador”);
      delay(5500);
      msg = 1;
      lcd.clear();
      }
      //————————————————————————————————-
      // Leitura dos botões de seleção de tempo
      // Não sai do loop ate precionar o botão de inicio
      //————————————————————————————————-

      while (Inicio == 0) // Nào sai da rotina de teclado enquanto Inicio for igual a 0
      {
      lcd.setCursor(4,1);

      if (horas < 10) lcd.print("0"); // Se as horas estão a menos de 10, coloque um "0" na frente.
      lcd.print(horas); // Sem esse código, ele mostra assim : H:M:S (1:M:S)
      lcd.print(":");

      if (minutos < 10) lcd.print("0"); // Se as minutos estão a menos de 10, coloque um "0" na frente.
      lcd.print(minutos);

      lcd.print(":");
      if (segundos < 10) lcd.print("0"); // Se as segundos estão a menos de 10, coloque um "0" na frente.
      lcd.print(segundos);

      for (int porta = 4; porta 0 )digitalWrite(rele, HIGH); //Se o tempo for maior que 0 segundos inicia o rele

      segundostotal = segundos + (minutos * 60) + (horas * 60 * 60); //Converte o tempo selecionado em segundos!!

      while (segundostotal > 0)
      {
      delay (1000);
      segundostotal–;

      horas = ((segundostotal / 60)/ 60); //torna os segundos totais em horas
      minutos = (segundostotal / 60) % 60; //torna os segundos totais em minutos
      segundos = segundostotal % 60; //torna os segundos totais em periodos de 60 segundos

      lcd.setCursor(0,0);
      lcd.print(” Tempo Restante”);

      lcd.setCursor(4,1);
      if (horas < 10) lcd.print("0");
      lcd.print(horas);
      lcd.print(":");

      if (minutos < 10) lcd.print("0");
      lcd.print(minutos);

      lcd.print(":");
      if (segundos < 10) lcd.print("0");
      lcd.print(segundos);

      if (segundostotal == 0)

      {
      while(1)
      {
      lcd.clear();
      lcd.setCursor(5,0);
      lcd.print("Tempo");
      lcd.setCursor(3,1);
      lcd.print("Finalizado");
      digitalWrite(rele, LOW); //Ao finalizar o processo desliga o rele

      sonarTono(TONO_ERROR,TIME_INTERVAL);
      lcd.clear();
      return;
      //exit(0);
      }
      }
      }

      }
      //————————————
      // Tom
      //————————————

      void sonarTono(int tono, int duracion)
      {
      tone(buzzer,4500);
      delay(1000);

      //Desligando o buzzer.
      noTone(buzzer);
      delay(1000);
      }

      //————————————————————————
      void Salva_Digito(int x, int y)
      {
      Digito =((x*10) +y); // Identifica tecla digitada
      contagem++;
      switch (Digito) // Seleciona valor com tecla digitada
      {
      case 11: Digito = 1; break;
      case 12: Digito = 2; break;
      case 13: Digito = 3; break;
      case 21: Digito = 4; break;
      case 22: Digito = 5; break;
      case 23: Digito = 6; break;
      case 31: Digito = 7; break;
      case 32: Digito = 8; break;
      case 33: Digito = 9; break;
      case 41: Digito = 0x2A; break; // Hexa para * Cancela
      case 42: Digito = 0; break;
      case 43: Digito = 0x23; break; // Hexa para # Enter
      }
      if ((Digito != 0x2A) & (Digito != 0x23)) // Se for diferente de * ou #
      { // Faça
      if (contagem 24) horas = 0; // Se horas maior que 24 faça igual 0
      }
      if ((contagem >=3) & (contagem 60) minutos = 0; // Se minutos maior que 24 faça igual 0
      }
      if ((contagem >=5) & (contagem 60) segundos = 0; // Se segundos maior que 24 faça igual 0
      }
      }
      if (Digito == 0x23) // Se for igual a # equivalente a enter
      { // Faça
      Inicio = 1; // Sai da rotina do teclado
      }
      if (Digito == 0x2A) // Se for igual a * equivalente a cancela
      { // Faça
      contagem = 0;
      horas = 0; // Zera Resultado
      minutos = 0; // Zera Resultado
      segundos = 0; // Zera Resultado
      }
      }
      //————————————————————————

  4. alguien podría decirme que elementos se necesitan para llevar a cabo este proyecto? lo agradeceria mucho

    • Un arduino de cualquiera (uno, mega, …) un buzzer, 3 interruptores, una pantalla lcd para arduino, y lo demas solo es cables (las conexiones del arduino a la lcd y los interruptores y la fuente de alimentación del arduino

Deja un comentario!

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s