Pantalla LCD

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.

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

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

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

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

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.

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.

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
}

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
}

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

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
  
}

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

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

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