Introdução ao Módulo Adaptador LCD I2C

Neste post, vamos dar uma olhada no módulo adaptador de LCD baseado em “I2C” ou “IIC” ou “I quadrado C”, que reduzirá as conexões de fio entre o Arduino e o monitor LCD para apenas 2 fios, economizando toneladas de pinos GPIO 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 com o 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 serial de computador inventado pela Philips semiconductors, hoje conhecido como NXP semiconductors. Este sistema de ônibus foi inventado em 1982.

O que é ônibus?

Barramento é 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 com suporte 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 dados seriais e relógio serial, respectivamente.

O relógio serial ou SCL é usado para sincronizar a comunicação de dados no barramento I2C. O SDA ou Dados Seriais é 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 com qual dispositivo escravo ele precisa se comunicar. Nenhum dispositivo escravo pode iniciar uma comunicação primeiro, apenas o dispositivo mestre pode fazer.

A linha de dados serial é bidirecional e robusta, após cada conjunto de dados de 8 bits ser enviado, 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 desenvolvido 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 de 2000, 2007, 2012 (com modo Ultra-Fast de 5 Mbps) 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 'dreno aberto', o que significa que ambas as linhas podem ficar LOW, mas não pode conduzir as linhas HIGH, então um resistor pull-up é conectado em cada uma das linhas.

Mas a maioria dos módulos I2C, como LCD ou RTC, possui resistores pull up integrados, portanto, não precisamos conectar um, a menos que seja especificado.

Resistor pull-up / pull-down: O resistor pull-up é um resistor conectado à linha + Ve da fonte para manter o nível lógico de uma linha em HIGH se a linha não for alta nem baixa.

Um resistor pull-down é um resistor conectado a –Ve linha da fonte 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, navegue em

YouTube e Google.

Agora vamos dar uma olhada no módulo I2C LCD:

Existem 16 pinos de saída para o display LCD que podem ser soldados diretamente na parte de trás 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 os pinos A4 e A5, respectivamente. Para Arduino mega SDA é o pino # 20 e SCL é o pino # 21.

Vamos comparar a aparência 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 de trás do display LCD e como podemos ver, economizamos muitos pinos GPIO para outras tarefas e também podemos continuar a adicionar mais 126 dispositivos I2C aos pinos A4 e A5.

Observe que a biblioteca padrão de Cristal Líquido não funciona com este adaptador I2C LCD, há uma biblioteca especial para isso, que será abordada em breve e mostraremos como usar este módulo com um exemplo de codificação.

Como conectar o adaptador I2C a um monitor 16 x 2

Nas seções acima do artigo, aprendemos os fundamentos do protocolo I2C e obtivemos uma visão geral básica do módulo adaptador LCD I2C. Neste post vamos aprender como conectar o módulo adaptador I2C LCD a um 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 possui 16 pinos de saída e 4 pinos de entrada. Podemos simplesmente soldar o adaptador na parte de trás do display LCD 16 x 2. Dos 4 pinos de entrada, os dois são + 5V e GND, o resto 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 do display ajustando o potenciômetro com uma pequena chave de fenda (destacada na caixa vermelha).

A luz de fundo 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 é 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 I2C LCD precisa de

biblioteca e a biblioteca pré-instalada de 'cristal líquido' não funcionam.

Você pode baixar a biblioteca I2C LCD aqui e adicioná-la ao Arduino IDE:

github.com/marcoschwartz/LiquidCrystal_I2C

No post anterior, aprendemos que os dispositivos I2C têm um endereço pelo qual o mestre ou o microcontrolador pode identificar o dispositivo e se comunicar.

Na maioria dos casos, para o módulo I2C LCD, o endereço seria “0x27”. Mas fabricantes diferentes podem ter endereços diferentes. Precisamos inserir o endereço correto no programa somente para que o display LCD funcione.

Para encontrar o endereço basta conectar 5V ao Vcc e GND ao GND do Arduino e o 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 ')
}
else
{
Serial.println('-------------- done -------------')
Serial.println('')
}
delay(5000)
}
// -------------------------------- //

Faça upload do 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 I2C LCD, não deve conectar nenhum outro dispositivo I2C durante a digitalização.
Concluindo, 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 RTC ou módulo de relógio de 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 a hora para RTC

• Abra o Arduino IDE e navegue até Arquivo> Exemplo> DS1307RTC> definir hora.
• 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 RTC, não precisamos encontrar o endereço, mas o encontramos durante a varredura de “0x68”, mas de qualquer forma a biblioteca RTC cuidará disso.

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.

Agora você já ganhou conhecimento básico sobre I2C e como usar o módulo adaptador I2C LCD.
Você gosta deste post? Você tem alguma pergunta? Por favor, expresse na seção de comentários, você pode obter uma resposta rápida.