Les meilleurs écrans et afficheurs pour arduino, que ce soit LCD, OLED, TFT, avec ou sans interface i2c, tactile ou couleur, pour débuter en électronique

Les 4 Meilleurs Afficheur pour Arduino
(écran LCD, OLED, TFT, i2c, …)

Besoin d’un écran d’affichage simple, performant, et pas cher pour votre Arduino ?

J’ai trouvé ce qu’il vous faut !

Ayant développé pas mal de projets électroniques ces dernières années, je me suis dis qu’il serait intéressant de vous faire un petit article ici, qui regroupe un peu tout les types d’afficheurs « de base », communicant avec un Arduino. J’en ai profité pour faire pas mal de recherches complémentaires, et pas mal de tests supplémentaires, afin de vous dresser une liste de ceux qui sont, selon moi, les meilleurs écran arduino du moment. Et ce, tant au niveau de la qualité, que du prix ! J’en profiterai par ailleurs pour vous glisser un petit guide d’achat en fin d’article, afin de vous permettre de mettre le doigt sur pas mal de choses à regarder avant tout achat, pour espérer faire le meilleur choix possible.

Perso, pour mes projets électroniques, j’installe quasiment toujours un écran LCD de 4 lignes 20 caractères (modèle i2c), pour pouvoir rapidement afficher des informations, de manière bien lisible, et ce, sans avoir à trop écrire de code pour cela ! Bien entendu, chaque type d’afficheur a ses avantages et ses inconvénients, c’est pourquoi je tenais à vous en présenter ici un peu tous les modèles qui existent en électronique, pouvant communiquer en toute simplicité avec un arduino. Alors c’est parti !

Tableau comparatif

(voir la suite du tableau à droite >>>)
TypeCouleur
(écriture)
AperçuRésolutionFond
(rétroéclairage)
Liens
Afficheur lcd QUIMAT
(mon choix*)
→ écran LCDBlanc Afficheur LCD arduino couleur en I2C, disposant 4 lignes et 20 caractères blancs, rétroéclairage bleu, pour débuter facilement projet électronique 4×20 caractèresBleu
Afficheur oled AZDelivery→ écran OLEDBlanc Afficheur OLED arduino I2C avec code tutorial pour débuter électronique, pilotage via IDE ARDUINO, avec affichage clair des informations bien lumineux 128×64 pixelsNoir
Afficheur tft AZDelivery→ écran TFTMulticolore Afficheur TFT arduino tactile et couleur, avec code source pour débuter pilotage via IDE, shield Arduino UNO, avec programme informatique 320×240 pixelsNoir
Afficheur 7-segments AZDelivery→ écran 7 segmentsRouge Afficheur 7 segments arduino à 4 digits, horloge programmée IDE depuis microcontrôleur, affichage facile, début en électronique avec platine soudée 4 chiffresNoir

1 – Le meilleur écran LCD arduino (i2c)

Écran LCD Quimat : le meilleur afficheur LCD arduino I2C de 4 lignes 20 caractères, couleur blanc sur fond bleu

Prix : €

Envie de pouvoir afficher rapidement des informations sur un écran, et ce, en toute simplicité ? Alors rien de tel qu’un afficheur LCD. Oui, mais pas n’importe lequel ! Car si vous prenez un modèle qui vampirise toutes les entrées/sorties de votre arduino, ou un modèle qui est très limité en nombre de caractères, ce ne serait pas génial ! C’est pourquoi je vous propose ici de découvrir un afficheur très apprécié des internautes, tant pour sa qualité, que pour son prix mini : l’écran LCD i2C de chez QUIMAT !

Tout d’abord, il s’agit d’un écran « i2c ». C’est à dire qu’il se pilote avec 2 fils seulement, via les pins SDA et SCL de votre Arduino. Et lorsqu’on rajoute les fils d’alimentations + et -, vous avez un afficheur complet avec 4 fils à brancher uniquement (difficile de faire plus simple !). Et c’est bien là toute la force de cet écran d’ailleurs. Car il permet d’économiser des pins d’entrée / sortie sur les arduino, permettant ainsi de les laisser libre pour autre chose.

Du coup, on a un afficheur super simple à mettre en œuvre, et ce, aussi bien sur le plan physique, que sur l’aspect programmation. Car oui, sa programmation est elle-aussi super simple ! Voici d’ailleurs un exemple de programme « de base » pour afficher des infos à l’écran :

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,20,4);  // "0x27" étant l'adresse de l'afficheur sur le bus I2C

void setup() {
  lcd.init();
  lcd.backlight();

  lcd.setCursor(0, 0); lcd.print("Ligne 1");
  lcd.setCursor(0, 1); lcd.print("Ligne 2");
  lcd.setCursor(0, 2); lcd.print("Ligne 3");
  lcd.setCursor(0, 3); lcd.print("Ligne 4");
}

void loop() {
}

Comme vous le voyez, l’écriture de données à l’écran est super simple, et le codage, super rapide à faire. Au passage, sur cet écran, on peut afficher jusqu’à 20 caractères sur chaque ligne, tout en sachant qu’il comporte 4 lignes distinctes. De quoi pouvoir afficher un peu tout ce qu’on veut (ou presque !).

Il y a d’ailleurs une autre chose que j’ai particulièrement apprécié ici : l’écran n’est pas livré seul, contrairement à bon nombre de concurrents. Non, ici l’afficheur est livré avec des supports à entretoises en nylon (« isolantes »), et des fils de connexion Dupont pour pouvoir le brancher. On a donc un ensemble très complet, et prêt à fonctionner, pour ainsi dire !

Au passage, l’écriture « couleur » de cet écran est vraiment magnifique, en blanc sur fond bleu (rétroéclairage). À ce sujet d’ailleurs : n’oubliez jamais de régler le petit potentiomètre de contraste d’affichage à l’arrière, sans quoi vous pourriez croire que votre écran ne fonctionne pas. En fait, il suffit de tourner le curseur (au dos de la petite plaquette) dans un sens ou dans l’autre, afin de faire apparaître les caractères de manière bien lisible à l’écran (fonction de la luminosité ambiante). C’est tout bête, mais c’est souvent source d’inquiétudes, lorsque rien ne s’affiche à l’écran, alors que ça devrait 😉

AVANTAGES
  • Écran LCD rétroéclairé (magnifique couleur bleu)
  • Pilotage en i2c (avec 2 fils seulement)
  • Raccordement facile et rapide à effectuer (un +, un -, et 2 fils de commande se branchant sur les lignes SDA et SCL de votre arduino)
  • Écriture de couleur blanche, super lisible
  • Livré COMPLET : avec entretoise support de fixation, et fils Dupont pour branchement sur carte Arduino
  • Tension de travail : 5V (idéal, dans la plupart des cas !)
  • Dimensions ; 60 x 99 x 22 mm environ
  • Permet l’affichage de 4 lignes de 20 caractères
  • Super compact, une fois la carte i2c soudée dessous l’écran
  • Très simple à utiliser, via l’IDE Arduino (avec code de programmation vraiment léger)
  • Écran particulièrement bien noté par les internautes
  • Excellent rapport qualité prix !
INCONVÉNIENTS
  • Attention à bien régler le contraste à l’arrière de l’écran, sur la petite platine i2c. Sinon, vous pourriez croire que votre afficheur est en panne, alors qu’il n’en est rien (dommage d’ailleurs que le fabricant ne le règle pas « correctement » avant de nous l’envoyer …)

Résumé et Avis (écran d’affichage lcd 4×20 caractères arduino)

Si vous cherchez un écran arduino simple, rapide à utiliser, et pas cher, vous êtes au bon endroit ! Car c’est bien là tous les avantages des afficheurs LCD i2c, fonctionnant sur 2 fils seulement ! Du coup, il n’y a rien de plus rapide à mettre en œuvre pour afficher des infos sur un écran, depuis un arduino, tant c’est simple à câbler, et surtout, programmer. Qui plus est, cet écran est fourni avec tout le nécessaire pour qu’il repose de manière bien stable, et puisse être raccordé facilement. C’est donc un afficheur fourni complet, mais qui est surtout simple à piloter, efficace, et pas cher ! Car oui, c’est bien là l’autre avantage de ces modules intégrés, alors pourquoi s’en priver ?

2 – Le meilleur écran OLED arduino (i2c)

Écran 128×64 OLED : le meilleur afficheur OLED 0.96 pouces avec pilotage I2C, de 64 x 128 pixels (écriture en blanc)

Prix : €

Voilà bien un écran super sympa, très pratique, et surtout : passe-partout ! Qui plus est, il se commande ultra facilement, sur 2 fils seulement. Par ailleurs, il dispose d’un angle de vue à couper le souffle ! Et si je rajoute à ça qu’il suffit seulement de quelques euros pour l’avoir, ça en fait l’un des meilleurs écrans qui soient ! Mais arrêtons là avec les compliments, et voyons voir, de plus près, toutes ses caractéristiques !

Tout d’abord, il s’agit d’un écran OLED (« Organic LED »). Et si il y a bien une chose qui symbolise cette technologie, c’est la visibilité est à couper le souffle qu’il permet ! Car contrairement aux écrans LCD classiques, où il faut se mettre bien en face pour pouvoir lire correctement tout ce qui est écrit, ici c’est complètement différent. Car l’angle de vue est très étendu, tant est si bien qu’on arriverait presque à lire totalement de biais ! Quel intérêt, me direz-vous ? Eh bien, en fait, cela permet d’avoir un affichage clair des infos à l’écran, et ce, en toute circonstance (ou presque !).

Autre atout de cet afficheur : il s’agit là d’un écran graphique. Donc contrairement aux écrans LCD classiques, qui sont limités à l’affichage de quelques caractères alphanumériques, ici, on peut aller au delà, et tracer toutes les formes qu’on veut (lignes, cercles, rectangles). Et tout ceci s’affiche sur un écran faisant presque 1 pouce de diagonale, avec une résolution égale à 128 x 64 pixels. Pas si mal, pour un petit écran 😉

Mais ce qui rend encore plus intéressant cet afficheur encore ici, c’est qu’il se pilote en toute simplicité, avec deux fils seulement (à raccorder sur les pins SDA et SCL de l’Arduino). Du coup, aucune difficulté pour le brancher, et tout la « complexité » se passe en fait au niveau logiciel. Mais là encore, ce n’est pas si compliqué que ça, car les librairies gratuites pour arduino permettent de simplifier le code au maximum, rendant ainsi le tout super facile à utiliser. D’ailleurs, voici un exemple de code permettant d’afficher des informations à l’écran :

#include <U8g2lib.h>
#include <Wire.h>

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

void setup() {
  // Initialisation
  u8g2.begin();

  // Affichage de données à l'écran
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_timB10_tf) ;	// sélection d'une police de caractère
  u8g2.drawStr(0, 10, "Ligne 1");		// écriture à la position (x=0 et y=10)
  u8g2.drawStr(0, 28, "Ligne 2");	  	// écriture à la position (x=0 et y=28)
  u8g2.drawStr(0, 46, "Ligne 3");	  	// écriture à la position (x=0 et y=46)
  u8g2.drawStr(0, 64, "Ligne 4");	  	// écriture à la position (x=0 et y=64)
  u8g2.sendBuffer();		  	        // affichage de ces infos à l'écran
}

void loop() {
}

Franchement, s’en servir est un véritable jeu d’enfant, une fois qu’on a compris les commandes de base ! Et clairement, on ne peut pas faire plus petit et plus efficace, pour afficher des informations depuis un arduino ! D’autant plus que le contraste est élevé sur ce type d’affichage, qui rend au passage la lecture particulièrement facile à faire (même si tout est écrit petit, et qu’il faut avoir de bons yeux, j’avoue !).

AVANTAGES
  • Écran OLED compact et efficace !
  • Écriture très lisible, même en regardant de biais (comparé aux écrans LCD, qui ont un « faible » angle de vue)
  • Résolution de 128 x 64 pixels (écriture en blanc sur fond noir)
  • Très facile à piloter : 2 fils suffisent (pins SDA et SCL) pour le piloter (communication i2c)
  • Codage facile à faire, pour afficher des informations à l’écran
  • Taille super compacte (0,96 pouces)
  • Alimentation de 3,3 à 5 V
  • Broches de connexion pouvant être soudées devant, comme derrière
  • Super lisible, de jour comme de nuit !
  • Super bien noté par les internautes
  • Très bon rapport qualité prix !
INCONVÉNIENTS
  • Comme la taille de l’écran est petite, cela peut ne pas vous convenir si vous avez des problèmes de vue (du mal à lire les petits caractères, j’entends)
  • L’affichage est monochrome, et non multicolore, ici
  • Attention, car la librairie Arduino pour le faire fonctionner prend beaucoup de place en mémoire (ce qui peut être un peu limite avec un Uno, par exemple)

Résumé et Avis (écran d’affichage oled 128 x 64 pixels arduino)

Si vous rêviez d’un écran discret, pratique, et pas cher, rien de tel que cet écran OLED i2C pour ce faire ! Car mesurant à peine un pouce de diagonale, et ayant une résolution de 64 x 128 pixels, cet afficheur arduino est certainement ce qui se fait de plus compact et de plus efficace, pour afficher des informations rapidement sur un écran. Par ailleurs, son pilotage depuis un Arduino étant hyper simple, c’est franchement le type d’afficheur rêvé, surtout qu’il est assez facile à prendre en main. En somme, c’est un afficheur simple, facile à utiliser, et rapide à mettre en œuvre. Alors que demander de mieux ?

3 – Le meilleur écran TFT arduino

Écran tactile TFT : le meilleur afficheur TFT couleur tactile de 2,4 pouces, avec stylo Touch Screen, faisant 240 x 320 pixels en multicolore

Prix : €€

À la recherche d’un écran graphique tactile et couleur pour votre Arduino ? Et tout ça sans avoir à vous ruiner ? Alors vous aimerez à coup sûr ce shield pour Arduino Uno, pouvant être utilisé dans bien des domaines. Car ici, on peut afficher vraiment tout ce qu’on veut, avec un maximum de couleurs, et même interagir avec l’écran ! Et ça, c’est tout simplement génial ! Qui plus est, sa taille idéale rend la lecture bien plus agréable ici, comparé aux petits écrans OLED, et son aspect compact lui permet une intégration complète dans son environnement. Tout ça, bien sûr, sans parler de sa programmation, qui elle est aussi facilité, de par la présence de librairies gratuites sur internet, pour s’en servir. Alors voyons tout cela d’un peu plus près 😉

Le premier avantage de cet écran est sans conteste son aspect tactile. Car cela permet de pouvoir interagir en toute simplicité avec l’arduino, sans avoir à passer par des boutons poussoirs ou autre. On gagne ainsi énormément de temps et d’argent, car tout est intégré à l’écran. Qui plus est, on peut du coup réaliser de superbes « interface homme machine » (IHM), et rendre ses projets bien plus sympa, et vivant !

Le second avantage ici est de disposer d’un affichage couleur. Car c’est bien ce qu’on pourrait reprocher aux afficheurs courants, qui sont monochromes la plupart du temps (ce qui limitent grandement ce que l’on veut faire ressortir à l’écran). Or, ici, ce sont pas moins de 262 000 nuances de couleurs qu’on peut faire apparaître avec ce type d’écran, de quoi faire à peu près tout ce qu’on veut !

Autre atout : cet écran TFT se commande en toute simplicité, grâce aux librairies déjà développées pour Arduino, et présentes un peu partout sur le web. D’ailleurs, pour l’illustrer, voici un exemple de code que j’ai pu faire, pour afficher la position X et Y de l’endroit où on appuie sur l’écran (ce qui permet d’envisager ensuite la création de boutons « cliquables » sur l’écran en lui-même) :

// Importation des librairies
#include <Adafruit_GFX.h>
#include <Adafruit_TFTLCD.h>
#include <TouchScreen.h>

// Définition des pins de l'écran TFT (ici shield)
#define LCD_CS A3
#define LCD_CD A2
#define LCD_WR A1
#define LCD_RD A0
#define LCD_RESET A4

// Définition des couleurs principales
#define BLACK       0x0000
#define BLUE        0x001F
#define RED         0xF800
#define GREEN       0x07E0
#define CYAN        0x07FF
#define MAGENTA     0xF81F
#define YELLOW      0xFFE0
#define WHITE       0xFFFF
#define ORANGE      0xFD20
#define GREENYELLOW 0xAFE5
#define NAVY        0x000F
#define DARKGREEN   0x03E0
#define DARKCYAN    0x03EF
#define MAROON      0x7800
#define PURPLE      0x780F
#define OLIVE       0x7BE0
#define LIGHTGREY   0xC618
#define DARKGREY    0x7BEF

// Définition des orientations possibles pour l'écran TFT
#define PORTRAIT_1 0        // Bouton reset en BAS (par défaut)
#define PORTRAIT_2 2        // Bouton reset en HAUT
#define PAYSAGE_1 1         // Bouton reset à DROITE
#define PAYSAGE_2 3         // Bouton reset à GAUCHE

// Définition des pins pour le TOUCHSCREEN
#define XM A3   // x en abcisse, et y en ordonnées (avec 0,0 en bas à gauche)
#define YP A2
#define XP 9
#define YM 8

// Calibration TOUCHSCREEN
#define TS_MINX 140
#define TS_MAXX 950

#define TS_MINY 110
#define TS_MAXY 910

// Initialisation de l'écran TFT, avec son TouchScreen
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

void setup() {
  // Démarrage du monitoring sériel
  Serial.begin(9600);
  Serial.println("Démarrage de l'application en cours ...");

  // Démarrage de l'écran TFT
  tft.reset();
  tft.begin(tft.readID());
  tft.fillScreen(BLACK);
  tft.setRotation(PAYSAGE_1);

  // Affichage d'un texte
  tft.setTextColor(YELLOW);
  tft.setCursor(0, 0);             // x horizontal  ... y vertical   (ici 0,0 est l'angle en HAUT à GAUCHE, et on écrit vers le bas)
  tft.setTextSize(2);
  tft.println("JT");

  // Set par défaut pour la suite
  tft.setTextColor(MAGENTA);
  tft.setTextSize(2);

  // Fin du setup
  Serial.println("Setup terminé.");
}

void loop() {
  // Trouve le point touché
  // ... pour rappel, ici, on a le (0,0) en bas à gauche, avec x en abcisse, et y en ordonnées
  TSPoint p = ts.getPoint();

  // On quitte le mode TOUCHSCREEN et on passe sur l'écran TFT
  pinMode(XM, OUTPUT);
  pinMode(YP, OUTPUT);
  
  if (p.z > ts.pressureThreshhold) {
    // Effaçage des anciennes valeurs affichées (position X/Y)
    tft.fillRect(90, 100, 130, 16, BLACK);  // x,y,width,lenght,color

    // Remise à l'échelle TS->TFT
    // et pour rappel, on veut : (0,0) en haut à gauche, avec x en abcisse, et y en ordonnées
    int x = map(p.x, TS_MAXX, TS_MINX, tft.width(), 0);
    int y = map(p.y, TS_MINY, TS_MAXY, tft.height(), 0);
    
    // Afficharge de la position en milieu d'écran
    tft.setCursor(90, 100);
    tft.print("X="); tft.print(x);
    tft.print(",Y="); tft.println(y);

    /* 
    // Si besoin d'afficher les valeurs du TS  
    Serial.print("X = "); Serial.print(p.x);
    Serial.print("\tY = "); Serial.print(p.y);
    Serial.print("\tPressure = "); Serial.println(p.z); */
  }

  delay(100);
}

N’ayez pas peur de la « longueur » du code, car en fait, le coeur même de l’affichage n’est pas si lourd que ça, une fois qu’on a bien compris son fonctionnement. Ah oui, au passage, voici un aperçu de ce que ce programme donne à l’écran, en vidéo (désolé pour la qualité, qui elle, n’est pas géniale !) :



Bien sûr, on peut tout imaginer ici, avec pour seules limites celles de son imagination (ou presque !). Par ailleurs, bien que le circuit imprimé de ce shield soit prévu pour s’embrocher sur un Arduino Uno, rien n’empêche de s’en servir avec d’autres arduino. Ainsi, imaginez tous les projets qu’on pourrait faire avec ! Par contre, il faudra faire un peu d’adaptation pour ce faire, et de patience pour le maîtriser, bien évidemment 😉

AVANTAGES
  • Écran TFT couleurs (262000 nuances de couleurs différentes, pour être précis !)
  • Surface tactile intégrée, et stylet inclus (bien plus efficace que les doigts !)
  • Taille confortable, de 2.4 pouces en diagonales
  • Résolution de 240 x 320 pixels (utilisable en mode PORTAIT ou PAYSAGE, via la programmation)
  • Pilotage de l’afficheur ultra facile avec un Arduino (communication SPI entre le contrôleur ILI9341 et l’arduino)
  • Lisibilité vraiment remarquable, pour ce type d’écran
  • Permet aussi bien l’affichage de texte, que de graphiques ou d’images
  • Compatible 3,3 et 5 volts
  • Sensibilité de l’écran tactile vraiment au top (ni trop sensible, ni pas assez)
  • Très apprécié des internautes !
  • Rapport qualité prix tout simplement excellent !
INCONVÉNIENTS
  • Un seul reproche à lui faire, une fois monté sur un Arduino Uno : il ne reste plus vraiment de broches disponibles pour faire autre chose. Dommage …
  • La programmation est évidemment un peu plus lourde, pour faire afficher des infos dessus. Mais ça reste à mettre en rapport avec les immenses possibilités qu’il permet d’envisager !

Résumé et Avis (écran d’affichage tft 320 x 240 pixels arduino)

Si vous étiez à la recherche d’un écran couleur qui soit à la fois tactile et pas cher, vous ne pouviez pas tomber mieux ! Car cet afficheur répond exactement à cela ! Mais c’est surtout le potentiel et les possibilités multiples qu’offrent ce type d’afficheur qui est extraordinaire. Car on peut tout imaginer ici : des boutons tactiles pour interagir avec son programme informatique, des affichages de valeurs sous toutes les formes (jauges de températures, compte-tours, …), des affichages de menus à plusieurs niveaux, … enfin bref, sans limite ou presque ! Et tout cela, pour une poignée d’euros seulement. Alors pourquoi s’en priver, surtout que cela peut rendre ses projets électroniques bien plus vivants !

4 – Le meilleur écran 7 SEGMENTS arduino

Écran 7 segments AZ-DELIVERY : le meilleur afficheur 7 SEGMENTS à 4 chiffres, pour Arduino (4 digits de couleur rouge)

Prix : €€€

Il y a des fois où n’a pas besoin d’un afficheur super sophistiqué, pour afficher des valeurs. Surtout lorsqu’on débute en électronique, et qu’on ne maîtrise pas encore la programmation sous l’IDE Arduino. C’est là où les afficheurs 7 SEGMENTS trouvent leur intérêt : pouvoir faire un affichage simple de valeurs, et ce, sans avoir à faire du codage lourd (ni à trouver des librairies très spécialisées, pour s’en servir !). Pour illustrer tout cela, voici un bloc d’affichage à 7 segments, sur 4 digits (quatre chiffres) : idéal pour afficher des valeurs numériques (0 à 9 donc), mais aussi des lettres (a, b, c, d, e, ou f). Les applications sont d’ailleurs multiples : faire une horloge, un compteur/décompteur d’évènement, un chronomètre, … enfin, plein de choses quoi ! D’ailleurs, voyons le en détail sans plus attendre.

Concernant l’afficheur en lui-même, on trouve 4 digits en façade, avec un double point au milieu. Tout ceci se commande en i2c, c’est à dire via 2 fils seulement, branchés sur l’arduino (mais pas n’importe où, comme vous pourrez le voir, dans l’exemple qui suit). Au niveau code de programmation, il suffit d’installer la librairie « TM1637 » dans votre IDE Arduino, et le tour est joué. Car la programmation en elle-même est vraiment simple. Voici d’ailleurs un exemple permettant d’afficher « 12:34 » à l’écran (j’aurais pu être plus créatif, je vous l’accorde !) :

#include <TM1637.h>

int CLK = 2;
int DIO = 3;

TM1637 tm(CLK,DIO);

void setup() {
  tm.init();  // Initialisation de l'afficheur
  tm.set(2);  // Paramétrage de la luminosité (réglable de 0 à 7)
}

void loop() {
  // exemple d'affichage: "12:34"
  tm.display(0,1);   // affiche le chiffre "1" sur le digit 0
  tm.display(1,2);   // affiche le chiffre "2" sur le digit 1
  tm.point(1);       // fait éclairer les ":" du milieu
  tm.display(2,3);   // affiche le chiffre "3" sur le digit 2
  tm.display(3,4);   // affiche le chiffre "4" sur le digit 3
}

Clairement, on peut difficilement faire plus simple ! Mais pour tout ceux qui voudraient approfondir l’utilisation de cet afficheur, je vous mets un lien vers un tutoriel expliquant comment se servir de cet écran 7 segments (en anglais), ainsi qu’une vidéo vous montrant un peu ses possibilités (en anglais aussi, en espérant que ça ne rebute pas trop certains d’entre vous, du fait que ce ne soit pas en français !).



En fait, je n’ai pas grand chose à dire de plus ici, car les bibliothèques disponibles sur l’IDE Arduino permettent de se servir de cet afficheur avec grande simplicité. Bien entendu, l’affichage en lui même sera limité aux chiffres « 0 à 9 », et aux lettres « a à f » (avec en prime des « : » au milieu, si vous souhaitez transformer cet afficheur en horloge !). Mais compte tenu du prix, ça reste un super afficheur pour arduino !

AVANTAGES
  • Écran 7 segments, pilotable avec 2 fils seulement
  • Permet d’afficher des chiffres de 0-9 et des lettres de a-f, en toute simplicité
  • Pilotage simple et rapide, via un Arduino
  • Très facile à mettre en œuvre, du fait du nombre de fils réduits à brancher, et du codage, qui est facile à appréhender
  • Affichage de couleur rouge (intensité réglable depuis votre programme informatique)
  • Idéal pour débuter en électronique, ou avec un arduino
  • Alimentation en 5 volts
  • Réglage de la luminosité directement via le code de programmation
  • Dimensions compactes (L x h x p : 41 mm x 23 mm x 11 mm, environ)
  • Particulièrement facile à dompter, via les nombreuses librairies et tutos disponibles sur internet (puce TM1637)
  • Vraiment bien noté par les internautes
  • Super rapport qualité prix !
INCONVÉNIENTS
  • Attention : gardez bien à l’esprit ici qu’on est limité à l’affichage des chiffres de 0 à 9, et des lettres « a à f », rien de plus !

Résumé et Avis (écran d’affichage 4 chiffres 7 segments arduino)

Si vous n’avez que quelques chiffres à afficher à l’écran, ou que vous vouliez faire du comptage, décomptage, ou chronométrage, rien de tel que cet écran 7 segments pour arduino. Car il est vraiment pas cher, et super facile à utiliser, avec quelques lignes de code seulement pour le piloter. Par ailleurs, le réglage de la luminosité peut même se faire de manière logicielle, via le programme arduino. Du coup, cela fait de cet afficheur un des écrans les plus simples et rapides à mettre en œuvre pour quelques euros seulement, idéal pour les débutants en électronique ou avec Arduino !

Écran I2C oled pour débutant en électronique, projet avec arduino, code de programmation IDE, logiciel exemple programme facile affichage simple

Comment choisir son afficheur arduino – Guide d’achat

Vous avez certainement dû vous en rendre compte : c’est difficile de s’y retrouver sur internet, tant il y a d’offres disponibles, sous toutes les formes, et à tous les prix ! Et les écrans pour arduino ne dérogent pas à cette règle. Car on en trouve partout, de tous les styles, et à tous les prix. Aussi, afin d’y voir plus clair, je vais essayer de vous détailler un maximum les points importants à scruter avant tout achat, afin de pouvoir vous guider du mieux possible lors de vos prochains achats. Bien entendu ici, il n’y a pas de mauvais choix en soi. Mais il s’agit tout de même d’acheter ce qui correspond réellement à ses besoins, et ne pas acheter un écran trop sophistiqué, qui serait du coup trop lourd à gérer ! Alors c’est parti 😉

Lire aussi : les meilleurs livres sur la programmation Arduino, pour bien débuter en électronique, dans le monde des microcontrôleurs !

Écran alphanumérique VS Écran graphique

La première question à vous poser, est de savoir si vous souhaitez afficher beaucoup d’informations à l’écran, ou pas. Car très rapidement, les écrans alphanumériques, qu’ils soient LCD ou à 7 SEGMENTS, montrent leur limite. Quand bien même vous pourriez organiser vos affichages sous forme de « menus imbriqués », la limite d’information affichable sur un seul écran est assez réduite. Du coup, posez-vous la question du volume d’informations que vous souhaitez afficher à l’écran. De là, vous pourrez déjà vous orienter vers telle ou telle technologie d’afficheur.

Par ailleurs, la différence entre écran graphique et écran alphanumérique est par définition la possibilité d’aller au delà du simple affichage de simples caractères. Car, avec un écran graphique, on peut afficher tout plein d’éléments graphiques (traits, cercles, rectangles, images, photos, …), alors qu’un écran alphanumérique serait limité à l’affichage de quelques caractères ou symboles seulement. D’où l’importance de bien réfléchir à vos besoins avant tout achat, mais en gardant à l’esprit qu’un écran graphique sera bien plus compliqué à piloter via arduino, qu’un simple écran alphanumérique !

Taille d’écran

Autre point important : la taille de l’écran dont vous aurez besoin. Et si je vous parle de ça ici, ce n’est pas pour rien ! Car certains afficheurs paraissent magnifiques en photo, mais une fois en main, ils se trouvent être ridiculement petits ! Je pense notamment aux écrans OLED, comme celui que je vous ai présenté plus haut. Car certes, ces modèles ont de très nombreux avantages, mais croyez-moi, si vous avez du mal à lire les petits caractères, vous allez vite en vouloir un plus gros ! C’est pourquoi, je vous recommande de jeter un coup d’œil aux différentes tailles d’écran qui existent, avant d’acheter quoi que ce soit.

Généralement, les écrans LCD permettent une lecture claire et aisée des infos affichées dessus (en terme de taille de caractères, j’entends). Il en va de même pour les afficheurs 7 SEGMENTS, qui sont plus gros, et par conséquent, mieux lisibles (même à distance).

Par contre, encore une fois, on trouve pas mal d’écrans graphiques de petite taille (mesurant moins d’un pouce), et sur lesquels il est parfois difficile d’arriver à bien lire tous les petits caractères. Non pas que l’écran soit de mauvaise qualité, bien au contraire, mais plutôt parce que l’écriture est souvent très petite ! Ainsi, je vous conseille de bien regarder les tailles d’écrans qui vous plaisent avant d’acheter tel ou tel modèle, afin de ne pas regretter votre achat par la suite 😉

Résolution d’affichage

Au delà des différentes tailles d’écrans, la résolution d’affichage est tout aussi importante. Car c’est elle qui va déterminer ce que vous allez pouvoir clairement afficher dessus.

Sauf exception, la résolution d’affichage est toujours exprimée en pixel. Ainsi, pour définir la résolution d’un écran, vous trouverez des dimensions spécifiées de la manière suivante : « 64×128 », « 320×240 », « 800×600 », etc. Il s’agit en fait du nombre de pixel que vous aurez de disponible en hauteur, et en largeur. Au passage, ne faites pas attention à l’ordre de ces nombres. Car « 128×64 » est la même chose que « 64×128 ». C’est juste que dans un cas l’écran est mesuré en format « paysage », et de l’autre, au format « portrait ».

Bien évidemment, plus vous aurez une résolution qui sera grande, et plus vous pourrez afficher d’informations, OU, les faire afficher en plus gros. C’est d’ailleurs le gros avantage de ces grands écrans ! Par contre, ne vous réjouissez pas trop vite. Car plus on monte en résolution, plus la programmation se complique, et plus le prix grimpe vite, lui aussi. Il s’agit donc de trouver le juste milieu, entre vos besoins, le budget que vous pensez y mettre, et l’espace de mémoire disponible que vous avez pour stocker votre programme et les librairies servant à faire fonctionner ces écrans 😉

Monochrome ou multicolore ?

Question bête : souhaitez-vous avoir un affichage à une seule couleur, comme c’est le cas les écrans LCD, ou à couleurs multiples, tels qu’on en voit sur les écrans TFT ? Car là aussi, la technologie d’afficheur que vous allez choisir va conditionner les possibilités que vous allez pouvoir faire avec. Aussi, si vous souhaitez afficher un texte en rouge sur l’écran, au milieu d’autres infos moins importantes, seuls des écrans OLED multicolores ou TFT pourront convenir. À l’inverse, si vous n’avez pas besoin de multiples couleurs, alors autant ne pas s’embarrasser avec ! Car cela ne ferait qu’alourdir votre code !

Une chose importante à noter : quand on parle d’écran monochrome, cela ne veut pas dire que tout sera blanc ou noir, et qu’il n’y aura aucune couleur. Car on peut parfois « tricher » ! Par exemple, si on prend un écran LCD à fond rétroéclairé en bleu, l’écriture en blanc dessus va faire ressortir cette magnifique couleur, et donner beaucoup plus de vie à vos projets. Mon conseil : ne partez pas sur des afficheurs trop compliqués, sauf si vous en avez réellement le besoin, car non seulement cela va vous compliquer la tâche au niveau de la programmation, mais aussi peut-être, vous revenir plus cher (suivant la taille d’écran que vous prenez). Dans tous les cas, prenez votre temps avant tout d’achat d’écran, quel qu’il soit !

Communication parallèle, ou série (SPI, i2C, …)

Vous verrez souvent plusieurs type de moyens de communication possibles, pour piloter les écrans pour arduino. Mais pour faire simple, on peut les classer en deux catégories principales, suivant le type de communication employé.

  • le plus « ancien » reste la connexion parallèle : les données sont diffusées en même temps sur 4, 8, ou plus de bits. L’avantage est sans conteste la rapidité, mais l’inconvénient majeur reste que cela nécessite beaucoup plus d’entrées/sorties pour communiquer, ce qui peut vite être handicapant. Car sur des petits projets comme ceux avec Arduino, on a vite fait de vampiriser toutes les pins.
  • le plus « économique » reste la connexion série. Ici, les données sont envoyées bit par bit, sur 2 fils généralement. L’avantage indéniable est l’économie de broches pour le câblage de ce type d’afficheur, et son inconvénient, bien entendu, sera sa lenteur (car on envoie toutes les données une par une …)

Mais clairement, ces dernières années, les écrans à connexion parallèle tendent à disparaître, au profit des écrans à connexion série. Car leur handicap majeur est celui de monopoliser trop de broches d’entrées sorties des microcontrôleurs. Du coup, les écrans à connexion série sont de plus en plus présents, car plus « économiques ». Car généralement, deux ou trois fils seulement suffisent pour piloter l’intégralité de l’afficheur (je pense aux modèles I2C et SPI), et clairement, ils ont l’avantage de ne pas surcharger les ports d’entrées sorties des microcontrôleurs. Par ailleurs, le prix des afficheurs série est désormais assez proche des afficheurs parallèles, de quoi enfoncer le clou un peu plus vers la communication série !

Du reste, la communication série se fait généralement via deux types de protocoles :

  • I2C, via les pins SDA et SCL des arduinos (et parfois sur d’autres broches, où l’i2c peut être émulé)
  • SPI, via les pins MISO, MOSI, et SCK des arduinos (avec parfois en plus une broche supplémentaire pour le SS)

Pour ma part, je vous conseille plutôt de partir sur des écrans série, type i2c, afin d’avoir une solution simple et rapide à mettre en œuvre (d’autant plus qu’aujourd’hui, la complexité logicielle est fortement allégée de par la présence de librairies toutes prêtes pour interagir avec tel ou tel contrôleur d’affichage !).

Tension d’alimentation

Juste un mot sur la tension d’alimentation, car tous les projets ne sont pas forcément alimentés de la même manière. En effet, usuellement, la tension d’alimentation des platines électronique est souvent 5 volts. Mais quelque fois, elle peut être différente. Je pense notamment aux ESP32, qui sont de plus en plus présents de nos jours, et qui travaillent en 3,3 volts. Du coup, vérifiez bien que l’écran que vous envisagez d’acheter soit bien compatible avec les signaux 3,3 ou 5V de votre microcontrôleur, afin de ne pas acheter un afficheur qui serait inutilisable dans votre cas !

Dernier point, concernant le courant d’alimentation, cette fois-ci. Faites attention à prévoir une alimentation « spécifique » pour vos écrans, si nécessaire, car les courants d’utilisation peuvent parfois être élevés (en tout cas, plus élevés que ce qu’un microcontrôleur pourrait fournir, avec tout plein d’autres périphériques raccordés en même temps dessus). Aussi, gardez bien à l’esprit que certains rétroéclairages d’afficheur peuvent être énergivores, et donc, qu’il sera nécessaire de les alimenter via des pistes de bonne taille (si vous réalisez vous-même vos PCB, j’entends).

Écran tactile arduino avec stylet pour projet électronique simple et facile, code de programmation exemple, programme informatique

Quel est le meilleur écran arduino ?

Les meilleurs écrans et afficheurs pour Arduino sont selon moi :

(voir la suite du tableau à droite >>>)

Remarques

Faites très attentions aux brochages des différents afficheurs, et de leurs tensions d’alimentation (et la compatibilité des signaux de communication). Car certains peuvent par exemple fonctionner en 3,3 volts, tandis que d’autres auront besoin de 5 volts. De même, certains auront besoin de se brancher sur un port I2C ou SPI, tandis que d’autres pourront se connecter sur les entrées ou sorties digitales, avec une émulation sérielle. Dans tous les cas, vérifiez bien l’adéquation de l’écran que vous envisagez d’acheter, avec ce qui va le piloter (votre microcontrôleur, par exemple !).

Conclusion

Nous voici au terme de ce petit article sur les différents types d’écrans arduino, ou plus exactement, ceux qu’on trouve le plus couramment sur le marché. N’hésitez pas à compléter ces infos avec toute la riche littérature qu’on trouve sur internet, et les nombreuses vidéos tuto qu’on trouve sur YouTube, qui pourront aussi grandement vous aider.

Pour ma part, j’équipe quasiment toujours mes platines électroniques d’un écran LCD i2C 4×20 caractères (rétroéclairage bleu), car cela me permet d’afficher rapidement des informations, en toute simplicité, en gros caractère, et pour pas cher ! Bien entendu, à chaque projet son écran. Donc à vous de trouver celui qui vous conviendra le mieux, selon vos besoins !

(*) Article mis à jour le 17/11/2020

You cannot copy content of this page