OLED vs. TFT-Displays

Viele Projekte, die in unseren Blogbeiträgen vorgestellt werden, geben ein optisches Feedback an den Benutzer. Sei es durch eine kleine LED oder ein kleines Display, welches uns den Status oder die aktuellen Informationen liefert. Die gängigsten Displays sind sogenannte OLED- oder TFT-Displays. Wo liegt der Unterschied der beiden Displays? Und wann sollen sie für Ihr Projekt lieber ein OLED-Display nutzen und wann ein TFT-Display?

Diese Fragen werden in diesem Blogbeitrag geklärt.

Das Sortiment von AZ-Delivery

Schaut man sich das Sortiment von AZ-Delivery an, stellt man schnell fest, dass es viele verschiedene Displaytypen und Displaygrößen gibt, siehe https://www.az-delivery.de/collections/displays.

Filtert man dann nach OLED oder TFT, wird die Auswahl zwar geringer, dennoch ist die Auswahl an Displays immer noch recht groß. Es gibt allerdings nur zwei verschiedene Arten, um die Displays anzusteuern. Zum einen I2C, was für Inter-Integrated Circuit steht, und SPI, was für Serial Peripheral Interface steht. Bei beiden handelt es sich um ein sogenanntes Bus-System. Grundprinzip bei beiden Bus-Systemen ist, dass Sie einen festen Master haben, meist einen Micro Controller, und die Displays als Slave eingebunden werden. Der Datenaustausch erfolgt durch zwei bis vier Leitungen, wobei je nach Bus-System auf die korrekte Verdrahtung geachtet werden muss. Näheres zu I2C
und SPI und der richtigen Verdrahtung können Sie bei Wikipedia nachlesen.

Die Technik hinter OLED und TFT

OLED ist die Abkürzung für organic light emitting diode, zu Deutsch organische Leuchtdiode.

TFT ist die Abkürzung für thin-film transistor, zu Deutsch Dünnschichttransistor.

Gerade hier liegt schon einmal der erste Unterschied.

OLED nutzt Materialien aus der organischen Chemie und TFT besteht aus einzeln ansteuerbaren Transistorschichten. Letzteres ist die Weiterentwicklung der LCD-Technik (Liquid Chrystal Display, Flüssigchistallanzeige). Es werden jeweils drei Dünnschicht-Transistoren verwendet, um einen Bildschirmpunkt zum Leuchten zu bringen. Auch für die Ansteuerung der OLEDs werden die Dünnschichttransistoren eingesetzt.

Gerade OLED hat immer noch den Ruf, dass diese lichtschwach, kurzlebig und unzuverlässig sein sollen. Das mag in der Vergangenheit gestimmt haben, aber im Vergleich zu vor 20 Jahren hat sich die Technik wahnsinnig verbessert. Damit bleibt dieses Vorurteil in der heutigen Zeit auf der Strecke.

Gerade weil OLED-Displays kein „backlight“, also Hintergrundbeleuchtung, brauchen, sind diese teilweise deutlich besser als ein TFT-Display. Im direkten Vergleich „verschluckt“ ein TFT knapp 90% des backlights.

Das heißt aber nicht, dass OLED nun heller ist als ein TFT, denn tatsächlich ist die Helligkeit von TFTs aufgrund der Hintergrundbeleuchtung deutlich besser als bei OLEDs. Jedoch hängt die Ablesbarkeit stark vom Kontrast ab, und da haben die OLEDs „die Nase vorn“.

Pro und Contra OLED / TFT

Wie im oberen beschrieben, ist die Technik hinter den beiden Displaytypen verschieden. Das bringt Vor- und auch Nachteile mit sich. Es gibt eben nicht DAS eine perfekte Display, sondern man muss den einen oder anderen Kompromiss eingehen. Tabelle 1 soll einmal einen ersten Eindruck der Unterschiede eines OLED- bzw. TFT-Displays darstellen.

	OLED	TFT
Bilddiagonale	Bis 1,3“*	Bis 2,8“**
Pixel	128 x 64	320 x 240
Spannungsversorgung	3,3V - 5V	3,3V und 5V***
Kommunikation	Meist I2C	SPI
Farbfähig	Nur eine feste Farbe	Farbe des anzuzeigenden Elements kann bestimmt werden
Anschlüsse	4 Pins	Mindestens 7 Pins
Zusätze	Keine	Touch und teilweise SD-Karten Slot
Hintergrundbeleuchtet	Nein	Ja

*)           Verfügbare Größe bei AZ-Delivery, Stand 02.2021

**)         Als Referenz dient das AZ-Touch Wandghäuse mit 2,8“ Touchscreen

***)       Das Display selbst nutzt nur 3,3V, Touch braucht eine separate Spannung

Tabelle 1: Vergleich OLED TFT

Weit wichtiger als die Pros und Contras ist natürlich, wie schnell sich diese Displays in ein Projekt einbinden lassen. In diesem Blog sollen daher zwei Faktoren betrachtet werden:

1. Wie groß ist der Verkabelungsaufwand?
2. Wie schnell kann ein Display in die Software eingebunden werden, um Text anzuzeigen?
3. (Nur für TFT) Wie hoch ist der Aufwand, um die Touch-Funktion zu benutzen?

Die Hard- und Software für diesen Blogbeitrag

Die Bauteile aus Tabelle 2 dienen für diesen Blog als Referenzhardware, decken aber nicht das komplette Angebot von AZ-Delivery ab. Viele Bauteile sind aber von Ansteuerung oder der verwendeten Bibliotheken identisch und verlangen nur eine minimale Anpassung in der Konfiguration.

Anzahl	Bauteil
1	Nano V3.0 with Atmega328 und CH340 oder Nano V3.0 with FT232RL und ATmega328
1	Mikrocontroller Board mit USB-Kabel, kompatibel mit Arduino Uno R3
1	2,4 TFT LCD Touch Display
1	0,96 Zoll OLED I2C Display 128 x 64 Pixel für Arduino und Raspberry Pi
1	0,91 Zoll OLED I2C Display 128 x 32 Pixel für Arduino und Raspberry Pi
1	ESP32 NodeMCU Module WLAN WiFi Development Board mit CP2102 (Nachfolgermodell zum ESP8266)
1	1,8 Zoll SPI TFT Display 128 x 160 Pixeln für Arduino und Raspberry Pi

Tabelle 2: Hardware für Test

Weitere Komplettpakete, wie das AZ-Touch Wandgehäuse, werden hier ebenfalls nicht betrachtet, auch wenn das verbaute TFT-Display theoretisch auch ohne die Platine von einem passenden Micro Controller betrieben werden kann.

Damit dieser Blog auch von Ihnen nachgebaut werden kann, benötigen Sie folgende Software und Bibliotheken:

• Arduino IDE (https://www.arduino.cc/en/Main/Software), hier am besten die aktuellste Version herunterladen
• Die Bibliothek Adafruit_SSD1306, bei Erstellung vom Beitrag in Version 2.4.1 verfügbar, mit allen Abhängigkeiten
• Die Bibliothek MCUFRIEND_kbv, bei Erstellung vom Beitrag in Version 2.9.9 verfügbar, mit allen Abhängigkeiten
• Die Bibliothek TFT_eSPI, bei Erstellung vom Beitrag in Version 2.3.59 verfügbar, mit allen Abhängigkeiten

Diese installieren Sie über die Bibliotheksverwaltung, siehe https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/arduino-ide-programmieren-fuer-einsteiger-teil-1 Abschnitt Bibliotheksverwaltung.

Das OLED-Display

Wie eingangs in diesem Blog erwähnt, ist das OLED-Display recht einfach.

Bei einem „Nano V3.0 mit Atmega328 CH340“ ist die Einbindung eines „0,96 Zoll OLED I2C Display 128 x 64 Pixel für Arduino und Raspberry Pi“ oder eines „0,91 Zoll OLED I2C Display 128 x 32 Pixel für Arduino und Raspberry Pi“ recht einfach, siehe Abbildung 1 und Abbildung 2.

Abbildung 1: Nano V3.0 mit großem i2c-Display

Abbildung 2: Nano V3.0 mit kleinem i2c-Display

Bei einem „ESP32 NodeMCU Module WLAN WiFi Development Board mit CP2102“ können beide I2C-Schnittstellen genutzt werden. Auch hier ist die Einbindung eines „0,96 Zoll OLED I2C Display 128 x 64 Pixel für Arduino und Raspberry Pi“ und eines „0,91 Zoll OLED I2C Display 128 x 32 Pixel für Arduino und Raspberry Pi“ recht einfach, siehe Abbildung 3.

Abbildung 3: ESP32 NodeMCU Module mit beiden i2c-Displays

Beachten Sie dabei, welche Spannung Ihre Displays benötigen; einige vertragen nur 3,3V, eine benötigen 5V und es gibt welche, die mit beiden Spannungen funktionieren, andernfalls werden Sie nichts auf dem Display sehen.

Damit die Displays auch etwas anzeigen, gibt es ein kurzes Demoprogramm, dass alle zwei Sekunden einen Zähler erhöht und entsprechend auf dem Display sichtbar macht. Code 1 für das kleine Display und Code 2 für das große Display behandelt die I2C-Displays separat. Beachten Sie bei der Initialisierung die korrekte Größe der Displays mit der Definition „#define SCREEN_WIDTH“ und „#define SCREEN_HEIGHT“. Damit geben Sie im späteren dem Objekt „display“ bei der Initialisierung „Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);“ die korrekte Pixelgröße mit.

// Nano V3.0 small i2c-display
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 09. Febuary 2021
// Update: 09. Febuary 2021
//-----------------------------------------------------
//Include needed libs
#include <Adafruit_SSD1306.h>
#include <Wire.h>

//Variables for display
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);

int iCnt;
/*
* =================================================================
* Function: setup
* Returns: void
* Description: Setup display and sensors
* =================================================================
*/
void setup() {
  Serial.begin(115200);
  iCnt = 0;
  Serial.print(F("Init display "));
  while(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C))
// Address 0x3C for OLED-Display
  {
    Serial.print(". ");
  }
  Serial.println(". DONE");
  // Clear the buffer
  display.clearDisplay();
  display.setTextSize(1); // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setCursor(0,0); // Start at top-left corner
  display.println("OLED-Display Demo");
  display.println("(c)Joern Weise");
  display.println("for AZ-Delivery");
  display.display();
  delay(5000);
}

/*
* =================================================================
* Function: loop
* Returns: void
* Description: Main loop to let program work
* =================================================================
*/
void loop() {

  display.setTextSize(1); // Normal 1:1 pixel scale
  display.clearDisplay(); //Delete old content
  display.setTextSize(1); // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setCursor(10,10); // Start at top-left corner
  display.print("Demo counter ");
  display.setTextSize(2); // Normal 2:1 pixel scale
//display.setCursor(64,32);
  display.println(iCnt);
  display.display(); //At last show new content
  iCnt++;
  if(iCnt >= 100)
    iCnt = 0;
  delay(2000); //Not the best solution, but effective for this demo
}

Code 1: OLED Beispielcode kleines i2c-Display mit Nano V30

// Nano V3.0 big i2c-display
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 09. Febuary 2021
// Update: 09. Febuary 2021
//-----------------------------------------------------
//Include needed libs
#include <Adafruit_SSD1306.h>
#include <Wire.h>

//Variables for display
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);

int iCnt;
/*
* =================================================================
* Function: setup
* Returns: void
* Description: Setup display and sensors
* =================================================================
*/
void setup() {
  Serial.begin(115200);
  iCnt = 0;
  Serial.print(F("Init display "));
  while(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C))
// Address 0x3C for OLED-Display
  {
    Serial.print(". ");
  }
  Serial.println(". DONE");
  // Clear the buffer
  display.clearDisplay();
  display.setTextSize(1); // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setCursor(0,0); // Start at top-left corner
  display.println("OLED-Display Demo");
  display.println("");
  display.println("(c)Joern Weise");
  display.println("");
  display.println("for AZ-Delivery");
  display.display();
  delay(5000);
}

/*
* =================================================================
* Function: loop
* Returns: void
* Description: Main loop to let program work
* =================================================================
*/
void loop() {

  display.setTextSize(1); // Normal 1:1 pixel scale
  display.clearDisplay(); //Clear old content
  display.setTextSize(1); // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setCursor(10,10); // Start at top-left corner
  display.print("Demo counter");
  display.setTextSize(2); // Normal 2:1 pixel scale
  display.setCursor(64,30);
  display.println(iCnt);
  display.display(); //Show new content
  iCnt++;
  if(iCnt >= 100)
    iCnt = 0;
  delay(2000); //Not the best solution, but effective for this demo
}

Code 2: OLED Beispielcode großem i2c-Display mit Nano V3.0

 

Da das ESP32 NodeMCU Module WLAN WiFi Development Board mit CP2102 beide eingesetzten i2c-Displays benutzt, kann der Code für beide Displays auf einen Quellcode reduziert werden, siehe Code 3.

// ESP32 with two i2c-displays
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 09. Febuary 2021
// Update: 09. Febuary 2021
//-----------------------------------------------------
//Include needed libs
#include <Adafruit_SSD1306.h>
#include <Wire.h>

//Define pins for both i2c
#define I2C_SDA1 17
#define I2C_SCL1 16
#define I2C_SDA2 21
#define I2C_SCL2 22

//Objects for I2C
TwoWire I2Cone = TwoWire(0);
TwoWire I2Ctwo = TwoWire(1);

//Variables for display
#define SCREEN_WIDTH_ONE 128 // OLED display width, in pixels
#define SCREEN_HEIGHT_ONE 64 // OLED display height, in pixels
#define SCREEN_WIDTH_TWO 128 // OLED display width, in pixels
#define SCREEN_HEIGHT_TWO 32 // OLED display height, in pixels
Adafruit_SSD1306 displayONE(SCREEN_WIDTH_ONE, SCREEN_HEIGHT_ONE, &I2Cone);
Adafruit_SSD1306 displayTWO(SCREEN_WIDTH_TWO, SCREEN_HEIGHT_TWO, &I2Ctwo);

int iCnt;

/*
* =================================================================
* Function: setup
* Returns: void
* Description: Setup display and sensors
* =================================================================
*/
void setup() {
  Serial.begin(115200);
  I2Cone.begin(I2C_SDA1, I2C_SCL1, 400000);
  I2Ctwo.begin(I2C_SDA2, I2C_SCL2, 400000);
  iCnt = 0;
  Serial.print(F("Init display one"));
  while(!displayONE.begin(SSD1306_SWITCHCAPVCC, 0x3C))
//   Address 0x3C for OLED-Display
  {
    Serial.print(". ");
  }
  Serial.println(". DONE");

  Serial.print(F("Init display two"));
  while(!displayTWO.begin(SSD1306_SWITCHCAPVCC, 0x3C))
// Address 0x3C for OLED-Display
  {
    Serial.print(". ");
  }
  Serial.println(". DONE");

  displayONE.clearDisplay(); // Clear the buffer
  displayONE.setTextSize(1); // Normal 1:1 pixel scale
  displayONE.setTextColor(SSD1306_WHITE); // Draw white text
  displayONE.setCursor(0,0); // Start at top-left corner
  displayONE.println("OLED-Display Demo");
  displayONE.println("");
  displayONE.println("(c)Joern Weise");
  displayONE.println("");
  displayONE.println("for AZ-Delivery");
  displayONE.display();

  displayTWO.clearDisplay(); // Clear the buffer
  displayTWO.setTextSize(1); // Normal 1:1 pixel scale
  displayTWO.setTextColor(SSD1306_WHITE); // Draw white text
  displayTWO.setCursor(0,0); // Start at top-left corner
  displayTWO.println("OLED-Display Demo");
  displayTWO.println("(c)Joern Weise");
  displayTWO.println("for AZ-Delivery");
  displayTWO.display();
  delay(5000);
}

/*
* =================================================================
* Function: loop
* Returns: void
* Description: Main loop to let program work
* =================================================================
*/
void loop() {
  displayONE.setTextSize(1); // Normal 1:1 pixel scale
  displayONE.clearDisplay();
  displayONE.setTextSize(1); // Normal 1:1 pixel scale
  displayONE.setTextColor(SSD1306_WHITE); // Draw white text
  displayONE.setCursor(10,10); // Start at top-left corner
  displayONE.print("Demo counter");
  displayONE.setTextSize(2); // Normal 2:1 pixel scale
  displayONE.setCursor(64,30);
  displayONE.println(iCnt);
  displayONE.display();

  displayTWO.setTextSize(1); // Normal 1:1 pixel scale
  displayTWO.clearDisplay();
  displayTWO.setTextSize(1); // Normal 1:1 pixel scale
  displayTWO.setTextColor(SSD1306_WHITE); // Draw white text
  displayTWO.setCursor(10,10); // Start at top-left corner
  displayTWO.print("Demo counter ");
  displayTWO.setTextSize(2); // Normal 2:1 pixel scale
  displayTWO.print(iCnt);
  displayTWO.display();

  iCnt++;
  if(iCnt >= 100)
    iCnt = 0;
  delay(2000); //Not the best solution, but effective for this demo
}

Code 3: ESP32 NodeMCU Module mit beiden i2c-Displays

Beachten Sie dabei, dass am Anfang vom Code zwei I2C-Verbindungen „I2Cone“ und „I2Ctwo“ erzeugt werden, welche dann später bei der Initialisierung der Displays verwendet werden. Somit können die Displays getrennt angesprochen werden. Bei allen Micro Controllern, siehe Abbildung 4, zeigen die Displays den Willkommenstext und den Democounter an.

Abbildung 4: Nano V3.0 und ESP32 NodeMCU Module mit i2c-Displays

Schaltet man das Licht aus, sieht man auch keinerlei Backlight, sondern eine gestochen scharfe Anzeige.

Das TFT-Display

Als nächstes sollen die TFT-Displays genauer betrachtet werden. Den Anfang macht das „2,4 TFT LCD Touch Display“. Dieses Display werden Sie ggf. aus einem früheren Blogbeitrag Tic Tac Toe mit 2,4“ Touchdisplay kennen. Dieses wird einfach auf ein Mikrocontroller Board mit USB-Kabel, kompatibel mit Arduino Uno R3 aufgesteckt. Eine Durchleitung aller I/O’s ist nicht vorgesehen, daher kann das Display nur als einziges Shield benutzt werden, siehe Abbildung 5.

Abbildung 5: 2,4 TFT LCD Touch Display mit ein Mikrocontroller Board mit USB-Kabel, kompatibel mit Arduino Uno R3

Für dieses spezielle Display wird die Bibliothek MCUFRIEND_kbv verwendet. Code 4 generiert wieder einen simplen Zähler auf dem Display. Was direkt auffällt beim Betrieb ist, dass das Display recht stark beim Update flackert.

// 2.4" TFT LCD Display with microcontroller compatible with Uno R3
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 11. Febuary 2021
// Update: 11. Febuary 2021
//-----------------------------------------------------
//Include needed libs
#include <MCUFRIEND_kbv.h>

//Everybody loves colors
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF

int iCnt;
MCUFRIEND_kbv tft; //Init display

/*
* =================================================================
* Function: setup
* Returns: void
* Description: Setup display and sensors
* =================================================================
*/
void setup() {
  Serial.begin(115200);
  uint16_t ID = tft.readID(); //Read id from display
  Serial.println("2.4 TFT LCD Display sample");
  Serial.print("TFT ID = 0x");
  Serial.println(ID, HEX);
  tft.begin(ID); //Startup display
  tft.setRotation(1); //PORTRAIT
  tft.fillScreen(BLACK); //Remove content from display
  //Set first text
  tft.setCursor(30,40);
  tft.setTextColor(BLUE);
  tft.setTextSize(4);
  tft.println("2.4' TFT");
  tft.setCursor(30,90);
  tft.setTextColor(RED);
  tft.println("LCD Display");

  tft.setTextSize(3);
  tft.setTextColor(WHITE);
  tft.setCursor(30,130);
  tft.print("(c)Joern Weise");

  tft.setTextColor(YELLOW);
  tft.setCursor(30,180);
  tft.setTextSize(3);
  tft.print("For Az-Delivery");
  iCnt = 0;
  delay(5000);
}

/*
* =================================================================
* Function: loop
* Returns: void
* Description: Main loop to let program work
* =================================================================
*/
void loop() {
  tft.fillScreen(BLACK); //Remove content
  //Write first line
  tft.setCursor(30,40);
  tft.setTextColor(BLUE);
  tft.setTextSize(4);
  tft.print("Demo count:");
  //Write second line with counter
  tft.setTextColor(YELLOW);
  tft.setCursor(150,130);
  tft.setTextSize(4);
  tft.print(iCnt);
  //Increase counter
  iCnt++;
  if(iCnt >= 100)
    iCnt = 0;
  delay(2000); //Not the best solution, but effective for this demo
}

Code 4: Simpler Count-Beispiel für 2,4 TFT LCD Touch Display mit ein Mikrocontroller Board

Abbildung 6 zeigt den gleichen Zähler, wie auch bei den OLED-Displays. Der größte bzw. wohl wichtigste Vorteil ist die Farbe.

Abbildung 6: Beispielzähler in Aktion

In der Theorie ist es auch möglich, dieses Display mit einem ESP32 NodeMCU zu verbinden, jedoch ist die Stromaufnahme vom Display so hoch, dass eine separate Spannungsquelle mit 3,3V genutzt werden muss. Mit dem falschen Anschluss können Sie einen Schaden an Ihrem Micro Controller und womöglich ihrem USB-Anschlusses am PC erzeugen, den richtigen Anschluss hier näher zu erläutert sprengt den Rahmen dieses Blogartikels. Sie finden aber im Internet diverse Quellen, die einen richtigen Anschluss zeigt.

Zuletzt soll noch eines der gängigsten TFT-Displays von AZ-Delivery gezeigt werden. Zunächst soll das „1.8“ TFT LED 128x160“-Display mit einem Nano V3.0 angesteuert werden. Abbildung 7 zeigt die Verdrahtung der beiden Komponenten mit Spannungsversorgung und SPI-Anschluss. Zu beachten: das Display wird mit 3,3V versorgt, die LED für die Hintergrundbeleuchtung separat mit 5 V.

Abbildung 7: Verdrahtung TFT mit Nano V3.0

Den Quellcode, siehe Code 5, wird genauso simple gehalten, wie bei den OLED-Displays.

// Nano V3.0 with 128x160TFT
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 13. Febuary 2021
// Update: 13. Febuary 2021
//-----------------------------------------------------
#include <TFT.h>
#include <SPI.h>

// pin definition for Nano V3.0
#define cs 10
#define dc 9
#define rst 8

int iCnt;
// create an instance of the library
TFT TFTscreen = TFT(cs, dc, rst);

/*
* =================================================================
* Function: setup
* Returns: void
* Description: Setup display and sensors
* =================================================================
*/
void setup() {
  Serial.begin(115200);
  int iCnt = 0;
  //initialize the library
  Serial.print(F("Init display ..."));
  TFTscreen.begin();
  Serial.println(". DONE");
  // clear the screen with a black background
  TFTscreen.background(0, 0, 0);
  //set the text size
  TFTscreen.setTextSize(1);
  //Write init text
  Serial.println("TFT DEMO (c) Joern Weise for az-delivery");
  TFTscreen.stroke(255, 255, 255);
  TFTscreen.text("TFT DEMO!", 6, 30);
  TFTscreen.text("(c)Joern Weise", 6, 60);
  TFTscreen.text("for az-delivery", 6, 90);
  delay(5000);
  TFTscreen.setTextSize(2);
}

/*
* =================================================================
* Function: loop
* Returns: void
* Description: Main loop to let program work
* =================================================================
*/
void loop() {
  TFTscreen.background(0,0,0);
  //generate a random color
  int redRandom = random(0, 255);
  int greenRandom = random (0, 255);
  int blueRandom = random (0, 255);

  // set a random font color
  TFTscreen.stroke(redRandom, greenRandom, blueRandom);

  // Print the first line for the counter
  TFTscreen.text("Demo count", 6, 57);
  //// little trick to convert an int to char
  char str[8];
  itoa( iCnt, str, 10 );
  // display counter
  TFTscreen.text(str, 70, 80);
  iCnt++;
  if(iCnt >= 100)
    iCnt = 0;
  delay(2000); //Not the best solution, but effective for this demo
}
 

 

Code 5: Simpler Zähler auf dem TFT-Display

Abbildung 8 zeigt den Zähler im Einsatz. Wie Sie vielleicht sehen, ist der Anschluss schnell gemacht. Interessant schon auf dem Bild zu sehen, dass das Backlight vom Display recht hell ist.

Abbildung 8: Fertiger Zähler auf dem Nano V3.0

Die Verdrahtung bei einem ESP32 ist ebenfalls überschaubar, siehe Abbildung 9.

Abbildung 9: Verdrahtung ESP32 mit dem TFT-Display

Ähnlich wie beim Nano V3.0, braucht es insgesamt sieben Anschlüsse, um das Display zu nutzen. Anders als beim Nano V3.0  wird beim ESP die Bibliothek TFT_eSPI  von Bodmer verwendet, die man mit dem Bibliotheks-Verwalter einbindet. Für den ESP32 muss die Datei User_Setup.h, die sich nach dem Einbinden ebenfalls im Ordner C:\Users\Benutzername\Documents\Arduino\libraries\TFT_eSPI befindet, noch angepasst werden. Es empfiehlt sich, die Originaldatei als Datei User_Setup_old.h zu sichern, bevor man die Änderungen vornimmt. Ein fertig angepasste Datei User_Setup.h finden Sie in meinem Git-Repository .

Mehr zu den Programm-Bibliotheken lesen Sie demnächst hier in einem weiteren Blog-Beitrag.

Abbildung10: Unterzeichnis der Programm-Bibliothek TFT_eSPI

Der Quellcode, siehe Code 6, ist ebenso einfach gehalten, wie schon davor. Kommentare sollen den Code verständlicher machen.

// ESP32 with 128x160TFT
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 13. Febuary 2021
// Update: 13. Febuary 2021
//-----------------------------------------------------
//Including needed libs
#include <TFT_eSPI.h> // Hardware-specific library
#include <SPI.h>

//Everybody loves colors
#define COLOR_BLUE 0x001F
#define COLOR_GREEN 0x07E0

//Create objects
TFT_eSPI tft = TFT_eSPI(); //Create TFT-object
int iCnt;
/*
* =================================================================
* Function: setup
* Returns: void
* Description: Setup display and sensors
* =================================================================
*/
void setup() {
  iCnt = 0;
  Serial.begin(115200);
  Serial.println("Starting setup");
  Serial.println("Init display ...");
  //Set up the display
  tft.init();
  Serial.println(". DONE");
  Serial.println("TFT DEMO (c) Joern Weise for az-delivery");
  tft.setRotation(3);
  tft.fillScreen(TFT_BLACK);
  tft.setTextSize(2);
  tft.setTextColor(COLOR_BLUE);
  tft.setCursor(20, 20);
  tft.print("TFT");
  tft.setTextColor(COLOR_GREEN);
  tft.print(" Demo");
  tft.setTextSize(1);
  tft.setTextColor(TFT_WHITE);
  tft.setCursor(30, 40);
  tft.print("(c) Joern Weise");
  tft.setTextColor(TFT_WHITE);
  tft.setCursor(30, 60);
  tft.print("for az-delivery");
  delay(5000);
  tft.setTextSize(2);
}

/*
* =================================================================
* Function: loop
* Returns: void
* Description: Main loop to let program work
* =================================================================
*/
void loop() {
  tft.fillScreen(TFT_BLACK); //Clear old content
  //Print first text
  tft.setCursor(20, 20);
  tft.setTextColor(TFT_WHITE);
  tft.print("Demo count");
  //Print counter
  tft.setCursor(80, 60);
  tft.setTextColor(COLOR_GREEN);
  tft.print(iCnt);
  iCnt++;
  if(iCnt >= 100)
    iCnt = 0;
  delay(2000); //Not the best solution, but effective for this demo
}

Code 6: Quellcode ESP32 mit TFT-Display

Das Resultat, siehe Abbildung 10, zeigt denselben Zähler wie zuvor, nur mit dem ESP32 und mit leicht anderen Farben und verschobener Position.

 Abbildung 11: Fertiger Zähler auf dem ESP32

Schaut man sich nun das TFT einmal genauer an oder macht den Raum dunkel, wird man das Backlight vom TFT deutlich sehen, siehe Abbildung 11.

Abbildung 12:Backlight beim TFT-Display

Gerade wenn man das Display in ein etwas dünnwandigeres Gehäuse einbaut, wird man den leichten Schein, in Abbildung 11 rot markiert, deutlich sehen. Daher sollte man schon ggf. im Vorfeld überlegen, wo und wie man ein solches Display verbauen will.

Ergebnis

In diesem Blogbeitrag haben Sie nun gesehen, welche Unterschiede ein OLED- und TFT-Display aufweisen und auch, was die Displays so einzigartig macht. Wie schon bei den Pros und Contras erwähnt, werden Sie nicht DAS Display finden, sondern Kompromisse eingehen müssen! Doch ob es nun ein OLED oder eher ein TFT wird, hängt meist von der Aufgabe und dem Umfang im Code ab. Wer Farbe benötigt, entscheidet sich für TFT, wer den stärkeren Kontrast gerade bei den kleinen Displays bevorzugt, ist mit den OLEDs besser bedient.

Die hier verwendeten Bibliotheken sind auch nur ein Beispiel, es gibt weitere Bibliotheken, die mehr oder weniger das Gleiche können.

Weitere spannende Blogbeiträge mit OLED- oder TFT-Displays finden sie ebenfalls bei AZ-Delivery:

• 66" Display Shield on ESP32 D1 Mini and D1 Mini ESP8266
• Micropython mit dem ESP32 / ESP8266 – [Teil 4]
• Ein kostengünstiger und mobiler I2C Scanner
• Tic Tac Toe mit 2,4“ Touchdisplay oder
• Kleine Wetterstation mit JSON und Mondphase

Dieses und weitere Projekte finden sich auf GitHub unter https://github.com/M3taKn1ght/Blog-Repo.