Anschluss von LCD-Displays über den IIC-Bus

Der Pragmatische Architekt  –  2 Kommentare

In der vergangenen Folge standen Temperatursensoren im Mittelpunkt. In der vorliegenden Folge wollen wir die Schaltung erweitern, um die Messwerte an einem LCD-Display auszugeben.

Wir hatten in der letzten Folge Schaltungen für Temperaturmessungen mit einem TMP36-Temperatursensor beziehungsweise alternativ mit dem Sensortyp DS18B20 erstellt. Die Messwerte sendete der Arduino dabei über den seriellen Monitor an den Hostrechner. Zum Einsatz kam folgende Schaltung:

Beispiel: Temperaturmessung über 1-Wire mit dem DS18B20 Temperatursensor

Das ist ganz nett. Es wäre aber noch beeindruckender, könnten wir ein LCD-Display zur Ausgabe nutzen.

Für den Arduino gibt es eine ganze Reihe preisgünstiger LCD-Displays, deren Preis bei nur wenigen Euros liegt, speziell bei den 16x2- und 20x4-Varianten. Allerdings erfordert ihr Anschluss eine ganze Reihe digitaler Eingänge.

Anschluss eines 16x2-LCD-Displays an das Arduino-Board

Programmieren der LCD-Ausgabe durch den Arduino ist kein Problem, da die IDE bereits eine eigene Bibliothek dafür mitbringt. Das Potentiometer in der obigen Schaltung dient zum Einstellen der Display-Helligkeit.

Anmerkung: Ein Potentiometer (Poti) ist ein variabler Widerstand dessen Widerstandswert sich durch Drehen des Knopfes einstellen lässt,

Hier ein exemplarischer Sketch zur Nutzung eines 16x2LCD-Displays:

#include <LiquidCrystal.h> // Benötigte Bibliothek für LCDs

// Angabe der angeschlossenen Arduino-Pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
// Das Display ist ein 16 x 2 Display
lcd.begin(16, 2);
// Nachricht am Display ausgeben
lcd.print("Hallo, iX!");
}

void loop() {
// Cursor auf zweite Zeile, 0. Spalte bewegen
lcd.setCursor(0, 1);
// Ausgabe der vergangenen Sekunden seit dem letzten Reset
lcd.print(millis()/1000);
}

Nachteil der Schaltung ist ihr nicht gerade sparsamer Umgang mit Arduino-Anschlüssen. Wir benötigen allein sechs Daten-Anschlüsse, um das Display zu steuern. Gibt es Abhilfe? Ja, die Rettung heißt IIC bzw. I2C (I squared C). Es handelt sich um ein Bussystem und damit um einen weiteren wichtigen Baustein für Arduino/Raspberry/BeagleBone-basierte IoT-Systeme.

I2C Bus

Das besagte Bus-System stammt von Philips' ehemaliger Halbleitersparte, die heute unter dem Namen NXP firmiert. Im Jahre 1982 hat das Unternehmen den IIC-Bus (Inter-Integrated Circuit) entwickelt, um die verschiedenen ICs in Schaltungen besser miteinander verbinden zu können. Manchmal findet sich auch die Abkürzung TWI (Two-Wire-Interface) statt I2C.

I2C unterstützt bis zu 5 MByte/Sekunde und funktioniert nach dem Master/Slave-Prinzip. Der Master und die Slaves sind über vier Leitungen miteinander verbunden: Versorgungsspannung, Erde, Takt (SCL) und Daten (SDA).

IIC-Bus verbindet Master und Slaves über 4 Leitungen (Bild: wikipedia.org)

Den Bustakt gibt der Master vor. Für die Übertragung von Bytes definiert I2C Start- und Stop-Signale, ebenso wie ein Bestätigungssignal ACK bzw. NACK. Sobald der Master mit einem Slave kommunizieren möchte, sendet er ein Byte, dessen unteren 7 Bits die Adresse des gewünschten Slaves beinhalten und dessen höchstes Bit dem Slave mitteilt, ob er (der Master) Daten senden (=> Signal auf Low) oder empfangen will (=> Signal auf High). Ist dem Slave die Datenübertragung mit dem Master zu schnell, hält er während der Übertragung einzelner Bytes die Taktleitung SCL auf Low.

Es handelt sich bei I2C um Open-Drain-Eingänge. Daher braucht es entsprechende Pull-up-Widerstände bei Master und Slaves.

Informationen zu I2C finden Sie auf Wikipedia.

Zeitverhalten am I²C-Bus: Zwischen dem Start-Signal (S) und dem Stopp-Signal (P) werden die Datenbits B1 bis BN übertragen. (Bild: wikipedia.org)

Anschluss des LCD-Displays über I2C

Um ein LCD-Display vom Arduino über I2C steuern zu können, kommt ein 16x2-Display mit entsprechendem I2C-Adapter zum Einsatz. Haben Sie bereits ein Display ohne I2C, können Sie einen I2C-Adapter separat über ebay, AliExpress oder Amazon erwerben. Der Preis liegt bei wenigen Euro. Händler, die Displays verkaufen, bieten in der Regel solche Adapter an. Die notwendigen Lötarbeiten halten sich in Grenzen und sind auch für Ungeübte machbar. Es darf natürlich auch ein bisschen mehr sein, etwa in Form eines 20x4-LCD.

Für den Anschluss I2C-fähiger Komponenten, benötigen wir die analogen Arduino-Pins A4 und A5 zur Datenübertragung sowie eine Verbindung der I2C Komponente mit GND und 5V-Ausgang des Arduino. Bei anderen Arduino-Boards können die Ports für SCL und SDA auch woanders liegen.

Temperaturausgabe auf LCD-Display

Die folgende Schaltung soll den Gesamtaufbau inklusive Temperatursensor illustrieren. Ich verwende als Basis die bekannte Schaltung mit Temperatursensor DS18B20 (siehe Bild oben). Sie können stattdessen aber auch die Schaltung aus der letzten Folge mit dem TMP36 (oder irgendeinem anderen Temperatursensor) verwenden. Die Schaltungen für Temperaturmessung und Display-Anzeige sind unabhängig voneinander ausgelegt. Den I2C-Adapter auf dem Display habe ich nicht eingezeichnet. Beachten Sie daher bitte die Bildunterschrift für genauere Angaben zu den konkreten Verbindungen.

Schaltung mit I2C-Anschluss des LCD Display (rote Leitung unten = 5V, schwarze Leitung = GND, gelbe Leitung von A4 and SDA des I2C-Adapters, grüne Leitung von A5 an SCL des I2C-Adapters)

Der Code eines Sketches könnte wie nachfolgend aussehen. Die fett markierten Teile dienen zur Ansteuerung des LCD. Die anderen Teile gehören zum ursprünglichen Sketch für Temperaturerfassung. Bei Nutzung eines anderen Temperatursensors wie dem TMP36 müssten sie Ihren Code entsprechend anpassen.

Während die I2C-Bibliothek in der Arduino IDE bereits enthalten ist, brauchen wir zum Betreiben eines LCD-Displays über I2C eine weitere Bibliothek, die wir uns über diesen Link besorgen. Das Einbinden der ZIP-Datei erfolgt in der Arduino IDE wie immer über das Sketch-Menü.

#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
// IIC-Bibliothek
#include <LiquidCrystal_I2C.h>
// LCD-Bibliothek für IIC
#define ONE_WIRE_BUS 2 // Data wire => Digitaler Pin 2 des Arduino
LiquidCrystal_I2C lcd(0x27,16,2);
// IIC-ID LCD: 0x27, Größe: 16x2
OneWire oneWire(ONE_WIRE_BUS); // Initialisieren des 1-Wire Bus
DallasTemperature sensors(&oneWire); // Übergabe der 1-Wire Info

void setup(void) {
lcd.init();
// LCD initialisieren
lcd.backlight(); // Hintergrundlicht einschalten
sensors.begin();
}

void loop(void) {
// Nun starten die eigentlichen Abfragen
sensors.requestTemperatures();

lcd.setCursor(0,0); // Cursor auf Beginn der 1. Zeile
lcd.print
("Temperatur in C");
lcd.setCursor(0,1);
// Cursor auf Beginn der 2. Zeile
lcd.print(sensors.getTempCByIndex(0)); // Temperatur ausgeben
}
I2C-Geräte finden

Wenn Sie das obige Listing näher studieren, fällt Ihnen in der sechsten Codezeile sicher auf, dass im Ausdruck lcd(0x27,16,2) der Wert 0x27 als erster Parameter vorzufinden ist – 16 ist die Zahl der Zeichen pro Zeile, 2 die Anzahl der Zeilen. Bei 0x27 handelt es sich um den I2C-Identifikators des von mir verwendeten LCD-Display-Typs. Sollten Sie für ihr LCD-Display die entsprechende ID nicht kennen, können Sie sich mit folgendem Sketch behelfen:

#include <Wire.h> // I2C einbinden
int count = 0; // Zahl der gefundenen I2C-Geräte
void setup() {
Serial.begin (9600); // Ausgaben erfolgen über seriellen Monitor
Wire.begin(); // Kommunikation starten (Arduino als Master)
} // end setup
void loop(){
count = 0; // Zahl gefundener Geräte
for (int i = 0; i < 128; i++){ // alle möglichen IDs scannen
Wire.beginTransmission (i);// Kommunikation mit Gerät(ID=i) testen
if (Wire.endTransmission () == 0) { // Erfolg!
Serial.print (”Gerät gefunden, ID = "); // Erfolgsmeldung
Serial.print (" 0x");
Serial.println(i, HEX);
count++;
} // end if
delay (10); // Kleine Pause
} // end for
Serial.print ("Gefundene Geräte insgesamt: ");
Serial.println (count);
} // end loop

Viele I2C-Scanner-Beispiele im Internet lassen die obige Schleife von 0 bis 255 laufen. Beim Arduino ist das unnötig, da nur die untersten 7 Bit zur Identifikation genutzt werden. Eine Suche der Kennungen bis 127 genügt deshalb.

Zusammenfassung

In dieser Folge ging es hauptsächlich um das Kennenlernen des I2C-Bus und um das Anschließen von I2C-Geräten wie zum Beispiel LCD-Displays. In der Zukunft werden wir die bisher eher spartanische Wetterstation noch um weitere Sensoren erweitern. Entsprechende Blog-Posts sind in Vorbereitung.

Die nächste Ausgabe beschäftigt sich allerdings mit Ultraschall- und Infrarot-Sensoren. Abwechslung muss sein.