Introducere în modulul adaptor I2C LCD

În acest post vom arunca o privire la modulul adaptor LCD bazat pe „I2C” sau „IIC” sau „I pătrat C”, care va reduce conexiunile de cabluri între Arduino și afișajul LCD la doar 2 fire, economisind, de asemenea, tone de pini GPIO pentru alți senzori / unități etc.

Înainte de a discuta despre modulul adaptor I2C LCD, este important să înțelegem ce este autobuzul I2C și cum funcționează.

Dar oricum nu trebuie să fii expert cu protocolul I2C pentru a lucra cu acest adaptor LCD de mențiune.

Ilustrarea conexiunii I2C:

I2C sau IIC înseamnă „Circuit inter-integrat” este o magistrală de computer serial inventată de semiconductorii Philips, astăzi cunoscuți ca semiconductori NXP. Acest sistem de autobuze a fost inventat în 1982.

Ce este autobuzul?

Autobuzul este un grup de cabluri / fire care transportă date de la un cip la alt cip / o placă de circuit la o altă placă de circuit.

Principalul avantaj al protocolului de magistrală I2C este că microcontrolerul sau senzorii sau cipurile acceptate pot fi interconectate cu doar două fire. Avantajul minunat al acestui protocol este că putem interconecta 127 de cipuri diferite sau senzori / drivere la un singur dispozitiv principal, de obicei un microcontroler cu doar 2 fire.

Care sunt cele două fire I2C?

Cele două fire sunt SDA și SCL, care sunt Serial Data și respectiv Serial clock.

Ceasul serial sau SCL este utilizat pentru a sincroniza comunicația de date prin magistrala I2C. SDA sau Serial Data este linia de date în care datele reale sunt transmise de la master la slave și invers. Dispozitivul principal controlează ceasul serial și decide ce dispozitiv sclav trebuie să comunice. Niciun dispozitiv sclav nu poate iniția o comunicare mai întâi, doar dispozitivul master poate face acest lucru.

Linia de date seriale este bidirecțională și robustă, după ce fiecare set de date de 8 biți este trimis, dispozitivul receptor trimite înapoi un bit de confirmare.

Cât de rapid este protocolul I2C?

Versiunea originală a protocolului I2C dezvoltată în 1982 a acceptat 100 Kbps. Următoarea versiune a fost standardizată în 1992, care suporta 400Kbps (modul Fast) și acceptă până la 1008 dispozitive. Următoarea versiune a fost dezvoltată în 1998 cu 3,4 Mbps (modul de mare viteză).

Mai multe alte versiuni I2C au fost dezvoltate în anii 2000, 2007, 2012 (cu modul Ultra-Fast de 5 Mbps), iar versiunea recentă a I2C a fost dezvoltată în 2014.

De ce rezistențe pull-up în autobuzul I2C?

SDA și SCL sunt „open-drain” ceea ce înseamnă că ambele linii pot scădea, dar nu pot conduce liniile HIGH, deci un rezistor de tragere este conectat pe fiecare dintre linii.

Dar, cu majoritatea modulelor I2C, cum ar fi LCD sau RTC, există rezistențe de tip pull up, deci nu este nevoie să le conectăm decât dacă este specificat.

Rezistență pull-up / pull-down: rezistența pull-up este un rezistor conectat la linia + Ve a sursei pentru a menține nivelul logic al unei linii la HIGH dacă linia nu este nici înaltă, nici scăzută.

Un rezistor pull-down este un rezistor conectat la linia –Ve a sursei pentru a menține nivelul logic al unei linii la LOW dacă linia nu este nici înaltă, nici scăzută.

Acest lucru previne, de asemenea, zgomotul care intră pe linii.

Sperăm că am zgâriat suprafața protocolului I2C, dacă aveți nevoie de mai multe informații despre protocolul I2C, vă rugăm să navigați pe

YouTube și Google.

Acum să aruncăm o privire la modulul LCD I2C:

Există 16 pini de ieșire pentru afișajul LCD care pot fi lipiți direct în partea din spate a modulului LCD 16 X 2.

Pinii de intrare sunt + 5V, GND, SDA și SCL. Pinii SDA și SCL de pe Arduino Uno sunt pinii A4 și respectiv A5. Pentru Arduino, mega SDA este pinul # 20, iar SCL este pinul # 21.

Să comparăm cum arată când conectăm ecranul LCD la Arduino fără adaptorul I2C și cu adaptorul.

Fără adaptor I2C:

Cu adaptor I2C:

Adaptorul este lipit pe partea din spate a ecranului LCD și, după cum putem vedea, am salvat o mulțime de pini GPIO pentru alte sarcini și, de asemenea, putem continua să adăugăm încă 126 de dispozitive I2C la pini A4 și A5.

Vă rugăm să rețineți că biblioteca standard cu cristale lichide nu va funcționa cu acest adaptor LCD I2C, există o bibliotecă specială pentru aceasta, care va fi acoperită în curând și vă vom arăta cum să utilizați acest modul cu un exemplu de codare.

Cum se conectează adaptorul I2C la afișajul 16 x 2

În secțiunile de mai sus ale articolului am aflat elementele de bază ale protocolului I2C și am făcut o prezentare generală de bază a modulului adaptor LCD I2C. În acest post vom învăța cum să conectăm modulul adaptor I2C LCD la un ecran LCD de 16 x 2 și vom vedea cum se programează cu un exemplu.

Avantajul major al protocolului I2C este că putem conecta senzorii / dispozitivele de intrare / ieșire acceptate în doar două linii și este util cu Arduino, deoarece are pini GPIO limitați.

Acum să vedem cum să conectăm modulul la ecranul LCD.

Modulul are 16 pini de ieșire și 4 pini de intrare. Putem doar lipi adaptorul pe partea din spate a ecranului LCD de 16 x 2. Din cei 4 pini de intrare, cei doi sunt + 5V și GND, restul celor doi sunt SDA și SCL.

Putem vedea că am salvat o mulțime de pini la Arduino pentru alte sarcini de intrare / ieșire.

Putem regla contrastul afișajului reglând potențiometrul cu șurubelniță mică (evidențiat în caseta roșie).

Iluminarea din spate acum poate fi controlată chiar în codul programului:

lcd.backlight ()

Aceasta va porni iluminarea de fundal de pe ecranul LCD.

lcd.noBacklight ()

Aceasta va opri iluminarea de fundal de pe ecranul LCD.

Putem vedea că este conectat un jumper, care este evidențiat în caseta roșie, dacă jumperul este îndepărtat, lumina de fundal rămâne OFF, indiferent de comanda programului.

Acum configurarea hardware este terminată, acum să vedem cum să codăm. Vă rugăm să rețineți că modulul LCD I2C are nevoie special

biblioteca și biblioteca „liquidcrystal” preinstalată nu vor funcționa.

Puteți descărca biblioteca LCD I2C de aici și adăuga la Arduino IDE:

github.com/marcoschwartz/LiquidCrystal_I2C

Din postarea anterioară am aflat că dispozitivele I2C au adresă prin care comandantul sau microcontrolerul pot identifica dispozitivul și comunica.

În majoritatea cazurilor, pentru modulul LCD I2C adresa ar fi „0x27”. Dar fabricarea diferită poate avea o adresă diferită. Trebuie să introducem adresa corectă în program numai atunci afișajul LCD va funcționa.

Pentru a găsi adresa, conectați doar 5V la Vcc și GND la GND de Arduino și pinul SCL al modulului I2C la A5 și SDA la A4 și încărcați codul de mai jos.

Aceasta va scana dispozitivele I2C conectate și va afișa adresa acestora.

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

Încărcați codul și deschideți monitorul serial.

După cum putem vedea, două dispozitive au fost detectate și adresele lor sunt afișate, dar dacă doriți să găsiți doar adresa modulului LCD I2C, nu ar trebui să conectați alte dispozitive I2C în timpul scanării.
Deci, în concluzie, am primit adresa „0x27”.

Acum vom face un ceas digital ca exemplu, deoarece există două dispozitive I2C, modulul LCD și RTC sau modulul de ceas în timp real. Ambele module vor fi conectate cu două fire.

Descărcați următoarea bibliotecă:
Biblioteca RTC: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

Cum să setați ora la RTC

• Deschideți Arduino IDE și navigați la Fișier> Exemplu> DS1307RTC> setați ora.
• Încărcați codul cu hardware completat și deschideți monitorul serial și ați terminat.

Diagrama circuitului:

Program:

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

Notă:

LiquidCrystal_I2C lcd (0x27, 16, 2)

„0x27” este adresa pe care am găsit-o prin scanare și 16 și 2 reprezintă numărul de rânduri și coloane de pe ecranul LCD.

Pentru RTC nu este nevoie să găsim adresa, dar am găsit-o în timp ce scanam „0x68”, dar oricum biblioteca RTC o va gestiona.

Acum să vedem cât de mult am redus congestia firelor și am salvat pinii GPIO pe Arduino.

Doar 4 fire sunt conectate la afișajul LCD, evidențiat în casetă roșie.

De asemenea, doar 4 fire sunt conectate de la Arduino, iar modulul RTC are aceleași linii.

Până acum ați câștigat cunoștințe de bază despre I2C și despre modul de utilizare a modulului adaptor LCD I2C.
Îți place această postare? Aveti vreo intrebare? Vă rugăm să exprimați în secțiunea de comentarii, este posibil să primiți un răspuns rapid.