OLED vs. écrans TFT

De nombreux projets présentés dans nos articles de blog fournissent un retour visuel à l'utilisateur. Que ce soit par le biais d'une petite LED ou d'un petit écran qui nous donne le statut ou les informations actuelles. Les écrans les plus courants sont les écrans dits OLED ou TFT. Quelle est la différence entre les deux affichages ? Et quand devriez-vous plutôt utiliser un écran OLED pour votre projet et quand un écran TFT ?

Ces questions seront clarifiées dans ce blog.

L'assortiment de AZ-Delivery

Si vous jetez un coup d'œil à la gamme de AZ-Delivery, vous constaterez rapidement qu'il existe de nombreux types et tailles d'affichage différents, voir https://www.az-delivery.de/collections/displays.

Si vous filtrez ensuite par OLED ou TFT, la sélection se réduit, mais le choix d'écrans reste assez large. Cependant, il n'y a que deux façons différentes de contrôler les écrans. L'une est I2C, qui signifie circuit intégré, et SPI, qui signifie interface périphérique série. Les deux sont un système dit de bus. Le principe de base des deux systèmes de bus est que vous avez un maître fixe, généralement un microcontrôleur, et que les écrans sont intégrés en tant qu'esclaves. L'échange de données s'effectue via deux à quatre lignes. Selon le système de bus, il faut veiller à un câblage correct. En savoir plus sur I2C et SPI et le câblage correct peuvent être trouvés sur Wikipedia.

La technologie derrière les OLED et les TFT

OLED est l'abréviation de Organic Light Emitting Diode (diode électroluminescente organique).

TFT est l'abréviation de Thin Film Transistor (transistor à couche mince).

C'est là que réside la première différence.

Les OLED utilisent des matériaux issus de la chimie organique et les TFT sont constitués de cristaux liquides. Ce dernier point peut vous sembler familier, car la technologie TFT est l'évolution de la technologie LCD. Une tension est appliquée aux cristaux liquides afin qu'ils changent d'orientation et que la transmission de la lumière soit modifiée.

Les OLED, en particulier, ont toujours la réputation d'être peu lumineux, de courte durée et peu fiables. C'était peut-être vrai dans le passé, mais par rapport à il y a 20 ans, la technologie s'est incroyablement améliorée. Ce préjugé n'a donc plus cours dans le monde d'aujourd'hui.

Comme les écrans OLED ne nécessitent pas de rétroéclairage, ils sont parfois bien meilleurs qu'un écran TFT. En comparaison directe, un TFT "avale" près de 90% du rétroéclairage.

Toutefois, cela ne signifie pas que les OLED sont plus lumineuses que les TFT, car la luminosité des TFT est en fait bien meilleure que celle des OLED en raison du rétroéclairage. Cependant, la lisibilité dépend fortement du contraste, et les OLED sont "en avance" sur ce point.

OLED / TFT positif et négatif

Comme décrit ci-dessus, la technologie qui sous-tend les deux types d'affichage est différente. Cela comporte des avantages et des inconvénients. Il n'y a pas LE présentoir parfait, mais vous devez faire l'un ou l'autre compromis. Le tableau 1 devrait donner une première impression des différences entre les écrans OLED et TFT.

	Catégorie	Transistor à film mince
Diagonale de l'image	Jusqu'à 1,3"*	Jusqu'à 2,8 pouces**
Pixel	128 x 64 in	320 x 240 mm
Alimentation électrique	3,3v - 5V	3, 3V et 5V***
Communication	Principalement I2C	Spi
Colorable	Une seule couleur fixe	Vous pouvez déterminer la couleur des éléments à afficher
Connexion	4 Pins	Au moins 7 broches
Additions	Aucune	Fente pour carte SD tactile et partielle
Rétro-éclairé	Non	Correct

Dimensions disponibles à la livraison Az, stand 02.2021

Référence: boîtier de téléphone AZ touch Wall avec écran tactile 2.8

L'affichage lui - même n'utilise que 3,3v et l'écran tactile nécessite une tension séparée

Tableau 1: comparaison des TFT OLED

Bien entendu, la rapidité avec laquelle ces écrans peuvent être intégrés dans un projet est bien plus importante que les avantages et les inconvénients. Ce blog se penchera donc sur deux facteurs :

1. Quelle est la charge de travail du câblage?
2. À quelle vitesse l'affichage s'intègre - t - il dans le logiciel pour afficher le texte?
3. (TFT seulement) Quelle est la charge de travail avec la fonction touch?

Le matériel et le logiciel pour ce blog post

Les composants du tableau 2 servent de matériel de référence pour ce blog, mais ne couvrent pas la gamme complète des produits AZ-Delivery. Cependant, de nombreux composants sont identiques en termes de commande ou de bibliothèques utilisées et ne nécessitent qu'un ajustement minimal de la configuration.

Numéro	Composant
1	Nano v3.0, prend en charge atmega328 et ch340 Ou Nano v3.0 avec ft232rl et atmega328
1	Carte de microcontrôleur avec câble USB, compatible avec arduino uno R3
1	2,4 écran tactile TFT LCD
1	0,96 Zoll OLED I2C 128 x 64 pixels pour arduino et Raspberry Pi
1	0,91 Zoll OLED I2C Display 128 x 32 pixels for arduino and Raspberry Pi
1	Esp32 nodemcu module WLAN wifi Development Board with cp2102 (modèles ultérieurs pour esp8266)
1	1,8 "SPI TFT Screen 128 x 160 pixels for arduino and Raspberry Pi

Tableau 2: matériel d'essai

D'autres ensembles complets, tels que le boîtier mural AZ-Touch, ne sont pas non plus considérés ici, même si l'écran TFT intégré peut théoriquement fonctionner sans la carte à partir d'un microcontrôleur approprié.

Pour que ce blog puisse également être reproduit par vous, vous avez besoin des logiciels et bibliothèques suivants :

• Arduino IDE (https://www.arduino.cc/en/Main/Software), le mieux est de télécharger la dernière version ici
• La bibliothèque Adafruit_SSD1306, au moment de l'écriture disponible en version 2.4.1, avec toutes les dépendances
• La bibliothèque MCUFRIEND_kbv, disponible au moment de l'écriture en version 2.9.9, avec toutes ses dépendances.
• La bibliothèque TFT_eSPI, au moment de l'écriture disponible en version 2.3.59, avec toutes ses dépendances.

Vous les installez via la gestion des bibliothèques, voir https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/arduino-ide-programmieren-fuer-einsteiger-teil-1 section Gestion des bibliothèques.

L'écran OLED

Comme mentionné au début de ce blog, l'écran OLED est assez simple.

Pour un "Nano V3.0 avec Atmega328 CH340", l'intégration d'un "0.96 inch OLED I2C Display 128 x 64 pixels for Arduino and Raspberry Pi" ou d'un "0.91 inch OLED I2C Display 128 x 32 pixels for Arduino and Raspberry Pi" est assez simple, voir Figure 1 et Figure 2.

Figure 1 : Nano V3.0 avec grand écran i2c

Figure 2 : Nano V3.0 avec petit écran i2c

Avec un "ESP32 NodeMCU Module WLAN WiFi Development Board with CP2102" les deux interfaces I2C peuvent être utilisées. Là encore, l'intégration d'un "écran OLED I2C de 0,96 pouce 128 x 64 pixels pour Arduino et Raspberry Pi" et d'un "écran OLED I2C de 0,91 pouce 128 x 32 pixels pour Arduino et Raspberry Pi" est assez simple, voir la figure 3.

Figure 3 : modules ESP32 NodeMCU avec les deux afficheurs i2c

Notez la tension dont vos écrans ont besoin ; certains ne tolèrent que 3,3V, un autre a besoin de 5V et il y en a qui fonctionnent avec les deux tensions, sinon vous ne verrez rien sur l'écran.

Pour que les écrans affichent quelque chose, il existe un petit programme de démonstration qui incrémente un compteur toutes les deux secondes et le rend visible sur l'écran. Le code 1 pour le petit écran et le code 2 pour le grand écran gèrent les écrans I2C séparément. Notez la taille correcte des écrans avec la définition "#define SCREEN_WIDTH" et "#define SCREEN_HEIGHT" pendant l'initialisation. Avec cela, vous donnez à l'objet "display" la bonne taille de pixel avec l'initialisation "Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire) ;".

Nano v3.0 petit écran I2C
Par Joern Weise
Licence: GNU GPL 3.0
Date de création: 9 février 2021
Mise à jour: 9 février 2021
//-----------------------------------------------------
Inclure les bibliothèques requises
« 35; comprend < adafruit < ssd1306.h >
35; y compris < wire.h >

Afficher les variables
« 35; définir la largeur de l'écran 128 / / OLED (pixels)
35; définir la hauteur d'affichage de l'écran / / OLED (pixels)
Affichage adafruit / ssd1306 (écran / largeur, écran / hauteur et ligne);

Sociétés internationales;
/*
* =================================================================
Fonction: paramètres
Retour: vide
Description: réglage de l'affichage et du capteur
* =================================================================
*/
Paramètres invalides ()
Démarrage en série (115 200);
Icnt = 0;
Impression en série (F ("Affichage initial");
Et (!Afficher le démarrage (ssd1306 à switchcapvcc, 0x3c))
OLED Display address 0x3c
  {
Impression continue (");
  }
Serial.println ().Terminé);
Effacer le tampon
Display.cleardisplay ();
Display.settextsize (1)Échelle normale de 1: 1 pixel
Display.settextcolor (ssd1306 - U White) /Dessiner un texte blanc
Afficher le curseur de configuration (0,0)En haut à gauche
Display.println ("OLED Display Demo");
Display.println ("(c) Joern mode");
Display.println ("for AZ delivery");
Display.display ();
Retard (5 000);
}

/*
* =================================================================
Fonction: cycle
Retour: vide
Description: boucle principale pour faire fonctionner le programme
* =================================================================
*/
Boucle invalide ()

Display.settextsize (1)Échelle normale de 1: 1 pixel
Display.cleardisplay () /Supprimer l'ancien contenu
Display.settextsize (1)Échelle normale de 1: 1 pixel
Display.settextcolor (ssd1306 - U White) /Dessiner un texte blanc
Afficher le curseur de configuration (10,10) /En haut à gauche
Afficher l'impression ("compteur de démonstration");
Afficher les dimensions (2)Échelle normale de 2: 1 pixels
Afficher le curseur de réglage (64,32);
Afficher.println (icnt);
Display.display () /Afficher le nouveau contenu à la fin
Icnt +;
Si (icnt > = 100)
Icnt = 0;
Retard (2000) /Pas la meilleure solution, mais très efficace pour cette démonstration
}

Code 1Exemple de code OLED avec Nano V3 petit affichage I2C

Nano v3.0 grand écran I2C
Par Joern Weise
Licence: GNU GPL 3.0
Date de création: 9 février 2021
Mise à jour: 9 février 2021
//-----------------------------------------------------
Inclure les bibliothèques requises
« 35; comprend < adafruit < ssd1306.h >
35; y compris < wire.h >

Afficher les variables
« 35; définir la largeur de l'écran 128 / / OLED (pixels)
« 35; définir la hauteur d'affichage de l'écran 64 / / OLED en pixels
Affichage adafruit / ssd1306 (écran / largeur, écran / hauteur et ligne);

Sociétés internationales;
/*
* =================================================================
Fonction: paramètres
Retour: vide
Description: réglage de l'affichage et du capteur
* =================================================================
*/
Paramètres invalides ()
Démarrage en série (115 200);
Icnt = 0;
Impression en série (F ("Affichage initial");
Et (!Afficher le démarrage (ssd1306 à switchcapvcc, 0x3c))
OLED Display address 0x3c
  {
Impression continue (");
  }
Serial.println ().Terminé);
Effacer le tampon
Display.cleardisplay ();
Display.settextsize (1)Échelle normale de 1: 1 pixel
Display.settextcolor (ssd1306 - U White) /Dessiner un texte blanc
Afficher le curseur de configuration (0,0)En haut à gauche
Display.println ("OLED Display Demo");
Display.println (");
Display.println ("(c) Joern mode");
Display.println (");
Display.println ("for AZ delivery");
Display.display ();
Retard (5 000);
}

/*
* =================================================================
Fonction: cycle
Retour: vide
Description: boucle principale pour faire fonctionner le programme
* =================================================================
*/
Boucle invalide ()

Display.settextsize (1)Échelle normale de 1: 1 pixel
Display.cleardisplay () /Effacer l'ancien contenu
Display.settextsize (1)Échelle normale de 1: 1 pixel
Display.settextcolor (ssd1306 - U White) /Dessiner un texte blanc
Afficher le curseur de configuration (10,10) /En haut à gauche
Afficher l'impression ("compteur de démonstration");
Afficher les dimensions (2)Échelle normale de 2: 1 pixels
Afficher le curseur de réglage (64,30);
Afficher.println (icnt);
Display.display () /Afficher le nouveau contenu
Icnt +;
Si (icnt > = 100)
Icnt = 0;
Retard (2000) /Pas la meilleure solution, mais très efficace pour cette démonstration
}

Code 2 : Code d'exemple OLED grand écran i2c avec Nano V3

 

Puisque la carte de développement ESP32 NodeMCU Module WLAN WiFi avec CP2102 utilise les deux écrans i2c déployés, le code pour les deux écrans peut être réduit à un seul code source, voir le code 3.

Esp32 avec deux écrans I2C
Par Joern Weise
Licence: GNU GPL 3.0
Date de création: 9 février 2021
Mise à jour: 9 février 2021
//-----------------------------------------------------
Inclure les bibliothèques requises
« 35; comprend < adafruit < ssd1306.h >
35; y compris < wire.h >

Définir deux pins I2C
« 35; I2C définissant sda1 17
« 35; définition I2C scl1 16
« 35; I2C définissant sda2 21
« 35; définition I2C scl2 22

Objet I2C
Deux fils i2cone = deux fils (0);
Deux fils i2ctwo = deux fils (1);

Afficher les variables
35; définir la largeur de l'écran comme une largeur d'affichage de 128 / / OLED (pixels)
« 35; définir la hauteur d'affichage de l'écran principal one 64 / / OLED en pixels
« 35; définir la largeur d'affichage de l'écran « u width» two 128 / / OLED en pixels
« 35; définir la hauteur de l'écran two 32 / / OLED en pixels
Adafruit / ssd1306 displayone (Screen / width / One, Screen / height one, & i2cone);
Adafruit / ssd1306 displaytwo (Screen / width / Two, Screen / height 2, & i2ctwo);

Sociétés internationales;

/*
* =================================================================
Fonction: paramètres
Retour: vide
Description: réglage de l'affichage et du capteur
* =================================================================
*/
Paramètres invalides ()
Démarrage en série (115 200);
I2cone. Start (I2C sda1, I2C scl1400000);
I2c2. Démarrage (I2C à sda2, I2C à scl2400000);
Icnt = 0;
Serial.print (F ("init Display one");
Et (!Displayone.start (ssd1306 Switch Capacitor VCC, 0x3c))
OLED Display address 0x3c
  {
Impression continue (");
  }
Serial.println ().Terminé);

Serial.print (F ("init Display two");
Et (!Affichage 2. Démarrage (ssd1306 - U switchcapvcc, 0x3c))
OLED Display address 0x3c
  {
Impression continue (");
  }
Serial.println ().Terminé);

Displayone.cleardisplay () /Effacer le tampon
Displayone.settextsize (1)Échelle normale de 1: 1 pixel
Displayone.settextcolor (ssd1306 - U White) /Dessiner un texte blanc
Displayone.setcursor (0,0) /En haut à gauche
Displayone.println ("OLED Display Demo");
Displayone.println (");
Displayone.println ("(c) Joern Weise");
Displayone.println (");
Displayone.println ("pour AZ delivery");
Displayone.display ();

Displaytwo.cleardisplay () /Effacer le tampon
Display2.settextsize (1) /Échelle normale de 1: 1 pixel
Afficher 2. Settextcolor (ssd1306 - U White) /Dessiner un texte blanc
2. Setcursor (0,0) /En haut à gauche
Displaytwo.println ("OLED Display Demo");
Displaytwo.println ("(c) Joern mode");
Displaytwo.println ("pour AZ delivery");
Displaytwo.display ();
Retard (5 000);
}

/*
* =================================================================
Fonction: cycle
Retour: vide
Description: boucle principale pour faire fonctionner le programme
* =================================================================
*/
Boucle invalide ()
Displayone.settextsize (1)Échelle normale de 1: 1 pixel
Displayone.cleardisplay ();
Displayone.settextsize (1)Échelle normale de 1: 1 pixel
Displayone.settextcolor (ssd1306 - U White) /Dessiner un texte blanc
Définir le curseur (10,10) /En haut à gauche
Displayone.print ("Demo Counter");
Displayone.settextsize (2)Échelle normale de 2: 1 pixels
Définir le curseur (64,30);
Displayone.println (icnt);
Displayone.display ();

Display2.settextsize (1) /Échelle normale de 1: 1 pixel
Displaytwo.cleardisplay ();
Display2.settextsize (1) /Échelle normale de 1: 1 pixel
Afficher 2. Settextcolor (ssd1306 - U White) /Dessiner un texte blanc
2. Définir le curseur (10,10) /En haut à gauche
Displaytwo.print ("Demo Counter");
Display2.settextsize (2) /Échelle normale de 2: 1 pixels
2. Impression (icnt);
Displaytwo.display ();

Icnt +;
Si (icnt > = 100)
Icnt = 0;
Retard (2000) /Pas la meilleure solution, mais très efficace pour cette démonstration
}

Code 3 : Module ESP32 NodeMCU avec les deux afficheurs i2c

Notez qu'au début du code, deux connexions I2C "I2Cone" et "I2Ctwo" sont créées, qui seront utilisées plus tard lors de l'initialisation des écrans. Ainsi, les écrans peuvent être traités séparément. Avec tous les micro-contrôleurs, voir la figure 4, les écrans affichent le texte de bienvenue et le compteur de démonstration.

Figure 4 : modules Nano V3 et ESP32 NodeMCU avec écrans i2c

Si vous éteignez la lumière, vous ne voyez pas de rétroéclairage, mais un écran net.

L'écran TFT

Ensuite, nous allons examiner de plus près les écrans TFT. Le premier est l'"écran tactile LCD TFT 2,4". Vous connaissez peut-être cet écran grâce à un précédent article de blog intitulé Tic Tac Toe avec écran tactile de 2,4 pouces. Il suffit de le brancher sur une carte de microcontrôleur avec un câble USB, compatible avec Arduino Uno R3. Un passage de toutes les entrées/sorties n'est pas prévu, de sorte que l'écran ne peut être utilisé que comme une seule protection, voir la figure 5.

Figure 5 : Écran tactile LCD TFT 2.4 avec une carte microcontrôleur avec câble USB, compatible avec Arduino Uno R3

Pour cet affichage spécial, la bibliothèque MCUFRIEND_kbv est utilisée. Le code 4 génère à nouveau un simple compteur sur l'écran. Ce que l'on remarque immédiatement lors de l'utilisation, c'est que l'écran scintille assez fortement pendant la mise à jour.

Affichage LCD TFT de 2,4 pouces avec microcontrôleur compatible uno R3
Par Joern Weise
Licence: GNU GPL 3.0
Date de création: 11 février 2021
Mise à jour: 11 février 2021
//-----------------------------------------------------
Inclure les bibliothèques requises
« 35; y compris < mcufriend'u kbv.h >

Tout le monde aime les couleurs.
« 35; noir défini 0x0000
« 35; définir bleu 0x001f
« 35; définir rouge 0xf800
« 35; définir vert 0x07e0
« 35; cyan défini 0x07ff
« 35; définir Magenta 0xf81f
« 35; définir jaune 0xffe0
« 35; définir blanc 0xffff

Sociétés internationales;
Mcufriend kbv TFT / /Initialisation de l'affichage

/*
* =================================================================
Fonction: paramètres
Retour: vide
Description: réglage de l'affichage et du capteur
* =================================================================
*/
Paramètres invalides ()
Démarrage en série (115 200);
Uint16 u t id = tft.readid () /Lire l'ID à partir de l'affichage
Serial.println ("2.4 TFT LCD display examples");
Serial.print ("TFT id = 0x");
Serial.println (ID, Hex);
DémarrerDémarrer l'affichage
TFT set rotation (1)Taux de Baud
Tft.fillscreen (noir)Supprimer le contenu de l'affichage
Définir le premier texte
Définir le curseur (30,40);
TFT. Couleur (bleu);
Tft.settextsize (4 off);
Tft.println ("2.4 'TFT");
Définir le curseur (30,90);
Tft.settextcolor (rouge);
Tft.println ("LCD");

Tft.settextsize (3);
Couleur (blanche);
Définir le curseur (30130);
Tft.print ("(c) Joern mode");

TFT. Couleur (jaune);
Définir le curseur (30180);
Tft.settextsize (3);
TFT. Print ("for AZ delivery");
Icnt = 0;
Retard (5 000);
}

/*
* =================================================================
Fonction: cycle
Retour: vide
Description: boucle principale pour faire fonctionner le programme
* =================================================================
*/
Boucle invalide ()
Tft.fillscreen (noir)Supprimer le contenu
Écrivez la première ligne
Définir le curseur (30,40);
TFT. Couleur (bleu);
Tft.settextsize (4 off);
Tft.print ("Demo Count:");
Écrivez la deuxième ligne avec le compteur
TFT. Couleur (jaune);
Définir le curseur (150130);
Tft.settextsize (4 off);
Impression TFT (icnt);
Compteur incrémental
Icnt +;
Si (icnt > = 100)
Icnt = 0;
Retard (2000) /Pas la meilleure solution, mais très efficace pour cette démonstration
}

Code 4 : Exemple de comptage plus simple pour un écran tactile LCD TFT 2,4 avec une carte microcontrôleur

La figure 6 montre le même compteur que pour les écrans OLED. Le plus grand avantage, ou probablement le plus important, est la couleur.

Figure 6 : Exemple de compteur en action

En théorie, il est également possible de connecter cet écran à un NodeMCU ESP32, mais la consommation de courant de l'écran est si élevée qu'il faut utiliser une source d'alimentation séparée de 3,3 V. Avec une mauvaise connexion, vous pouvez endommager votre micro-contrôleur et éventuellement votre port USB sur le PC. Expliquer la connexion correcte plus en détail dépasse le cadre de cet article de blog. Cependant, vous pouvez trouver sur Internet diverses sources qui montrent une connexion correcte.

Enfin, l'un des écrans TFT les plus courants de AZ-Delivery sera présenté. Tout d'abord, l'écran "1.8" TFT LED 128x160" doit être contrôlé avec un Nano V3.0. La figure 7 montre le câblage des deux composants avec l'alimentation et le connecteur SPI. Note : l'écran est alimenté en 3,3V, la LED pour le rétro-éclairage séparément en 5V.

Figure 7 : Câblage du TFT avec Nano V3.0

Le code source, voir code 5, reste aussi simple que pour les écrans OLED.

Nano v3.0 avec 128x160tft
Par Joern Weise
Licence: GNU GPL 3.0
Date de création: 13 février 2021
Mise à jour: 13 février 2021
//-----------------------------------------------------
35; y compris < tft.h >
« 35; y compris < spi.h >

Définition de la broche Nano v3.0
« 35; définition CS 10
« 35; définition DC 9
« 35; définir les 8 premiers

Sociétés internationales;
Créer une instance de la bibliothèque
Écran TFT = TFT (CS, DC, rst);

/*
* =================================================================
Fonction: paramètres
Retour: vide
Description: réglage de l'affichage et du capteur
* =================================================================
*/
Paramètres invalides ()
Démarrage en série (115 200);
Int icnt = 0;
Initialiser la bibliothèque
Serial.print (F ("init Display...");
Tftscreen.start ();
Serial.println ().Terminé);
Effacer l'écran avec un fond noir
Tftscreen. Background (0, 0, 0);
Définir la taille du texte
Tftscreen.settextsize (1);
Écrire le texte d'initialisation
Serial.println ("TFT Demonstration (c) Joern Weise for AZ delivery");
Tftscreen. Street (255255255);
Tftscreen.text ("TFT Demo!",6, 30);
Texte ("; c) Joern Weise", 6, 60);
Tftscreen.text ("for AZ delivery", 6, 90);
Retard (5 000);
Tftscreen.settextsize (2);
}

/*
* =================================================================
Fonction: cycle
Retour: vide
Description: boucle principale pour faire fonctionner le programme
* =================================================================
*/
Boucle invalide ()
Tftscreen. Background (0,0,0);
Générer des couleurs aléatoires
Int redrandom = random (0255);
Int greenrandom = random (0255);
Int bluerandom = aléatoire (0255);

Définir une police aléatoire
Tftscreen. Street (Red Random, Green Random, Blue Random);

Imprimer la première ligne du compteur
Tftscreen.text ("Demo count", 6, 57);
Conseils pour convertir int en char
Caractère str [8];
ITOA (icnt, str, 10);
Afficher les compteurs
Texte (Str, 70, 80);
Icnt +;
Si (icnt > = 100)
Icnt = 0;
Retard (2000) /Pas la meilleure solution, mais très efficace pour cette démonstration
}
 

Code 5 : Compteur simple sur l'écran TFT

La figure 8 montre le compteur en service. Comme vous pouvez le constater, la connexion se fait rapidement. Il est intéressant de voir déjà sur la photo que le rétro-éclairage de l'écran est assez lumineux.

Figure 8 : Compteur terminé sur le Nano V3.0

Le câblage d'un ESP32 est également simple, voir la figure 9.

Figure 9 : Câblage de l'ESP32 avec l'écran TFT

Comme pour le Nano V3.0, il faut un total de sept connexions pour utiliser l'écran. Contrairement au Nano V3.0, l'ESP utilise la bibliothèque TFT_eSPI de Bodmer, que vous incluez avec le gestionnaire de bibliothèque. Pour l'ESP32, le fichier User_Setup.h, qui se trouve également dans le dossier C:\Users\Username\Documents\Arduino\libraries\TFT_eSPI, doit être modifié. Il est recommandé d'enregistrer le fichier original sous le nom de User_Setup_old.h avant d'effectuer les modifications. Un fichier User_Setup.h prêt à l'emploi peut être trouvé dans mon dépôt Git .

Vous pourrez lire plus d'informations sur les bibliothèques du programme dans un autre article du blog, ici même, prochainement.

Figure10 : Sous-répertoire de la bibliothèque de programmes TFT_eSPI

Le code source, voir code 6, reste aussi simple que précédemment. Les commentaires doivent rendre le code plus compréhensible.

Esp32 avec 128x160tft
Par Joern Weise
Licence: GNU GPL 3.0
Date de création: 13 février 2021
Mise à jour: 13 février 2021
//-----------------------------------------------------
Inclure les bibliothèques requises
"35; include < TFT" espi.h > / / hardware specific Libraries
« 35; y compris < spi.h >

Tout le monde aime les couleurs.
« 35; définir la couleur»u bleu 0x001f
"35; définir vert 0x07e0

Créer un objet
TFT ESPI TFT = TFT ESPI () /Créer un objet TFT
Sociétés internationales;
/*
* =================================================================
Fonction: paramètres
Retour: vide
Description: réglage de l'affichage et du capteur
* =================================================================
*/
Paramètres invalides ()
Icnt = 0;
Démarrage en série (115 200);
Serial.println ("startup settings");
Serial.println ("initialiser l'affichage...");
Configuration de l'affichage
Tft.init ();
Serial.println ().Terminé);
Serial.println ("TFT Demonstration (c) Joern Weise for AZ delivery");
Régler la rotation (3);
TFT. Fillscreen (TFT Black);
Tft.settextsize (2 off);
Tft.settextcolor (bleu);
Définir le curseur (20, 20);
Impression TFT ("TFT");
Tft.settextcolor (vert);
Impression TFT ("démonstration");
Tft.settextsize (1);
Couleur (TFT blanc);
Définir le curseur (30, 40);
Impression TFT ("(c) Joern Weise");
Couleur (TFT blanc);
Définir le curseur (30, 60);
TFT. Print ("for AZ delivery");
Retard (5 000);
Tft.settextsize (2 off);
}

/*
* =================================================================
Fonction: cycle
Retour: vide
Description: boucle principale pour faire fonctionner le programme
* =================================================================
*/
Boucle invalide ()
Tft.fillscreen (TFT Black)Effacer l'ancien contenu
Imprimer le premier texte
Définir le curseur (20, 20);
Couleur (TFT blanc);
Tft.print ("Demo count");
Compteur d'impression
Définir le curseur (80, 60);
Tft.settextcolor (vert);
Impression TFT (icnt);
Icnt +;
Si (icnt > = 100)
Icnt = 0;
Retard (2000) /Pas la meilleure solution, mais très efficace pour cette démonstration
}

Code 6 : Code source ESP32 avec écran TFT

Le résultat, voir Figure 10, montre le même compteur que précédemment, mais avec l'ESP32 et avec des couleurs légèrement différentes et une position décalée.

Figure 11 : Compteur terminé sur l'ESP32

Si vous regardez maintenant de plus près le TFT ou si vous assombrissez la pièce, vous verrez clairement le rétroéclairage du TFT, voir la Figure 11.

Figure 12 : Rétro-éclairage de l'écran TFT

En particulier si vous installez l'écran dans un boîtier un peu plus fin, vous verrez clairement la légère lueur, marquée en rouge dans la Figure 11. Par conséquent, vous devez réfléchir à l'avance à l'endroit et à la manière dont vous souhaitez installer un tel écran.

Résultat

Dans cet article de blog, vous avez vu les différences entre un écran OLED et un écran TFT, ainsi que ce qui rend ces écrans si uniques. Comme déjà mentionné dans les avantages et les inconvénients, vous ne trouverez pas LE présentoir, mais devrez faire des compromis ! Mais qu'il devienne un OLED ou plutôt un TFT dépend principalement de la tâche et de la portée du code. Si vous avez besoin de couleurs, optez pour les écrans TFT. Si vous préférez un contraste plus fort, notamment pour les petits écrans, les OLED vous conviendront mieux.

Les bibliothèques utilisées ici ne sont qu'un exemple, il existe d'autres bibliothèques qui peuvent faire plus ou moins la même chose.

Vous trouverez également d'autres articles passionnants sur les écrans OLED ou TFT sur le blog AZ-Delivery :

• Bouclier d'affichage 66" sur ESP32 D1 Mini et D1 Mini ESP8266
• Micropython avec l'ESP32 / ESP8266 - [Partie 4]
• Un scanner I2C mobile et à faible coût
• Tic Tac Toe avec écran tactile de 2,4" ou
• Petite station météo avec JSON et phase de lune

Ce projet et d'autres peuvent être consultés sur GitHub à l'adresse https://github.com/M3taKn1ght/Blog-Repo.