Inleiding tot I2C LCD-adaptermodule

In deze post gaan we een kijkje nemen op 'I2C' of 'IIC' of 'I square C' gebaseerde LCD-adaptermodule, die de draadverbindingen tussen Arduino en LCD-scherm zal verminderen tot slechts 2 draden, waardoor ook tonnen GPIO-pinnen worden bespaard voor andere sensoren / drives etc.

Voordat we het hebben over de I2C LCD-adaptermodule, is het belangrijk om te begrijpen wat de I2C-bus is en hoe deze werkt.

Maar hoe dan ook, u hoeft geen expert te zijn met het I2C-protocol om met deze genoemde LCD-adapter te werken.

Illustratie van I2C-verbinding:

De I2C of IIC staat voor 'Inter-Integrated Circuit' is een seriële computerbus uitgevonden door Philips halfgeleiders, tegenwoordig bekend als NXP halfgeleiders. Dit bussysteem is uitgevonden in 1982.

Wat is de bus?

Bus is een groep kabels / draden die gegevens van de ene chip naar de andere chip / een printplaat naar een andere printplaat transporteren.

Het belangrijkste voordeel van het I2C-busprotocol is dat de ondersteunde microcontroller of sensoren of chips met slechts twee draden met elkaar kunnen worden verbonden. Het verbluffende voordeel van dit protocol is dat we 127 verschillende chips of sensoren / stuurprogramma's kunnen verbinden met één masterapparaat, meestal een microcontroller met slechts twee draden.

Wat zijn de twee I2C-draden?

De twee draden zijn SDA en SCL, die respectievelijk seriële gegevens en seriële klok zijn.

De seriële klok of SCL wordt gebruikt om de datacommunicatie via de I2C-bus te synchroniseren. De SDA of seriële gegevens is de datalijn waarin de feitelijke gegevens worden overgedragen van master naar slave en vice versa. Het master-apparaat bestuurt de seriële klok en beslist voor welk slave-apparaat het moet communiceren. Geen enkel slave-apparaat kan eerst een communicatie initiëren, alleen een master-apparaat kan dit doen.

De seriële datalijn is bidirectioneel en robuust, nadat elke set van 8 bit data is verzonden, stuurt het ontvangende apparaat een bevestigingsbit terug.

Hoe snel I2C-protocol is?

De originele versie van het I2C-protocol, ontwikkeld in 1982, ondersteunde 100 Kbps. De volgende versie werd gestandaardiseerd in 1992 en ondersteunde 400 Kbps (snelle modus) en ondersteunde maximaal 1008 apparaten. De volgende versie werd in 1998 ontwikkeld met 3,4 Mbps (High Speed-modus).

Verschillende andere I2C-versies zijn ontwikkeld in de jaren 2000, 2007, 2012 (met 5 Mbps Ultra-Fast-modus) en de recente versie van I2C is ontwikkeld in 2014.

Waarom pull-up weerstanden in de I2C-bus?

De SDA en SCL zijn 'open-drain', wat betekent dat beide lijnen LAAG kunnen worden, maar dat ze de lijnen niet HOOG kunnen aansturen, dus een pull-up-weerstand is op elk van de lijnen aangesloten.

Maar bij de meeste I2C-modules, zoals LCD of RTC, zijn pull-up-weerstanden ingebouwd, dus we hoeven er geen aan te sluiten, tenzij dit is gespecificeerd.

Pull-up / Pull-down-weerstand: Pull-up-weerstand is een weerstand die is aangesloten op de + Ve-lijn van de voeding om het logische niveau van een lijn op HOOG te houden als de lijn niet hoog of laag is.

Een pull-down-weerstand is een weerstand die is aangesloten op de –Ve lijn van de voeding om het logische niveau van een lijn op LAAG te houden als de lijn niet hoog of laag is.

Dit voorkomt ook dat er ruis in de lijnen komt.

We hopen dat we het oppervlak van het I2C-protocol hebben bekrast, als je meer informatie nodig hebt over het I2C-protocol, surf dan verder

YouTube en Google.

Laten we nu eens kijken naar de I2C LCD-module:

Er zijn 16 uitgangspennen voor het LCD-scherm die rechtstreeks op de achterkant van de 16 x 2 LCD-module kunnen worden gesoldeerd.

De invoerpinnen zijn + 5V, GND, SDA en SCL. De SDA- en SCL-pinnen op Arduino Uno zijn respectievelijk pinnen A4 en A5. Voor Arduino is mega SDA pin # 20 en SCL is pin # 21.

Laten we eens kijken hoe het eruit ziet als we het LCD-scherm op Arduino aansluiten zonder de I2C-adapter en met de adapter.

Zonder I2C-adapter:

Met I2C-adapter:

De adapter is aan de achterkant van het LCD-scherm gesoldeerd en zoals we kunnen zien, hebben we heel veel GPIO-pinnen bewaard voor andere taken en kunnen we doorgaan met het toevoegen van 126 extra I2C-apparaten aan pinnen A4 en A5.

Houd er rekening mee dat de standaard Liquid Crystal-bibliotheek niet werkt met deze I2C LCD-adapter, hiervoor is een speciale bibliotheek die binnenkort wordt behandeld en we zullen u laten zien hoe u deze module kunt gebruiken met een coderingsvoorbeeld.

Hoe de I2C-adapter op een 16 x 2 beeldscherm aan te sluiten

In de bovenstaande secties van het artikel hebben we de basisprincipes van het I2C-protocol geleerd en een basisoverzicht gegeven over de I2C LCD-adaptermodule. In dit bericht gaan we leren hoe we de I2C LCD-adaptermodule kunnen aansluiten op een 16 x 2 LCD-scherm en we zullen zien hoe we dit programmeren met een voorbeeld.

Het grote voordeel van het I2C-protocol is dat we de ondersteunde sensoren / invoer- / uitvoerapparaten in slechts twee lijnen kunnen aansluiten en het is handig met Arduino omdat het beperkte GPIO-pinnen heeft.

Laten we nu eens kijken hoe we de module op het LCD-scherm kunnen aansluiten.

De module heeft 16 outputpinnen en 4 inputpinnen. We kunnen de adapter gewoon aan de achterkant van het 16 x 2 LCD-scherm solderen. Van de 4 invoerpinnen zijn de twee + 5V en GND, de rest van de twee zijn SDA en SCL.

We kunnen zien dat we bij Arduino veel pinnen hebben bewaard voor andere input / output-taken.

We kunnen het contrast van het display aanpassen door de potentiometer aan te passen met een kleine schroevendraaier (gemarkeerd in rood vak).

De achtergrondverlichting kan nu worden bediend in de programmacode zelf:

lcd.backlight ()

Hierdoor wordt de achtergrondverlichting op het LCD-scherm ingeschakeld.

lcd.noBacklight ()

Hierdoor wordt de achtergrondverlichting op het LCD-scherm uitgeschakeld.

We kunnen zien dat er een jumper is aangesloten, die is gemarkeerd in een rood vak, als de jumper wordt verwijderd, blijft de achtergrondverlichting UIT, ongeacht het programmacommando.

Nu de hardware-installatie is voltooid, laten we nu kijken hoe we coderen. Onthoud dat de I2C LCD-module speciaal nodig heeft

bibliotheek en de vooraf geïnstalleerde 'liquidcrystal' -bibliotheek werken niet.

U kunt de I2C LCD-bibliotheek van hier downloaden en toevoegen aan Arduino IDE:

github.com/marcoschwartz/LiquidCrystal_I2C

Uit het vorige bericht hebben we geleerd dat I2C-apparaten een adres hebben waarmee de master of de microcontroller het apparaat kan identificeren en communiceren.

In de meeste gevallen zou het adres voor de I2C LCD-module '0x27' zijn. Maar verschillende fabricage kan een ander adres hebben. We moeten het juiste adres in het programma invoeren, alleen dan werkt uw LCD-scherm.

Om het adres te vinden, verbindt u 5V met Vcc en GND met GND van Arduino en SCL-pin van I2C-module met A5 en SDA met A4 en uploadt u de onderstaande code.

Hiermee worden de aangesloten I2C-apparaten gescand en hun adres weergegeven.

​

Upload de code en open de seriële monitor.

Zoals we kunnen zien, zijn er twee apparaten gedetecteerd en worden hun adressen weergegeven, maar als u alleen het adres van de I2C LCD-module wilt vinden, moet u tijdens het scannen geen andere I2C-apparaten aansluiten.
Dus tot slot kregen we het adres '0x27'.

Nu gaan we als voorbeeld een digitaal horloge maken omdat er twee I2C devices zijn, de LCD module en RTC of real time klok module. De beide modules worden met twee draden verbonden.

Download de volgende bibliotheek:
RTC-bibliotheek: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

Hoe u de tijd instelt op RTC

• Open Arduino IDE en ga naar Bestand> Voorbeeld> DS1307RTC> tijd instellen.
• Upload de code met voltooide hardware en open seriële monitor en je bent klaar.

Schakelschema:

Programma:

​

Notitie:

LiquidCrystal_I2C lcd (0x27, 16, 2)

De '0x27' is het adres dat we hebben gevonden door te scannen en 16 en 2 zijn het aantal rijen en kolommen op het LCD-scherm.

Voor RTC hoeven we het adres niet te vinden, maar we hebben het gevonden tijdens het scannen van '0x68', maar de RTC-bibliotheek zal het in ieder geval afhandelen.

Laten we nu eens kijken hoeveel we de draadcongestie hebben verminderd en GPIO-pinnen op Arduino hebben opgeslagen.

Er zijn slechts 4 draden aangesloten op het LCD-scherm, gemarkeerd in een rood vak.

Er zijn ook slechts 4 draden aangesloten vanaf Arduino en de RTC-module deelt dezelfde lijnen.

U heeft inmiddels basiskennis opgedaan over I2C en het gebruik van de I2C LCD adapter module.
Vind je dit bericht leuk? Heb je nog vragen? Geef alsjeblieft aan in het commentaargedeelte, je kunt snel een antwoord krijgen.