mercredi 18 septembre 2019

Autopsie d'un message UART


On peut probablement passer des années à utiliser l'UART de l'Arduino de façon routinière sans savoir exactement ce qui se passe sous le capot. Dans ce billet, je m'amuse à observer le contenu d'un message UART.

Tout comme SPI et I2C, l'UART est un mode de communication série, ce qui signifie que les données sont acheminées l'une à la suite de l'autre sur une même broche du microcontrôleur.

La transmission UART implique 2 broches en plus de la masse (GND): TX pour la transmission, et RX pour la réception.  Sur un Arduino Uno, la broche numéro 0 reçoit les données (RX) alors que la broche numéro 1 est émettrice (TX). Le TX d'un des appareils impliqués dans la communication est toujours relié au RX de l'autre appareil.

Avec Arduino, vous utilisez l'UART chaque fois que vous faites appel à la classe Serial: Serial.print, Serial.println, Serial.read, etc. Typiquement, on l'utilise pour la communication entre un microcontrôleur et un ordinateur, ou entre plusieurs microcontrôleurs. Le protocole MIDI, beaucoup utilisé en musique, est une liaison UART à 31250 bauds.

Le sigle UART signifie "Universal Asynchronous Receiver Transmitter": le protocole permet donc d'émettre et de recevoir des données de façon asynchrone.  "Asynchrone" signifie qu'il n'existe pas de signal d'horloge commun partagé par l'émetteur et le récepteur, d'où la nécessité de régler l'émetteur et le récepteur à une même vitesse de transmission. Par exemple, lorsque votre sketch Arduino commence par Serial.begin(9600), vous réglez la vitesse de l'UART à 9600 bauds du côté Arduino, ce qui vous oblige à régler le moniteur série, du côté ordinateur, à 9600 bauds également.

Pour observer des messages UART, j'ai branché un analyseur logique à la broche TX d'un Arduino Uno, et j'ai visualisé les résultats sur le logiciel Sigrok PulseView.


Le sketch ne surprendra personne: je règle la vitesse de la communication à 9600 bauds, et j'envoie le message A, suivi d'un court délai pour m'aider à mieux distinguer l'émission de deux messages distincts.


Voici ce que me présente l'analyseur logique lors de l'émission de ce message:



Pendant qu'aucun message n'est transmis, la broche TX est au niveau logique haut. Un message UART commence toujours par un bit de départ (start) de niveau logique bas afin d'annoncer le début d'un message.

Le bit de départ est suivi d'une succession de 8 bits qui constituent le message proprement dit. Dans ce cas, ces 8 bits sont 1, 0, 0, 0, 0, 0, 1, et 0. Puisque le message débute par le bit de poids faible et se termine par le bit de poids fort, le résultat correspond au nombre binaire 01000001, ou 65 en décimal, soit le code ASCII de la lettre "A".

Le message se termine par un bit de fin (stop) de niveau logique haut. La broche demeure ensuite au niveau logique haut jusqu'à l'émission du prochain message.

Vous pouvez constater qu'il n'y a aucune frontière visible entre l'émission de deux bits consécutifs identiques; c'est la raison pour laquelle il est important que l'émetteur et le récepteur soient réglés à la même vitesse. Avec une transmission à 9600 bauds, chaque bit dure environ 100 µs (1/9600).


Si je double la vitesse de transmission pour qu'elle soit de 19200 bauds, la durée de chaque bit sera plutôt de 1/19200, donc environ 50 µs:


Si j'envoie un message constitué de plusieurs caractères, chacun des caractères est accompagné par son bit de départ et son bit de fin. Ici, j'ai envoyé le message "OK":


Cette fois, le message est constitué d'un bit de départ, de 8 bits correspondant au nombre binaire 01001111 (ou 79 en décimal, le code ASCII pour le caractère O), d'un bit de fin, d'un deuxième bit de départ, de 8 bits correspondant au nombre binaire 01001011 (ou 75 en décimal, correspondant au code ASCII pour le caractère "K"), et d'un dernier bit de fin.

Modifier les paramètres par défaut

Par défaut, la communication UART de l'Arduino est réglée à 8 bits de données, pas de parité et un bit "stop", mais il est possible de modifier ces paramètres en ajoutant un deuxième paramètre à la fonction Serial.begin().

Quelques exemples:

  • Serial.begin(9600, SERIAL_5N1) règle la vitesse de transmission à 9600 bauds, avec 5 bits de données, pas de parité, et un bit stop.
  • Serial.begin(4800, SERIAL_7N2) règle la vitesse de transmission à 4800 bauds, avec 7 bits de données, pas de parité, et 2 bits stop.
  • Serial.begin(19200, SERIAL_8E1) règle la vitesse de transmission à 19200 bauds, avec 8 bits de données, parité paire ("even")  et un bit stop.
  • Serial.begin(115200, SERIAL_8O2) règle la vitesse de transmission à 115200 bauds, avec 8 bits de données, parité impaire ("odd"), et 2 bits stop.
(Voir cette page pour tous les cas possibles.)

Parité

Le bit de parité est un bit optionnel qui peut être ajouté entre les bits de données et le bit stop afin de vérifier sommairement que l'intégrité du message a été correctement transmise. La parité peut être paire ou impaire.

Le sketch ci-dessous envoie le symbole "a" avec un bit de parité paire:


Voici le résultat:

Le bit start est suivi du nombre binaire 01100001 (ou 97 qui est le code ASCII pour "a"), du bit de parité (1), puis du bit stop.

Lorsque la parité est paire, le bit de parité prend la valeur nécessaire pour que le nombre total de bits qui sont au niveau logique haut soit paire. Dans cet exemple, si vous comptez le nombre de "1" dans le message "01100001", vous obtenez 3, qui est un chiffre impair. Puisque nous avons réglé la parité pour qu'elle soit paire, le bit de parité a pris la valeur "1" afin que le total 3 + 1 donne un résultat pair.

Voici un deuxième exemple, toujours avec une parité paire, sauf que le message est maintenant la lettre "c":


Cette fois, le bit de parité est au niveau logique bas, car le message correspondant à la lettre "c" est 01100011, qui comporte 4 bits au niveau logique haut. Ce nombre étant déjà paire, on lui additionne un bit de parité ayant la valeur "0" afin que le total demeure paire.

Comme vous pouvez le deviner, ce sera le contraire si j'envoie les mêmes messages avec un bit de parité impaire:


Si le message est "a", le bit de parité est au niveau logique bas, afin que le total des bits de niveau haut soit impair: 1 + 1 + 1 + 0 = 3:

Si le message est "c", le bit de parité est au niveau logique haut, afin que le total des bits de niveau haut soit impair:  1 + 1 + 1 + 1 + 1 = 5:


Yves Pelletier   (TwitterFacebook)

samedi 14 septembre 2019

Jouer une mélodie avec l'ESP32


La façon la plus simple de jouer une mélodie avec un Arduino, ou même avec un ESP8266, est d'utiliser la fonction "tone", qui permet de produire sur une broche un signal carré de la fréquence de notre choix.

La fonction "tone", toutefois, ne fonctionne pas avec l'ESP32.

Le billet d'aujourd'hui consistera donc à jouer une mélodie simple au moyen de l'ESP32, malgré l'absence de la fonction "tone". Pour ce faire, nous produirons un signal PWM dont nous ferons varier la fréquence. Si vous ne vous y connaissez pas trop en production d'un signal PWM avec l'ESP32, la lecture de ce précédent article pourrait vous être utile.



Circuit

Presque toutes les broches de l'ESP32 peuvent servir à produire un signal PẀM, nous avons donc l'embarras du choix. J'ai choisi, tout à fait arbitrairement, la broche GPIO 4.

Pour transformer en onde sonore les impulsions électriques générées par cette broche, vous pouvez utiliser un buzzer piézoélectrique ou un haut-parleur.

Nous ne le répéterons jamais assez: contrairement au buzzer piézoélectrique (qui a une grande résistance), ce n'est pas une bonne idée de brancher un haut-parleur directement à la sortie d'un microcontrôleur, à cause de sa très faible résistance. On utilise plutôt un transistor comme intermédiaire.

Sketch

Dans le sketch ci-dessous, une mélodie est définie au moyen d'un tableau "melodie" qui contient la hauteur de chaque note (do, ré, mi...), le numéro de l'octave et la durée.

Au début du programme, la broche GPIO 4 est associée au canal PWM numéro 0 (ledcAttachPin).

Pendant l'exécution de la mélodie, la fréquence du canal PWM 0 est réglée à la valeur adéquate (ledcSetup) et on démarre un signal PWM dont le rapport cyclique est de 50% (ledcWrite).

Pour mieux séparer les notes les unes des autres, un très bref moment de silence est inséré à la fin de chaque note (le rapport cyclique est réglé à 0).



Résultat:

Pour finir, une courte vidéo de l'ESP32 en action...


Articles similaires

D'autres articles publiés dans ce blog expliquent comment jouer une mélodie avec un Arduino,  un STM32 Nucleo,  un  ATTiny85, ou un microcontrôleur PIC.

Vous pouvez également consulter la liste des billets impliquant l'ESP32.


Yves Pelletier   (TwitterFacebook)

jeudi 12 septembre 2019

Dans un blog près de chez vous...(6)



Ça faisait longtemps...

mercredi 11 septembre 2019

Écran OLED SH1106 I2C et ESP32 ou ESP8266


Aujourd'hui, explorons comment écrire et dessiner sur un petit écran OLED monochrome branché à une carte ESP32 ou ESP8266.

L'écran en question a une taille de 1,3 pouce (environ 3,5 cm X 1,8 cm) et une résolution de 128 X 64 pixels. Il est basé sur le contrôleur SH1106 et utilise le protocole I2C. L'image produite est blanche sur fond noir.

Cet billet pourrait possiblement vous être utile même si vous utilisez un écran différent de celui que j'ai utilisé, puisque la bibliothèque u8g2 est compatible avec un très grand nombre de modèles d'écrans monochromes.

Connexions de l'afficheur à l'ESP32

  • Broche GND de l'afficheur - Broche GND de l'ESP32
  • Broche VCC de l'afficheur - Broche 3V3 de l'ESP32
  • Broche SCL de l'afficheur - Broche GPIO 22 de l'ESP32
  • Broche SDA de l'afficheur - Broche GPIO 21 de l'ESP32

Connexions de l'afficheur à l'ESP8266

  • Broche GND de l'afficheur - Broche GND de l'ESP8266
  • Broche VCC de l'afficheur - Broche 3V3 de l'ESP8266
  • Broche SCL de l'afficheur - Broche GPIO 5 de l'ESP8266
  • Broche SDA de l'afficheur - Broche GPIO 4 de l'ESP8266

Installation de la bibliothèque u8g2

Nous utiliserons la bibliothèque u8g2, qui peut facilement être installée depuis le gestionnaire de bibliothèques de l'IDE Arduino.

Essai des exemples fournis avec la bibliothèque


Évidemment, plusieurs exemples sont fournis avec la bibliothèque. Cependant, puisque la bibliothèque supporte plusieurs modèles d'écrans différents, chaque fichier d'exemple débute par une longue liste de constructeurs: il faut décommenter la ligne qui correspond au modèle d'écran que vous utilisez (dans mon cas: SH1106 128X64  I2C).


Écriture de texte à l'écran

Plusieurs dizaines de polices de caractères peuvent être utilisées pour écrire du texte à l'écran (voir la liste complète). Si vous désirez utiliser des caractères accentués, il est important de choisir une police dont le nom se termine par "f", ce qui indique que la police inclut tous les caractères nécessaires. De plus, la fonction "enableUTF8Print()" doit être appelée au démarrage du programme.


  • enableUTF8Print: pour permettre l'utilisation de caractères accentués
  • setFont: pour choisir une police de caractère
  • setCursor: pour choisir l'endroit sur l'écran où on désire écrire du texte
  • print: écriture du texte à la position du curseur

Dans un premier temps, le texte est écrit en mémoire (buffer). Il faut ensuite utiliser sendBuffer() pour transférer l'image à l'écran.



Dessiner des formes géométriques


Plusieurs fonctions facilitent le traçage de formes géométriques à l'écran:
  • drawPixel: pour dessiner un point
  • drawLine: pour dessiner une ligne droite
  • drawFrame: pour dessiner un contour de rectangle (vide)
  • drawBox: pour dessiner un rectangle plein
  • drawCircle: pour dessiner un contour circulaire (vide)
  • drawDisc: pour dessiner un cercle plein
  • drawTriangle: pour dessiner un triangle


Afficher un bitmap XBM



La fonction drawXBMP permet de tracer à l'écran une image bitmap de type XBM. J'ai obtenu de bons résultat en sauvegardant un petit dessin en format .xbm avec le logiciel Gimp, puis en ouvrant le fichier obtenu avec un éditeur de texte: j'en ai tiré le contenu de la variable "logoBitmap" dans le sketch de démonstration ci-dessous.


Un sketch

Pour finir, voici mon sketch complet,  qui fait apparaître des dessins et du texte à l'écran.




Articles similaires:

J'ai déjà utilisé le même écran OLED avec un Raspberry Pi et avec un Arduino.

Avec l'ESP32 et l'ESP8266, j'ai aussi utilisé ces afficheurs:  écran couleur SPI ST7735afficheur LCD 16 X 2afficheur 7 segments TM1638.

Vous pouvez également consulter la liste de tous mes articles concernant l'ESP8266 et l'ESP32.

Yves Pelletier   (TwitterFacebook)

samedi 7 septembre 2019

ESP32: utilisation du capteur à effet Hall intégré

Les concepteurs de l'ESP32 ont jugé utile de le munir d'un capteur à effet Hall intégré grâce auquel il est possible de détecter le champ magnétique d'un aimant placé à proximité du module.

Ce capteur se situe à l'intérieur de la partie de la carte qui est recouverte par un bouclier métallique, à peu près au centre du rectangle; il mesure la composante du champ magnétique orientée perpendiculairement à la carte.

L'exemple "HallSensor", accessible dans l'IDE Arduino par les menus "Fichier - Exemples - ESP32 - HallSensor" constitue une façon simple et rapide de vérifier le bon fonctionnement du capteur à effet Hall (au besoin, vous pouvez vous référer à ce précédent billet pour apprendre comment programmer l'ESP32 au moyen de l'IDE Arduino).


Prenez soin de ne pas brancher quoi que ce soit aux broches GPIO36 et GPIO39, car leur ADC est utilisé lors de l'utilisation du capteur à effet Hall.

En ce qui concerne la programmation dans l'IDE Arduino, la lecture du champ magnétique au moyen du capteur à effet Hall intégré se limite à l'utilisation de la fonction "hallRead()", qui retourne un entier.

Voici ce que j'ai obtenu en avec l'exemple "HallSensor", lorsqu'aucun aimant n'était placé à proximité du module ESP32: les valeurs affichées varient entre 32 et 40.


J'ai ensuite placé un petit aimant tout proche du centre du bouclier métallique du module ESP32 (j'avais collé l'aimant à l'extrémité d'un petit support en carton afin de faciliter les manipulations).


Les valeurs mesurées dépendent du pôle de l'aimant qui fait face au module ESP32. Pour un sens, les valeurs diminuent (elles peuvent même devenir négatives).



...alors qu'en plaçant l'aimant dans l'autre sens, les valeurs augmentent aux environs de 100.


D'après mes observations, il est difficile de mesurer quoi que ce soit si l'aimant est situé à plus de quelques millimètres du centre du bouclier métallique. Pour une mesure plus précise du champ magnétique, des capteurs externes me semblent plus appropriés (voir par exemple le HMC5883L ou le A1302).

Pour détecter la présence d'un aimant tout près de l'ESP32, par contre, il n'y a pas de doute: le module à effet Hall intégré fonctionne très bien.

Détecter l'ouverture d'une porte 

On pourrait penser à une application où l'ESP32 est fixé à un cadre de porte. Lorsque la porte est fermée, un aimant est appuyé contre l'ESP32, et cet aimant s'éloigne de l'ESP32 lorsqu'on ouvre la porte. Grâce aux mesures effectuées par le capteur à effet Hall intégré, l'ESP32 sait quand la porte est ouverte ou non. Et puisqu'il s'agit d'un ESP32, pourquoi ne pas afficher les résultats dans une page web?

C'est ce que fait le sketch ci-dessous: il s'agit d'un serveur web qui affiche la date et l'heure des 10 plus récentes ouvertures de la porte.



Au démarrage, du programme, le moniteur série nous indique l'adresse IP du serveur web.


En tapant cette adresse IP dans un navigateur, on accède à la page web qui indique la date et l'heure des plus récentes ouvertures de la porte.


Si vous désirez utiliser vous-mêmes le sketch, vous devez évidemment assigner aux constantes ssid et password les valeurs correspondant à votre réseau WiFi, mais également vérifier que la valeur de la constante Hallnormal correspond à ce qu'affiche votre capteur en absence de l'aimant, et régler la constante decalage afin que l'heure affichée corresponde bien au pays dans lequel vous vous trouvez,


Yves Pelletier   (TwitterFacebook)

lundi 2 septembre 2019

ESP32: production d'un signal analogique

L'ESP32 comporte deux convertisseurs numérique / analogique (DAC) à 8 bits, ce qui permet de produire un véritable signal analogique, c'est à dire une tension pouvant prendre n'importe quelle valeur située entre 0 et 3,3 V (à ne pas confondre avec un signal modulé en largeur impulsion, PWM, que nous avons également traité dans un récent billet).


Broches GPIO

Deux broches peuvent servir de sortie analogique: GPIO 25 et GPIO 26.

La fonction dacWrite()

Si vous programmez l'ESP32 avec l'IDE Arduino, vous pouvez facilement contrôler la tension des sorties analogiques au moyen de la fonction dacWrite().

Cette fonction prend deux paramètres en argument: le numéro de la broche GPIO que vous désirez contrôler (25 ou 26) et une valeur située entre 0 et 255 qui représente la tension désirée (0 pour 0 volt, et 255 pour 3,3 volts).

Par exemple, pour régler la broche GPIO 25 à une valeur de 1 volt, vous écrivez: "dacWrite(25, 77);" puisque 77 * 3,3 / 255 = 1.

Sketch minimaliste

Le sketch ci-dessous présente le strict minimum pour produire un signal analogique périodique. Résultat: un signal en dent de scie.


Amplitude et fréquences contrôlables par potentiomètre

Voici un deuxième sketch un tout petit peu plus ambitieux: cette fois, nous produisons un signal sinusoïdal dont l'amplitude et la fréquence peuvent être modifiées grâce à deux potentiomètres.






Yves Pelletier   (TwitterFacebook)


mardi 27 août 2019

Écrire sur une carte SD avec l'ESP32

Voyons un peu comment procéder pour écrire ou lire des fichiers sur une carte SD avec un ESP32. Ça peut s'avérer utile pour archiver des valeurs mesurées par des capteurs branchés à l'ESP32, par exemple.

En plus de l'ESP32 et d'une carte SD, nous aurons besoin d'un lecteur de carte SD du genre illustré ci-dessous, qui communique avec le microcontrôleur au moyen du protocole SPI (en fait, il est possible de lier directement les broches de l'ESP32 aux connecteurs de la carte, mais ça ne me semble pas très pratique).



Nous programmerons l'ESP32 au moyen de l'IDE Arduino donc, au besoin, vous pouvez vous référer à ce précédent tutoriel pour obtenir des informations supplémentaires.

Connexions

Puisque le module communique par SPI, les connexions sont les suivantes:
  • GND du module SD --- GND de l'ESP32
  • +3.3 du module SD --- 3V3 de l'ESP32
  • +5 du module SD --- pas branché
  • CS du module SD --- GPIO 5 de l'ESP32*
  • MOSI du module SD --- GPIO 23 de l'ESP32
  • SCK du module SD --- GPIO 18 de l'ESP32
  • MISO du module SD --- GPIO 19 de l'ESP32

* La broche CS peut être modifiée dans le sketch, si désiré.

Exemple SD_Test

En général, une fois le module SD connecté, je recommande l'essai du sketch d'exemple CardInfo fourni avec l'IDE Arduino. Mais bien que ce sketch fonctionne correctement avec les cartes Arduino conventionnelles, avec l'ESP8266 et avec les cartes à base de STM32, il est incompatible avec l'ESP 32.

Nous allons plutôt nous rabattre sur le sketch SD_Test, accessible par le menu Fichier - Exemples - SD(esp32) - SD_Test.


Ce sketch comporte 8 routines utiles pour interagir avec une carte SD:
  • listDir: retourne la liste du contenu d'un répertoire
  • createDir: créé un répertoire
  • removeDir: efface un répertoire
  • readFile: lit le contenu d'un fichier
  • writeFile: remplace le contenu d'un fichier
  • appendFile: ajoute du contenu supplémentaire dans un fichier
  • renameFile: renomme un fichier
  • deleteFile: efface un fichier
L'auteur du sketch n'est pas du genre à abuser des commentaires, mais en lisant la section setup() du sketch, on parvient à avoir une assez bonne idée de la façon d'utiliser ces foncions.

Si vous exécutez ce sketch pendant qu'une carte SD se trouve dans le lecteur branché à l'ESP32, le moniteur série devrait vous présenter des informations concernant le contenu de votre carte, ce qui démontrera que vos branchements sont corrects. Si le module SD est mal branché, le moniteur série se contentera d'afficher le message "Card Mount Failed".



Exemple 1: écrire des valeurs mesurées dans un fichier texte

Dans le sketch ci-dessous, je mesure toutes les 5 secondes la valeur analogique de la broche GPIO 36, et j'enregistre le résultat dans un fichier nommé "Valeurs.txt" sur la carte SD (le fichier est créé s'il n'existe pas déjà).





Exemple 2: data logger consultable par WiFi

Ce deuxième sketch est la version ESP32 d'un projet préalablement réalisé sur l'ESP8266: en plus d'enregistrer la valeur mesurée (ainsi que la date et l'heure de la mesure) sur une carte SD, l'ESP32 produit une page web permettant de consulter les 10 mesures les plus récentes.



Articles similaires

D'autres tutoriels comportant un module lecteur de carte SD ont été publiés sur ce blog: carte SD et Arduino Uno, carte SD et ESP8266, carte SD et Bluepill, carte SD et STM32 Nucleo, carte SD et MSP430 Launchpad...

Vous pouvez également consulter la liste des articles concernant l'ESP32.


Yves Pelletier   (TwitterFacebook)

vendredi 23 août 2019

Écran couleur SPI ST7735 et ESP32 / ESP8266


Aujourd'hui, je vous prodigue quelques conseils sur l'utilisation d'un petit écran couleur de 128 X 160 pixels, utilisant le protocole SPI, et basé sur le contrôleur ST7735, avec une carte ESP32 ou ESP8266.

Il existe plusieurs écrans similaires mais comportant certaines différences (par exemple, ceux dont le contrôleur est le S6D02A1 ou encore le ILI9163). Il est possible que mes indications vous soient utiles même si votre écran n'est pas rigoureusement identique à celui que j'ai utilisé.

Mon modèle porte la mention "KMR-1.8 SPI". Il est muni d'un lecteur de carte SD (que je n'ai pas utilisé pour l'instant) et de 16 connecteurs.




Connexions

Voici la façon de brancher votre écran à l'ESP32 ou à l'ESP8266 pour pouvoir utiliser sans modification la bibliothèque de Bodmer, que je vous présente un peu plus loin.

Schéma du circuit pour un module de développement STM32 (voir description un peu plus loin).

Schéma du circuit pour une carte Wemos D1 mini (voir description ensuite).

Allons-y broche par broche ( la broche numéro 1 de l'écran est celle qui est en bas sur les schéma ci-dessus):
  • #1 GND du KMR-1.8: GND de l'ESP8266 ou de l'ESP32
  • #2 VCC du KMR-1.8: sortie 5 V de l'ESP8266 ou de l'ESP32 *
  • #3 NC du KMR-1.8: Pas branché
  • #4 NC du KMR-1.8: Pas branché
  • #5 NC du KMR-1.8: Pas branché
  • #6 RESET du KMR-1.8: GPIO 2 de l'ESP8266 ou GPIO 4 de l'ESP32
  • #7 AO du KMR-1.8: GPIO 0 de l'ESP8266 ou GPIO 2 de l'ESP32
  • #8 SDA du KMR-1.8: GPIO 13 de l'ESP8266 ou GPIO 23 de l'ESP32
  • #9 SCL du KMR-1.8: GPIO 14 de l'ESP8266 ou GPIO 18 de l'ESP32
  • #10 CS du KMR-1.8: GPIO 15 de l'ESP8266 ou GPIO 15 de l'ESP32
  • #11 SCK du KMR-1.8: pas branché (lecteur de carte SD)
  • #12 MISO du KMR-1.8: pas branché (lecteur de carte SD)
  • #13 MOSI du KMR-1.8: pas branché (lecteur de carte SD)
  • #14 SD_CS du KMR-1.8: pas branché (lecteur de carte SD)
  • #15 LED+ du KMR-1.8: 3.3 V **
  • #16 LED- du KMR-1.8: GND
* Mon écran comporte un régulateur de tension 65z5 (portant la désignation "U2" sur le circuit imprimé) qui permet d'alimenter le module avec une tension de 5 V (si vous préférez l'alimenter avec 3,3 V, il faut fermer par une soudure le jumper "JP1" au verso de l'écran). Notez que certains écrans en apparence identiques sont conçus pour être alimentés avec 3,3 V! Sur ma carte ESP32, la broche "VIN" est directement liée au 5 V de l'alimentation USB et constitue donc une excellente sortie 5 V.

** Pour le rétroéclairage, j'ai utilisé une résistance de protection d'une centaine de ohms, mais elle ne semble pas obligatoire.

Installation de la bibliothèque TFT_eSPI

TFT_eSPI est une bibliothèque spécialement conçue pour piloter des écrans TFT SPI avec l'ESP32 ou l'ESP8266. Elle est compatible avec les contrôleurs ILI9341, ILI9163, ST7735, S6D02A1, ILI9481, ILI9486, ILI9488, HX8357D et ST7789! Elle a été conçue par Bodmer, le même qui a fait des bibliothèques similaires pour l'Arduino. Vous pouvez installer la bibliothèque TFT_eSPI par l'entremise du gestionnaire de bibliothèque de l'IDE Arduino.

Modifications à apporter au fichier User_Setup.h

Une fois la bibliothèque installée, il est très important d'ouvrir le fichier "User_Setup.h" afin d'y sélectionner les paramètres qui conviennent à votre écran. Le chemin d'accès, à partir de votre dossier "libraries", est "libraries / TFT_eSPI / User_Setup.h".

Parmi tous les contrôleurs énumérés, il faut en choisir un seul: pour mon écran, c'est le ST7735.


Ensuite, je choisi la définition qui correspond à mon écran: 128 pixels de largeur et 160 pixels de hauteur.

Il existe plusieurs variantes d'écrans basés sur le ST7735, et Bodmer les a classés selon la couleur de l'onglet de la pellicule qui protégeait l'écran lors de l'achat. En général, on les essaie au hasard jusqu'à ce qu'on tombe sur celle qui fonctionne; dans mon cas, il s'agit du ST7735_BLACKTAB. Si vous choisissez la mauvaise variante, votre écran fonctionnera quand même, mais avec les mauvaises couleurs, ou avec des bandes de pixels aléatoires sur les bords de l'image.

Si vous utilisez un ESP8266, il faut décommenter les lignes qui indiquent le numéro des broches reliées à CS, DC et RST. Bodmer a utilisé la numérotation des cartes NodeMCU. Si vous utilisez une carte ESP8266 qui ne respecte pas la même convention, utilisez plutôt les numéros de GPIO: remplacez "PIN_D8" par "15", "PIN_D3" par "0", et "PIN_D4" par "2".
Si vous utilisez un ESP32, les lignes à décommenter se trouvent un peu plus bas:


Exécution des exemples fournis avec la bibliothèque

Pour vérifier le fonctionnement correct de votre écran, il est temps de faire l'essai de quelques-uns des nombreux exemples fournis avec la bibliothèque (Menu Fichier / Exemples / TFTeSPI / 160 X 128 ). Si tout va bien, vous devriez voir apparaître une image sur l'écran. Si rien n'apparaît à l'écran, ça peut être causé par une connexion incorrecte, ou un paramètre mal réglé dans le fichier User_Setup.h ... bonne chance!



Quelques sketches

Je vous présente un premier sketch qui ne fait rien de très utile sauf explorer quelques fonctions simples de la bibliothèque:
  • setRotation: pour régler l'écran en mode portrait ou en mode paysage
  • fillScreen: pour remplir tout l'écran avec la couleur désirée
  • setTextColor: pour choisir la couleur du texte à écrire
  • drawString: pour écrire un texte qui débute à la position choisie
  • drawCentreString: pour écrire un texte dont le centre se trouve à la position choisie
  • drawLine: pour tracer une droite entre deux positions
  • drawRect: pour tracer le contour d'un rectangle
  • drawCircle: pour tracer le contour d'un cercle
  • drawRoundRect: pour tracer le contour d'un rectangle à coins arrondis
  • drawTriangle: pour tracer un triangle
  • fillRect: pour tracer un rectangle plein
  • fillCircle: pour tracer un cercle plein
  • fillRoundRect: pour tracer un rectangle plein à coins arrondis
  • fillTriangle: pour tracer un triangle plein
  • drawPixel: pour tracer un point


La vidéo ci-dessous permet de constater le résultat.



Un deuxième sketch présente à l'écran la mesure de l'entrée analogique A0.


Articles similaires

Le même écran a également été utilisé avec une carte Arduino Uno.  Vous pouvez également consulter la liste des articles concernant l'ESP8266 et l'ESP32.


Yves Pelletier
   (TwitterFacebook)


Related Posts Plugin for WordPress, Blogger...