Introduksjon til I2C LCD-adaptermodul

I dette innlegget skal vi ta en titt på “I2C” eller “IIC” eller “I square C” -basert LCD-adaptermodul, som vil redusere ledningstilkoblingene mellom Arduino og LCD-skjermen til bare to ledninger, og sparer også mange GPIO-pinner for andre sensorer / stasjoner etc.

Før vi diskuterer om I2C LCD-adaptermodul, er det viktig å forstå hva I2C-bussen er og hvordan den fungerer.

Men uansett trenger du ikke å være ekspert med I2C-protokoll for å jobbe med denne nevnte LCD-adapteren.

Illustrasjon av I2C-tilkobling:

I2C eller IIC står for 'Inter-Integrated Circuit' er en seriell datamaskinbuss oppfunnet av Philips halvledere, i dag kjent som NXP halvledere. Dette bussystemet ble oppfunnet i 1982.

Hva er buss?

Buss er en gruppe kabler / ledninger som fører data fra en brikke til en annen brikke / ett kretskort til et annet kretskort.

Den største fordelen med I2C-bussprotokollen er at den støttede mikrokontrolleren eller sensorer eller brikker kan kobles sammen med bare to ledninger. Hensynet til denne protokollen er at vi kan koble 127 forskjellige sjetonger eller sensorer / drivere til en hovedenhet, som vanligvis er en mikrokontroller med bare to ledninger.

Hva er de to I2C-ledningene?

De to ledningene er SDA og SCL, som er henholdsvis Serial Data og Serial Clock.

Serieklokken eller SCL brukes til å synkronisere datakommunikasjonen over I2C-bussen. SDA eller Serial Data er datalinjen der de faktiske dataene overføres fra master til slave og omvendt. Hovedenheten styrer serieklokken og bestemmer hvilken slaveenhet den trenger for å kommunisere. Ingen slaveenheter kan starte en kommunikasjon først, bare master-enheten kan gjøre det.

Seriedatalinjen er toveis og robust, etter at hvert sett med 8-biters data er sendt, sender mottakerenheten en bekreftelsesbit.

Hvor rask I2C-protokoll er?

Den opprinnelige versjonen av I2C-protokollen som ble utviklet i 1982, støttet 100 Kbps. Den neste versjonen ble standardisert i 1992, som støttet 400 kbps (hurtigmodus) og støttet opptil 1008 enheter. Den neste versjonen ble utviklet i 1998 med 3,4 Mbps (høyhastighetsmodus).

Flere andre I2C-versjoner ble utviklet i årene 2000, 2007, 2012 (med 5Mbps Ultra-Fast-modus), og den nyeste versjonen av I2C ble utviklet i 2014.

Hvorfor trekke motstander i I2C-buss?

SDA og SCL er 'open-drain', noe som betyr at begge linjene kan gå LAV, men det kan ikke drive linjene HØYT, så en mottaksmotstand er koblet til hver av linjene.

Men med de fleste av I2C-modulene som LCD eller RTC har det innebygd pull up-motstander, så vi trenger ikke å koble til en med mindre den er spesifisert.

Pull-up / Pull-down motstand: Pull-up motstand er en motstand koblet til + Ve-linjen i forsyningen for å holde logikknivået til en linje til HØY hvis linjen verken er høy eller lav.

En nedtrekksmotstand er en motstand som er koblet til –Ve-ledningen for å holde logikknivået til en linje til LAV hvis linjen verken er høy eller lav.

Dette forhindrer også støy som kommer inn i linjene.

Vi håper vi har skrapet overflaten av I2C-protokollen. Hvis du trenger mer informasjon om I2C-protokollen, kan du surfe videre

YouTube og Google.

La oss nå ta en titt på I2C LCD-modulen:

Det er 16 utgangspinner for LCD-skjerm som kan loddes direkte på baksiden av 16 X 2 LCD-modulen.

Inngangstappene er + 5V, GND, SDA og SCL. SDA- og SCL-pinnene på Arduino Uno er henholdsvis pinner A4 og A5. For Arduino er mega SDA pin nr. 20 og SCL er pin nr. 21.

La oss sammenligne hvordan det ser ut når vi kobler opp LCD-skjermen til Arduino uten I2C-adapteren og med adapteren.

Uten I2C-adapter:

Med I2C-adapter:

Adapteren er loddet på baksiden av LCD-skjermen, og da vi kan se at vi lagret massevis av GPIO-pinner til andre oppgaver, og vi kan også fortsette å legge til 126 flere I2C-enheter til pinnene A4 og A5.

Vær oppmerksom på at det vanlige Liquid Crystal-biblioteket ikke fungerer med denne I2C LCD-adapteren, det er et spesielt bibliotek for dette, som snart vil bli dekket, og vi viser deg hvordan du bruker denne modulen med kodeeksempel.

Hvordan koble I2C-adapter til 16 x 2-skjerm

I avsnittene ovenfor i artikkelen lærte vi det grunnleggende om I2C-protokollen og tok en grunnleggende oversikt over I2C LCD-adaptermodul. I dette innlegget skal vi lære hvordan du kobler I2C LCD-adaptermodulen til 16 x 2 LCD-skjerm, og vi vil se hvordan programmet med et eksempel.

Den største fordelen med I2C-protokollen er at vi kan koble de støttede sensorene / inngangs- / utdataenhetene på bare to linjer, og det er nyttig med Arduino, da den har begrensede GPIO-pinner.

La oss nå se hvordan du kobler modulen til LCD.

Modulen har 16 utgangspinner og 4 inngangspinner. Vi kan bare lodde adapteren på baksiden av 16 x 2 LCD-skjermen. Av de 4 inngangspinnene er de to + 5V og GND, resten av de to er SDA og SCL.

Vi kan se at vi lagret mange pinner på Arduino til andre input / output oppgaver.

Vi kan justere kontrasten på skjermen ved å justere potensiometeret med liten skrutrekker (uthevet i rød boks).

Bakgrunnsbelysningen kan nå styres i selve programkoden:

lcd.backlight ()

Dette vil slå PÅ bakgrunnsbelysningen på LCD-skjermen.

lcd.noBaklys ()

Dette vil slå AV bakgrunnsbelysningen på LCD-skjermen.

Vi kan se at det er en tilkoblet genser, som er uthevet i rød boks. Hvis genseren fjernes, forblir bakgrunnsbelysningen AV uansett programkommando.

Nå er maskinvareoppsettet ferdig. La oss nå se hvordan du koder. Husk at I2C LCD-modul trenger spesiell

biblioteket og det forhåndsinstallerte 'liquidcrystal' -biblioteket fungerer ikke.

Du kan laste ned I2C LCD-biblioteket herfra og legge til Arduino IDE:

github.com/marcoschwartz/LiquidCrystal_I2C

Fra forrige innlegg lærte vi at I2C-enheter har adresse som master eller mikrokontrolleren kan identifisere enheten og kommunisere med.

I de fleste tilfeller vil adressen til I2C LCD-modulen være '0x27'. Men forskjellig produksjon kan ha annen adresse. Vi må oppgi riktig adresse i programmet bare da vil LCD-skjermen fungere.

For å finne adressen er det bare å koble 5V til Vcc og GND til GND på Arduino og SCL-pinne på I2C-modulen til A5 og SDA til A4 og laste opp koden nedenfor.

Dette skanner de tilkoblede I2C-enhetene og viser adressen deres.

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

Last opp koden og åpne seriell skjerm.

Som vi kan se ble det oppdaget to enheter og adressene deres vises, men hvis du bare vil finne adressen til I2C LCD-modulen, bør du ikke koble til andre I2C-enheter mens du skanner.
Så til slutt fikk vi adressen “0x27”.

Nå skal vi lage en digital klokke som eksempel fordi det er to I2C-enheter, LCD-modulen og RTC eller klokkemodulen i sanntid. Begge modulene kobles til med to ledninger.

Last ned følgende bibliotek:
RTC-bibliotek: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

Hvordan sette tid til RTC

• Åpne Arduino IDE og naviger til Fil> Eksempel> DS1307RTC> angi tid.
• Last opp koden med ferdig maskinvare og åpen seriell skjerm, så er du ferdig.

Kretsskjema:

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

Merk:

LiquidCrystal_I2C lcd (0x27, 16, 2)

“0x27” er adressen vi fant ved å skanne, og 16 og 2 er antall rader og kolonner på LCD-skjermen.

For RTC trenger vi ikke finne adressen, men vi fant under skanning av '0x68', men uansett vil RTC-biblioteket håndtere den.

La oss nå se hvor mye vi reduserte ledningsbelastningen og lagret GPIO-pinner på Arduino.

Bare fire ledninger er koblet til LCD-skjermen, uthevet i rød boks.

Også bare 4 ledninger er koblet fra Arduino, og RTC-modulen deler de samme linjene.

Nå har du fått grunnleggende kunnskap om I2C og hvordan du bruker I2C LCD-adaptermodul.
Liker du dette innlegget? Har du noen spørsmål? Vennligst uttrykk i kommentarseksjonen, du kan få et raskt svar.