Pantalla LCD

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:

Conexión directa a Arduíno Conexión a través de interface I2C
lcd
[tecnoloxia.org CC By-SA]
lcd_controladori2c
[tecnoloxia.org CC By-SA]

pins_tira2No 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. LCD con I2C

lcd_i2c
[tecnoloxia.org CC By-SA from Fritzing]
I²C ou I2C  é un bus de comunicacións en serie que utiliza dúas liñas para transmitir a información: unha para os datos e outra para o sinal de reloxo, polo que a conexión dunha pantalla LCD con interface I2C resulta moi sinxela, pois só temos catro pins.

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.i2c_fritzing

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.

2. Conexión directa

Debes soldar unha tira de pins á pantalla LCD, conectala nunha protoboard, e realizar as seguintes conexións:

lcd_fritzing2
[Esquema exemplo de fritzing]
1º) Alimentación: 3º) Pins de control: 5º) LED: (opcional)
  • A pantalla LCD debería acenderse se conectamos a alimentación do Arduíno
  • Vss: GND
  • Vcc: 5V
  • Rs: ao pin 12 do Arduíno
  • RW: a GND
  • E: ao pin 11 do Arduíno
  • É o díodo de retro-iluminación.
  • LED K: a GND
  • LED A: a unha resistencia de 220Ω conectada a 5V no outro extremo.
2º) Potenciómetro: 4º) Cables de datos:
  • Encárgase do axuste do brillo. Fai unha proba despois de conectalo. Deberían verse as matrices de puntos.
  • Vo: Pin central do potenciómetro.
  • Un pin dos extremos do potenciómetro a 5V e o outro a GND.
  • DB4: ao pin 5 do Arduíno
  • DB5: ao pin 4 do Arduíno
  • DB6: ao pin 3 do Arduíno
  • DB7: ao pin 2 do Arduíno

lcd_fritzing1
[Esquema exemplo de fritzing]

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 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).

libreria
[tecnoloxia.org CC By-SA]
Hai que incluír ademais outra librería estándar que xa temos no IDE de Arduíno e que se encarga da comunicación I2C: (Sketch → Incluír biblioteca → Wire)  (Wire reference)

Configuración

i2c_scanner
[tecnoloxia.org CC By-SA]
Debemos coñecer o enderezo da pantalla LCD en hexadecimal.

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();

/* 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

// pins

LiquidCrystal_I2C lcd(0x27, 16, 2);

// Configuración:

void setup(){
  
  lcd.init();                // Inicializar a LCD   
//(pode que nalgunha librería teñeas que iniciar coa instrución lcd.begin(); e non a anterior. Consulta a documentación)
  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:
// 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 directa

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();

#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:
// 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)

// 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.

// 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

// 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.

// 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
  
}

consola_findelinha
[tecnoloxia.org CC By-SA]
Se ves que se imprimen caracteres estraños despois do texto introducido na consola, pode ser que esteas engadindo o salto de liña.

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.

lcdchar
[tecnoloxia.org CC By-SA from lcdchar]
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);

// 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.

Propostas:

Estas son algunhas ideas para traballar, pero o ideal é que traballes o necesario para incorporar unha pantalla LCD ao teu proxecto.

  1. 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.
  2. 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).
  3. 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)

Se queres facer o teu propio soporte poden axudarche estas medidas:

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í)

arduinolcdgame
[Captura de Arduino LCD Game from circuits.io]


Deixa un comentario