Anschluss von LCD-Displays über den IIC-Bus

Inhaltsverzeichnis

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:

Mehr Infos

Was bisher geschah:

• Lauschen mit Sensoren
  
• JavaScript an Arduino: Es werde Licht
  
• Anschluss vieler LEDs an wenige Ausgänge
  
• Do-it-Yourself-Projekt: iXduino – Arduino on a Breadboard
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 3 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 2 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 1 von 3)

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.

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. I²C (I squared C). Es handelt sich um ein Bussystem und damit um einen weiteren wichtigen Baustein für Arduino/Raspberry/BeagleBone-basierte IoT-Systeme.

I²C 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 I²C.

I²C 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).

Den Bustakt gibt der Master vor. Für die Übertragung von Bytes definiert I²C 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 I²C um Open-Drain-Eingänge. Daher braucht es entsprechende Pull-up-Widerstände bei Master und Slaves.

Informationen zu I2C finden Sie auf Wikipedia.

Anschluss des LCD-Displays über I²C

Um ein LCD-Display vom Arduino über I²C steuern zu können, kommt ein 16x2-Display mit entsprechendem I²C-Adapter zum Einsatz. Haben Sie bereits ein Display ohne I²C, können Sie einen I²C-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 I²C-fähiger Komponenten, benötigen wir die analogen Arduino-Pins A4 und A5 zur Datenübertragung sowie eine Verbindung der I²C 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 I²C-Adapter auf dem Display habe ich nicht eingezeichnet. Beachten Sie daher bitte die Bildunterschrift für genauere Angaben zu den konkreten Verbindungen.

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 I²C-Bibliothek in der Arduino IDE bereits enthalten ist, brauchen wir zum Betreiben eines LCD-Displays über I²C 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 I²C-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 I²C-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 I²C-Bus und um das Anschließen von I²C-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. ()