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

pins_tira2

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

[Esquema exemplo de fritzing]

2. LCD con 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.

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


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

#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

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

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

[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

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

}

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


// lcd.clear();        // Borrar pantalla

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

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

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

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

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

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.

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

}

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

[Captura de Arduino LCD Game from circuits.io]

Descrición:

Conexión:

1. Conexión directa

2. LCD con I2C

Configuración:

1. Configuración normal

Librería

Configuración

2. Configuración con I2C

Librerías

Configuración

Prácticas

1. Texto

2. Scroll

3. Scroll automático

4. Consola

5. Debuxos

Simulación

Propostas:

Deseño 3D

Extra:

Deixa unha resposta Cancelar a resposta