Neste post, vamos dar uma olhada no módulo adaptador LCD baseado em “I2C” ou “IIC” ou “I square C”, que reduzirá as conexões de fios entre o Arduino e o display LCD para apenas 2 fios, também economizando toneladas de pinos GPIO para outros sensores / drives etc.
Antes de discutirmos sobre o módulo adaptador I2C LCD, é importante entender o que é o barramento I2C e como ele funciona.
Mas de qualquer forma você não precisa ser um especialista em protocolo I2C para trabalhar com este adaptador LCD mencionado.
Ilustração da conexão I2C:
O I2C ou IIC significa “Inter-Integrated Circuit” é um barramento de computador serial inventado pelos semicondutores Philips, hoje conhecidos como semicondutores NXP. Este sistema de ônibus foi inventado em 1982.
O que é ônibus?
Bus é um grupo de cabos/fios que transportam dados de um chip para outro chip/uma placa de circuito para outra placa de circuito.
A principal vantagem do protocolo de barramento I2C é que o microcontrolador ou sensores ou chips suportados podem ser interligados com apenas dois fios. A vantagem deste protocolo é que podemos interconectar 127 chips ou sensores / drivers diferentes a um dispositivo mestre que geralmente é um microcontrolador com apenas 2 fios.
Quais são os dois fios I2C?
Os dois fios são SDA e SCL que são Serial Data e Serial clock respectivamente.
O relógio serial ou SCL é usado para sincronizar a comunicação de dados pelo barramento I2C. O SDA ou Serial Data é a linha de dados na qual os dados reais são transmitidos do mestre para o escravo e vice-versa. O dispositivo mestre controla o relógio serial e decide para qual dispositivo escravo ele precisa se comunicar. Nenhum dispositivo escravo pode iniciar uma comunicação primeiro, apenas o dispositivo mestre pode fazê-lo.
A linha de dados Serial é bidirecional e robusta, após o envio de cada conjunto de dados de 8 bits, o dispositivo receptor envia de volta um bit de confirmação.
Quão rápido é o protocolo I2C?
A versão original do protocolo I2C desenvolvida em 1982 suportava 100 Kbps. A próxima versão foi padronizada em 1992, que suportava 400 Kbps (modo rápido) e suportava até 1008 dispositivos. A próxima versão foi desenvolvida em 1998 com 3,4 Mbps (modo de alta velocidade).
Várias outras versões do I2C foram desenvolvidas nos anos 2000, 2007, 2012 (com modo Ultra-Fast de 5Mbps) e a versão recente do I2C foi desenvolvida em 2014.
Por que resistores pull-up no barramento I2C?
O SDA e o SCL são “open-drain”, o que significa que ambas as linhas podem ficar em LOW, mas não podem conduzir as linhas em HIGH, então um resistor de pull-up é conectado em cada uma das linhas.
Mas com a maioria dos módulos I2C, como LCD ou RTC, foram construídos resistores pull-up, portanto, não precisamos conectar um, a menos que seja especificado.
Resistor de pull-up / pull-down: O resistor de pull-up é um resistor conectado à linha +Ve da alimentação para manter o nível lógico de uma linha em ALTO se a linha não for alta nem baixa.
Um resistor pull-down é um resistor conectado à linha –Ve da alimentação para manter o nível lógico de uma linha em BAIXO se a linha não for alta nem baixa.
Isso também evita que o ruído entre nas linhas.
Esperamos ter arranhado a superfície do protocolo I2C, se você precisar de mais informações sobre o protocolo I2C, por favor, navegue em
YouTube e Google.
Agora vamos dar uma olhada no módulo LCD I2C:
Existem 16 pinos de saída para display LCD que podem ser soldados diretamente na parte traseira do módulo LCD 16 X 2.
Os pinos de entrada são +5V, GND, SDA e SCL. Os pinos SDA e SCL no Arduino Uno são pinos A4 e A5, respectivamente. Para Arduino mega SDA é o pino 20 e SCL é o pino 21.
Vamos comparar como fica quando conectamos o LCD ao Arduino sem o adaptador I2C e com o adaptador.
Sem adaptador I2C:
Com adaptador I2C:
O adaptador é soldado na parte traseira do display LCD e como podemos ver que economizamos muitos pinos GPIO para outras tarefas e também podemos continuar adicionando mais 126 dispositivos I2C aos pinos A4 e A5.
Observe que a biblioteca padrão de Cristal Líquido não funcionará com este adaptador LCD I2C, existe uma biblioteca especial para isso, que será abordada em breve e mostraremos como usar este módulo com exemplo de codificação.
Como conectar o adaptador I2C ao monitor 16 x 2
Nas seções acima do artigo, aprendemos os fundamentos do protocolo I2C e fizemos uma visão geral básica do módulo adaptador I2C LCD. Neste post vamos aprender como conectar o módulo adaptador I2C LCD ao display LCD 16 x 2 e veremos como programar com um exemplo.
A principal vantagem do protocolo I2C é que podemos conectar os sensores / dispositivos de entrada / saída suportados em apenas duas linhas e é útil com o Arduino, pois possui pinos GPIO limitados.
Agora vamos ver como conectar o módulo ao LCD.
O módulo tem 16 pinos de saída e 4 pinos de entrada. Podemos apenas soldar o adaptador na parte traseira do display LCD de 16 x 2. Dos 4 pinos de entrada, os dois são +5V e GND, o restante dos dois são SDA e SCL.
Podemos ver que salvamos muitos pinos no Arduino para outras tarefas de entrada/saída.
Podemos ajustar o contraste da tela ajustando o potenciômetro com uma pequena chave de fenda (destacada na caixa vermelha).
A retroiluminação agora pode ser controlada no próprio código do programa:
lcd.backlight();
Isso ligará a luz de fundo do visor LCD.
lcd.noBacklight();
Isso desligará a luz de fundo do visor LCD.
Podemos ver que há um jumper conectado, que está destacado na caixa vermelha, se o jumper for removido, a luz de fundo permanece DESLIGADA, independentemente do comando do programa.
Agora que a configuração do hardware está feita, agora vamos ver como codificar. Lembre-se de que o módulo LCD I2C precisa de
library e a biblioteca “liquidcrystal” pré-instalada não funcionarão.
Você pode baixar a biblioteca I2C LCD aqui e adicionar ao Arduino IDE:
github.com/marcoschwartz/LiquidCrystal_I2C
No post anterior aprendemos que os dispositivos I2C possuem endereço pelo qual o mestre ou o microcontrolador podem identificar o dispositivo e se comunicar.
Na maioria dos casos, para o módulo LCD I2C o endereço seria “0x27”. Mas fabricação diferente pode ter endereço diferente. Temos que inserir o endereço correto no programa somente para que seu display LCD funcione.
Para encontrar o endereço basta conectar 5V ao Vcc e GND ao GND do Arduino e pino SCL do módulo I2C ao A5 e SDA ao A4 e fazer o upload do código abaixo.
Isso fará a varredura dos dispositivos I2C conectados e mostrará seus endereços.
// -------------------------------- //
#include
void setup()
{
Wire.begin();
Serial.begin(9600);
while (!Serial);
Serial.println("-----------------------");
Serial.println("I2C Device Scanner");
Serial.println("-----------------------");
}
void loop()
{
byte error;
byte address;
int Devices;
Serial.println("Scanning...");
Devices = 0;
for (address = 1; address < 127; address++ )
{
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
Serial.print("I2C device found at address 0x");
if (address < 16)
{
Serial.print("0");
}
Serial.print(address, HEX);
Serial.println(" !");
Devices++;
}
else if (error == 4)
{
Serial.print("Unknown error at address 0x");
if (address < 16)
Serial.print("0");
Serial.println(address, HEX);
}
}
if (Devices == 0)
{
Serial.println("No I2C devices found\n");
}
else
{
Serial.println("-------------- done -------------");
Serial.println("");
}
delay(5000);
}
// -------------------------------- //
Carregue o código e abra o monitor serial.
Como podemos ver, dois dispositivos foram detectados e seus endereços são exibidos, mas se você deseja encontrar apenas o endereço do módulo LCD I2C, não deve conectar nenhum outro dispositivo I2C durante a varredura.
Então, em conclusão, obtivemos o endereço “0x27”.
Agora vamos fazer um relógio digital como exemplo porque existem dois dispositivos I2C, o módulo LCD e o módulo RTC ou relógio em tempo real. Os dois módulos serão conectados com dois fios.
Baixe a seguinte biblioteca:
Biblioteca RTC: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time
Como definir o tempo para RTC
• Abra o Arduino IDE e navegue até File > Example > DS1307RTC > set time.
• Carregue o código com o hardware completo e o monitor serial aberto e pronto.
Diagrama de circuito:
Programa:
//------------Program Developed by R.Girish-------//
#include
#include
#include
#include
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup()
{
lcd.init();
lcd.backlight();
}
void loop()
{
tmElements_t tm;
lcd.clear();
if (RTC.read(tm))
{
if (tm.Hour >= 12)
{
lcd.setCursor(14, 0);
lcd.print("PM");
}
if (tm.Hour < 12)
{
lcd.setCursor(14, 0);
lcd.print("AM");
}
lcd.setCursor(0, 0);
lcd.print("TIME:");
if (tm.Hour > 12)
{
if (tm.Hour == 13) lcd.print("01");
if (tm.Hour == 14) lcd.print("02");
if (tm.Hour == 15) lcd.print("03");
if (tm.Hour == 16) lcd.print("04");
if (tm.Hour == 17) lcd.print("05");
if (tm.Hour == 18) lcd.print("06");
if (tm.Hour == 19) lcd.print("07");
if (tm.Hour == 20) lcd.print("08");
if (tm.Hour == 21) lcd.print("09");
if (tm.Hour == 22) lcd.print("10");
if (tm.Hour == 23) lcd.print("11");
}
else
{
lcd.print(tm.Hour);
}
lcd.print(":");
lcd.print(tm.Minute);
lcd.print(":");
lcd.print(tm.Second);
lcd.setCursor(0, 1);
lcd.print("DATE:");
lcd.print(tm.Day);
lcd.print("/");
lcd.print(tm.Month);
lcd.print("/");
lcd.print(tmYearToCalendar(tm.Year));
} else {
if (RTC.chipPresent())
{
lcd.setCursor(0, 0);
lcd.print("RTC stopped!!!");
lcd.setCursor(0, 1);
lcd.print("Run SetTime code");
} else {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Read error!");
lcd.setCursor(0, 1);
lcd.print("Check circuitry!");
}
}
delay(1000);
}
//------------Program Developed by R.Girish-------//
Observação:
LiquidCrystal_I2C lcd(0x27, 16, 2);
O “0x27” é o endereço que encontramos ao escanear e 16 e 2 são o número de linhas e colunas no display LCD.
Para o RTC, não precisamos encontrar o endereço, mas encontramos durante a varredura “0x68”, mas de qualquer maneira a biblioteca RTC lidará com isso.
Agora vamos ver o quanto reduzimos o congestionamento de fios e salvamos os pinos GPIO no Arduino.
Apenas 4 fios estão conectados ao display LCD, destacados na caixa vermelha.
Além disso, apenas 4 fios são conectados do Arduino e o módulo RTC compartilha as mesmas linhas.
Até agora você adquiriu conhecimento básico sobre I2C e como usar o módulo adaptador LCD I2C.
Você gosta deste post? Você tem alguma pergunta? Por favor, expresse na seção de comentários, você pode obter uma resposta rápida.
Hashtags: #Introdução #Módulo #Adaptador #LCD #I2C
FONTE
Nota: Este conteúdo foi traduzido do Inglês para português (auto)
Pode conter erros de tradução
Olá, se tiver algum erro de tradução (AUTO), falta de link para download etc…
Veja na FONTE até ser revisado o conteúdo.
Status (Ok Até agora)
Se tiver algum erro coloque nos comentários