Haga clic para más productos.
No se encontraron productos.

Tutorial LCD, conectando tu arduino a un LCD1602 y LCD2004

379494

En este tutorial se explicaran el funcionamiento de los LCD alfanuméricos, desarrollaremos varios ejemplos prácticos, aprenderemos a cómo usar los LCD en nuestros proyectos y como crear caracteres personalizados.

 

En muchos de nuestros proyectos necesitamos visualizar o monitorear parámetros, si bien una solución es los display de 7 segmentos, pero solo estamos limitados a valores numéricos e incluso si deseamos poner varios dígitos a nivel de hardware aumenta nuestro diseño electrónico por lo que necesitamos técnicas de multiplexado.
Los LCD alfanuméricos son la solución más práctica, para este problema, empezando por su bajo consumo, diferentes tamaños disponibles, y trabaja con caracteres alfanuméricos, por lo que podemos representar cualquier texto o variable.

Los LCD alfanuméricos más utilizados en el mercado son el LCD1602 y el LCD204 con tamaños de 16x2 y 20x4 caracteres respectivamente. Entre estos tamaños también hay diferentes modelos los cuales varían en color y sobretodo en la presencia o no de un Backlight (retro iluminador incorporado)

LCD 16x2LCD 20x4

El LCD tiene una memoria interna en donde almacena todos sus caracteres alfanuméricos, los cuales podemos extender en ocho caracteres personalizados adicionales.

Los caracteres soportados por la mayoría de modelos de LCD son los siguientes:

  
Tabla de caracteres LCD

  

Para la comunicación del LCD y un controlador utiliza un bus de 8 datos, pero se puede configurar para trabajar con un buz de 4 datos. También usa pines de control RS (chip select) RW (lectura/escritura) y E (enable).

Para controlar el contrastes usa una entrada analógica VEE el cual por lo general se usa un potenciómetro para poder variar el contraste, y los LCD q traen Backlight tiene dos pines al final Led+ (A) y Led- (K) los cuáles se pueden alimentar directamente a 5V o a través de una resistencia si se tratase de un LED, variando su resistencia se pude variar la intensidad de luz.

   

Conexiones entre Arduino y display LCD1602

  

LCD1602 o LCD2004

Arduino Uno, Nano, Mega, etc.

1.VSS

GND

2. VDD

5V

3. VEE

Potenciómetro

4. RS

D8

5. RW

GND

6. EN

D9

11. D4

D4

12. D5

D5

13. D6

D6

14. D7

D7

15. Led+

VCC

16. Led-

GND

    

Conexion LCD1602 y arduino

  

Conexiones entre Arduino y display LCD2004

Las conexiones para el LCD de 20 x 4 son las mismas:

  

  

Conexion LCD 20x4 y Arduino

Librería LiquidCrystal de Arduino

El IDE de Arduino ya viene con una librería que nos permite manejar diferentes tamaños de LCD’s, La documentación completa la pueden encontrar en la página oficial de Arduino: LiquidCrystal

Explicaremos las funciones principales, las cuales se usaran en este tutorial.

LiquidCrystal(rs, en, d4, d5, d6, d7)

Función constructor, crea una variable de la clase LiquidCrystal, con los pines indicados.

begin(cols, rows)

Inicializa el LCD, es necesario especificar el número de columnas (cols) y filas (rows) del LCD.

clear()

Borra la pantalla LCD y posiciona el cursor en la esquina superior izquierda (posición (0,0)).

setCursor(col, row)

Posiciona el cursor del LCD en la posición indicada por col y row (x,y); es decir, establecer la ubicación en la que se mostrará posteriormente texto escrito para la pantalla LCD.

write()

Escribir un carácter en la pantalla LCD, en la ubicación actual del cursor.

print()

Escribe un texto o mensaje en el LCD, su uso es similar a un Serial.print

scrollDisplayLeft()

Se desplaza el contenido de la pantalla (texto y el cursor) un espacio hacia la izquierda.

scrollDisplayRight()

Se desplaza el contenido de la pantalla (texto y el cursor) un espacio a la derecha.

createChar (num, datos)

Crea un carácter personalizado para su uso en la pantalla LCD. Se admiten hasta ocho caracteres de 5x8 píxeles (numeradas del 0 al 7). Donde: num es el número de carácter y datos es una matriz que contienen los pixeles del carácter. Se verá un ejemplo de esto mas adelante.

Explicado la librería veamos unos ejemplos:

  

Un Hola mundo con Arduino y LCD7

  

Mostraremos  texto y un valor numérico en el LCD, para esto cargamos el siguiente sketch:

  

#include <LiquidCrystal.h>

//Crear el objeto LCD con los números correspondientes (rs, en, d4, d5, d6, d7)
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  // Inicializar el LCD con el número de  columnas y filas del LCD
  lcd.begin(16, 2);
  // Escribimos el Mensaje en el LCD.
  lcd.print("Hola Mundo");
}

void loop() {
   // Ubicamos el cursor en la primera posición(columna:0) de la segunda línea(fila:1)
  lcd.setCursor(0, 1);
   // Escribimos el número de segundos trascurridos
  lcd.print(millis()/1000);
  lcd.print(" Segundos");
  delay(100);
}

  

Como se observa con la función printf() escribimos el texto, y con setCursor(x,y) indicamos la poción en donde deseamos que se escriba el texto.

Después de cargar, en su LCD deben obtener el siguiente resultado

 

 Hola mundo LCD 16x2 y Arduino

   

  

Para el caso del LCD de 20x4 tienen que especificar este tamaño cundo inicializan el LCD.

  

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  // Inicializar el LCD con el número de  columnas y filas del LCD
  lcd.begin(20,4);
  // Escribimos el Mensaje en el LCD
  lcd.print("Hola Mundo");
  lcd.setCursor(0,2);
  lcd.print("NAYLAMP MECHATRONICS");
  lcd.setCursor(0,3);
  lcd.print("       PERU  ");
}

void loop() {
  // Ubicamos el cursor en la primera posición (columna:0) de la segunda línea(fila:1)
  lcd.setCursor(0, 1);
  // Escribimos el número de segundos trascurridos
  lcd.print(millis()/1000);
  lcd.print(" segundos");
  delay(100);

}


Hola munod LCD 20x4 y Arduino

  

Desplazando el texto en el LCD

En este ejemplo para desplazar el texto usaremos la función scrollDisplayLeft();

  

#include <LiquidCrystal.h>

//Crear el objeto LCD con los números correspondientes (rs, en, d4, d5, d6, d7)
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  // Inicializar el LCD con el número de  columnas y filas del LCD
  lcd.begin(16, 2);
  // Escribimos el Mensaje en el LCD en una posición  central.
  lcd.setCursor(10, 0);
  lcd.print("WWW.NAYLAMPMECHATRONICS.COM");
  lcd.setCursor(5, 1);
  lcd.print("Tutorial LCD, Test de desplazamiento  ");
}

void loop() {
  //desplazamos una posición a la izquierda
  lcd.scrollDisplayLeft(); 
  delay(250);
}

Como se observa en el código, inicialmente escribimos el texto, luego desplazamos el texto una posición por cada ciclo con una pausa de 250ms , tiempo que si se varía aumentará o disminuirá la velocidad de desplazamiento, notar que el texto que escribimos es mayor a los 16 caracteres, pero igual el texto no se pierde, esto es porque el espacio de trabajo por cada fila en realidad es de 40 caracteres, y el LCD solo muestra los 16 primeros caracteres, pero al desplazarlo logramos ver los demás caracteres.

  

 Desplazamiento de texto LCD con Arduino

   

Mostrando datos de sensores o variables en el LCD

En este ejemplo mostramos en el LCD variables, que pueden representar valores de sensores u otros datos. Para simular los sensores usaremos potenciómetros conectados a los pines analógicos.

  

#include <LiquidCrystal.h>

//Crear el objeto LCD con los números correspondientes (rs, en, d4, d5, d6, d7)
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  // Inicializar el LCD con el número de  columnas y filas del LCD
  lcd.begin(16,2);
}

void loop() {
  int sen1=analogRead(A0);
  float sen2=analogRead(A1)*(5.0 / 1023.0);
  float sen3=analogRead(A2)*(100.0 / 1023.0);
  int tiempo=millis()/1000;
  // Cursor en la primera posición de la primera fila
  lcd.setCursor(0,0);
  lcd.print("ADC:");
  lcd.print(sen1);
  lcd.print("   ");
  // Cursor en la 11° posición de la primera fila
  lcd.setCursor(10,0);
  lcd.print("V:");
  lcd.print(sen2,1);//1 decimal
  lcd.print("V  ");
  // Cursor en la primera posición de la 2° fila
  lcd.setCursor(0,1);
  lcd.print("T:");
  lcd.print(sen3,1); //1 decimal
  lcd.print("337C  "); // "337" -> "°"
  // Cursor en la 11° posición de la 2° fila
  lcd.setCursor(10,1);
  lcd.print("t:");
  lcd.print(tiempo);
  lcd.print(" s  ");
  
  delay(200);
  
}

Su resultado debe ser el siguiente.

  

datos y variables con LCD de 16x2 y arduino

  

De igual manera se trabaja con el LCD de 20x4, con la ventaja de tener más espacio para mostrar los valores.

  

#include <LiquidCrystal.h>

//Crear el objeto LCD con los números correspondientes (rs, en, d4, d5, d6, d7)
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  // Inicializar el LCD con el número de  columnas y filas del LCD
  lcd.begin(20,4);
}

void loop() {
  int sen1=analogRead(A0);
  float sen2=analogRead(A1)*(5.0 / 1023.0);
  float sen3=analogRead(A2)*(100.0 / 1023.0);
  int tiempo=millis()/1000;
  // Cursor en la primera posición de la primera fila
  lcd.setCursor(0,0);
  lcd.print("ADC: ");
  lcd.print(sen1);
  lcd.print("   ");
  // Cursor en la 1° posición de la 2° fila
  lcd.setCursor(0,1);
  lcd.print("Voltaje: ");
  lcd.print(sen2);
  lcd.print(" V  ");
  // Cursor en la primera posición de la 3° fila
  lcd.setCursor(0,2);
  lcd.print("Temperatura:");
  lcd.print(sen3); //1 decimal
  lcd.print(" 337C  "); // "337" -> "°"
  // Cursor en la 1° posición de la 4° fila
  lcd.setCursor(0,3);
  lcd.print("tiempo: ");
  lcd.print(tiempo);
  lcd.print(" s  ");
  
  delay(200);
  
}

   Datos y variables con LCD 20x4 y arduino

  

Agregando nuevos caracteres a nuestro LCD

En algunos casos el LCD no tiene los caracteres que deseamos, o necesitamos dibujar caracteres personalizados, en este caso usamos la función createChar () pero antes expliquemos como está constituido un carácter:

Un carácter está formado  por 5x8 pixeles  los cuales se representan por 8 bytes, uno para cada fila, los 5 bits menos significativos representan los pixeles del carácter

  

 Caracter Alfanumerico

  

Como máximo podemos crear 8 caracteres nuevos.

Para este ejemplo crearemos los siguientes caracteres:

 

pixeles de nuevos caracteres LCD

   

A continuación se muestra el código para implementar los nuevos caracteres.

#include <LiquidCrystal.h>
//Crear el objeto LCD con los números correspondientes (rs, en, d4, d5, d6, d7)
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

byte N[8] = {
B11111,
B10001,
B10001,
B10001,
B10001,
B10001,
B10001,
B00000,
};
byte A[8] = {
B11111,
B10001,
B10001,
B10001,
B10001,
B11111,
B10001,
B00000,
};
byte Y[8] = {
B10001,
B10001,
B10001,
B10001,
B11111,
B00100,
B00100,
B00000,
};
byte L[8] = {
B10000,
B10000,
B10000,
B10000,
B10000,
B10000,
B11111,
B00000,
};
byte M[8] = {
B11111,
B10101,
B10101,
B10101,
B10101,
B10101,
B10101,
B00000,
};
byte P[8] = {
B11111,
B10001,
B10001,
B10001,
B11111,
B10000,
B10000,
B00000,
};
byte cara[8] = {
B00000,
B10001,
B00000,
B00000,
B10001,
B01110,
B00000,
};
byte cuerpo[8] = {
B01110,
B01110,
B00100,
B11111,
B00100,
B01010,
B10001,
B00000,
};

void setup () {
  lcd.createChar (0,N);
  lcd.createChar (1,A);
  lcd.createChar (2,Y);
  lcd.createChar (3,L);
  lcd.createChar (4,M);
  lcd.createChar (5,P);
  lcd.createChar (6,cara);
  lcd.createChar (7,cuerpo);
  // Inicializar el LCD con el número de  columnas y filas del LCD
  lcd.begin (20, 4); 
  
  // Escribimos el texto en el LCD
  lcd.print("Nuevos Caracteres");
  lcd.setCursor(0, 1);
  lcd.print("------");
  lcd.write (byte (0));
  lcd.write (byte (1));
  lcd.write (byte (2));
  lcd.write (byte (3));
  lcd.write (byte (1));
  lcd.write (byte (4));
  lcd.write (byte (5));
  lcd.print("-------");
  
  lcd.setCursor(0, 2);
  for(int i=0;i<10;i++)
  {
    lcd.write (byte (6));
    lcd.write (' ');
  }
  lcd.setCursor(0, 3);
  for(int i=0;i<20;i++)
    lcd.write (byte (7));
  
}

void loop () {}

Como observan en el código es necesario crear los nuevos caracteres antes de inicializar el LCD. El resultado del ejemplo anterior es el siguiente:

  

Nuevos caracteres LCD y Arduino

  

El ejemplo anterior se trabajó con un LCD de 20x4 pero ya saben cómo modificar para trabajar con un LCD de 16x2.

 

Productos relacionados
Artículos relacionados
15 Comentarios
  • Tu*************

    Tu************* 24/02/2023 Responder

    Gracias por el aporte, es genial, lo utilizo de referencia cada rato
  • Jo*** ******ro

    Jo*** ******ro 28/01/2023 Responder

    Muy buena Información. Gracias
  • Ga*****

    Ga***** 03/06/2022 Responder

    Hola, una consulta ¿De donde van y vienen los 3 cbles negros?
  • Lu** ****el

    Lu** ****el 20/07/2021 Responder

    Este es el mejor sitio que eh encontrado en cuanto Arduino, explicación fácil y muy bueno el apoyo con las imágenes 10/10
  • Pe*** **** *****co

    Pe*** **** *****co 27/09/2020 Responder

    Bueno antes de todo gracias por los tutoriales son muy buenos.
  • Ma*** ****na

    Ma*** ****na 24/05/2020 Responder

    Al principio me aparecía la pantalla iluminada solo con el backlight, y procedí a comprobar los voltajes de salida del arduino al LCD (ya que estoy trabajando con una copia china), allí encontré apenas 4.56v. Decidí colocar una fuente extra solo para el LCD, y comencé a observar los datos con caracteres aleatorios... en ese punto me dí cuenta de un pequeño error al colocar la fuente independiente, ya que le mandaba 5.12v al LCD, pero los datos que visualizaba eran "flotantes" debido a la falta de una referencia a tierra de ambas fuentes; solución, colocar un puente uniendo los GND del arduino y la fuente extra al LCD, asunto arreglado.
  • Jo***

    Jo*** 12/11/2019 Responder

    mi pantalla solo se queda celeste, ¿saben cuál podría ser la causa?
  • Pa***

    Pa*** 28/04/2019 Responder

    Hola,

    Estoy intentando escribir en la pantalla y no doy, aun con tus mismos ejemplos, no paso del primero.

    Estoy usando un arduino UNO con una placa sunstar 2004 (20x4), con un bus de 4 bits, tal cual los diagramas de arriba.

    Parecen activarse los caracteres de las lineas 1 y 3, que corresponden con el 1111 1111 de la tabla de caracteres del principio, y son los únicos que parecen ser afectados al mover el potenciómetro del contraste.

    Tengo que decir que no tengo la pantalla soldada a los pines. El error puede deberse a un mal contacto de alguno de los bits de datos durante una porción de segundo?

    Voy a seguir jugando a ver si consigo algo.

    Un saludo y a ver si sabes ayudarme.

    Gracias!
  • jo***

    jo*** 02/01/2019 Responder

    Buenas tardes, tengo unda duda.
    Cuandos display puedo conectar en un Arduino MEGA?
    • Jo***

      Jo*** 26/05/2019 Responder

      Tantos como conjunto de pines para cada LCD tengas y ademas por I2C puedes meterunos 128, creo, por puerto I2C. o sea una burrada.
  • Jo*** **iz

    Jo*** **iz 28/08/2018 Responder

    Gran calidad de explicacioón, junto con los maravillosos ejemplos e ilustraciones. Todo muy completo...Tendré su pagina de consulta....Great, Great....
  • Fe******

    Fe****** 17/07/2018 Responder

    Hola! Antes que nada excelente pagina! Felicitaciones. Tengo un LCD 2004, creo estar haciendo todo tal cual me decis, estoy usasndo un potenciometro de 10k, y no se por que el brillo de la pantalla es minimo, si hay luz practicamente no se ven las letras, son casi transparentes, se te ocurre que puede ser?
    • Ju** *******co

      Ju** *******co 30/07/2018 Responder

      Tené en cuenta que el tutorial es para la intensidad de luz en las letras. El backlight se maneja con el A (anodo) y el K (catodo), es decir, las ultimas 2 entradas del LCD de izquierda a derecha. Tendrías que poner otro potenciometro entre estos dos para variar su intensidad.
  • An****

    An**** 03/06/2018 Responder

    Buenas noches, una pregunta resulta que tengo que simular una LCD 20x4, para un trabajo me podrías decir qué programa utilizaste para simular la LCD y el programa hola mundo. Mil gracias
    • Jo***

      Jo*** 26/05/2019 Responder

      Seguramente con FRITZING lo puedas hacer.
Dejar un comentario
Deja su comentario

Menú

Ajustes

Crear una cuenta gratuita para usar listas de deseos.

Registrarse