Guia de como controlar um LCD I2C de caracteres com Arduino

Este artigo inclui tudo o que você precisa saber sobre como usar um LCD I2C de caracteres com o Arduino. Incluí um diagrama de ligação e muitos códigos de exemplo.

A primeira parte deste artigo aborda os conceitos básicos de exibição de texto e números. Na segunda metade, irei entrar em mais detalhes sobre como exibir caracteres personalizados e como você pode usar as outras funções da biblioteca LiquidCrystal_I2C.

Depois de saber como exibir texto e números no LCD, sugiro que dê uma olhada nos artigos abaixo. Nesses tutoriais, você aprenderá como medir e exibir dados do sensor no LCD.

Suprimentos

Componentes de hardware

• LCD I2C de 16×2 caracteres LCD
• LCD I2C de 20×4 caracteres (alternativa)
• Arduino Uno Rev 3
• Fios de ligação (macho para fêmea) × 4
• Cabo USB tipo A/B

Básico I2C LCD

Este tipo de LCD é ideal para exibir texto e números, daí o nome ‘LCD de caracteres’. Os LCDs I2C que estamos usando neste tutorial vêm com um pequeno circuito adicional montado na parte traseira do módulo. Este módulo possui um chip PCF8574 (para comunicação I2C) e um potenciômetro para ajustar a luz de fundo do LED. A vantagem de um LCD I2C é que a fiação é muito simples. Você só precisa de dois pinos de dados para controlar o LCD.

Os LCDs padrão normalmente requerem cerca de 12 conexões, o que pode ser um problema se você não tiver muitos pinos GPIO disponíveis.

Se você olhar atentamente para o LCD, poderá ver os pequenos retângulos que formam os caracteres individuais do LCD. Cada retângulo é composto por uma grade de 5 × 8 pixels. Posteriormente neste tutorial, mostrarei como você pode controlar os pixels individuais para exibir caracteres personalizados no LCD.

Especificações

As especificações dos LCDs de 16 × 2, 20 × 4 e outros tamanhos são praticamente as mesmas. Todos eles usam o mesmo controlador LCD Hitachi HD44780, então você pode trocá-los facilmente. Você só precisará alterar as especificações de tamanho no código do Arduino.

As especificações de um display 16 × 2 I2C típico podem ser encontradas na tabela abaixo.

Especificações de LCD I2C de 16×2

*** (Pode acontecer em versão origem chinesa ou outras, variar o endereço)

Para mais informações, você pode verificar as fichas técnicas abaixo. Os datasheet dos 16×2 e 20×4 incluem as dimensões do LCD e você pode encontrar mais informações sobre o driver Hitachi LCD no DataSheet HD44780. O chip PCF8574 é usado no módulo I2C na parte traseira do LCD.

Como conectar o LCD I2C ao Arduino UNO

O diagrama de ligação abaixo mostra como conectar o LCD I2C ao Arduino. Conectar um LCD I2C é muito mais fácil do que conectar um LCD padrão. Você só precisa conectar 4 pinos em vez de 12.

As conexões também são fornecidas na tabela abaixo.

Conexões LCD I2C

Se você não estiver usando um Arduino Uno, os pinos SDA e SCL podem estar em um local diferente. Observe que um Arduino Uno com o layout R3 (pinagem 1.0) também possui os cabeçalhos de pinos SDA (linha de dados) e SCL (linha do relógio) próximos ao pino AREF. Verifique a tabela abaixo para mais detalhes.

Localizações de pinos SDA e SCL em diferentes placas Arduino.

Ajustando o contraste do LCD

Depois de conectar o LCD, você precisará ajustar o contraste do visor. No módulo I2C, você encontrará um potenciômetro que pode girar com uma pequena chave de fenda.

Conecte o conector USB do Arduino para alimentar o LCD. Você deve ver a luz de fundo acender. Agora gire o potenciômetro até que uma (LCD 16×2) ou 2 filas (LCD 20×4) de retângulos apareçam.

Você pode ajustar o contraste posteriormente, se necessário.

Feito isso, podemos começar a programar o LCD.

Instalando a biblioteca LiquidCrystal_I2C Arduino

Neste tutorial, estarei usando a biblioteca LiquidCrystal_I2C. Esta biblioteca possui muitas funções integradas que tornam a programação do LCD bastante fácil. A versão mais recente dessa biblioteca pode ser encontrada aqui no GitHub ou baixe em nosso servidor a versão (aqui).

Certifique-se de ter esta biblioteca exata instalada e exclua quaisquer outras bibliotecas que tenham o mesmo nome (LiquidCrystal_I2C). Outras bibliotecas provavelmente funcionarão bem, mas podem usar nomes ligeiramente diferentes para as diferentes funções.

A biblioteca LiquidCrystal_I2C funciona em combinação com a biblioteca Wire.h, que permite a comunicação com dispositivos I2C. Esta biblioteca vem pré-instalada com o IDE Arduino.

<<< Atualização >>>

Use a Library no fim do artigo, pois a original foi excluída do Repositório da Arduino.cc

A biblioteca inclui alguns exemplos que você pode usar, mas terá que modificá-los para corresponder à configuração do seu hardware. Incluí muitos códigos de exemplo abaixo que você pode usar com a configuração de ligação mostrada anteriormente.

Primeiro, mostrarei um exemplo de código básico e, em seguida, explicarei as funções com mais detalhes.

Como encontrar o endereço I2C do meu LCD?

A maioria dos LCDs I2C é enviada com o endereço padrão ‘0x27’, mas pode ser diferente dependendo do lote/fabricante. Se for esse o caso, você precisará encontrar o endereço real do LCD antes de começar a usá-lo.

No site do Arduino, você pode encontrar um esboço de exemplo simples que verifica o barramento I2C em busca de dispositivos. Se um dispositivo for encontrado, ele exibirá o endereço no monitor serial.

Você pode copiar o código clicando no botão no canto superior direito do campo do código.

/*I2C_scanner
   Este sketch testa endereços de 7 bits padrão.
   Dispositivos com endereço de bit mais alto podem não ser vistos corretamente.*/
  
#include <Wire.h>
void setup() {
  Wire.begin();
  Serial.begin(9600);
  while (!Serial);
  Serial.println("\nI2C Scanner");
}
void loop() {
  byte error, address;
  int nDevices;
  Serial.println("Scanning...");
  nDevices = 0;
  for (address = 1; address < 127; address++ ) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0) {
      Serial.print("Dispositivo I2C encontrado no endereço 0x");
      if (address < 16)
        Serial.print("0");
      Serial.print(address, HEX);
      Serial.println("  !");
      nDevices++;
    }
    else if (error == 4) {
      Serial.print("Unknown error at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.println(address, HEX);
    }
  }
  if (nDevices == 0)
    Serial.println("Nenhum dispositivo I2C encontrado\n");
  else
    Serial.println("Pronto\n");
  delay(5000);
}

Se você carregar este esboço para o Arduino e executá-lo, deverá ver a seguinte saída no Monitor Serial (Ctrl + Shift + M).

Anote o endereço que encontrar, você precisará dele mais tarde ao programar o LCD.

Código de exemplo básico do Arduino para LCD I2C

Você pode fazer upload do seguinte código de exemplo para o Arduino usando o IDE do Arduino.

Para este tutorial, usei este display LCD de 16×2 caracteres I2C, mas você também pode usar outros LCDs I2C de tamanhos diferentes.

Este esboço de exemplo exibirá o clássico ‘Olá Mundo!’ Na primeira linha do LCD e o ‘tutorial LCD’ na segunda linha. A seguir, explicarei como o código funciona.

/* LCD I2C com código de exemplo Arduino. */ 
// Incluir as bibliotecas: 
// LiquidCrystal_I2C.h: 
#include <Wire.h> 

// Biblioteca para comunicação I2C 
#include <LiquidCrystal_I2C.h> 

// Biblioteca para LCD 
// Ligação: o pino SDA está conectado ao A4 e o pino SCL ao A5.
// Conecte ao LCD via I2C, endereço padrão 0x27 (A0-A2 sem jumpers) 
// Inicializa o display no endereço 0x27
LiquidCrystal_I2C lcd(0x27, 16,2 );

  // Mude para (0x27,20,4) para LCD 20x4. 
void setup() { 
  // Inicializa o display LCD 16x2
  lcd.begin (16, 2);
  // Inicializa o display LCD 20x4 
  //lcd.begin (20, 4);
  // Liga a luz de fundo do LCD
  lcd.setBacklight(HIGH); 
} 

void loop() { 
  // Imprime 'Olá Mundo!' na primeira linha do LCD: 
  lcd.setCursor(2, 0); // Coloque o cursor na terceira coluna e na primeira linha. 
  lcd.print("Ola Mundo!"); // Imprima a string "Olá Mundo!" 
  lcd.setCursor(2, 1); 
  //Coloque o cursor na terceira coluna e na segunda linha (a contagem começa em 0!). 
  lcd.print("LCD tutorial"); 
}

Como funciona o código

Primeiro, as bibliotecas necessárias são incluídas. Conforme mencionado anteriormente, precisamos das bibliotecas wire.h * e LiquidCrystal_I2C. No restante deste tutorial, cobrirei mais das funções integradas desta biblioteca.

* Ao usar a versão mais recente da biblioteca LiquidCrystal_I2C, não é mais necessário incluir a biblioteca wire.h em seu sketch. A outra biblioteca importa wire.h automaticamente.

// Incluir as bibliotecas:
// LiquidCrystal_I2C.h:
#include <Wire.h> // Biblioteca para comunicação I2C
#include <LiquidCrystal_I2C.h> // Biblioteca para LCD

A próxima etapa é criar um objeto LCD com a classe LiquidCrystal_I2C e especificar o endereço e as dimensões. Para isso, usamos a função LiquidCrystal_I2C (endereço, colunas, linhas). É aqui que você precisará alterar o endereço padrão para o endereço encontrado anteriormente, se ele for diferente.

Ao usar um LCD 20 × 4, altere esta linha para LiquidCrystal_I2C (0x27,20,4);

Observe que chamamos a tela de ‘LCD’. Você pode dar a ele um nome diferente se quiser, como ‘menu_display’. Você precisará alterar ‘lcd’ para o novo nome no resto do sketch.

// Biblioteca para LCD 
// Ligação: o pino SDA está conectado ao A4 e o pino SCL ao A5. 
// Conecte ao LCD via I2C, endereço padrão 0x27 (A0-A2 sem jumpers) 
// Inicializa o display no endereço 0x27 
LiquidCrystal_I2C lcd(0x27, 16, 2);

Na configuração, o LCD é iniciado com lcd.init() e a luz de fundo é ligada com lcd.backlight()

void setup() {
 // Inicializa o display LCD 16x2 
 lcd.begin (16, 2); para 
 // Inicializa o display LCD 20x4 
 //lcd.begin (20, 4); 
 // Liga a luz de fundo do LCD 
 lcd.setBacklight(HIGH); 
}

Na seção de loop do código, o cursor é colocado na terceira coluna e na primeira linha do LCD com lcd.setCursor(2,0). Observe que a contagem começa em 0 e o primeiro argumento especifica a coluna. Portanto, lcd.setCursor(2,1) define o cursor na terceira coluna e na segunda linha.

Em seguida, a string ‘Olá Mundo!’ É impressa com lcd.print(“Olá Mundo!”). Observe que você precisa colocar aspas (”“) ao redor do texto, pois estamos imprimindo uma string de texto. Quando você deseja imprimir números, não são necessárias aspas. Por exemplo, lcd.print(12345).

Outras funções úteis da biblioteca LiquidCrystal_I2C

O sketch de exemplo acima mostra os fundamentos da exibição de texto no LCD. Agora daremos uma olhada nas outras funções da biblioteca LiquidCrystal_I2C.

clear()

Limpa a tela LCD e posiciona o cursor no canto superior esquerdo (primeira linha e primeira coluna) do visor. Você pode usar esta função para exibir palavras diferentes em um loop.

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
}
void loop() {
  lcd.clear();
  lcd.print("Segunda-feira");
  delay(2000);
  lcd.clear();
  lcd.print("13:45");
  delay(2000);
}

home()

Posiciona o cursor no canto superior esquerdo do LCD. Use clear() se também quiser limpar o display.

cursor()

Exibe o cursor do LCD: um sublinhado (linha) na posição do próximo caractere a ser impresso.

noCursor()

Oculta o cursor do LCD. O exemplo a seguir cria um cursor piscando no final de “Olá Mundo!”.

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,20,4);
void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("Olá Mundo!");
}
void loop() {
  lcd.scrollDisplayLeft();
  delay(500);
}

scrollDisplayRight()

Rola o conteúdo da tela (texto e cursor) um espaço à direita.

autoscroll()

Esta função ativa a rolagem automática do LCD. Isso faz com que cada saída de caractere para a exibição ultrapasse os caracteres anteriores em um espaço. Se a direção do texto atual for da esquerda para a direita (o padrão), a tela rola para a esquerda; se a direção atual for da direita para a esquerda, a tela rola para a direita. Isso tem o efeito de enviar cada novo caractere para o mesmo local no LCD.

O seguinte sketch de exemplo permite a rolagem automática e imprime o caractere de 0 a 9 na posição (16,0) do LCD. Altere para (20,0) para um LCD 20×4.

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,20,4);
void setup() {
  lcd.init();
  lcd.backlight();
}
void loop() {
  lcd.autoscroll();
  lcd.setCursor(16, 0);
  for (int x = 0; x < 10; x++) {
    lcd.print(x);
    delay(500);
  }
  lcd.clear();
}

noAutoscroll()

Desativa a rolagem automática do LCD.

leftToRight()

Esta função faz com que o texto flua para a direita do cursor, como se a exibição fosse justificada à esquerda (padrão).

rightToLeft()

Esta função faz com que o texto flua para a esquerda do cursor, como se a exibição estivesse justificada à direita.

Como criar e exibir personagens personalizados?

Com a função createChar() é possível criar e exibir caracteres personalizados no LCD. Isso é especialmente útil se você deseja exibir um caractere que não faz parte do conjunto de caracteres ASCII padrão.

CGROM e CGRAM

Os LCDs baseados no controlador Hitachi HD44780 LCD têm dois tipos de memória: CGROM e CGRAM (Character Generator ROM e RAM). O CGROM gera todos os padrões de caracteres de 5 x 8 pontos a partir dos códigos de caracteres de 8 bits padrão. O CGRAM pode gerar padrões de caracteres definidos pelo usuário.

Para telas de 5 x 8 pontos, o CGRAM pode escrever até 8 caracteres personalizados e para telas de 5 x 10 pontos 4. Para obter mais informações, consulte a ficha técnica.

Código de exemplo de caractere personalizado

O seguinte sketch de exemplo cria e exibe oito caracteres personalizados (numerados de 0 a 7).

Você pode copiar o código clicando no botão no canto superior direito do campo do código.

/* Código de exemplo do Arduino para exibir caracteres personalizados no LCD de caracteres I2C. */ 
// Incluir a biblioteca: 
#include <LiquidCrystal_I2C.h> 

// Cria o objeto lcd da classe LiquidCrystal_I2C: 
LiquidCrystal_I2C lcd(0x27,20,4);

// Faça caracteres personalizados: 
byte Heart[] = { B00000, B01010, B11111, B11111, B01110, B00100, B00000, B00000 }; 
byte Bell[] = { B00100, B01110, B01110, B01110, B11111, B00000, B00100, B00000 }; 
byte Alien[] = { B11111, B10101, B11111, B11111, B01110, B01010, B11011, B00000 }; 
byte Check[] = { B00000, B00001, B00011, B10110, B11100, B01000, B00000, B00000 }; 
byte Speaker[] = { B00001, B00011, B01111, B01111, B01111, B00011, B00001, B00000 }; 
byte Sound[] = { B00001, B00011, B00101, B01001, B01001, B01011, B11011, B11000 }; 
byte Skull[] = { B00000, B01110, B10101, B11011, B01110, B01110, B00000, B00000 }; 
byte Lock[] = { B01110, B10001, B10001, B11111, B11011, B11011, B11111, B00000 }; 
void setup() { 
  // Inicializa o display LCD 16x2
  //lcd.begin (16, 2); para 
  // Inicializa o display LCD 20x4
  lcd.begin (20, 4);
  // Liga a luz de fundo do LCD
  lcd.setBacklight(HIGH); 
  // Crie novos personagens: 
  lcd.createChar(1, Heart); 
  lcd.createChar(2, Bell); 
  lcd.createChar(3, Alien); 
  lcd.createChar(4, Check); 
  lcd.createChar(5, Speaker); 
  lcd.createChar(6, Sound); 
  lcd.createChar(7, Skull); 
  lcd.createChar(8, Lock); // 
  // Limpa
  lcd.clear(); 
  // Imprima uma mensagem para o lcd: 
  lcd.print("Personagem Custom"); 
} 

// Imprime todos os caracteres personalizados: 
void loop() { 
  lcd.setCursor(0, 1); 
  lcd.write(1); 
  lcd.setCursor(2, 1); 
  lcd.write(2); 
  lcd.setCursor(4, 1); 
  lcd.write(3); 
  lcd.setCursor(6, 1); 
  lcd.write(4); 
  lcd.setCursor(8, 1); 
  lcd.write(5); 
  lcd.setCursor(10, 1); 
  lcd.write(6); 
  lcd.setCursor(12, 1); 
  lcd.write(7); 
  lcd.setCursor(14, 1); 
  lcd.write(8); 
}

Você deve ver a seguinte saída no LCD:

Como funciona o código

Depois de incluir a biblioteca e criar o objeto LCD, os arranjos de caracteres personalizados são definidos. Cada array consiste em 8 bytes (apenas 5 bits são considerados). Há 1 byte para cada linha da matriz de 5 x 8 led. Neste exemplo, 8 caracteres personalizados são criados.

// Faça caracteres personalizados:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

É possível editar cada linha manualmente, mas recomendo usar esta ferramenta visual no GitHub. Este aplicativo cria automaticamente a matriz de caracteres e você pode clicar nos pixels para ligá-los ou desligá-los.

Na configuração, os caracteres personalizados são criados com lcd.createChar(num, data).

O primeiro argumento nesta função é o número do caractere personalizado (0-7) e o segundo argumento é a matriz de caracteres que criamos.

// Crie novos personagens:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

No loop, todos os caracteres são exibidos com lcd.write(). Como argumento, usamos o número do caractere personalizado que queremos exibir.

lcd.setCursor(0, 1);
lcd.write(0);

Conclusão

Neste artigo, mostrei como usar um LCD I2C de caracteres com o Arduino. Espero que você tenha achado útil e informativo. Se sim, compartilhe com um amigo que também gosta de eletrônica e de fazer coisas!

Eu adoraria saber quais projetos você planeja construir (ou já construiu) com esses LCDs. Se você tiver alguma dúvida, sugestão ou se achar que falta algo neste tutorial, por favor, deixe um comentário abaixo.

(Atualizado em 17/06/22) (Library do Projeto não existe mais, use está) (LiquidCrystal_I2C)