Tutoriel Arduino/NodeMCU d'affichage OLED I2C : 15 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Le tout premier programme que vous écrivez lorsque vous commencez à apprendre un

nouveau langage de programmation est: "Hello World!".

Le programme lui-même ne fait rien de plus qu'imprimer un texte "Hello World" sur l'écran.

Alors, comment faire en sorte que notre Arduino affiche le "Hello World!"?

Dans cette vidéo, je vais vous montrer comment démarrer avec les petits écrans OLED I2C 0.91 (128x32) et 0.96 (128x64).

Il existe des centaines de tutoriels sur le Web expliquant la même chose de différentes manières, mais je n'en ai pas trouvé qui me dise tout sur l'écran OLED et comment l'utiliser dans différents scénarios. Il m'a fallu du temps pour tout comprendre. J'ai donc pensé que je devrais créer un tutoriel sur ce que j'ai appris et combiner toutes les fonctionnalités et les façons dont les écrans OLED peuvent être utilisés dans nos projets.

Étape 1: Ce que nous allons apprendre aujourd'hui

Dans cette vidéo nous parlerons de:

- Qu'est-ce qu'un écran OLED ?

- Ensuite, nous examinerons de plus près les écrans OLED I2C 0.91 (128x32) et 0.96 (128x64)

- Ensuite, nous parlerons de l'installation de la bibliothèque Adafruit sur votre IDE Arduino

- Ensuite, nous allons connecter NodeMCU et Arduino à un écran OLED

- Ensuite, nous examinerons le code et afficherons des graphiques et du texte dessus

- Nous parlerons également de l'application de polices personnalisées et de l'affichage d'images

- Ensuite, nous allons connecter plusieurs OLED à un micro-contrôleur à l'aide du multiplexeur I2C

- Enfin, nous parlerons de quelques erreurs courantes que les gens commettent lors de l'utilisation des écrans OLED

Étape 2: Configuration matérielle requise

Pour ce tutoriel, nous avons besoin de:

- Une planche à pain

- Un écran OLED I2C 0.91" (128x32) et 0.96" (128x64)

- Arduino UNO/NANO (ce qui est pratique)

- NodeMCU

- Multiplexeur TCA9548A I2C

- Peu de câbles de connexion

- et un câble USB pour télécharger le code

Étape 3: Qu'est-ce qu'un écran OLED ?

OLED ou diode électroluminescente organique est une diode électroluminescente

diode (DEL) dans laquelle la couche électroluminescente émissive est un film de composé organique (des millions de petites lumières DEL) qui émet de la lumière en réponse à un courant électrique.

Les OLED sont utilisées pour créer des affichages numériques dans des appareils tels que des écrans de télévision, des moniteurs d'ordinateur, des systèmes portables tels que des téléphones portables, des consoles de jeux portables et des PDA. Un écran OLED fonctionne sans rétroéclairage car il émet de la lumière visible.

Étape 4:

Il existe de nombreux types d'écrans OLED disponibles dans le

marché en fonction de leur

- Tailles

- Couleur

- Marques

- Protocole

- SPI (Serial Peripheral Interface) ou I2C

- Schéma de contrôle à matrice passive (PMOLED) ou à matrice active (AMOLED)

Dans ce tutoriel, je vais parler de la connexion du

couleur bleue 0.91 (128x32 OLED) et 0.96 (128x64 OLED) I2C OLDE s'affiche sur un Arduino NANO et NodeMCU. La technologie de bus I2C n'utilise que 2 broches du MCU, nous avons donc des tas disponibles pour d'autres capteurs.

Étape 5: Regardez de plus près

Voyons ces deux écrans de plus près.

À l'arrière de ces écrans, il y a des tas de condensateurs et de résistances SMD soudés à bord; mais, puisque c'est un appareil I2C, nous ne nous soucions que de ces 2 broches (SCL et SDA)

L'écran se connecte à Arduino en utilisant seulement quatre fils - deux pour l'alimentation (VCC et GND) et deux pour les données (horloge série SCL et

données série SDA), ce qui rend le câblage très simple. La connexion de données est I2C (I²C, IIC ou Inter-Integrated Circuit) et cette interface est également appelée TWI (Two Wire Interface).

- Les broches intégrées peuvent être dans un ordre différent, alors vérifiez toujours trois fois avant de les connecter à votre projet.

- La tension de fonctionnement est comprise entre 3v et 5v, mais il est préférable d'utiliser les conseils de la fiche technique du fabricant.

- Parfois, nous devons utiliser 2 écrans dans nos projets. Alors, comment pouvons-nous y parvenir?

L'astuce est d'avoir une adresse configurable sur votre écran. Cette unité a une adresse configurable entre 0x78 et 0x7A. Juste en dessoudant la résistance 0Ohm d'un côté et en la raccordant de l'autre côté ou simplement en mettant une soudure globale, nous pouvons changer l'adresse. Nous en parlerons en détail lorsque nous connecterons plusieurs écrans à un Arduino dans la dernière section de ce didacticiel.

Sur la photo, ces écrans ont l'air très grands. Mais, pratiquement parlant, ils sont minuscules. Ils sont constitués de 128 x 32/64 pixels OLED individuels et ne nécessitent aucun rétro-éclairage. Jetez un coup d'œil à cela et voyez à quel point c'est petit. Même s'ils sont petits, ils peuvent être très utiles dans tous les projets électroniques.

Étape 6: Bibliothèque

Il existe plusieurs bibliothèques disponibles pour contrôler ces

affiche. Dans le passé, j'ai utilisé la "bibliothèque u8glib" mais je trouve la bibliothèque AdaFruit très facile à comprendre et à utiliser dans nos projets. Je vais donc utiliser la bibliothèque AdaFruit dans ce tutoriel.

Pour contrôler l'écran OLED, vous aurez besoin de la bibliothèque "adafruit_GFX.h" et de la bibliothèque "adafruit_SSD1306.h".

Il existe deux façons de télécharger et d'installer la bibliothèque sur votre IDE Arduino.

Méthode 1

Allez dans le "Gestionnaire de bibliothèque" et recherchez "adafruit_SSD1306" et "adafruit_gfx"

Sélectionnez la dernière version et cliquez sur le bouton Installer.

Une fois installé, vous pouvez utiliser ces bibliothèques dans votre programme.

Méthode 2

Ces deux bibliothèques peuvent également être téléchargées depuis github (vous avez besoin des deux):

Je vais fournir les liens dans la description ci-dessous.

La bibliothèque d'affichage:

La bibliothèque GFX:

Une fois téléchargé, copiez le dossier Adafruit_SSD1306-master du fichier compressé téléchargé dans le dossier des bibliothèques Arduino. Ce dossier se trouve généralement dans Documents > Arduino > bibliothèques sur les systèmes Windows. Sous Linux, il se trouve généralement dans le dossier d'accueil > Arduino > bibliothèques. Enfin, dans le dossier de la bibliothèque Arduino, renommez le dossier Adafruit_SSD1306-master en Adafruit_SSD1306. Même si vous ne renommez pas, c'est très bien.

Étape 7:

Maintenant, regardons le "Adafruit_SSD1306.h"

déposer

Deux choses que nous devons savoir dans cette bibliothèque:

1. Si vous souhaitez utiliser le plus petit affichage, utilisez le 128_32 par défaut, sinon pour le plus grand affichage, commentez le 128_32 et décommentez le 128_64

2. Si vous avez soudé l'adresse 0x7A sur la carte (dont nous parlerons plus tard), utilisez l'adresse 0x3D 7 bits pour les plus grands écrans, sinon utilisez l'adresse 0x3C par défaut. Pour les écrans plus petits, l'adresse est 0x3C.

Étape 8: Câblage des OLED 128 X 64/32

Commençons par connecter le NodeMCU à l'écran.

La première et la plus importante chose à noter est que certains des écrans peuvent avoir les broches d'alimentation GND et VCC interverties. Vérifiez votre écran pour vous assurer qu'il est identique à l'image. Si les broches sont permutées, assurez-vous de modifier les connexions à l'Arduino ou au NodeMCU.

- Câblage OLED NodeMCU

OLED VCC - NodeMCU 3.3V

OLED GND - NodeMCU GND

OLED SCL – NodeMCU D1

OLED SDA – NodeMCU D2

- Câblage Arduino Uno OLED

OLED VCC – Arduino 5V

OLED GND – Arduino GND

OLED SCL – Arduino Uno A5

OLED SDA – Arduino Uno A4

- Câblage OLED Arduino MEGA 2560

OLED VCC – Arduino 5V

OLED GND – Arduino GND

OLED SCL – Arduino MEGA 2560 broche 21

OLED SDA – Arduino MEGA 2560 broche 20

Étape 9: Coder

La bibliothèque Adafruit est livrée avec de très bons exemples pour les deux

Écrans 128x32 et 128x64.

La bibliothèque se trouve sous Fichier > Exemples > Adafruit SSD1306 > puis le type d'affichage dans l'IDE Arduino.

Nous allons utiliser l'exemple 128x32 I2C et le modifier pour qu'il fonctionne à la fois avec les écrans 128x64 et 128x32 en le connectant à un Arduino puis à une carte NodeMCU.

Le code commence par inclure les deux bibliothèques Adafruit. Dans ce tutoriel, je vais insister uniquement sur les parties du code qui nous sont nécessaires pour charger à la fois les cartes et les écrans. Si vous souhaitez en savoir plus sur le code, veuillez laisser un commentaire sur mon blog ou dans la section commentaires ci-dessous et je m'efforce de vous répondre.

- Nous allons d'abord charger le code sur un Arduino Nano connecté à un écran 128x32.

Nous pouvons utiliser le code tel quel sans aucune modification.

128x32 utilise l'adresse 0x3C, donc ce bit a l'air bien ici, permet de vérifier la bibliothèque d'en-tête, oui, il utilise également l'adresse 0x3C et le type d'affichage est 128x32.

- Connectons maintenant l'écran 128x64. Comme nous le savons, il utilise l'adresse 0x3C par défaut, nous n'avons donc pas besoin de mettre à jour l'adresse dans le code ou la bibliothèque.

Nous avons juste besoin de commenter le 128_32 et de décommenter le 128_64 dans la bibliothèque d'en-tête et de changer LCDHEIGHT en 64 dans notre code.

- Maintenant, pour exécuter le même code sur un NodeMCU, nous devons modifier une ligne supplémentaire dans notre code.

Le reste du code "#define OLED_RESET 4" > "#define OLED_RESET LED_BUILTIN" est identique à Arduino

À peu près pour afficher tout ce que nous devons d'abord effacer l'écran précédent en utilisant

display.clearDisplay(); // Vide le tampon

Puis dessinez l'objet

ligne de test(); // Tracer une ligne

Montrez-le sur le matériel

display.display(); // Rendez-les visibles sur le matériel d'affichage !

Attendez un peu avant d'afficher l'élément suivant.

retard (2000); // Attendre 2 secondes

Dans cet exemple, nous affichons quelques éléments tels que du texte, des lignes, des cercles, du texte défilant, des triangles, etc. Allez-y et utilisez votre imagination et affichez ce que vous voulez sur ces petits écrans.

Étape 10: personnalisation du texte et ajout d'images

Parfois, votre code doit afficher des polices personnalisées et

images. Si vous êtes très bon en mappage de bits, il vous suffit de créer un tableau d'octets en allumant ou en éteignant les minuscules LED de l'écran pour créer des polices et des images personnalisées.

Cependant, je ne suis pas très doué pour faire ces mappages et je ne veux pas passer des heures à créer les tables de bitmap.

Alors, quelles sont mes options? J'utilise généralement deux sites Web pour générer des polices et des images personnalisées. Les liens sont fournis dans la description ci-dessous.

Polices personnalisées

Accédez au site Web du convertisseur de polices, sélectionnez la famille de polices, le style, la taille, la version de la bibliothèque en tant que "Police Adafruit GFX", puis appuyez sur le bouton "Créer". Sur le côté droit de cette page, vous pouvez voir à quoi ressemblera votre police sur l'affichage réel.

En fonction de votre sélection, la page Web génère le fichier d'en-tête des polices. Créez un fichier appelé "modified_font.h" dans le même dossier où se trouve votre code et copiez et enregistrez le code généré dedans. Ensuite, il vous suffit d'inclure le fichier d'en-tête dans votre code pour utiliser la police personnalisée.

#include "modified_font.h"

Ensuite, il vous suffit de définir la police avant d'afficher le texte pour lui appliquer la police personnalisée.

display.setFont(&Your_Fonts_Name);

Vous pouvez obtenir le nom de la police à partir du fichier d'en-tête que vous venez d'ajouter à votre projet. C'est tout, facile.

La mémoire est toujours un problème lors de l'utilisation de polices personnalisées, alors tenez toujours compte des octets qui seront consommés par la mémoire. N'oubliez pas qu'Arduino UNO n'a que 32 Ko de mémoire.

Images personnalisées

Pour afficher une image bitmap sur votre écran, vous devez d'abord créer une image de taille 128 x 64/32.

J'utilise le bon vieux "MS Paint" pour créer une image bitmap 128 x 64 que je téléchargerai ensuite sur ce site Web de conversion d'images. Le site Web convertit les images en chaînes d'octets, qui peuvent être utilisées avec les écrans Arduino et OLED.

Commencez par télécharger l'image sur le site Web. Cochez ensuite la case "Inverser les couleurs de l'image" et remplacez le "Format du code de sortie" par "Code Arduino", puis sélectionnez l'orientation et appuyez sur le bouton "Générer le code" pour générer le tableau d'octets. La section "Aperçu" vous montre à quoi ressemblera votre image sur l'affichage réel.

J'ai inclus le code avec ce tutoriel que vous pouvez utiliser pour afficher vos images. Il vous suffit de remplacer le tableau de mon code par celui que vous venez de générer, puis de le charger sur votre Arduino.

Étape 11: connexion de 2 écrans

Il est facile de connecter deux écrans 128 x 64 à votre projet.

Il vous suffit de dessouder la résistance 0Ohm de l'adresse 0x78 et de la mettre sur 0x7A puis d'utiliser l'adresse 0x3D dans votre code au lieu de l'adresse 0x3C par défaut.

Vous devez vous demander pourquoi nous utilisons les adresses 0x3C et 0x3D et non les adresses 0x78 et 0x7A. Arduino accepte les adresses 7 bits et non les adresses matérielles 8 bits. Ainsi, nous devons d'abord convertir l'adresse 8 bits en binaire, puis couper le bit le moins significatif pour obtenir les 7 bits. Convertissez ensuite les 7 bits en HEX pour obtenir les adresses 0x3C ou 0x3D que vous entrez dans votre code.

Tout d'abord, initialisez l'affichage en lui donnant un nom unique:

Adafruit_SSD1306 display1(OLED_REST);

Adafruit_SSD1306 display2(OLED_REST);

Ensuite, dans votre code, utilisez l'affichage 1 et l'affichage 2 pour appeler les instructions de début contenant les adresses de périphérique:

display1.begin(SSD1306_SWITCHCAPVCC, 0x3C); // affiche 1 adresse op 0x3C

display2.begin(SSD1306_SWITCHCAPVCC, 0x3D); // affiche l'adresse 2 op 0x3D

C'est tout, vous pouvez maintenant continuer et faire ce que vous voulez en utilisant l'affichage 1 ou l'affichage 2 dans le reste de votre code. J'ai fourni un exemple avec ce tutoriel.

Le câblage est exactement le même que ce que nous avons fait auparavant, il vous suffit d'ajouter un autre écran aux mêmes broches I2C de l'Arduino ou du NodeMCU. Sur la base des adresses, le MCU envoie ensuite les données sur la ligne de données I2C.

Étape 12: Connecter plus de 2 écrans

Maintenant, que se passe-t-il si vous souhaitez connecter plus de 2 écrans ?

Arduino a un nombre limité de broches et, par conséquent, vous ne pouvez pas avoir plus d'un certain nombre de blindages qui lui sont attachés. De plus, il ne possède qu'une seule paire de bus I2C.

Alors, comment pouvons-nous attacher plus de 2 écrans I2C à un Arduino ? L'astuce consiste à utiliser un multiplexeur TCA9548.

Le TCA9548 permet à un seul microcontrôleur de communiquer avec jusqu'à « 64 capteurs », tous avec la même adresse I2C ou une adresse différente en attribuant un canal unique à chaque sous-bus esclave de capteur.

Lorsque nous parlons d'envoyer des données sur 2 fils à plusieurs appareils, nous avons alors besoin d'un moyen de les adresser. C'est la même chose que le facteur venant sur une seule route et déposant les paquets de courrier dans différentes maisons parce qu'ils ont des adresses différentes écrites dessus.

Le multiplexeur se connecte aux lignes 3V3, GND, SDA et SCL du microcontrôleur. Les capteurs esclaves sont connectés à l'un des huit ports esclaves SCL/SDA de la carte. Les canaux sont sélectionnés en envoyant au TCA9548A son adresse I2C (0x70 {default} - 0x77) suivie du numéro de canal (0b00000001 - 0b10000000). Vous pourriez avoir au maximum 8 de ces multiplexeurs connectés ensemble sur des adresses 0x70-0x77 afin de contrôler 64 des mêmes parties adressées I2C. En connectant les trois bits d'adresse A0, A1 et A2 à VIN, vous pouvez obtenir différentes combinaisons d'adresses. J'expliquerai cela en détail dans mon prochain tutoriel sur la carte de dérivation TCA9548A. Pour l'instant, connectons simplement 8 OLED à cette carte et regardons rapidement le code.

Lien:

VIN à 5V (ou 3,3V)

GND à la terre

Horloge SCL vers I2C

Données SDA vers I2C

Connectez ensuite les capteurs à VIN, GND et utilisez l'un des bus multiplexés SCn / SDn

Maintenant, Int le code commençons par inclure la bibliothèque "Wire" et par définir l'adresse des multiplexeurs.

#include "Fil.h"

#comprendre

#define MUX_Address 0x70 // Adresse des encodeurs TCA9548A

Ensuite, nous devons sélectionner le port avec lequel nous voulons communiquer et envoyer les données dessus à l'aide de cette fonction:

void tcaselect(uint8_t i) {

si (i > 7) retour;

Wire.beginTransmission(MUX_Address);

Wire.write(1 << i);

Wire.endTransmission();

}

Ensuite, nous allons initialiser l'affichage dans la section de configuration en appelant "u8g.begin();" pour chaque écran attaché au MUX "tcaselect(i);"

Une fois initialisé, nous pouvons alors faire ce que nous voulons simplement en appelant la fonction "tcaselect(i);" où "i" est la valeur du bus multiplexé, puis l'envoi des données et de l'horloge en conséquence.

Étape 13: Avantages et inconvénients

L'image d'un OLED est magnifique. Cependant, les OLED ont également

désavantages. Parce que les écrans OLED contiennent des matières organiques, leur durée de vie est plus courte que les écrans LCD. De plus, de nombreux écrans OLED subissent des brûlures après avoir affiché la même image pendant une longue période. Après un burn-in, l'image reste à l'écran même après avoir montré une autre image. Assurez-vous donc de continuer à actualiser l'écran toutes les quelques secondes. L'eau peut endommager instantanément les matières organiques de ces écrans.

Avantages

Pas besoin de rétro-éclairage

Les écrans sont très fins et légers

Basse consommation énergétique

Les angles de vision sont plus larges que les écrans LCD

La luminosité et le contraste sont excellents

Haute vitesse et faible temps de réponse

Couleur noir profond

Désavantages

Une technologie coûteuse

Cycle de vie court

Les OLEDS sont plus susceptibles de brûler

Dégâts d'eau

Étape 14: Erreurs courantes

Pour conclure le tutoriel, parlons de quelques erreurs courantes

les gens font en utilisant ces écrans:

- Vérifiez toujours trois fois les broches avant de l'utiliser dans votre projet

- Reprenez la bonne adresse de bibliothèque dans le fichier d'en-tête et dans votre code

#define SSD1306_I2C_ADDRESS 0x3C // dans Adafruit_SSD1306.h

et

display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // dans ton code

Si l'adresse est erronée, l'OLED n'affichera rien

- La taille de l'affichage doit être modifiée dans le pilote avant de pouvoir être utilisée. S'il n'est pas modifié, vous obtiendrez un message d'erreur lors de la tentative de vérification du code

#error ("Hauteur incorrecte, veuillez corriger Adafruit_SSD1306.h!");

- Si vous utilisez NodeMCU, assurez-vous de remplacer l'OLED_RESET de 4 à LED_BUILTIN

#define OLED_RESET LED_BUILTIN

J'ai des gens de scène qui font toutes sortes de choses à l'aide de cet écran OLED. Certains ont même fait des jeux vidéo et tout. Je ne suis vraiment pas intéressé à faire un jeu vidéo en utilisant ce petit écran. Cependant, je vais maintenant vous laisser explorer votre imagination et sortir des idées étonnantes.

Étape 15: Liens

-Blog:

- Ajouter une image:

- Texte personnalisé:

- Bibliothèque d'affichage Adafruit:

- Bibliothèque Adafruit GFX:

- bibliothèque u8glib: https://code.google.com/archive/p/u8glib/ ou

Si vous souhaitez utiliser le plus petit affichage, utilisez le 128_32 par défaut, sinon pour le plus grand affichage, commentez le 128_32 et décommentez le 128X64 NO_ACK dans votre code (décommentez simplement le type d'écran que vous utilisez) (les polices sont dans la bibliothèque de polices)