Utilisation d'un écran OLED SPI SSD1306 avec Arduino

Dans cet article, nous explorons l'utilisation d'un écran OLED SPI SSD1306 avec un Arduino.

OLED signfie "organic light-emitting diode": chaque pixel de l'écran peut s'allumer comme s'il s'agissait d'une LED (par opposition à d'autres technologies d'affichage qui nécessitent un rétroéclairage). Ces petits écrans monochromes ne coûtent pas cher et offrent un excellent contraste peu importe l'éclairage ambiant. 

J'ai fait mes tests avec un afficheur dont la résolution est 128 par 64 pixels (c'est la résolution la plus fréquente). 

Jusqu'à tout récemment, j'avais exclusivement utilisé des écrans OLED qui utilisaient une interface I2C: 4 connecteurs étaient suffisants pour les faire fonctionner. Les modèles SPI, qui sont en principe plus rapides, comportent 7 connecteurs.

Les broches de mon afficheur sont identifiées de cette façon:

• GND (la masse)
• VCC (alimentation qui, sur ce modèle, peut être de 5 V ou de 3,3 V)
• D0 : qui est en fait le signal d'horloge SPI (SCLK)
• D1: qui transmet les infos du microcontrôleur vers l'écran (MOSI)
• RES: reset
• DC: permet permuter entre les modes "data" ou "command"
• CS: "chip select", essentiel si plusieurs appareils sont branchés sur le même bus SPI.

Par défaut, l'afficheur fonctionne en "SPI à 4 fils". Mais il est possible de le transformer en afficheur "SPI à 3 fils" ou I2C en modifiant la configuration des résistances au verso de l'écran.

Connexions de l'écran OLED à un Arduino Uno

J'ai fait mes premiers tests avec un Arduino Uno, et j'ai branché l'écran OLED de cette façon:

• GND de l'écran OLED : GND de l'Arduino Uno
• VCC de l'écran OLED: sortie 5 V de l'Arduino Uno
• D0 : broche 13 de l'Arduino Uno
• D1: broche 11 de l'Arduino Uno
• RES: broche 8 de l'Arduino Uno
• DC: broche 9 de l'Arduino Uno
• CS: broche 10 de l'Arduino Uno

Les broches RES, DC et CS peuvent être branchées à n'importe quel broche de l'Arduino: nous les définissons dans le sketch. Les broches D0 et D1, toutefois, doivent être connectées aux broches dédiées à la communications SPI.

Autres cartes

J'ai aussi fait des tests sur d'autres cartes (ESP8266, ESP32, STM32), également programmées au moyen de l'IDE Arduino. J'indique ici les numéros des broches utilisées pour D0 et D1 (SCLK et MOSI):

ESP8266:   D0: GPIO14  et D1: GPIO13

ESP32:  D0: 18  et D1: 23

STM32 "Blue Pill":  D0: A5 et D1: A7

Vous branchez RES, DC et CS où vous voulez, en n'oubliant pas de modifier le sketch en conséquence.

Bibliothèque u8g2 ou Adafruit?

Les deux bibliothèques les plus utilisées pour piloter un écran OLED avec une carte Arduino sont u8g2 et la bibliothèque d'Adafruit. Chacune des deux constitue un excellent choix.

J'ai testé les deux bibliothèques avec un Arduino Uno, un ESP32, un ESP8266 et un STM32 "Blue Pill". Tout a fonctionné correctement avec la bibliothèque u8g2, mais je ne suis pas parvenu à faire fonctionner la Blue Pill avec la bibliothèque d'Adafruit (l'écran demeurait noir).

Il me semble que la bibliothèque d'Adafruit est un peu plus conviviale, et que u8g2 présente un plus grand choix de polices de caractères (incluant des polices accentuées, ce qui est bien pratique en français).

Évidemment, chacune des deux bibliothèques est accompagnée d'un grand nombre de fichiers d'exemples qui permettent de visualiser rapidement plusieurs résultats possibles.

Vous trouverez ci-dessous deux sketches qui sont assez similaire: ils affichent un peu de texte et quelques formes géométriques simples, ainsi qu'une illustration bitmap. Le premier sketch est conçu pour être utilisé avec la bibliothèque u8g2, alors que l'autre nécessite la bibliothèque d'Adafruit.

Sketch utilisant la bibliothèque u8g2

Ce premier sketch utilise la bibliothèque u8g2, que vous pouvez installer à partir du gestionnaire de bibliothèques.

-

-

Sketch utilisant la bibliothèque Adafruit

La bibliothèque Adafruit SSD1306 nécessite également la bibliothèque Adafruit GFX. Les deux bibliothèques peuvent être installées dans le gestionnaire de bibliothèques.

-

-

Affichage d'un dessin bitmap

Les deux scripts ci-dessus affichent un dessin bitmap dont les données se trouvent au début du sketch. Pour transformer un dessin bitmap en données exploitables par un Arduino, plusieurs options sont possible: on peut utiliser un logiciel comme Gimp pour sauvegarder l'illustration sous la forme d'un fichier XBM qu'on  ouvre ensuite avec un éditeur de texte, ou on peut utiliser un outil en ligne comme celui-ci.

À lire également:

J'ai publié quelques articles concernant l'utilisation d'un écran OLED I2C SH1106: avec un Arduino Uno,  avec une carte ESP8266 ou ESP32, ou avec une carte STM32.

D'autres articles concernent l'utilisation d'autres afficheur avec un Arduino: Écran couleur ST7735,  afficheur Nokia 5110, afficheur LCD 2 X 16, etc.

Yves Pelletier (Facebook)

Utilisation d'un écran tactile TFT SPI 240 X 320 (ILI9341) avec un ESP8266

Cet article a été mis à jour le 13 mai 2021 (ajout d'un deuxième sketch).

Dans cet article, nous branchons à un ESP8266 un écran tactile TFT de 240 X 320 pixels (2,4"), muni d'un contrôleur ILI9341, qui communique sur le bus SPI. 

Pour interagir avec l'écran, il est possible d'utiliser un doigt; mais puisque sa surface utile est assez petite (5 cm par 4 cm), l'écran est accompagné d'un stylet qui permet de toucher une position beaucoup plus précise.

Attention: on trouve sur le marché des versions non-tactiles de cet écran. Lisez soigneusement la description avant d'acheter...

Connexions

Le module comporte 18 broches: 

• 2 broches pour l'alimentation
• 7 broches pour l'affichage
• 5 broches pour le capteur tactile
• 4 broches pour le lecteur de carte SD (que je n'utilise pas dans cet article)

J'ai branché l'écran à l'ESP8266 de cette façon:

• Broche VCC de l'écran - Sortie 3,3 V de l'ESP8266
• Broche GND de l'écran - Broche GND de l'ESP8266
• Broche CS de l'écran - Broche GPIO 15 (D8) de l'ESP8266
• Broche RESET de l'écran - Broche GPIO 2 (D4)  de l'ESP8266
• Broche DC/RS de l'écran - Broche GPIO 0 (D3) de l'ESP8266
• Broche SDI (MOSI) de l'écran - Broche GPIO 13 (D7) de l'ESP8266
• Broche SCK de l'écran - Broche GPIO 14 (D5) de l'ESP8266
• Broche LED de l'écran - Sortie 3,3 V de l'ESP8266
• Broche SDO (MISO) de l'écran - Broche GPIO 12 (D6) de l'ESP8266
• Broche T_CLK de l'écran - Broche GPIO 14 (D5) de l'ESP8266
• Broche T_CS de l'écran - Broche GPIO 4 (D2) de l'ESP8266
• Broche T_DIN de l'écran - Broche GPIO 13 (D7) de l'ESP8266
• Broche T_DO de l'écran - Broche GPIO 12 (D6) de l'ESP8266
• Broche T_IRQ de l'écran - pas connectée

Les broches dont le symbole commence par la lettre T concernent le capteur tactile: il n'est pas nécessaire de les brancher si vous désirez utiliser l'écran comme simple afficheur.

Installation de la bibliothèque

J'ai installé la bibliothèque TFT_eSPI de Bodmer par l'entremise du gestionnaire de bibliothèques de l'IDE Arduino.

Configuration de la bibliothèque (fichiers User_Setup)

Avant d'utiliser la bibliothèque TFT_eSPI, il est important de la configurer en fonction du type d'écran que nous utilisons.  Pour ce faire, vous devez ouvrir le répertoire où la bibliothèque TFT_eSPI a été installée (dans le dossier "libraries" de votre sketchbook Arduino).

Deux possibilités s'offrent à vous: 

• Apporter les modifications nécessaires dans le fichier User_Setup.h
• Sélectionner un fichier User_Setup prédéfini

C'est cette deuxième option que j'ai utilisé: j'ai d'abord ouvert le fichier "User_Setup_Select.h" et j'y ai décommenté la ligne 24: "#include <User_Setups/Setup1_ILI9341.h>". De cette façon, la bibliothèque utilisera les informations consignées dans le fichier "Setup1_ILI9341.h"

J'ai ensuite ouvert le fichier "Setup1_ILI9341.h" qui se trouve dans le dossier "User_setups".

Aux lignes 6, 7 et 8, on choisi le numéro des broches de l'ESP8266 qui correspondent aux broches CS, DC et RST de l'écran. Les broches indiquées sont déjà correctes si vous utilisez un module NodeMcu. Si ce n'est pas le cas, vous devrez probablement remplacer "PIN_D8" par "15", "PIN_D3" par "0" et "PIN_D4" par 2.

Sur la capture d'écran ci-dessus, portez attention à la ligne 11, qui ne se trouvait pas dans le fichier au départ: j'ai indiqué la broche qui correspond à la broche T_CS (chip select du capteur tactile):

"#define TOUCH_CS PIN_D2"

Ici encore, si vous n'utilisez pas un module NodeMcu, vous devrez peut-être utiliser le numéro de la broche GPIO 4:

"#define TOUCH_CS 4"

La bibliothèque TFT_eSPI est maintenant configurée pour l'utilisation de notre écran avec un ESP8266. Si, à une autre occasion, vous désirez utiliser un autre microcontrôleur ou un autre écran, il s'agira de sélectionner un autre fichier User_Setup.

Exemple de sketch: deux boutons

La bibliothèque TFT_eSPI comporte un grand nombre d'exemples très instructifs.

Je vous propose ci-dessous un sketch très simple qui permet d'explorer l'affichage de texte et de formes géométriques simples, ainsi que la gestion de boutons virtuels à l'écran.

Deux boutons s'affichent au bas de l'écran: un bouton qu'on touche pour faire apparaître un rectangle, et un autre qui permet d'afficher un cercle.

L'exemple Keypad_240X320 (fourni avec la bibliothèque) montre comment conserver les données de calibration de l'écran dans un fichier SPIFF pour qu'il ne soit pas nécessaire de répéter cette calibration à chaque utilisation (je n'ai pas inclus cette fonctionnalité dans mon sketch).

-

-

Exemple de sketch: un bouton coulissant

J'ai écrit ce deuxième sketch pour qu'il soit utilisé avec une carte STM32, mais il fonctionne à la perfection sur un ESP8266, sans la moindre modification, puisque les informations propres au microcontrôleur se trouvent dans le fichier User_Setup.

Il s'agit cette fois d'un bouton coulissant qui pourrait servir à contrôler la luminosité d'une LED, la positon d'un servomoteur, etc.

-

-

À lire également

Le même écran tactile, utilisé avec une carte STM32 Blue Pill.

D'autres afficheurs utilisés avec l'ESP8266:

• Écran couleur SPI ST7735
• Écran OLED I2C SH1106
• Écran Nokia 5110
• Afficheur LCD 16 X 2
• Afficheur numérique à base de TM1638

Yves Pelletier (Twitter, Facebook)

VS1003 / VS1053 en mode MIDI (Arduino, ESP32, ESP8266)

Au cours des dernières semaines, j'ai utilisé mon module VS1003 / VS1053 pour jouer des fichiers mp3 ainsi que des émissions de webradio. Mais ce module peut également être utilisé comme synthétiseur MIDI: il génère des sons qui correspondent aux commandes MIDI que vous lui transmettez (ces messages peuvent être générés par un contrôleur MIDI ou par votre sketch Arduino).

En principe, la méthode recommandée pour mettre le VS1053 en mode "MIDI temps réel" consiste à faire un reset en soumettant sa broche GPIO 0 à une signal logique bas, et sa broche GPIO 1 à un signal logique haut. On peut ensuite lui acheminer les messages MIDI par son entrée RX.

Tout ça est bien joli si les broches GPIO et RX sont accessibles sur le module que vous utilisez. C'est le cas, par exemple, pour les modules mis en marché par Sparkfun et par Adafruit, mais ce n'est pas le cas pour le module "LCSoft Studio" que j'utilise.

Il existe heureusement une autre solution qui, elle, est applicable à mon module: grâce à des patches logicielles fournies par VLSI, le module peut exécuter les commandes MIDI reçues sur le bus SPI. Cette méthode nécessite des programmes un tout petit peu plus compliqués, d'autant plus que le VS1003 et le VS1053 requièrent un traitement légèrement différent (les deux modèles sont généralement interchangeables, à un point tel que je croyais être propriétaire d'un VS1053, alors qu'il s'agit finalement d'un VS1003).

Heureusement, Kevin, l'auteur de l'excellent blog Simple DIY Electronic Music Projects a écrit un sketch Arduino qui permet de contrôler un VS1003 ou un VS1053 au moyen d'un contrôleur MIDI (un clavier musical, par exemple). Un potentiomètre branché à l'Arduino permet de modifier le timbre de l'instrument (piano, vibraphone, flûte, etc.). Ses travaux sont présentés dans trois articles: 

• Arduino MIDI VS1053 Synth
• Arduino MIDI VS1003 Synth
• Arduino MIDI VS1003 or VS1053 Synth

J'ai testé avec succès le sketch de Kevin sur un Arduino Uno, sur un ESP8266 et sur un ESP32.

Le sketch

Vous trouverez sur Github le sketch ArduinoMIDIVS10xxSynth ainsi que les 4 fichiers qui doivent être placés dans le même dossier.

Le sketch fonctionne pour le VS1003 et pour le VS1053, mais vous devez indiquer de quel module il s'agit en commentant la ligne 63 ou la ligne 64. 

Si vous branchez un potentiomètre à l'entrée A0 de l'Arduino pour sélectionner le timbre de l'instrument, prenez soin de décommenter la ligne 87. Vous pouvez aussi ajouter un contrôle de volume à l'entrée A1, mais je ne le recommande pas lors des premiers essais (le son était inaudible pour la plupart des positions du potentiomètre).

Si vous préservez la ligne 53, une suite de notes sera jouée au démarrage du programme, ce qui constitue une excellente façon de vérifier que tout fonctionne correctement.

Circuit: Arduno Uno

Le circuit intégré VS1053 est conçu pour fonctionner à un niveau logique de 3,3 V, c'est pourquoi j'ai utilisé un circuit intégré 4050 pour abaisser les signaux de 5 V générés par l'Arduino (au besoin, vous pouvez consulter cet article pour plus d'informations sur l'utilisation d'un 4050).

Voici donc les connexions du module VS1003 avec l'Arduino:

• Broche 5 V du VS1003 - Broche 5 V de l'Arduino Uno
• Broche XGND du VS1003 - Broche GND de l'Arduino Uno
• Broche MISO du VS1003 - Broche 12 de l'Arduino Uno*
• Broche MOSI du VS1003 - 4050 - Broche 11 de l'Arduino Uno
• Broche SCK du VS1003 - 4050 - Broche 13 de l'Arduino Uno
• Broche DREQ du VS1003 - Broche 2 de l'Arduino Uno*
• Broche XRST du VS1003 - 4050 - Broche 8 de l'Arduino Uno
• Broche XCS du VS1003 - 4050 - Broche 6 de l'Arduino Uno
• Broche XDCS du VS1003 - 4050 - Broche 7 de l'Arduino Uno

* Les broches MISO et DREQ sont des sorties du VS1003 et leur signal ne doit donc pas être abaissé par le 4050.

Pour la réception des messages MIDI, la sortie MIDI d'un clavier musical était branchée à la broche 0 (RX) de l'Arduino Uno par l'entremise d'un optocoupleur 4N35 (plus de détails dans cet article). 

Finalement, un potentiomètre est branché à l'entrée A0 de l'Arduino: il permet de sélectionner le timbre ("sound bank") du son généré par le VS1003.

J'ai dû apporter des modifications aux lignes 102 à 105 du sketch pour qu'elles concordent avec mes connexions:

Circuit: ESP8266

Le programme fonctionne également avec un ESP8266. Presque toutes les broches GPIO de l'ESP8266 sont utilisées, mais il n'est pas nécessaire d'adapter les niveaux logiques. Cette fois, l'optocoupleur 4N35 doit être branché à 3,3 V plutôt qu'à 5 V.

• Broche 5 V du VS1003 - Broche 5 V de l'ESP8266
• Broche XGND du VS1003 - Broche GND de l'ESP8266
• Broche MISO du VS1003 - Broche GPIO12 de l'ESP8266
• Broche MOSI du VS1003 - Broche GPIO13 de l'ESP8266
• Broche SCK du VS1003 - Broche GPIO14 de l'ESP8266
• Broche DREQ du VS1003 - Broche GPIO4 de l'ESP8266
• Broche XRST du VS1003 - Broche GPIO5 de l'ESP8266
• Broche XCS du VS1003 - Broche GPIO16 de l'ESP8266
• Broche XDCS du VS1003 - Broche GPIO2 de l'ESP8266

Pour la réception des signaux MIDI,  l'optocoupleur 4N35 est branché à la broche RX de l'ESP8266.

Finalement, un potentiomètre est branché à l'entrée A0 de l'ESP8266.

(Le schéma montre mon Wemo D1 Mini)

Pour l'ESP8266, j'ai aussi modifié les lignes 102 à 105 du sketch de la façon suivante:

Circuit: ESP32

Ça fontionne aussi avec l'ESP32.

J'ai utilisé ces connexions:

• Broche 5 V du VS1003 - Broche VIN de l'ESP32
• Broche XGND du VS1003 - Broche GND de l'ESP32
• Broche MISO du VS1003 - Broche D19 de l'ESP32
• Broche MOSI du VS1003 - Broche D23 de l'ESP32
• Broche SCK du VS1003 - Broche D18 de l'ESP32
• Broche DREQ du VS1003 - Broche D4 de l'ESP32
• Broche XRST du VS1003 - Broche D21 de l'ESP32
• Broche XCS du VS1003 - Broche D5 de l'ESP32
• Broche XDCS du VS1003 - Broche D16 de l'ESP32

Pour la réception des signaux MIDI,  l'optocoupleur 4N35 est branché à la broche RX de l'ESP8266.

Finalement, un potentiomètre est branché à l'entrée A0 de l'ESP8266.

... et j'ai modifié les lignes 102 à 105 du sketch de cette façon:

À lire également

• ESP32 et VS1003 / VS1053: écouter les fichiers mp3 d'une carte SD
• Lecture de fichiers mp3 avec Arduino Uno et VS1003 / VS1053
• Webradio à base d'ESP32 et VS1003 /  VS1053

Yves Pelletier (Twitter, Facebook)

    

ESP8266 et ESP32: Contrôle d'une matrice de LEDs RGB

J'avais déjà fait l'essai de ma matrice constituée de 16 rangées de 16 LEDs RGB (contrôleur WS2812B) avec un Arduino Uno. Cette fois-ci, c'est avec un module ESP32 ainsi qu'avec un module ESP8266 que j'ai pu contrôler (à distance) les LEDs de la matrice.

Alimentation et niveau logique

Il faudra choisir pour la matrice de LEDs une alimentation capable de fournir un courant de quelques ampères, particulièrement si vous prévoyez allumer ses 256 LEDs en même temps.

La fiche technique du WS2812B indique que son alimentation doit se situer entre 3,5 V et 5,3 V, et que son V_IH (la plus petite tension considérée comme un niveau logique haut) est égal à 70% de la tension d'alimentation. 

Nous pouvons en conclure que:

• Si nous alimentons le WS2812B avec une tension de 3,3 V, son fonctionnement correct n'est pas garanti, puisqu'il s'agit d'une tension plus faible que le minimum recommandé.

• Si le WS2812B est alimenté à 5 V, un signal logique d'au moins 3,5 V est requis, en principe, pour garantir son fonctionnement; le signal de 3,3 V issu d'un ESP8266 ou d'un ESP32 pourrait donc être insuffisant.  Dans ce cas, un convertisseur de niveau logique pourrait être nécessaire pour élever à 5 V le signal généré par le microcontrôleur. 

Une autre solution consiste à diminuer un peu la tension d'alimentation de la matrice (si la tension d'alimentation du WS2812B est de 4,7 V ou moins, un niveau logique de 3,3 V se situe dans les normes recommandées par le fabricant).

Pour ma part, tout a fonctionné sans problème en utilisant directement le signal de 3,3 V généré par la broche GPIO 5 du module ESP, même quand la tension d'alimentation de la matrice était de 5 V.

Connexions

Le verso de la matrice comporte 8 fils, mais ils ne sont pas tous nécessaires (ils servent entre autre à brancher plusieurs matrices ensemble, afin d'obtenir un panneau géant).

• Un des fils rouges marqués "5 V" est branché à la borne positive de l'alimentation de la matrice de LEDs (cette alimentation doit être capable de générer quelques ampères).
• Le fil noir (marqué GND) est branché à la borne négative de l'alimentation de la matrice de LEDs.
• Un des fils blancs (marqués GND) est branché à la masse (sortie GND) du module ESP32 ou ESP8266.
• Le fil vert marqué DIN est branché à la broche GPIO 5 du module ESP32 ou ESP8266 (ça peut aussi être une autre broche, si vous modifiez le sketch ci-dessous en conséquence).

Installation des bibliothèques

J'ai conservé les deux mêmes bibliothèques que j'avais utilisées lors de l'utilisation avec l'Arduino Uno: la bibliothèque FastLED de Daniel Garcia (disponible par le gestionnaire de bibliothèques de l'IDE Arduino) et la bibliothèque LED Matrix par Jorgen - Viking God.

Sketch

Les deux sketches que j'avais rédigés lors de l'essai de la matrice de LEDs avec l'Arduino Uno fonctionnent très bien avec les modules ESP, à la condition de modifier le numéro de la broche GPIO utilisée (5 plutôt que 3).

Dans le sketch ci-dessous, j'ai choisi d'utiliser les fonctionnalités WiFi des modules ESP8266 / ESP32: une page web générée par le module ESP permet d'allumer n'importe quelle LED de la matrice avec la couleur désirée (on choisit "Noir" pour éteindre la LED).

Pour atteindre cette page web, on utilise l'adresse IP affichée sur le moniteur série de l'IDE Arduino lors du démarrage du programme.

-

-

À lire également:

• La même matrice de LEDs, contrôlée par un Arduino Uno
• Mes autres projets impliquant l'ESP8266 et/ou l'ESP32

Yves Pelletier (Twitter, Facebook)

ESP32/ESP8266: Écriture et lecture d'un fichier en mémoire flash

Il est possible d'enregistrer des fichiers dans la mémoire flash de l'ESP8266 et de l'ESP32. Par exemple, on peut utiliser la mémoire flash pour héberger les fichiers html d'un serveur web, ou encore pour enregistrer les données d'un data logger. Les fichiers sont préservés suite à un redémarrage, une coupure d'alimentation, ou le téléversement d'un nouveau programme.

SPIFFS ou LittleFS?

Pendant quelques années, le système de fichiers recommandé pour l'ESP8266 était SPIFFS, mais il n'est plus activement supporté par l'équipe de développement du core Arduino pour ESP8266, et il risque de disparaître totalement dans une future version. Il est plutôt recommandé d'utiliser le système de fichiers LittleFS, dont la bibliothèque est intégrée dans le core Arduino ESP8266.

Du côté de l'ESP32, la future disparition du format SPIFFS ne semble pas aussi explicite pour l'instant. Au moment où j'écris ces lignes, seule la bibliothèque SPIFFS est distribuée avec le core Arduino ESP32 (version 1.0.4) et il faut installer une bibliothèque supplémentaire pour utiliser LittleFS,  mais on indique que cette bibliothèque sera bientôt intégré au core ESP32 pour Arduino.

Un sketch rédigé pour le format SPIFFS ne nécessite que très peu de modifications pour fonctionner avec LittleFS. Cependant, si vous avez déjà enregistré des fichiers en format SPIFFS, ils seront effacés si vous exécutez ensuite un sketch qui utilise le format LittleFS.

J'ai utilisé Little FS sur les deux plateformes, car j'aime bien concevoir des programmes qui fonctionnent à la fois sur ESP8266 et sur ESP32.

LittleFS sur ESP8266

Il n'y a aucune bibliothèque à installer, puisqu'elle est déjà intégrée au core. Deux fichiers d'exemple sont fournis (Menu Fichier - Exemples - LittleFS(esp8266)).

LittleFS sur ESP32

Pour l'ESP32, j'ai installé la bibliothèque LITTLEFS par lorol en passant par le gestionnaire de bibliothèques de l'IDE Arduino.  (Attention, lecteur du futur: ce ne sera peut-être plus nécessaire au moment où tu liras ces lignes...)

Là encore, deux fichiers d'exemple sont fournis (Menu Fichier - Exemples - LittleFS_esp32).

Mon projet

Mon but était de rédiger un sketch fonctionnant aussi bien avec l'ESP8266 qu'avec l'ESP32. Trois boutons sont connectés au module: un premier bouton lit le contenu d'un fichier intitulé "document.txt", un deuxième bouton ajoute des données dans le fichier (un nombre entier qui augmente à chaque écriture", et le troisième bouton supprime le fichier.

Les boutons sont branchés de la façon suivante:

• Bouton "Lecture du fichier": GPIO 4
• Bouton "Écriture dans le fichier": GPIO 5
• Bouton "Suppression du fichier": GPIO 15

Schéma des connexion sur module Wemos D1 mini:

Schéma des connexions sur module ESP32:

Le sketch

Il existe quelques différences de syntaxe entre la version ESP8266 et la version ESP32, ce qui m'a obligé à utiliser des directives au préprocesseur (#defined ARDUINO_ARCH_ESP32 et #defined ARDUINO_ARCH_ESP8266).

Par exemple, dans la version ESP8266, il faut écrire "LittleFS" alors que c'est "LITTLEFS" dans la version ESP32.

Pour l'ESP32, j'ai utilisé l'expression "LITTLEFS.begin(1)" pour qu'un répertoire en format LittleFS soit créé s'il n'en existe pas déjà un.  Mais pour obtenir le même comportement avec l'ESP8266, il faut simplement écrire "LittleFS.begin()".

De plus, la routine "listDir" qui fait la liste des fichiers est assez différentes pour les deux microcontrôleurs.

--

On peut constater l'effet de l'appui sur un bouton en regardant l'affichage du moniteur série:

À lire également

• Fichiers sur carte SD et ESP8266
• Fichiers sur carte SD et ESP32
• Mes autres articles impliquant l'ESP32 ou l'ESP8266.

Yves Pelletier (Twitter, Facebook) 

Programmation OTA de l'ESP32 / ESP8266

La programmation OTA ("Over the air") consiste à programmer à distance, via le réseau WiFi, un ESP32 ou un ESP8266.

De cette façon, vous pouvez mettre à jour le sketch exécuté par un ESP32 ou un ESP8266 en laissant ce dernier à l'endroit où il se trouve, sans qu'il soit nécessaire de le brancher à votre ordinateur par un câble USB.

Nous effectuerons cette opération au moyen de l'IDE Arduino (il existe d'autres méthodes impliquant, par exemple, un navigateur web). L'IDE Arduino doit avoir été préalablement configuré pour la programmation de l'ESP32 ou de l'ESP8266. 

La documentation spécifie également que Python doit être installé sur l'ordinateur, mais ça n'implique aucunement que vous devrez programmer quoi que ce soit en Python;  je suppose que l'IDE utilise un script en Python pendant le processus.

Pour que le module ESP puisse être programmé à distance, il faut qu'il contienne déjà un sketch qui contient les routines qui gèrent l'OTA. L'exemple "BasicOTA" (qui se trouve dans le répertoire "ArduinoOTA") a été spécialement conçu à cette fin: commençons par le téléverser dans notre module ESP qui, à cette étape, doit obligatoirement être branché à l'ordinateur par un câble USB (n'oubliez pas d'écrire le ssid et le mot de passe aux endroits appropriés, au début du programme).

Maintenant que le sketch "BasicOTA" a été téléversé, il n'est plus nécessaire que votre module ESP soit branché à l'ordinateur par USB: il s'agit qu'il soit alimenté et à portée du même réseau Wifi que l'ordinateur que vous utilisez pour le programmer.

Si le module ESP est connecté au réseau Wifi, vous devriez voir un nouveau port série s'afficher dans l'IDE Arduino (le nom est plutôt long et contient l'adresse IP du module ESP). Il s'agit de choisir ce port pour reprogrammer le module.

Mais attention: si vous désirez pouvoir, dans l'avenir, programmer à nouveau votre module par OTA, le sketch que vous téléversez doit obligatoirement contenir les routines qui gèrent l'OTA. En d'autres mots, tout le contenu du sketch "BasicOTA" doit se trouver à l'intérieur du nouveau sketch.

Exemple de sketch: Blink modifiable par OTA

Par exemple, le sketch ci-dessous se contente de faire clignoter la LED embarquée du module ESP, mais il a la particularité de pouvoir être modifié par OTA. Il s'agit essentiellement du sketch "BasicOTA", auquel j'ai ajouté les instructions qui permettent à la LED de clignoter (les lignes 24, 28,  79 à 82).

Il s'agit d'un point de départ intéressant pour tester que tout fonctionne correctement. Vous pouvez, par exemple, modifier la fréquence de clignotement de la LED et constater immédiatement si le sketch a été mis à jour ou non. (Remarquez que le moniteur série de l'IDE Arduino n'est pas fonctionnel pour les ports série OTA).

Comme toujours dans les sketches qui nécessitent une connexion à un réseau Wifi, vous devrez remplacer les astérisques par le nom du réseau et le mot de passe approprié.

-

-

Exemple de sketch: Webserver modifiable par OTA

Voici un deuxième exemple de sketch modifiable par OTA; cette fois, l'ESP diffuse une page web (ici encore, vous pourrez vérifier que la mise à jour s'effectue bel et bien en apportant des modifications au contenu de la page web). Au départ, la page affiche la valeur retournée par millis() (ce qui n'est pas spécialement utile, mais je voulais quelque chose de simple avec une valeur qui change avec le temps).

-

-

Pour atteindre cette page web avec un navigateur, vous utilisez l'adresse IP indiquée dans le nom du port série.

À lire également

Mes autres articles impliquant l'ESP32 ou l'ESP8266.

Yves Pelletier (Twitter, Facebook) 

Contrôler plusieurs servomoteurs avec le PCA9685

Certains projets de robotique nécessitent le contrôle simultanés de plusieurs servomoteurs: bras robotique, robot marcheur, etc. Pour ce genre de projet, un module PWM/Servo PCA9685 peut se révéler très utile.

Un seul de ces modules peut contrôler jusqu'à 16 servomoteurs simultanément, en n'utilisant que les deux broches I2C du microcontrôleur. Et si ce n'est pas suffisant, il est possible de connecter plusieurs modules PCA9685 au même microcontrôleur grâce à un système qui permet de modifier assez facilement l'adresse I2C. 

Le module comporte pas moins de 62 connecteurs, qu'il faut souder soi-même.

Du côté gauche de la photo, vous pouvez voir les connecteurs qui se branchent au microcontrôleur:

• Broche GND - la masse
• Broche OE - "output enable": permet de désactiver tous les servomoteurs en la mettant au niveau logique HAUT. Il n'est pas nécessaire de la brancher si on n'en a pas besoin.
• Broche SCL - signal d'horloge I2C
• Broche SDA - transfert de données I2C
• Broche VCC - Alimentation logique: 5 V pour les microcontrôleurs qui fonctionnent à un niveau logique de 5 V, et 3,3 V pour les microcontrôleurs qui fonctionnent à un niveau logique de 3,3 V
• Broche V+ : Alimentation des servomoteurs (5 V); ce connecteur est également présent sous la forme d'un bornier à vis.

La même série de connecteurs est répétée de l'autre côté du module, pour faciliter la connexion de plusieurs modules (au cas où votre projet nécessiterait plus que 16 servomoteurs).

Finalement, 16 groupes de 3 connecteurs permettent de branchement des servomoteurs, du canal numéro 0 (à gauche) jusqu'au canal numéro 15 (à droite).

J'ai testé le module sur les cartes suivantes: Arduino Uno, ESP32, ESP8266, STM32 Nucleo et STM32 Blue Pill. Dans chaque cas, il s'agit de connaître la position des broches I2C, et de prendre soint d'utiliser une alimentation VCC de même valeur que le niveau logique du microconrôleur.

Branchement du module PCA9685 à un Arduino Uno

• Broche GND du module PCA9685 : Broche GND de l'Arduino
• Broche SCL du module PCA9685: Broche A5 de l'Arduino
• Broche SDA du module PCA9685: Broche A4 de l'Arduino
• Broche VCC: sortie 5 Vde l'Arduino

Branchement du module PCA9685 à un ESP8266

• Broche GND du module PCA9685 : GND
• Broche SCL du module PCA9685: Broche GPIO 5 de l'ESP8266
• Broche SDA du module PCA9685: Broche GPIO 4 de l'ESP8266
• Broche VCC: 3,3 V

Branchement du module PCA9685 à un ESP32

• Broche GND du module PCA9685 : GND
• Broche SCL du module PCA9685: Broche D22 de l'ESP32
• Broche SDA du module PCA9685: Broche D21 de l'ESP32
• Broche VCC: 3,3 V

Branchement du module PCA9685 à un STM32 F103C8 "Blue Pill"

• Broche GND du module PCA9685 : GND
• Broche SCL du module PCA9685: Broche B6 de la Blue Pill
• Broche SDA du module PCA9685: Broche B7 de la Blue Pill
• Broche VCC: 3,3 V

Branchement du module PCA9685 à un STM32 Nucleo

• Broche GND du module PCA9685 : GND
• Broche SCL du module PCA9685: Broche SCL/D15 du Nucleo
• Broche SDA du module PCA9685: Broche SDA/D14 du Nucleo
• Broche VCC: 3,3 V

Installation de la bibliothèque PWM Servo Driver

J'ai ensuite installé la bibliothèque PWM Servo Driver par Adafruit dans l'IDE Arduino, ce qui peut être fait par l'entremise du gestionnaire de bibliothèques.

Exemple de sketch

Le sketch ci-dessous contrôle 3 servomoteurs respectivement branchés aux canaux 0, 1 et 2 du module (je ne disposais malheureusement pas de 16 servomoteurs). Le servomoteur branché au canal 0 fait un mouvement lent entre ses deux positions extrêmes, celui du canal 1 va plus vite dans un sens que dans l'autre, alors que celui du canal 2 prend une position aléatoire qui change toutes les deux secondes.

La méthode setPWM permet de régler la positon des servomoteurs. Puisque le signal PWM généré est de 12 bits, une période complète peut être séparée en 4096 valeurs différentes. Le premier paramètre indique le numéro du canal (de 0 à 15), le deuxième paramètre indique à quel moment le signal PWM devient haut (de 0 à 4095), et le troisième paramètre indique à quel moment le signal PWM devient bas (de 0 à 4095).

Par exemple, pwm.setPWM(2, 0, 160) règle le signal du canal 2 de façon à ce qu'il devienne haut au tout début d'un cycle (0/4095), et qu'il devienne bas à 160/4095 d'un cycle. Il s'agit donc d'un rapport cyclique d'environ 4%.

-

-

Vidéo

Voici finalement une courte vidéo qui montre le mouvement des trois servomoteurs.

Yves Pelletier (Twitter, Facebook)