OLED vs. TFT-Displays

Many projects that are presented in our blog posts provide visual feedback to the user. Be it through a small LED or a small display, which provides us with the status or the current information. The most common displays are so-called OLED or TFT displays. Where is the difference between the two displays? And when do you prefer to use an OLED display for your project and when to use a TFT display?

These questions will be answered in this blog post.

The AZ-Delivery assortment

If you look at the AZ-Delivery assortment, you can quickly find out that there are many different display types and display sizes, see https://www.az-delivery.de/collections/displays.

If you then filter for OLED or TFT, the selection will be lower, but still the selection of displays is still quite large. However, there are only two different ways to control the displays. On the one hand I2C, which stands for Inter-Integrated Circuit, and SPI, which stands for Serial Peripheral Interface. Both are a so-called bus system. The basic principle for both bus systems is that you have a fixed master, usually a micro controller, and the displays are integrated as a slave. The data exchange is carried out by two to four lines, whereby the correct wiring has to be taken care of depending on the bus system. Closer to I2C
and SPI and you can read the correct wiring on Wikipedia.

The technology behind OLED and TFT

OLED is the abbreviation for organic IIght eMitting diode, to German organic light-emitting diode.

TFT is the abbreviation for T-FIlm TTransistor, to German thin-film transistor.

This is where the first difference lies.

OLED uses materials from organic chemistry and TFT is made up of liquid crystals. The latter could be known to you, since the technology behind TFT is the further development of the LCD technology. A voltage is applied to the liquid crystals so that the liquid crystals change their orientation and thus the transmittance of light changes.

Just OLED still has the reputation that these should be light-weak, short-lived and unreliable. That may have voted in the past, but in comparison to 20 years ago, the technique has improved insanely. So this prejudice remains on the track in today's time.

Precisely because OLED displays do not need a "backlight", i.e. backlight, they are in part significantly better than a TFT display. In direct comparison, a TFT "swallows" almost 90% of the backlight.

This does not mean that OLED is now brighter than a TFT, because in fact the brightness of TFTs due to the backlight is significantly better than with OLEDs. However, the readability strongly depends on the contrast, and since the OLEDs have "the nose at the front".

Pro and Contra OLED/TFT

As described in the above, the technique behind the two display types is different. This leads to advantages and disadvantages. There is not that a perfect display, but one has to deal with the one or the other compromise. Table 1 is to give a first impression of the differences of an OLED or TFT displays.

 

OLED

TFT

Screen diagonals

Up to 1.3 "*

Up to 2.8 "**

Pixels

128 x 64

320 x 240

Power supply

3.3V-5V

3.3V and 5V***

Communication

Mostly I2C

SPI

Color capable

Only one solid color

The color of the item to be displayed can be determined

Connectors

4 Pins

At least 7 Pins

Additions

None

Touch and partial SD card slot

Background lit

No

Yes

*) Available size at AZ-Delivery, Booth 02.2021

**) As a reference, the AZ-Touch wall housing with 2.8 " touchscreen

***) The display itself uses only 3.3V, Touch needs a separate voltage

Table 1: Comparison of OLED TFT

Far more important than the Pros and Contras is, of course, how quickly these displays can be integrated into a project. Two factors are therefore to be considered in this blog:

  1. How large is the cabling effort?
  2. How fast can a display be integrated into the software to display text?
  3. (Only for TFT) How high is the effort to use the Touch function?

The hard-and software for this blog post

The components from Table 2 are used for this blog as reference hardware, but do not cover the complete offer of AZ-Delivery. Many components, however, are identical to the control or the libraries used, and require only a minimal adjustment in the configuration.

Number Component
1 Nano V3.0 with Atmega328 and CH340
or
Nano V3.0 with FT232RL and ATmega328
1 Microcontroller board with USB cable, compatible with Arduino Uno R3
1 2.4 TFT LCD Touch Display
1 0.96 inch OLED I2C display 128 x 64 pixels for Arduino and Raspberry Pi
1 0.91 inch OLED I2C display 128 x 32 pixels for Arduino and Raspberry Pi
1 ESP32 NodeMCU Module WLAN WiFi Development Board with CP2102 (Successor model to ESP8266)
1 1.8 inch SPI TFT display 128 x 160 pixels for Arduino and Raspberry Pi

Table 2: Hardware for test

Further complete packages, such as the AZ-Touch wall housing, are also not considered here, even if the installed TFT display can theoretically be operated without the board from a matching Micro Controller.

In order for this blog to be rebuilt by you, you will need the following software and libraries:

  • Arduino IDE (https://www.arduino.cc/en/Main/Software), best download the latest version here
  • The library Adafruit_SSD1306, available when creating the post in version 2.4.1, with all dependencies
  • The library MCUFRIEND_kbv, available when creating the post in version 2.9.9, with all dependencies
  • The library TFT_eSPI, available when creating the post in version 2.3.59, with all dependencies

You can install them by using the library management, see https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/arduino-ide-programmieren-fuer-einsteiger-teil-1 Library management section.

The OLED display

As mentioned above in this blog, the OLED display is quite simple.

With a "Nano V3.0 with Atmega328 CH340", the integration of a "0.96 inch OLED I2C display 128 x 64 pixels for Arduino and Raspberry Pi" or a "0.91 inch OLED I2C display 128 x 32 pixels for Arduino and Raspberry Pi" is quite simple, see Figure 1 and Figure 2.

Figure 1: Nano V3.0 with large i2c display

Figure 2: Nano V3.0 with small i2c display

In the case of an "ESP32 NodeMCU Module WLAN WiFi Development Board with CP2102", both I2C interfaces can be used. Here, too, the inclusion of a "0.96 inch OLED I2C display 128 x 64 pixels for Arduino and Raspberry Pi" and a "0.91 inch OLED I2C display 128 x 32 pixels for Arduino and Raspberry Pi" is quite simple, see Figure 3.

Figure 3: ESP32 NodeMCU Module with both i2c displays

Keep in mind what voltage your displays need; some will only carry 3.3V, one need 5V and there are those that work with both voltages, otherwise you will not see anything on the display.

So that the displays also show something, there is a short demo program, that every two seconds a counter increases and correspondingly makes visible on the display. Code 1 for the small display and Code 2 for the large display, the I2C displays are treated separately. During initialization, be aware of the correct size of the displays with the definition "#define SCREEN_WIDTH" and "#define SCREEN_HEIGHT". In the later the object "display" you will enter "Adafruit_SSD1306 display (SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);" with the correct pixel size.

// Nano V3.0 small i2c-display
// Author: Joern Weise
// License: GNU GPl 3.0
// Created: 09. Febuary 2021
// Update: 09. Febuary 2021
//-----------------------------------------------------
// Include needed libs
#include
#include

// 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 sample code small i2c-Display with Nano V3

// Nano V3.0 big i2c-display
// Author: Joern Weise
// License: GNU GPl 3.0
// Created: 09. Febuary 2021
// Update: 09. Febuary 2021
//-----------------------------------------------------
// Include needed libs
#include
#include

// 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 sample code large i2c display with Nano V3 

Since the ESP32 NodeMCU modules use WiFi Development Board with CP2102 both used i2c displays, the code for both displays can be reduced to a source code, see Code 3.

// ESP32 with two i2c displays
// Author: Joern Weise
// License: GNU GPl 3.0
// Created: 09. Febuary 2021
// Update: 09. Febuary 2021
//-----------------------------------------------------
//Include needed libs
'35; include
%35; include

//Define pins for both i2c
'35; defines the I2C of SDA1 17
'35; define I2C SCL1 16
'35; defines the I2C of SDA2 21
'35; define I2C SCL2 22

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

//Display variables
35; define WIDTH SCREEN to ONE 128 // OLED display width, in pixels
'35; define HEIGHT SCREEN ONE 64 // OLED display height, in pixels
'35; define SCREEN'u WIDTH'u TWO 128 // OLED display width, in pixels
'35; define SCREEN'u 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.start(115200);
I2Cone.start(I2C SDA1, I2C SCL1, 400000);
I2Ctwo.start(I2C to SDA2, I2C to SCL2, 400000);
iCnt = 0;
Serial.print(F("Init display one");
while(! displayONE.start(SSD1306 SWITCHCAPVCC, 0x3C))
// Address 0x3C for OLED display
  {
Serial.print(".");
  }
Serial.println(). DONE);

Serial.print(F("Init display two"));
while(! displayTWO.start(SSD1306-u 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-u 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-u WHITE); // Draw white text
displayTWO.setCursor(0,0); // Start at top-left corner
displayTWO.println("OLED-Display Demo");
displayTWO.println("(c)Joern mode");
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-u 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-u 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 modules with both i2c displays

Note that at the beginning of the code two I2C connections "I2Cone" and "I2Ctwo" will be created, which will then be used later in the initialization of the displays. Thus, the displays can be addressed separately. For all Micro Controllers, see Figure 4, the displays display the welcome text and the demo counter.


Figure 4: Nano V3 and ESP32 NodeMCU Module with i2c Displays

If you turn off the light, you will not see any backlight, but a razor-sharp display.

The TFT display

Next, the TFT displays are to be considered more closely. The "2,4 TFT LCD Touch Display" is the beginning. You may be able to display this display from an earlier blog post Tic Tac Toe with 2,4 " Touch display . This is simply plugged onto a microcontroller board with USB cable, compatible with Arduino Uno R3. A transmission of all I/O's is not provided, so the display can only be used as a single shield, see Figure 5.

Figure 5: 2.4 TFT LCD touch display with a microcontroller board with USB cable, compatible with Arduino Uno R3

For this special display, the library will be MCUFRIEND_kbv is used. Code 4 Generates a simple counter on the display again. What is striking when it comes to operation is that the display is very much flickering with the update.

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

// 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 example for 2.4 TFT LCD touch display with a microcontroller board

Figure 6 shows the same counter, as with the OLED displays. The largest or probably the most important advantage is the color.

Figure 6: Example counter in action

In theory, it is also possible to connect this display to an ESP32 NodeMCU, however, the power consumption from the display is so high that a separate voltage source with 3.3V has to be used. With the wrong connection you can create a damage to your Micro Controller and possibly your USB port on the PC, the correct connection here can be explained in more detail the frame of this blog article. However, you can find various sources on the Internet that show a correct connection.

Finally, one of the most common TFT displays of AZ-Delivery is to be shown. First of all, the "1.8" TFT LED 128x160 " display is to be controlled with a Nano V3.0. Figure 7 shows the wiring of the two components with power supply and SPI connection. To note: the display is supplied with 3.3V, the LED for the backlight separately with 5 V.

Figure 7: Wiring TFT with Nano V3.0

The source code, see Code 5, it is kept just as simple as in the OLED displays.

// Nano V3.0 with 128x160TFT
// Author: Joern Weise
// License: GNU GPl 3.0
// Created: 13. Febuary 2021
// Update: 13. Febuary 2021
//-----------------------------------------------------
#include
#include

// 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 to 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 counter on the TFT display

Figure 8 shows the meter in use. As you may see, the connection is quick. Interesting already on the picture to see that the backlight of the display is quite bright.

Figure 8: Fertiger counter on the Nano V3.0

The wiring for an ESP32 is also manageable, see Figure 9.

Figure 9: Wiring ESP32 with the TFT display

Similar to the Nano V3.0, a total of seven ports need to be used to use the display. In contrast to the Nano V3.0, the ESP is the TFT_eSPI library used by Bodmer, which you use with the librarian. For the ESP32, the file User_Setup.h, which is also located in the folder C:\Users\username\Documents\Arduino\libraries\TFT_eSPI after the binding, must still be adjusted. It is recommended that you back up the original file as a User_Setup_old.h file before making the changes. A completed User_Setup.h file can be found in my Git repository .

You can read more about the program libraries here in another blog post.

Abbildung10: Subdirectory of the program library TFT_eSPI

The source code, see Code 6, it's just as simple as it was before. Comments should make the code more understandable.

// ESP32 with 128x160TFT
// Author: Joern Weise
// License: GNU GPl 3.0
// Created: 13. Febuary 2021
// Update: 13. Febuary 2021
//-----------------------------------------------------
// Including needed libs
#include // Hardware-specific library
#include

// 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: ESP32 source code with TFT display

The result, see Figure 10, shows the same counter as before, only with the ESP32 and with slightly different colors and moved position.

Figure 11: Fertiger counter on ESP32

If you look at the TFT once more or make the room dark, you will see the backlight of the TFT clearly, see Figure 11.

Figure 12: Backlight at TFT display

Just when you insert the display into a slightly thin-walled housing, you will get the light sham, in Figure 11 red marked, clearly visible. Therefore, you should be able to in advance to think about where and how to fend off such a display.

Result

In this blog post you have now seen the differences between an OLED and TFT display and also what makes the displays so unique. As already mentioned in the Pros and Contras, you will not find the display, but compromise! However, whether it becomes an OLED or rather a TFT is mostly dependent on the task and the extent in the code. If you need color, you decide for TFT, who prefer the stronger contrast, especially in small displays, is better served with the OLEDs.

The libraries used here are also just one example, there are other libraries that can do more or less the same.

Other exciting blog posts with OLED or TFT displays can also be found at AZ-Delivery:

This and other projects can be found on GitHub under https://github.com/M3taKn1ght/Blog-Repo.

DisplaysEsp-32For arduinoProjects for beginners

4 comments

Jörn Weise

Jörn Weise

Hallo,
da ich mich nur im Digitalfunk bewege, war mir dieses Problem nicht bekannt, ist aber natürlich eine Erwähnung wert. Wir werden das noch als negativen Punkt in unsere Liste eintragen.

Norbert

Norbert

Schade dass in diesem Beitrag nicht auf den, aus meiner Sicht, Hauptnachteil der OLED Displays, den Einbrenneffekt, eingegangen wird.
Ich habe aus diesem Grund bereits mehrere OLED- durch TFT-Displays ersetzt.

D. Schwanen

D. Schwanen

Guter ausführlicher Blogbeitrag.

Thomas

Thomas

Die OLED haben noch einen unerwähnten aber nicht unerheblichen Nachteil: Sie produzieren oftmals HF-Störungen. Als Amateurfunker musste ich dies schon leidlich erfahren.

Leave a comment

All comments are moderated before being published

Recommended blog posts

  1. Install ESP32 now from the board manager
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - ESP programming via WLAN