Introduktion till I2C LCD-adaptermodul

I det här inlägget ska vi ta en titt på 'I2C' eller 'IIC' eller 'I square C' -baserad LCD-adaptermodul, vilket minskar trådanslutningarna mellan Arduino och LCD-skärm till bara två ledningar, vilket också sparar massor av GPIO-stift för andra sensorer / enheter etc.

Innan vi diskuterar om I2C LCD-adaptermodul är det viktigt att förstå vad I2C-buss är och hur den fungerar.

Men hur som helst behöver du inte vara expert med I2C-protokoll för att arbeta med detta nämna LCD-adapter.

Illustration av I2C-anslutning:

I2C eller IIC står för 'Inter-Integrated Circuit' är en seriell datorbuss som uppfanns av Philips halvledare, idag känd som NXP-halvledare. Detta bussystem uppfanns 1982.

Vad är buss?

Buss är en grupp kablar / ledningar som transporterar data från ett chip till ett annat chip / ett kretskort till ett annat kretskort.

Den största fördelen med I2C-bussprotokollet är att den stödda mikrokontrollern eller sensorerna eller chipsen kan sammanlänkas med bara två ledningar. Fördelarna med detta protokoll är att vi kan koppla ihop 127 olika chips eller sensorer / drivrutiner till en huvudenhet som vanligtvis är en mikrokontroller med bara två ledningar.

Vad är de två I2C-kablarna?

De två ledningarna är SDA och SCL som är Serial Data respektive Serial Clock.

Serieklockan eller SCL används för att synkronisera datakommunikationen över I2C-bussen. SDA eller Serial Data är datalinjen där den faktiska informationen överförs från master till slav och vice versa. Huvudenheten styr serieklockan och bestämmer för vilken slavenhet den behöver kommunicera. Ingen slavenhet kan initiera en kommunikation först, bara masterenheten kan göra.

Den seriella datalinjen är dubbelriktad och robust, efter att varje uppsättning 8-bitars data har skickats skickar den mottagande enheten tillbaka en bekräftelsebit.

Hur snabbt är I2C-protokollet?

Den ursprungliga versionen av I2C-protokollet som utvecklades 1982 stödde 100 Kbps. Nästa version standardiserades 1992 som stödde 400 Kbps (snabbläge) och stödde upp till 1008 enheter. Nästa version utvecklades 1998 med 3,4 Mbps (höghastighetsläge).

Flera andra I2C-versioner utvecklades under åren 2000, 2007, 2012 (med 5Mbps Ultra-Fast-läge) och den senaste versionen av I2C utvecklades 2014.

Varför dra upp motstånd i I2C-buss?

SDA och SCL är 'open-drain' vilket betyder att båda linjerna kan gå LÅG men det kan inte driva ledningarna HÖGt, så ett uppdragningsmotstånd är anslutet på var och en av ledningarna.

Men med de flesta av I2C-modulerna som LCD eller RTC har inbyggda pull-up-motstånd, så vi behöver inte ansluta en om det inte anges.

Pull-up / Pull-down resistor: Pull-up resistor är ett motstånd anslutet till + Ve-linjen i matningen för att hålla logiknivån för en linje till HÖG om linjen varken är hög eller låg.

Ett neddragningsmotstånd är ett motstånd som är anslutet till –Ve-linjen i matningen för att hålla logiknivån för en linje LÅG om linjen varken är hög eller låg.

Detta förhindrar också att buller kommer in i ledningarna.

Vi hoppas att vi har repat ytan på I2C-protokollet. Om du behöver mer information om I2C-protokollet kan du surfa vidare

YouTube och Google.

Låt oss nu titta på I2C LCD-modulen:

Det finns 16 utgångsstift för LCD-display som kan lödas direkt på baksidan av 16 X 2 LCD-modulen.

Ingångarna är + 5V, GND, SDA och SCL. SDA- och SCL-stiften på Arduino Uno är stift A4 respektive A5. För Arduino är mega SDA stift nr 20 och SCL är stift nr 21.

Låt oss jämföra hur det ser ut när vi kopplar upp LCD-skärmen till Arduino utan I2C-adaptern och med adaptern.

Utan I2C-adapter:

Med I2C-adapter:

Adaptern är lödad på baksidan av LCD-skärmen och eftersom vi kan se att vi sparade massor av GPIO-stift för andra uppgifter och också kan vi fortsätta lägga till 126 fler I2C-enheter till stift A4 och A5.

Observera att det vanliga Liquid Crystal-biblioteket inte fungerar med denna I2C LCD-adapter, det finns ett speciellt bibliotek för detta, som snart kommer att täckas och vi visar hur du använder den här modulen med kodningsexempel.

Hur man ansluter I2C-adapter till 16 x 2-skärm

I ovanstående avsnitt av artikeln lärde vi oss grunderna i I2C-protokollet och tog en grundläggande översikt över I2C LCD-adaptermodul. I det här inlägget ska vi lära oss hur man ansluter I2C LCD-adaptermodulen till 16 x 2 LCD-skärm och vi kommer att se hur programmet med ett exempel.

Den största fördelen med I2C-protokollet är att vi kan ansluta de sensorer / in- / utmatningsenheter som stöds på bara två rader och det är till hjälp med Arduino eftersom det har begränsade GPIO-stift.

Låt oss nu se hur man ansluter modulen till LCD.

Modulen har 16 utgångar och 4 ingångar. Vi kan bara lödda adaptern på baksidan av 16 x 2 LCD-skärmen. Av de fyra ingångsstiften är de två + 5V och GND, resten av de två är SDA och SCL.

Vi kan se att vi sparade många stift på Arduino för andra in- / utmatningsuppgifter.

Vi kan justera skärmens kontrast genom att justera potentiometern med liten skruvmejsel (markerad i röd ruta).

Bakgrundsbelysningen kan nu styras i själva programkoden:

lcd.backlight ()

Detta tänder bakgrundsbelysningen på LCD-skärmen.

lcd.noBakljus ()

Detta stänger av bakgrundsbelysningen på LCD-skärmen.

Vi kan se att det finns en bygel ansluten, som är markerad i en röd ruta. Om bygeln tas bort förblir bakgrundsbelysningen AV oavsett programkommando.

Nu är hårdvarukonfigurationen klar, nu ska vi se hur man kodar. Kom ihåg att I2C LCD-modul behöver special

biblioteket och det förinstallerade biblioteket 'liquidcrystal' fungerar inte.

Du kan ladda ner I2C LCD-biblioteket härifrån och lägga till Arduino IDE:

github.com/marcoschwartz/LiquidCrystal_I2C

Från det föregående inlägget fick vi veta att I2C-enheter har en adress genom vilken mastern eller mikrokontrollern kan identifiera enheten och kommunicera.

I de flesta fall skulle adressen för I2C LCD-modulen vara '0x27'. Men olika tillverkningar kan ha olika adresser. Vi måste ange rätt adress i programmet först då kommer din LCD-display att fungera.

För att hitta adressen ansluter du bara 5V till Vcc och GND till GND på Arduino och SCL-stift på I2C-modulen till A5 och SDA till A4 och ladda upp nedanstående kod.

Detta skannar de anslutna I2C-enheterna och visar deras adress.

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

Ladda upp koden och öppna den seriella bildskärmen.

Som vi kan se upptäcktes två enheter och deras adresser visas, men om du bara vill hitta adressen till I2C LCD-modulen bör du inte ansluta några andra I2C-enheter under skanningen.
Så avslutningsvis fick vi adressen “0x27”.

Nu ska vi göra en digital klocka som exempel eftersom det finns två I2C-enheter, LCD-modulen och RTC eller realtidsklockmodulen. Båda modulerna kommer att anslutas med två ledningar.

Ladda ner följande bibliotek:
RTC-bibliotek: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

Hur man ställer in tiden till RTC

• Öppna Arduino IDE och navigera till Arkiv> Exempel> DS1307RTC> ställ in tid.
• Ladda upp koden med färdig maskinvara och öppna seriell bildskärm så är du klar.

Kretsschema:

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

Notera:

LiquidCrystal_I2C lcd (0x27, 16, 2)

“0x27” är adressen som vi hittade genom att skanna och 16 och 2 är antalet rader och kolumner på LCD-skärmen.

För RTC behöver vi inte hitta adressen men vi hittade när vi skannade '0x68', men hur som helst kommer RTC-biblioteket att hantera den.

Låt oss nu se hur mycket vi minskade trängseln och sparade GPIO-stift på Arduino.

Endast fyra ledningar är anslutna till LCD-skärmen, markerade i röd ruta.

Dessutom är endast fyra ledningar anslutna från Arduino och RTC-modulen delar samma linjer.

Nu har du fått grundläggande kunskaper om I2C och hur du använder I2C LCD-adaptermodulen.
Gillar du det här inlägget? Har du några frågor? Vänligen uttryck i kommentarsektionen, du kan få ett snabbt svar.