Introducció al mòdul d'adaptador LCD I2C

En aquest post, anem a fer una ullada al mòdul adaptador LCD basat en “I2C” o “IIC” o “I quadrat C”, que reduirà les connexions de cable entre la pantalla Arduino i la pantalla LCD a només 2 cables, estalviant també tones de pins GPIO per a altres sensors / unitats, etc.

Abans de discutir sobre el mòdul adaptador LCD I2C, és important entendre què és i com funciona el bus I2C.

Però, de tota manera, no necessiteu ser un expert amb el protocol I2C per treballar amb aquest adaptador LCD de menció.

Il·lustració de la connexió I2C:

I2C o IIC significa 'Circuit inter-integrat' és un bus d'ordinador sèrie inventat pels semiconductors de Philips, avui coneguts com a semiconductors NXP. Aquest sistema d’autobusos es va inventar el 1982.

Què és Bus?

El bus és un grup de cables / cables que transporten dades d’un xip a un altre xip / una placa de circuit a una altra placa de circuit.

El principal avantatge del protocol de bus I2C és que el microcontrolador o els sensors o xips compatibles es poden connectar amb només dos cables. L’avantatge impressionant d’aquest protocol és que podem interconnectar 127 xips o sensors / controladors diferents a un dispositiu mestre que sol ser un microcontrolador amb només 2 cables.

Quins són els dos cables I2C?

Els dos cables són SDA i SCL, que són dades de sèrie i rellotge de sèrie respectivament.

El rellotge serial o SCL s’utilitza per sincronitzar la comunicació de dades a través d’un bus I2C. La SDA o Serial Data és la línia de dades en què es transmeten les dades reals de mestre a esclau i viceversa. El dispositiu mestre controla el rellotge de sèrie i decideix quin dispositiu esclau ha de comunicar. Cap dispositiu esclau pot iniciar una comunicació primer, només el dispositiu mestre pot fer-ho.

La línia de dades sèrie és bidireccional i robusta, després que s’enviïn cada conjunt de dades de 8 bits, el dispositiu receptor envia un bit de confirmació.

Quina velocitat té el protocol I2C?

La versió original del protocol I2C desenvolupada el 1982 suportava 100 Kbps. La següent versió es va estandarditzar el 1992, que suportava 400 Kbps (mode ràpid) i suportava fins a 1008 dispositius. La següent versió es va desenvolupar el 1998 amb 3,4 Mbps (mode d'alta velocitat).

Diverses altres versions I2C es van desenvolupar els anys 2000, 2007 i 2012 (amb mode ultra ràpid de 5 Mbps) i la versió recent d’I2C es va desenvolupar el 2014.

Per què les resistències pull-up al bus I2C?

El SDA i el SCL són de 'drenatge obert', cosa que significa que les dues línies poden baixar, però no pot conduir les línies ALTA, de manera que es connecta una resistència de tracció a cada una de les línies.

Però amb la majoria dels mòduls I2C, com ara LCD o RTC, hi ha resistències incorporades, de manera que no cal connectar-ne un tret que s’especifiqui.

Resistència pull-up / pull-down: la resistència pull-up és una resistència connectada a la línia + Ve del subministrament per mantenir el nivell lògic d’una línia a HIGH si la línia no és ni alta ni baixa.

Una resistència desplegable és una resistència connectada a la línia –Ve del subministrament per mantenir el nivell lògic d’una línia a BAIX si la línia no és ni alta ni baixa.

Això també evita que el soroll entri a les línies.

Esperem haver ratllat la superfície del protocol I2C; si necessiteu més informació sobre el protocol I2C, navegueu

YouTube i Google.

Vegem ara el mòdul LCD I2C:

Hi ha 16 pins de sortida per a pantalla LCD que es poden soldar directament a la part posterior del mòdul LCD de 16 X 2.

Els pins d'entrada són + 5V, GND, SDA i SCL. Els pins SDA i SCL d’Arduino Uno són els pins A4 i A5 respectivament. Per a Arduino, la mega SDA és el pin # 20 i SCL el pin # 21.

Comparem el seu aspecte quan connectem la pantalla LCD a Arduino sense l'adaptador I2C i amb l'adaptador.

Sense adaptador I2C:

Amb adaptador I2C:

L'adaptador està soldat a la part posterior de la pantalla LCD i, com podem comprovar, hem desat un munt de pins GPIO per a altres tasques i també podem continuar afegint 126 dispositius I2C més als pins A4 i A5.

Tingueu en compte que la biblioteca estàndard de cristall líquid no funcionarà amb aquest adaptador LCD I2C, hi ha una biblioteca especial per a això, que es cobrirà aviat i us mostrarem com utilitzar aquest mòdul amb un exemple de codificació.

Com connectar l’adaptador I2C a la pantalla de 16 x 2

A les seccions anteriors de l'article vam aprendre els conceptes bàsics del protocol I2C i vam fer una visió general bàsica del mòdul adaptador LCD I2C. En aquest post aprendrem a connectar el mòdul adaptador I2C LCD a la pantalla LCD de 16 x 2 i veurem com es programa amb un exemple.

L’avantatge principal del protocol I2C és que podem connectar els sensors / dispositius d’entrada / sortida compatibles en només dues línies i és útil amb Arduino, ja que té pins GPIO limitats.

Ara veurem com connectar el mòdul a la pantalla LCD.

El mòdul té 16 pins de sortida i 4 pins d’entrada. Només podem soldar l’adaptador a la part posterior de la pantalla LCD de 16 x 2. Dels 4 pins d'entrada, els dos són + 5V i GND, la resta dels dos són SDA i SCL.

Podem veure que hem desat molts pins a Arduino per a altres tasques d’entrada / sortida.

Podem ajustar el contrast de la pantalla ajustant el potenciòmetre amb un petit tornavís (ressaltat en un quadre vermell).

La il·luminació de fons ara es pot controlar al propi codi del programa:

lcd.backlight ()

Això activarà la llum de fons de la pantalla LCD.

lcd.noBacklight ()

Això apagarà la llum de fons de la pantalla LCD.

Podem veure que hi ha un pont connectat, que està ressaltat en un quadre vermell, si el pont està eliminat, la llum de fons es manté APAGADA independentment de l’ordre del programa.

Ara la configuració del maquinari està acabada; ara veurem com codificar. Recordeu que el mòdul LCD I2C necessita especials

la biblioteca i la biblioteca 'liquidcrystal' preinstal·lada no funcionaran.

Podeu descarregar la biblioteca LCD I2C des d’aquí i afegir-la a Arduino IDE:

github.com/marcoschwartz/LiquidCrystal_I2C

A la publicació anterior vam saber que els dispositius I2C tenen una adreça mitjançant la qual el mestre o el microcontrolador poden identificar el dispositiu i comunicar-se.

En la majoria dels casos, per al mòdul LCD I2C l'adreça seria '0x27'. Però diferents fabricacions poden tenir una adreça diferent. Hem d’introduir l’adreça correcta al programa només perquè la pantalla LCD funcioni.

Per trobar l'adreça, connecteu 5V a Vcc i GND a GND d'Arduino i el pin SCL del mòdul I2C a A5 i SDA a A4 i pengeu el codi següent.

Això escanejarà els dispositius I2C connectats i mostrarà la seva adreça.

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

Pengeu el codi i obriu el monitor sèrie.

Com podem veure, es van detectar dos dispositius i es mostren les seves adreces, però si voleu trobar només l'adreça del mòdul LCD I2C, no heu de connectar cap altre dispositiu I2C mentre escanejeu.
Per tant, en conclusió, vam obtenir l'adreça '0x27'.

Ara farem un rellotge digital com a exemple perquè hi ha dos dispositius I2C, el mòdul LCD i el mòdul RTC o rellotge en temps real. Els dos mòduls es connectaran amb dos cables.

Descarregueu la biblioteca següent:
Biblioteca RTC: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

Com configurar l'hora a RTC

• Obriu Arduino IDE i aneu a Fitxer> Exemple> DS1307RTC> establir l'hora.
• Pengeu el codi amb el maquinari complet i obriu el monitor sèrie i ja haureu acabat.

Esquema de connexions:

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

Nota:

LiquidCrystal_I2C lcd (0x27, 16, 2)

El '0x27' és l'adreça que hem trobat escanejant i 16 i 2 són el nombre de files i columnes de la pantalla LCD.

Per a RTC no cal que trobem l'adreça, però sí que ho vam trobar mentre escanejàvem '0x68', però, de totes maneres, la biblioteca RTC ho gestionarà.

Ara anem a veure quant hem reduït la congestió de cables i hem estalviat els pins GPIO a Arduino.

Només hi ha 4 cables connectats a la pantalla LCD, ressaltats en un quadre vermell.

També només hi ha 4 cables connectats des d’Arduino i el mòdul RTC comparteix les mateixes línies.

Ja heu adquirit coneixements bàsics sobre I2C i sobre com utilitzar el mòdul adaptador LCD I2C.
T'agrada aquesta publicació? Té vostè alguna pregunta? Si us plau, expressa a la secció de comentaris, és possible que obtinguis una resposta ràpida