Ansteuerung des LCD-Displays (16x2 oder 20x4)

Hier wird die Verwendung des LCD 16x2 bzw. 20x4 mit I²C Anschluss getestet und verschiedene Funktionen der LiquidCrystal_I2C Bibliothek getestet. Außerdem wird am Beispiel der LiquidCrystal_I2C Bibliothek erklärt, wie man Arduino-Erweiterungsbibliotheken installiert.

Installation der Bibliothek

Variante 1 : mit der Bibliotheksverwaltung der Arduino IDE

• in der Arduino IDE die Bibliotheksverwaltung öffnen (Werkzeuge -> Bibliotheken verwalten…)
• in der Filterzeile “LiquidCrystal” eingeben
• die Bibliothek “LiquidCrystal_I2C von Frank de Brabander” auswählen und installieren (aktuelle Version 2.0.0)

Variante 2 : aktuelle Version von github herunterladen und manuell installieren

Bibliotheken werden unterhalb des Arbeitsverzeichnis der Arduino-IDE abgelegt, welches standardmäßig ~/Arduino ist. Das Arbeitsverzeichnis kann man in den Einstellungen ändern. Die Bibliotheken liegen standardmäßig unterhalb von ~/Arduino/libraries.

Um eigene Bibliotheken zu installieren, gibt es verschiedene Möglichkeiten.

Github-Repo downloaden und als ZIP-Archiv installieren

• GitHub-Repository-Seite öffnen, für die LiquidCrystal Bibliothek ist das https://github.com/johnrickman/LiquidCrystal_I2C
• Auf “Code” klicken und als zip-Datei herunterladen
• in der Arduino-IDE auf Sketch->Bibliothek einbinden->.ZIP-Bibliothek hinzufügen…
• dann das Quelltextarchiv auswählen und fertig

Manuelle Installation des Quelltextes

Man kann auch einfach selbst das Verzeichnis für die Bibliothek interhalb von ~/Arduino/libraries anlegen und dort seinen Quelltext platzieren. Einfach den heruntergeladenen Quelltext entpacken und dann kann man die Bibliothek verwenden.

Verdrahtung

Das LCD Display mit der I²C-Adapterplatine anzuschließen ist einfach:

siehe auch Erläuterungen dazu im Blog-Post Das I²C Protokoll und Auslesen von I²C Adressen angeschlossener Geräte. In diesem Post steht auch drin, wie man die I²C-Bus-Adresse des Displays ermittelt, falls man das nicht schon weiß.

Testprogramm

Bei mir ist das LCD-Display unter der Addresse 0x27 zu finden. Das kann man mit dem I²C-Blog gezeigten Adressen-Scan-Programm ermitteln.

Hier ist nun ein kleines dokumentiertes Testprogramm für das Display (ich verwende zunächst das 16x2 Display).

// Testprogramm für die Ansteuerung des 16x2 LCD Displays über I²C Protokoll
#include <LiquidCrystal_I2C.h>

// lcd Objekt erstellen und im Konstruktor mit I²C Adresse und 
// Anzahl Zeichen pro Zeile und Anzahl Zeilen initialisieren
LiquidCrystal_I2C lcd(0x27,16,2);  // beim 20x4 Display einfach 20,4 übergeben

void setup() {
  // LCD initialisieren
  lcd.init();                      
  // Hintergrundlicht einschalten
  lcd.backlight();
  // Cursor in Zeile 0 und Spalte 3 (nullbasierte Nummerierung) setzten
  lcd.setCursor(3,0);
  // Text ausgeben (Cursor wird weiterbewegt)
  lcd.print("Text oben...");
  // Cursor neu positionieren, diesmal in 2. Zeile
  lcd.setCursor(0,1);
  // und wieder Text ausgegen
  lcd.print("...und unten");
}

void loop() {
}

Wenn man das Programm bei einem frisch gekauften LCD-Display ausführt, sieht man zwar das Einschalten des Hintergrundlichts, aber keinen Text. Das liegt daran, dass man anfänglich noch den Kontrast einregeln muss. Dazu gibt es auf der Adapterplatine ein kleines Stellrad: Dieses dreht man mit einem kleinen Schraubendreher so lange, bis man einen guten Kontrast sieht.

Funktionen der LCD-I²C Bibliothek

Es gibt leider keine gute Dokumentation der Bibliothek, selbst im offiziellen Quelltextrepository gibt’s keine Erklärungen. Daher habe ich hier mal durch Ausprobieren und Anschauen des Quelltextes eine kleine Anleitung gebastelt.

Das Beispiel oben zeigt schon das wesentliche Konzept der Bibliothek. Es gibt einen Cursor, der in einer bestimmten Zelle des Displays steht. Wenn man nun mit lcd.print() Text schreibt, wird der Cursor nach jedem ausgegebenen Zeichen weiterbewegt.

Das LCD-Display wandelt Zeichen entsprechend einer hinterlegten ASCII-Tabelle in angezeigte Zeichenformen um. Das ist wichtig, wenn man Umlaute wie äöüß oder ê á è oder sonstwelche Zeichen anzeigen möchte. Bei Zeichen, welche nicht in der Standard-US-ASCII-Tabelle enthalten sind, muss man deren Erscheinungsbild manuell vorher definieren. Doch zunächst zur Basisfunktionalität der Bibliothek.

Basisfunktionen

Folgende Memberfunktionen der Klasse LiquidCrystal_I2C sind für die grundlegenden Funktionen notwendig:

• Hintergrundbeleuchtung ein: backlight()

• Hintergrundbeleuchtung aus: noBacklight()

• Bildschirm löschen (= ein Leerzeichen auf in alle Zellen schreiben): clear()
• Cursor positionieren: setCursor(int x, int y), bei einem 16x2 Display ist x=0…15, und y=0..1 zu verwenden
• Cursor nach 0,0 positionieren: home()
• Text schreiben: print(text)
• Bildschirm leeren: `noDisplay()
• Bildschirm wieder anzeigen (mit zuletzt angezeigtem Text): display()
• Cursor an der aktuellen Position als Box (wie im Überschreibenmodus) blinken lassen (ist sinnvoll, falls man Eingaben anzeigen will): blink()
• Cursorblinken wieder ausschalten: noBlink()
• Cursor dauerhaft als _ anzeigen: cursor()
• Cursor wieder ausblenden: noCursor()

Erweiterte Funktionen

Für die erweiterten Funktionen ist es wichtig zu wissen, dass das I²C-LCD-Konvertermodul intern einen Puffer hält, der größer als die Anzahl der anzeigbaren Zeichen ist. Bei einem 16x2 Display steht für jede Zeile ein 32-Zeichen langer Puffer bereit. Beim 20x4er Display reicht der Puffer jedoch nur für die anzeigbaren Zeichen. Deshalb sind die nachfolgend beschriebenen Scroll-Funktionen für das 20x4er Display nicht zu verwenden.

Man kann also in jede Zeile 32 Zeichen mit print() schreiben (wenn der Cursor anfänglich bei x=0 stand). Davon werden immer nur 16 Zeichen pro Zeile angezeigt. Man kann dies nutzen, um eine Laufschrift zu erzeugen, oder einfach zwischen vier 16-Zeichen langen Textschnippseln umzuschalten.

Wenn der Text länger als der interne Puffer ist, so wird einfach auf der nächsten Zeile weitergeschrieben. Man kann also mit einem 64-Zeichen langen Text, beginnend bei Cursorposition 0,0 den gesamte Displayspeicher befüllen.

Beim 20x4er Display sieht die Sache etwas anders aus. Wenn man beginnend auf Position 0,0 beginnt, einen Text länger als 20 Zeichen zu schreiben, so landet der überhängende Text in Zeile 3 (also wird ab Position 0,2 weiter geschrieben). Text der länger als 40 Zeichen ist wird dann in Zeile 2 (also ab Position 0,1) weiter geschrieben und danach in Zeile 4. Darauf hat man keinen Einfluss. Beim 20x4er Display sollte man bei der Programmierung also strikt darauf achten, immer im Berich x=0..3, y=0..19 zu bleiben.

Display scrollen

Testen wir mal das Scrollen:

// Testprogramm für die Ansteuerung des 16x2 LCD Displays über I²C Protokoll
#include <LiquidCrystal_I2C.h>

// lcd Objekt erstellen und im Konstruktor mit I²C Adresse und 
// Anzahl Zeichen pro Zeile und Anzahl Zeilen initialisieren
LiquidCrystal_I2C lcd(0x27,16,2);  // beim 20x4 Display einfach 20,4 übergeben

void setup() {

  // LCD initialisieren
  lcd.init();                      
  // Hintergrundlicht einschalten
  lcd.backlight();
  // Cursor in Zeile 0 und Spalte 3 (nullbasierte Nummerierung) setzten
  lcd.setCursor(0,0);
  // Text ausgeben (Cursor wird weiterbewegt)
  lcd.print("Ein 32-Zeichen langer Text......");
  // Cursor neu positionieren, diesmal in 2. Zeile
  lcd.setCursor(0,1);
  // und wieder Text ausgegen
  lcd.print("....und noch so ein langer Text.");
}


void loop() {
  // kurz warten
  delay(2000);
  // dann in einer Schleife 16-mal den Text nach links schieben
  for (int i=0; i<16; ++i) {
    lcd.scrollDisplayLeft();
    delay(500);
  }
  // wieder kurz warten, während wir die rechte Hälfte des Texts sehen
  delay(2000);
  // und wieder zurückscrollen
  for (int i=0; i<16; ++i) {
    lcd.scrollDisplayRight();
    delay(500);
  }
}

Bei den Scrolloperationen wird der Speicher nicht geändert.

Es gibt in der Header-Datei der Bibliothek noch die Funktionen printLeft() und printRight() die offensichtlich mal dazu gedacht waren, den linken oder rechten Teil des Puffers anzuzeigen. Verwenden kann man die nicht, da die Implementierung fehlt. Man kann aber trotzdem ein schnelles Umschalten zwischen rechter und linke Seite des internen Puffers realisieren, indem man einfach 16 mal hintereinander (in einer Schleife) scrollDisplayLeft() bzw. scrollDisplayRight() ohne delay() aufruft. Das sieht dann aus wie ein sofortiges Umschalten des Displays.

Textschreibrichtung ändern

Mit der Memberfunktion rightToLeft() kann man den Text von rechts nach links schreiben. Bei nachfolgenden print()-Aufrufen wird der Cursor entsprechend nach links bewegt. mit leftToRight() schaltet man wieder in die andere Schreibrichtung um.

  // Text rückwärts schreiben
  lcd.setCursor(15,0);
  lcd.rightToLeft();
  lcd.print("Text verkehrt...");

Display je nach Texteingabe scrollen

Normalerweise wandert der Cursor bei Ausgabe von Text mit und verschwindet nach Zeichen 15 auf dem nichtsichtbaren (aber noch im Puffer befindlichen) Bereich der Displayzeile. Man kann jedoch das Display auch so konfigurieren, dass der ausgegebene Text zunächst automatisch nach links gescrollt wird und so nicht sichtbar ist. Das macht man mit der Memberfunktion autoscroll(). Ausschalten kann man diese Funktion mit noAutoscroll().

Ein Beispiel:

// Testprogramm für die Ansteuerung des 16x2 LCD Displays über I²C Protokoll
#include <LiquidCrystal_I2C.h>

// lcd Objekt erstellen und im Konstruktor mit I²C Adresse und 
// Anzahl Zeichen pro Zeile und Anzahl Zeilen initialisieren
LiquidCrystal_I2C lcd(0x27,16,2);  // beim 20x4 Display einfach 20,4 übergeben

void setup() {
  // LCD initialisieren
  lcd.init();                      
  // Hintergrundlicht einschalten
  lcd.backlight();
  lcd.clear();
  // wir beginnen bei x=0 und schreiben einen 10 Zeichen langen Text im Modus "Autoscroll"
  lcd.setCursor(0,0);
  lcd.autoscroll();
  lcd.print("16 Zeichen Text!");
  // das Display ist nun an Position x=16 gescrollt und wir sehen einen leeren Bildschirm

  // autoscroll wieder ausschalten und Cursor an Position 20,0 setzen
  lcd.noAutoscroll();
  lcd.setCursor(20,0);
  lcd.print("ENDE");
  // wir sehen nun in der Mitte des Bildschirms das Wort "ENDE"
  delay(2000);
  // nun scrollen wir wieder zurück
  for (int i=0; i<16; ++i) {
    lcd.scrollDisplayRight();
    delay(500);
  }
}

void loop() {
}