Einführung in das I2C LCD Adapter Modul

Einführung in das I2C LCD Adapter Modul

In diesem Beitrag werfen wir einen Blick auf das LCD-Adaptermodul auf der Basis von „I2C“ oder „IIC“ oder „I Square C“, das die Kabelverbindungen zwischen Arduino und LCD-Display auf nur 2 Kabel reduziert und außerdem Tonnen von GPIO-Pins spart andere Sensoren / Antriebe usw.

Bevor wir uns mit dem I2C-LCD-Adaptermodul befassen, ist es wichtig zu verstehen, was der I2C-Bus ist und wie er funktioniert.



Sie müssen jedoch kein Experte für das I2C-Protokoll sein, um mit diesem erwähnten LCD-Adapter arbeiten zu können.



Abbildung der I2C-Verbindung:

Abbildung der I2C-Verbindung:

Das I2C oder IIC steht für 'Inter-Integrated Circuit', ein serieller Computerbus, der von Philips Halbleitern erfunden wurde und heute als NXP-Halbleiter bekannt ist. Dieses Bussystem wurde 1982 erfunden.

Was ist Bus?

Bus ist eine Gruppe von Kabeln / Drähten, die Daten von einem Chip zu einem anderen Chip / einer Leiterplatte zu einer anderen Leiterplatte übertragen.



Der Hauptvorteil des I2C-Busprotokolls besteht darin, dass der unterstützte Mikrocontroller oder die Sensoren oder Chips mit nur zwei Drähten miteinander verbunden werden können. Der überwältigende Vorteil dieses Protokolls besteht darin, dass wir 127 verschiedene Chips oder Sensoren / Treiber mit einem Master-Gerät verbinden können, bei dem es sich normalerweise um einen Mikrocontroller mit nur 2 Drähten handelt.

Was sind die beiden I2C-Drähte?

Die beiden Drähte sind SDA und SCL, die serielle Daten bzw. serielle Uhr sind.

Die serielle Uhr oder SCL wird verwendet, um die Datenkommunikation über den I2C-Bus zu synchronisieren. Die SDA- oder seriellen Daten sind die Datenleitungen, in denen die tatsächlichen Daten vom Master zum Slave und umgekehrt übertragen werden. Das Master-Gerät steuert die serielle Uhr und entscheidet, für welches Slave-Gerät es kommunizieren muss. Kein Slave-Gerät kann zuerst eine Kommunikation initiieren, nur das Master-Gerät.



Die serielle Datenleitung ist bidirektional und robust. Nachdem jeder Satz von 8-Bit-Daten gesendet wurde, sendet das empfangende Gerät ein Bestätigungsbit zurück.

Wie schnell ist das I2C-Protokoll?

Die ursprüngliche Version des 1982 entwickelten I2C-Protokolls unterstützte 100 Kbit / s. Die nächste Version wurde 1992 standardisiert und unterstützte 400 Kbit / s (Fast Mode) und bis zu 1008 Geräte. Die nächste Version wurde 1998 mit 3,4 Mbit / s (Hochgeschwindigkeitsmodus) entwickelt.

In den Jahren 2000, 2007 und 2012 wurden mehrere andere I2C-Versionen entwickelt (mit ultraschnellem 5-Mbit / s-Modus), und die aktuelle Version von I2C wurde 2014 entwickelt.

Warum Pull-up-Widerstände im I2C-Bus?

Der SDA und der SCL sind 'Open-Drain', was bedeutet, dass beide Leitungen auf LOW gehen können, aber die Leitungen nicht auf HIGH fahren können, sodass an jeder der Leitungen ein Pull-up-Widerstand angeschlossen ist.

Bei den meisten I2C-Modulen wie LCD oder RTC sind jedoch Pull-up-Widerstände eingebaut, sodass wir keinen anschließen müssen, es sei denn, dies ist angegeben.

Pull-up / Pull-down-Widerstand: Der Pull-up-Widerstand ist ein Widerstand, der an die + Ve-Leitung der Versorgung angeschlossen ist, um den Logikpegel einer Leitung auf HIGH zu halten, wenn die Leitung weder hoch noch niedrig ist.

Ein Pulldown-Widerstand ist ein Widerstand, der an die Leitung –Ve der Versorgung angeschlossen ist, um den Logikpegel einer Leitung auf LOW zu halten, wenn die Leitung weder hoch noch niedrig ist.

Dies verhindert auch das Eindringen von Rauschen in die Leitungen.

Wir hoffen, wir haben die Oberfläche des I2C-Protokolls zerkratzt. Wenn Sie weitere Informationen zum I2C-Protokoll benötigen, surfen Sie bitte weiter

YouTube und Google.

Schauen wir uns nun das I2C-LCD-Modul an:

Pinbelegung des I2C-LCD-Moduls

Es gibt 16 Ausgangspins für die LCD-Anzeige, die direkt auf die Rückseite des 16 x 2 LCD-Moduls gelötet werden können.

Die Eingangspins sind + 5V, GND, SDA und SCL. Die SDA- und SCL-Pins auf Arduino Uno sind die Pins A4 bzw. A5. Für Arduino ist Mega SDA Pin # 20 und SCL Pin # 21.

Vergleichen wir, wie es aussieht, wenn wir das LCD ohne I2C-Adapter und mit dem Adapter an Arduino anschließen.

Ohne I2C-Adapter:

Arduino ohne I2C-Adapter

Mit I2C-Adapter:

Arduino mit I2C-Adapter

Der Adapter ist auf der Rückseite des LCD-Displays verlötet. Wie wir sehen können, haben wir viele GPIO-Pins für andere Aufgaben gespeichert und können den Pins A4 und A5 weiterhin 126 weitere I2C-Geräte hinzufügen.

Bitte beachten Sie, dass die Standard-Flüssigkristallbibliothek mit diesem I2C-LCD-Adapter nicht funktioniert. Hierfür gibt es eine spezielle Bibliothek, die in Kürze behandelt wird. Wir zeigen Ihnen, wie Sie dieses Modul anhand eines Codierungsbeispiels verwenden.

So schließen Sie den I2C-Adapter an ein 16 x 2-Display an

In den obigen Abschnitten des Artikels haben wir die Grundlagen des I2C-Protokolls kennengelernt und einen grundlegenden Überblick über das I2C-LCD-Adaptermodul gegeben. In diesem Beitrag erfahren Sie anhand eines Beispiels, wie Sie das I2C-LCD-Adaptermodul an ein 16 x 2-LCD-Display anschließen.

Der Hauptvorteil des I2C-Protokolls besteht darin, dass wir die unterstützten Sensoren / Eingabe- / Ausgabegeräte in nur zwei Leitungen verkabeln können. Dies ist bei Arduino hilfreich, da es nur über begrenzte GPIO-Pins verfügt.

Nun wollen wir sehen, wie das Modul an das LCD angeschlossen wird.

Das Modul verfügt über 16 Ausgangspins und 4 Eingangspins. Wir können den Adapter einfach auf die Rückseite des 16 x 2 LCD-Displays löten. Von den 4 Eingangspins sind die beiden + 5V und GND, der Rest der beiden sind SDA und SCL.

Wir können sehen, dass wir bei Arduino viele Pins für andere Eingabe- / Ausgabeaufgaben gespeichert haben.

Wir können den Kontrast des Displays einstellen, indem wir das Potentiometer mit einem kleinen Schraubendreher einstellen (im roten Kästchen hervorgehoben).

Die Hintergrundbeleuchtung kann jetzt im Programmcode selbst gesteuert werden:

LCD-Rücklicht()

Dadurch wird die Hintergrundbeleuchtung des LCD-Displays eingeschaltet.

lcd.noBacklight ()

Dadurch wird die Hintergrundbeleuchtung des LCD-Displays ausgeschaltet.

Wir können sehen, dass ein Jumper angeschlossen ist, der in einem roten Kästchen hervorgehoben ist. Wenn der Jumper entfernt wird, bleibt die Hintergrundbeleuchtung unabhängig vom Programmbefehl AUS.

Nachdem das Hardware-Setup abgeschlossen ist, sehen wir uns an, wie Code erstellt wird. Bitte denken Sie daran, dass das I2C-LCD-Modul spezielle Anforderungen hat

Bibliothek und die vorinstallierte 'Liquidcrystal' -Bibliothek funktionieren nicht.

Sie können die I2C-LCD-Bibliothek hier herunterladen und zur Arduino IDE hinzufügen:

github.com/marcoschwartz/LiquidCrystal_I2C

Aus dem vorherigen Beitrag haben wir erfahren, dass I2C-Geräte eine Adresse haben, unter der der Master oder der Mikrocontroller das Gerät identifizieren und kommunizieren können.

In den meisten Fällen lautet die Adresse für das I2C-LCD-Modul „0x27“. Unterschiedliche Hersteller können jedoch unterschiedliche Adressen haben. Wir müssen nur dann die richtige Adresse in das Programm eingeben, dann funktioniert Ihr LCD-Display.

Um die Adresse zu finden, verbinden Sie einfach 5 V mit Vcc und GND mit GND von Arduino und SCL-Pin des I2C-Moduls mit A5 und SDA mit A4 und laden Sie den folgenden Code hoch.

Dadurch werden die angeschlossenen I2C-Geräte gescannt und ihre Adresse angezeigt.

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

Laden Sie den Code hoch und öffnen Sie den seriellen Monitor.

Wie wir sehen können, wurden zwei Geräte erkannt und ihre Adressen angezeigt. Wenn Sie jedoch nur die Adresse des I2C-LCD-Moduls suchen möchten, sollten Sie während des Scannens keine anderen I2C-Geräte anschließen.
Abschließend haben wir also die Adresse '0x27' bekommen.

Jetzt werden wir als Beispiel eine Digitaluhr herstellen, da es zwei I2C-Geräte gibt, das LCD-Modul und das RTC- oder Echtzeituhrmodul. Die beiden Module werden mit zwei Drähten verbunden.

Laden Sie die folgende Bibliothek herunter:
RTC-Bibliothek: github.com/PaulStoffregen/DS1307RTC
TimeLib.h: github.com/PaulStoffregen/Time

So stellen Sie die Zeit auf RTC ein

• Öffnen Sie die Arduino IDE und navigieren Sie zu Datei> Beispiel> DS1307RTC> Zeit einstellen.
• Laden Sie den Code mit der fertigen Hardware hoch und öffnen Sie den seriellen Monitor. Fertig.

Schaltplan:

Programm:

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

Hinweis:

LiquidCrystal_I2C lcd (0x27, 16, 2)

Die '0x27' ist die Adresse, die wir beim Scannen gefunden haben, und 16 und 2 sind die Anzahl der Zeilen und Spalten auf dem LCD-Display.

Für RTC müssen wir die Adresse nicht finden, aber wir haben sie beim Scannen von '0x68' gefunden, aber die RTC-Bibliothek wird sie trotzdem verarbeiten.

Nun wollen wir sehen, um wie viel wir die Kabelüberlastung reduziert und GPIO-Pins auf Arduino gespeichert haben.

Es sind nur 4 Drähte an das LCD-Display angeschlossen, das im roten Feld hervorgehoben ist.

Außerdem sind nur 4 Drähte von Arduino angeschlossen und das RTC-Modul teilt sich die gleichen Leitungen.

Inzwischen haben Sie Grundkenntnisse über I2C und die Verwendung des I2C-LCD-Adaptermoduls erworben.
Gefällt dir dieser Beitrag? Haben Sie irgendwelche Fragen? Bitte drücken Sie im Kommentarbereich aus, Sie erhalten möglicherweise eine schnelle Antwort.




Zurück: Einfache Transistor-Diodentester-Schaltung Weiter: Machen Sie diese IR-Fernbedienung Range Extender Circuit