Descrición:
LCD vén do inglés Liquid Crystal Display, é dicir, é unha pantalla de cristal liquido. As LCDs alfa-numéricas permiten mostrar mensaxes de texto sinxelos e hainas dispoñibles en diferentes formatos. A que usaremos aquí (modelo 1602A) ten un formato 16×2 (16 caracteres e dúas liñas).
Imos ver dúas opcións de conexión e programación:
|
|
|
![]() [tecnoloxia.org CC By-SA] |
![]() [tecnoloxia.org CC By-SA] |
No primeiro caso, para poder realizar as conexións da pantalla debemos soldar unha tira de pins nos conectores e suxeitala cunha protoboard.
No segundo caso o controlador xa vén integrado e preparado para conectar. Úsanse unicamente dous pins de Arduíno, polo que pode ser interesante para proxectos complexos nos que xa teñamos moitos pins ocupados con outras cousas.
Conexión:
Elixe a opción correspondente á pantalla que vaias utilizar:
1. Conexión directa
Debes soldar unha tira de pins á pantalla LCD, conectala nunha protoboard, e realizar as seguintes conexións:

[Esquema exemplo de fritzing]
1º) Alimentación: | 3º) Pins de control: | 5º) LED: (opcional) |
|
|
|
2º) Potenciómetro: | 4º) Cables de datos: | |
|
|

[Esquema exemplo de fritzing]
2. LCD con I2C

[tecnoloxia.org CC By-SA from Fritzing]
No caso dunha placa Arduíno UNO as conexións serían:
- GND e Vcc para a alimentación.
- SDA ao pin analóxico A4. É o pin de datos.
- SCL ao pin analóxico A5. É o que envía o sinal de reloxo.
A tarxeta Arduíno UNO Rev3 ten outros dous pins que podemos utilizar igualmente para a comunicación I2C, e que están na parte superior, xunto aos pins dixitais. Está indicado pola parte de atrás da tarxeta. Se tes este modelo de Arduíno e che resulta máis cómodo podes substituír as conexións A4 e A5 polos pins SDA e SCL da parte superior.
O módulo I2C soe vir acoplado á parte posterior da pantalla LCD, e incorpora un potenciómetro que permite o axuste do brillo.
Configuración:
Nestas lapelas móstranse os programas de inicio da LCD normal e da LCD con I2C respectivamente. Na sección de prácticas mostraremos diversos exemplos de programas a incluír no loop(){ } e que se programan do mesmo xeito sexa cal sexa a opción escollida.
1. Configuración normal
Librería
Antes de nada debemos incorporar a librería “LiquidCrystal.h” que xa está incluída no propio IDE de Arduíno: Sketch → Incluír biblioteca → LiquidCrystal
Despois debemos crear unha instancia chamada lcd, da clase LiquidCrystal, e escribimos os parámetros cos pins que utilizamos para conectar a pantalla a Arduíno. LiquidCrystal lcd( RS, EN, d4, d5, d6, d7);
Configuración
No setup() debemos indicar o número de columnas e o número de filas da nosa LCD: lcd.begin(columnas, filas);
Imos escribir unha primeira mensaxe que aparece cando iniciamos o programa e que só se vai executar unha vez, pois está no setup().
- Para enviar un texto e que se mostre na pantalla utilizamos a función: lcd.print(“texto”);
- Para borrar a pantalla utilizamos a función lcd.clear();
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
#include <LiquidCrystal.h> // Configuración: LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Escribimos os pins ao que está conectada a LCD void setup() { lcd.begin(16, 2); // nº columnas, nº de filas lcd.print("LCD acesa!"); // Escribimos delay(1000); lcd.clear(); // Borrar pantalla } // Programa: void loop(){ // Substitúe este bucle polos que aparecen nas seguintes prácticas para probalas } |
Carga este programa e axusta o contraste co potenciómetro ata que se vexa ben o texto. Para que se mostre o texto permanentemente ata que finalices o axuste comenta a instrución de borrado:
1 2 3 |
// lcd.clear(); // Borrar pantalla |
Elimina o comentario antes de introducir os programas seguintes no loop() para que se borre a pantalla de benvida antes de que se executen.
2. Configuración con I2C
Librerías
O primeiro que debemos facer é incorporar a librería LiquidCrystal-I2C. Pódese descargar directamente neste zip. Unha vez gardada no noso ordenador engadímola ao directorio de librerías do IDE de Arduíno (” Sketch → Incluír biblioteca → engadir biblioteca zip”) e despois incluímola no noso proxecto (Sketch → Incluír biblioteca → LiquidCrystal-I2C).

[tecnoloxia.org CC By-SA]
Configuración

[tecnoloxia.org CC By-SA]
Cada compoñente que conectamos a un bus I2C ten un enderezo único, o que permite que os datos sexan enviados a un dispositivo concreto no caso de ter conectado máis de un. O enderezo por defecto destas pantallas LCD soe ser 0x27, pero depende do modelo. Se tes outro dispositivo podes atopar o seu enderezo utilizando o programa I2C scanner no teu Arduíno. Sairá unha mensaxe como a da imaxe.
Despois debemos introducir os parámetros da clase LiquidCrystal_I2C. No noso caso serán o enderezo, o número de columnas e o número de filas: LiquidCrystal_I2C lcd(0x27, 16, 2);
Proba este programa cunha mensaxe de inicio.
- Para enviar un texto e que se mostre na pantalla utilizamos a función: lcd.print(“texto”);
- Para borrar a pantalla utilizamos a función lcd.clear();
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
/* Pantalla LCD con I2C */ // Librerías #include <Wire.h> // Para a comunicación I2C #include <LiquidCrystal_I2C.h> // Para o control da LCD con I2C // Configuración: LiquidCrystal_I2C lcd(0x27, 16, 2); void setup(){ lcd.begin(); // Inicializar a LCD lcd.backlight(); // acender lcd.print("LCD acesa!"); // Escribimos texto delay (2000); lcd.clear(); // Borrar pantalla } // Programa: void loop() { // Aquí escribiremos os programas } |
Carga este programa e axusta o contraste co potenciómetro ata que se vexa ben o texto. Para que se mostre o texto permanentemente ata que finalices o axuste comenta a instrución de borrado:
1 2 3 |
// lcd.clear(); // Borrar pantalla |
Elimina o comentario antes de introducir os programas seguintes no loop() para que se borre a pantalla de benvida antes de que se executen.
Prácticas
Aquí móstranse algúns exemplos de programas que podes incluír no loop(){ } que deixamos baleiro. Lémbrate de poñer primeiro o programa correspondente á configuración da túa pantalla LCD.
1. Texto
Imos escribir un texto na pantalla en diferentes posicións. Para indicar a posición do cursor debemos utilizar a función lcd.setCursor(columna, liña); A nosa pantalla ten 16 columnas (de 0 a 15) e 2 liñas (0 a de arriba e 1 a de abaixo)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// Posición do punteiro: void loop() { lcd.home(); // Pon o cursor no (0,0) lcd.print("Posicion:"); // Escribe un texto delay(500); lcd.setCursor(10, 0); // Cursor na columna 10 liña 0 lcd.print("10,0"); delay(500); lcd.setCursor(0, 1); // Cursor na columna 0 liña 1 lcd.print("0,1"); delay(500); lcd.setCursor(5, 1); // Cursor na columna 5 liña 1 lcd.print("5,1"); delay(500); lcd.setCursor(10, 1); lcd.print("10,1"); delay(3000); lcd.clear(); // Borrar pantalla } |
2. Scroll
Agora imos facer scroll cun texto derminado. Para mover un texto pola pantalla usaremos as funcións lcd.scrollDisplayLeft(); para movernos cara á esquerda e lcd.scrollDisplayRight(); cara á dereita.
Debemos indicar mediante un bucle for o número de posicións que queremos movernos. A velocidade do desprazamento pódese axustar cambiando o valor do delay do bucle for.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
// Scroll void loop(){ lcd.print("tecnoloxia"); // Escribimos (texto de 10 caracteres) delay(1000); for (int pos=0; pos<10; pos++) { // Scroll 10 posicións á esquerda lcd.scrollDisplayLeft(); delay(150); } delay(1000); for (int pos=0; pos<26; pos++) { // Scroll 26 posicións á dereita. (10 da palabra + 16 da pantalla) lcd.scrollDisplayRight(); delay(150); } delay(1000); for (int pos=0; pos<13; pos++) { // Mover ao centro da pantalla (5 da palabra +8 da pantalla) lcd.scrollDisplayLeft(); delay(150); } delay(3000); lcd.clear(); // Borrar pantalla } |
3. Scroll automático
Tamén podemos configurar a pantalla para que faga scroll automático cando se introduce un texto. Para iso temos que utilizar a función lcd.autoscroll(); para activalo e lcd.noAutoscroll(); para desactivalo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// Scroll automático void loop(){ lcd.setCursor(0, 0); for (int thisChar=0; thisChar<10; thisChar++) { // Escribir de 0 a 9 sen scroll lcd.print(thisChar); delay(500); } lcd.autoscroll(); // Poñemos a pantalla en modo scroll automático: lcd.setCursor(16, 1); // Cursor na columna 16 liña 1 for (int thisChar=0; thisChar<10; thisChar++) { // Escribir de 0 a 9 (con scroll automático) lcd.print(thisChar); delay(500); } lcd.noAutoscroll(); // Paramos o scroll automático delay(3000); lcd.clear(); } |
4. Consola
Agora imos mostrar na pantalla LCD un texto recollido desde a consola serie. Só falta que ti lle poñas scroll a gusto.
Para entender como funciona a consola serie podes mirar previamente esta páxina.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
// Texto desde consola // ** Engadir isto no setup() do teu programa Serial.begin(9600); // Iniciamos a comunicación serial while(!Serial); // ** void loop() { lcd.print("Introduce texto"); lcd.setCursor(0, 1); lcd.print("na consola serie"); delay(1000); while(Serial.available()==0); // Agarda mentres non recibe datos if (Serial.available()) { // Cando están entrando caracteres polo porto serie ... delay(100); // Damos tempo para que chegue a mensaxe lcd.clear(); // Borramos a pantalla while (Serial.available() > 0) { // Mentres haxa datos no buffer lcd.write(Serial.read()); // Lemos os caracteres e escribímolos la LCD delay(100); } } delay(3000); lcd.clear(); // Borrar pantalla } |

[tecnoloxia.org CC By-SA]
Para solucionalo selecciona na parte inferior da consola “Falta final de liña”.
5. Debuxos
Podemos definir os nosos propios caracteres e amosalos na pantalla, e incluso crear animacións.
O primeiro que debemos facer é definir os nosos caracteres personalizados creando un array cos valores dos píxeles de cada carácter, formado por 40 puntos distribuídos en 8 filas e 5 columnas. Nesta web tes unha aplicación para debuxar e extraer o código dos teus debuxos.Despois rexistramos o novo carácter coa instrución lcd.createChar(número asignado, nome do array);
Para mostralo na pantalla LCD temos dúas opcións:
- lcd.write(número do carácter);
- lcd.print((char)número do carácter);
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
// Debuxos void loop() { // definición dos novos caracteres byte corazon1[8] = {B00000,B01010,B11111,B11111,B11111,B01110,B00100,B00000}; byte corazon2[8] = {B00000,B01010,B10101,B10001,B10001,B01010,B00100,B00000}; byte bateria1[8] = {B01110,B11011,B10001,B10001,B10001,B10001,B10001,B11111}; byte bateria2[8] = {B01110,B11011,B10001,B10001,B10001,B10001,B11111,B11111}; byte bateria3[8] = {B01110,B11011,B10001,B10001,B10001,B11111,B11111,B11111}; byte bateria4[8] = {B01110,B11011,B10001,B10001,B11111,B11111,B11111,B11111}; byte bateria5[8] = {B01110,B11011,B10001,B11111,B11111,B11111,B11111,B11111}; byte bateria6[8] = {B01110,B11111,B11111,B11111,B11111,B11111,B11111,B11111}; lcd.createChar(0, corazon1); lcd.createChar(1, corazon2); lcd.createChar(2, bateria1); lcd.createChar(3, bateria2); lcd.createChar(4, bateria3); lcd.createChar(5, bateria4); lcd.createChar(6, bateria5); lcd.createChar(7, bateria6); // I love tecnoloxia lcd.home(); // Pon o cursor no (0,0) lcd.print("I "); lcd.print((char)0); // Pinta o corazón1 lcd.print(" tecnoloxia "); delay(3000); lcd.clear(); // Animación carga: lcd.home(); for (int i=2; i<=7; i++){ lcd.clear(); lcd.print((char)i); delay(1000); } lcd.print(" Carga completa"); delay(3000); lcd.clear(); // Animación corazón: for (int j=0; j<10; j++){ // Repetimos 10 veces for (int i=0; i<=1; i++){ // debuxa os corazóns 1 e 2 cun intervalo de tempo lcd.clear(); lcd.print((char)i); delay(300); } } delay(2000); lcd.clear(); } |
Hai que ter en conta que só podemos usar 8 caracteres especiais simultaneamente (de 0 a 7). O número asignado indica a posición da memoria da pantalla onde gardamos o carácter personalizado. Esta pantalla ten 8 posicións de memoria, polo que se queremos gardar un noveno deseño teremos que substituír algún dos gardados anteriormente no momento de utilizalo.
Simulación
Na seguinte simulación veñen recollidos todos os programas anteriores. Para introducir texto na consola preme antes en “Code Editor”.
Propostas:
Estas son algunhas ideas para traballar, pero o ideal é que traballes o necesario para incorporar unha pantalla LCD ao teu proxecto.
- Datos dos sensores: Mostra na pantalla LCD os datos procedentes dun sensor. Por exemplo, dun sensor de temperatura mostra os graos centígrados e kelvin.
- Datos de saída: Mostra na pantalla os datos de saída dalgún actuador do teu proxecto: Led aceso ou apagado, ángulo dun servo, estado dun motor (sentido de xiro e parado).
- Ascensor: Nun proxecto dun ascensor de 3 pisos, mostra na pantalla o piso no que está ou se está subindo ou baixando.
Deseño 3D
En Thingiverse tedes o STL deste soporte para LCD deseñado polo alumnado de Tecnoloxía Industrial de 2ºBach (curso 16-17)
Extra:
Cando remates o teu traballo podes botar unha partida a Arduino LCD Game.
Facendo clic en “Code editor” podes copiar o código para cargalo no teu Arduíno. Se usas unha LCD con interface I2C lémbrate de adaptar a configuración do programa. Engade un pulsador ao pin 2. (Instrucións aquí)