Examen des modules d’affichage ESP32 de 3,5 pouces et 7,0 pouces d’Elecrow utilisant la programmation Arduino

Bonjour, je suis ravi de tester les modules d’affichage ESP32 et les écrans tactiles HMI d’Elecrow avec des tailles allant de 2,4 à 7,0 pouces. Pour cette test, Elecrow m’a gentiment fourni des modèles de 3,5 pouces et de 7,0 pouces. Bien que leurs écrans diffèrent en taille, les deux modules partagent plusieurs composants, tels que le microcontrôleur ESP32, ce qui en fait des options adaptables à une variété de projets.

Le module d’affichage Elecrow 7,0 pouces est alimenté par le module ESP32-S3-WROOM-1-N4R8 équipé d’un microprocesseur ESP32-S3 dual-core LX6 32 bits, 4 Mo de flash, 384 Ko de ROM et 512 Ko de SRAM. Ce microcontrôleur prend en charge à la fois le WiFi et le Bluetooth pour la communication sans fil. L’écran de 7,0 pouces lui-même est un écran tactile capacitif avec une résolution de 800 × 480 pixels. L’écran est contrôlé par le pilote EK9716BD3/EK73002ACGB et est compatible avec LVGL pour des fonctionnalités supplémentaires.

Dans le cas du module d’affichage de 3,5 pouces, la principale différence réside dans l’utilisation du module ESP32-WROOM-32-N4 basé sur le processeur ESP32 dual-core LX6 avec 520 Ko de SRAM (un peu plus que la version 7,0 pouces). ). L’écran est un écran tactile résistif LCD avec une résolution de 320 × 480 pixels et il est contrôlé par le pilote ILI9488.

L’appareil prend en charge la programmation via divers IDE, frameworks et langages, notamment l’IDE Arduino, l’Espressif IDF, PlatformIO et MicroPython. De plus, les deux modules sont équipés de connecteurs I2C et de broches GPIO pour l’extension. Les appareils prennent également en charge les connexions UART, et de plus amples détails et spécifications peuvent être trouvés dans le tableau récapitulatif du fabricant ci-dessous.

Déballage des modules d’affichage Elecrow ESP32

Les deux présentoirs d’échantillons ont été soigneusement emballés dans une boîte en carton et expédiés depuis la Chine. En ouvrant la boîte, j’ai trouvé le papier bulle enroulé autour des deux écrans, chaque écran étant emballé séparément dans sa propre boîte en carton. La taille des cartons et du papier bulle était parfaite. Une fois manipulé, le colis semblait solide et sécurisé. L’assemblage des composants sur les PCB a été réalisé avec soin. Les PCB utilisaient des masques de soudure rouges et une sérigraphie blanche.

À l’intérieur de la boîte de l’écran de 7 pouces, il y avait un jeu d’écrans, un câble Crowtail/Grove vers DuPont à 4 broches et un câble USB Type-C. De plus, le fabricant a également fourni un boîtier pour l’écran composé de feuilles acryliques de 6 mm d’épaisseur. Dans mon cas, le fabricant a déjà assemblé le module d’écran dans le boîtier en acrylique et l’a solidement fixé avec des vis.

L’emballage du module écran de 3,5 pouces était également bien conçu et offrait une protection adéquate au produit. À l’intérieur de la boîte, j’ai trouvé un jeu d’écran, un stylet pour interagir avec l’écran, un câble Crowtail/Grove vers DuPont à 4 broches et un câble USB Type-C. Le constructeur a également fourni un boîtier en acrylique, mais celui-ci n’est pas encore assemblé. L’assemblage du module d’affichage dans le boîtier en acrylique donne lieu à une expérience similaire, offrant une sensation de robustesse et de construction avec une bonne épaisseur.

Test avec le firmware d’usine

Lors de mon test initial, j’ai connecté l’écran à mon ordinateur portable à l’aide du câble USB Type-C fourni et je l’ai branché sur le port USB des cartes. Lorsque les appareils ont démarré, ils affichaient le même code de démonstration d’usine, comme indiqué sur le site Web du fabricant et sur YouTube. J’ai commencé à interagir en touchant divers éléments de l’interface utilisateur sur les écrans avec mes doigts et le stylet fourni. Dans l’ensemble, j’ai trouvé que cela fonctionnait normalement, mais il n’était peut-être pas aussi fluide ou réactif que dans les vidéos promotionnelles. La netteté et la luminosité des couleurs étaient également à un niveau normal pour ce type d’écran. Les angles de vision sont quelque peu limités par les caractéristiques des dalles d’affichage TN. Il ne correspond peut-être pas aux performances des écrans IPS, mais l’écran reste adapté à diverses applications.

Flasher le programme de démonstration d’usine à l’aide de l’IDE Arduino

Les appareils prennent en charge le développement via divers IDE comme mentionné ci-dessus, mais dans cette test, j’ai décidé de les tester avec l’IDE Arduino. Le fabricant a fourni des guides expliquant les étapes nécessaires à l’installation de la bibliothèque requise, disponibles sur son site Web, ainsi que des démonstrations vidéo sur YouTube. Cependant, au début, j’étais un peu confus quant à l’endroit où trouver les exemples de codes ou les détails des bibliothèques nécessaires. En effet, les informations sur le site Web et les exemples de vidéos sur YouTube diffèrent à de nombreux endroits. Cependant, après avoir passé un certain temps, j’ai trouvé que les informations nécessaires pour flasher le programme sont plus faciles à suivre si vous regardez le Wiki pour l’écran de 7 pouces et l’écran de 3,5 pouces. Vous pouvez également trouver l’exemple de code dans le référentiel GitHub du fabricant.

Préparation de l’IDE Arduino

Le guide d’installation ne précise pas la version de l’IDE Arduino. Le site Web et les exemples vidéo YouTube utilisent Arduino IDE version 1.8.19. Cependant, pour cet examen, je voulais tester si l’utilisation d’une version plus récente de l’IDE Arduino poserait des problèmes. Par conséquent, j’ai choisi d’installer la dernière version de l’IDE Arduino, qui au moment de la rédaction de cette critique est la version 2.2.1.

Après avoir préparé l’IDE, j’ai téléchargé le fichier nécessaire comme indiqué sur le site Web du fabricant. En résumé, nous pouvons utiliser le Arduino_35.zip pour l’écran de 3,5 pouces et le Arduino_7inch.zip fichier pour l’écran de 7,0 pouces à partir du référentiel GitHub mentionné ci-dessus.

Pour les autres configurations dans l’IDE Arduino, le fabricant recommande de définir l’URL du gestionnaire de carte supplémentaire sur https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Ensuite, installez la carte ESP32. Le constructeur nous recommande de choisir la carte ESP32 version 2.0.3. L’autre configuration nécessaire pour chaque carte se résume comme suit :

Configuration pour écran de 7,0 pouces :

• Carte : MODULE de développement ESP32S3
• Mode Flash : QIM 80 MHz
• Taille du flash : 4 Mo (32 Mo)
• Schéma de partition : énorme application (3 Mo sans OTA/1 Mo SPIFFS)
• PSRAM : PSRAM OPI

Configuration pour écran de 7,0 pouces :

• Carte : MODULE ESP32S3-WROOM-DA
• Mode Flash : QIM 80 MHz
• Taille du flash : 4 Mo (32 Mo)
• Schéma de partition : énorme application (3 Mo sans OTA/1 Mo SPIFFS)

Préparez les exemples de code pour l’écran de 7 pouces

Après avoir téléchargé le Arduino_7inch.zip fichier, nous devons installer manuellement la bibliothèque nécessaire en copiant tous les fichiers du dossier bibliothèques à l’intérieur Arduino_7inch au chemin des bibliothèques de l’IDE ​​Arduino lui-même. Si nous craignons que ces bibliothèques soient redondantes ou causent des problèmes avec les bibliothèques existantes, nous pouvons également spécifier le chemin de cette bibliothèque ailleurs. Pour ce faire, ouvrez le File/Preferences et réglez le Sketchbook location au chemin que vous voulez.

Ensuite, j’ai ouvert le HMI-7.ino fichier et j’ai essayé d’ajouter la commande Serial.println("Yes!"); à la dernière ligne du setup() fonction pour vérifier si le nouveau code était en cours d’exécution. Ensuite, j’ai essayé de le compiler. Le premier problème courant que j’ai trouvé était que le Arduino GFX library manquait toujours. J’ai donc installé la version 1.3.1 et réessayé. La compilation a pris un moment et, même si j’ai remarqué plusieurs avertissements, le code a été compilé sans aucun problème.

Préparation des exemples de code pour l’écran de 3,5 pouces

Pour flasher l’exemple de code de démonstration d’usine sur cet écran, le processus est similaire à l’exemple mentionné précédemment. Nous devons placer la bibliothèque de la carte dans le dossier « bibliothèques » d’Arduino. De plus, nous devons remplacer le User_Setup.h fichier de la bibliothèque TFT_eSPI avec le fichier du firmware téléchargé pour garantir que les paramètres TFT_eSPI correspondent à notre appareil.

Pour cet écran, j’ai utilisé le fichier LVGL_Arduino3.5RTP-Hor.ino du dossier 3.5-Factory-Program\3.5-Factory-Program\LVGL_Arduino3.5RTP-Hor\extrait du 3.5-Factory-Program.zip déposer. Pour moi, la compilation s’est faite sans problème supplémentaire.

Téléchargement du code sur les modules d’affichage Elecrow ESP32

Pour télécharger le binaire sur la carte, vous devez d’abord mettre les modules d’affichage ESP32 en mode téléchargement. Vous pouvez le faire en maintenant enfoncé le bouton BOOT de la carte, suivi d’un appui court sur le bouton RESET, puis en relâchant le bouton BOOT. Une fois réussi, le tableau entrera en mode de téléchargement et l’écran deviendra noir. Vous pouvez ouvrir la fenêtre Serial Monitor pour vérifier si la carte est entrée en mode de téléchargement. Le tableau affichera le message ‘waiting for download‘ si l’entrée en mode téléchargement est réussie.

Une fois en mode téléchargement, appuyez sur le bouton « Télécharger » dans l’IDE Arduino pour flasher le programme sur la carte. Après avoir téléchargé avec succès sur le tableau, appuyez à nouveau sur le bouton RESET du tableau pour redémarrer. Vous pouvez maintenant utiliser le nouveau programme comme prévu.

Les détails sur mes modules reçus pendant le processus de téléchargement sont fournis ci-dessous.

Écran de 7,0 pouces :

• Sketch utilise 1 707 637 octets (54 %) d’espace de stockage du programme. Le maximum est de 3 145 728 octets.
• Les variables globales utilisent 94 316 octets (28 %) de mémoire dynamique, laissant 233 364 octets pour les variables locales. Le maximum est de 327 680 octets.
• La puce est ESP32-S3
• Caractéristiques : Wi-Fi, BLE
• Le cristal est à 40 MHz

Écran de 3,5 pouces :

• Sketch utilise 2375949 octets (75 %) d’espace de stockage du programme. Le maximum est de 3 145 728 octets.
• Les variables globales utilisent 74 536 octets (22 %) de mémoire dynamique, laissant 253 144 octets pour les variables locales. Le maximum est de 327 680 octets.
• La puce est ESP32-D0WDQ6 (révision 1)
• Caractéristiques : WiFi, BT, Dual Core, 240 MHz, calibrage VRef dans efuse, schéma de codage Aucun
• Le cristal est à 40 MHz

Après avoir examiné le code du module d’affichage de 3,5 pouces, j’ai découvert que ce programme de démonstration d’usine dispose d’un mode de test que nous pouvons essayer. Pour ce faire, nous tapons ‘b‘ dans le moniteur série et sélectionnez le mode que nous souhaitons tester en fonction des informations ci-dessous. En résumé, il existe plusieurs modes de test pour différents composants de la carte, comme par exemple taper ‘R‘ pour afficher l’écran en rouge, tester les signaux GPIO, tester l’écran tactile et la connexion WiFi, etc. Chaque mode fournit des informations supplémentaires à lire via le moniteur série, et vous pouvez quitter chaque mode en tapant la lettre minuscule ‘i‘.

Voici la liste des commandes disponibles.

• R : Affiche l’écran en rouge
• G : Affiche l’écran en vert
• B : Affiche l’écran en bleu
• S : Teste la carte SD
• T : Teste l’écran tactile
• L : teste les broches GPIO
• i : Teste l’interface I2C
• W : Teste la connexion WiFi
• U : Teste le port série
• P : Teste le haut-parleur
• V : Teste la connexion Bluetooth
• I : Quitte le mode test actuel et revient au menu principal
• C : Quitte le mode test et revient à l’écran normal

Exemples d’applications

Pour expérimenter d’autres composants tels que GPIO-D, I2C, TF et UART-1, j’ai testé les exemples pour chaque carte et constaté qu’ils fonctionnaient comme prévu. Par conséquent, pour la partie restante de cette test, je testerai la fonctionnalité en réalisant deux mini-projets. J’utiliserai le module à écran tactile de 7,0 pouces comme tableau de bord pour afficher les données sur la qualité de l’air, et le module à écran tactile de 3,5 pouces pour afficher les valeurs obtenues à partir d’un module multispectromètre via le port I2C.

Mini-projet 1 : Tableau de bord sur la qualité de l’air avec module d’affichage Elecrow ESP32 de 7 pouces

Pour que les données sur la qualité de l’air soient affichées, j’utiliserai les informations d’AirGradient ONE que j’ai examinées plus tôt. J’ai apporté de légers ajustements au code côté serveur simplement pour prendre en charge HTTP GET/POST demandes de récupération des dernières données de mesure et réponse au format JSON. Dans cette test, il y a 11 valeurs à afficher, selon le JSON format ci-dessous.

{"result":"OK","data":[{"id":"32403","date_time":"2023-12-31 09:36:04","tvoc":"67","nox":"2","co2":"422","pm25":"20","pm01":"12","pm10":"20","pm03pcount":"2229","temp":"29.6","hum":"62"}]}

Après cela, j’ai conçu l’interface utilisateur pour afficher les données à l’aide de SquareLine Studio version 1.3.2. Dans cet exemple de programme, j’ai divisé l’écran en trois parties. La première partie sert à afficher la date et l’heure. La deuxième partie affiche les données de température et d’humidité. La troisième partie affiche les données restantes. J’ai défini les valeurs nécessaires dans SquareLine Studio comme suit.

• Créer/Arduino avec TFT_eSPI
• Résolution : 800 × 480
• Profondeur de couleur : 16 bits
• Choisissez la version LVGL en fonction de la version de la bibliothèque de l’appareil : 8.3.3

J’ai utilisé le 7.0-inch_Squareline_Demo.ino fichier du GitHub du fabricant comme code de démarrage. J’ai ajouté du code lié à la connexion WiFi et utilisé Arduino JSON version 0.2.0 pour gérer les données JSON du serveur comme indiqué ci-dessous.

</p> <p>void request_data() { String url = API_ENDPOINT + « /get.php?m=latest »; Serial.println(« Envoi de la demande : « ); Série.println(url); http.begin(url.c_str()); http_request_payload = « api_key=KEY&m=MODE »; http.addHeader(« Content-Type », « application/x-www-form-urlencoded »); http_response_code = http.POST(http_request_payload); Serial.print(« Code de réponse : « ); Série.println(http_response_code); if(http_response_code > 0){ String réponse_text = http.getString(); Serial.print(« Texte de réponse : « ); Serial.println(response_text); JSONVar my_json_obj = JSON.parse(response_text); Serial.print(« Résultat : « ); Serial.println(my_json_obj[« result »]); Serial.print(« données: « ); Serial.println(my_json_obj[« data »]); // Afficher les dernières données show_data(my_json_obj[« data »][0]); } http.end(); }

J’ai ensuite mis à jour les éléments de l’interface utilisateur en utilisant le update_arc et update_bar les fonctions. Les fonctions prennent simplement la valeur des données (val), le plus bas (min) et supérieur (max) limites, ainsi que la valeur seuil (t0, t1, t2) pour déterminer la couleur de plages spécifiques. La valeur d’entrée sera mise à l’échelle sur une plage de 0 à 100 et l’élément d’interface utilisateur donné sera mis à jour selon les fonctions ci-dessous.

</p> <p>void update_arc(lv_obj_t *arc, float val, float min, float max, float t0, float t1, float t2) { float y = 100,0 * ((val – min)/(max – min)); si(y <= 0,0) { y = 0,0; } si(y >= 100,0) { y = 100,0; } lv_arc_set_value(arc, int(y)); if((val >= min) && (val < t0)) { // Bleu lv_obj_set_style_arc_color(arc, color_value_low, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } else if((val >= t0) && (val < t1)) { // Vert lv_obj_set_style_arc_color(arc, color_value_normal, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } else if((val >= t1) && (val < t2)) { // Jaune lv_obj_set_style_arc_color(arc, color_value_high, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } else if(val >= t2) { // Rouge lv_obj_set_style_arc_color(arc, color_value_very_high, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } else { lv_obj_set_style_arc_color(arc, color_value_error, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } }

</p> <p>void update_bar(lv_obj_t *bar, float val, float min, float max, float t0, float t1, float t2) { float y = 100,0 * ((val – min)/(max – min)); si(y <= 0,0) { y = 0,0; } si(y >= 100,0) { y = 100,0; } lv_bar_set_value(bar, int(y), LV_ANIM_OFF); if((val >= min) && (val < t0)) { // Bleu lv_obj_set_style_bg_color(bar, color_value_low, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } else if((val >= t0) && (val < t1)) { // Vert lv_obj_set_style_bg_color(bar, color_value_normal, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } else if((val >= t1) && (val < t2)) { // Jaune lv_obj_set_style_bg_color(bar, color_value_high, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } else if(val >= t2) { // Rouge lv_obj_set_style_bg_color(bar, color_value_very_high, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } else { lv_obj_set_style_bg_color(bar, color_value_error, LV_PART_INDICATOR | LV_STATE_DEFAULT ); } }

Mini-projet 2 : Affichage multispectromètre avec module d’affichage Elecrow ESP32 de 3,5 pouces

Je suis maître de conférences dans une université en Thaïlande. Nous proposons généralement des cours qui utilisent des multispectromètres pour comparer la réflectance de plantes ou d’autres objets au sol avec les valeurs analysées à partir d’images satellite. Le problème est que si ces appareils offrent des mesures à haute résolution, ils sont souvent très coûteux, allant de plusieurs milliers à plusieurs dizaines de milliers de dollars américains pour certains modèles. Cela peut limiter les possibilités de mes étudiants d’acquérir une pratique pratique et d’effectuer une analyse complète des données.

Par conséquent, pour la dernière partie de cet examen et de ces tests, j’expérimenterai l’écran de 3,5 pouces avec le module Sparkfun AS7341 (malheureusement, ce module n’est plus en production). L’objectif est de créer un appareil portable et rentable pour mesurer des valeurs. Ce module est un capteur multispectral économique conçu pour mesurer la lumière sur différentes longueurs d’onde. Il utilise le capteur AS7341 d’AMS, capable de mesurer la lumière dans 11 plages de longueurs d’onde, allant de la couleur bleue (415 nanomètres) au proche infrarouge (NIR) (915 nanomètres). Le module prend en charge à la fois Qwiic et I2C Connexions.

J’ai connecté le module d’affichage au capteur AS7341 via I2C à l’aide des câbles fournis par le fabricant. Cependant, j’ai rencontré des problèmes en essayant d’utiliser le capteur avec la bibliothèque Arduino Sparkfun AS7341X (ce qui s’est également produit avec de nombreuses cartes ESP32 que je possède). J’ai ensuite testé la connexion avec la bibliothèque Arduino Adafruit AS7341, qui est conçue pour un module différent mais utilise le même capteur AS7341. Grâce à la bibliothèque d’Adafruit, je peux me connecter au capteur. Même si je ne peux pas contrôler les LED blanches, NIR et UV sur le module de capteur, je peux appeler les fonctions pour tester le scan avec succès. Je vais donc utiliser la bibliothèque d’Adafruit pour démontrer l’application.

Un problème mineur que j’ai trouvé à cette étape est que les broches I2C du module d’affichage reçu sont définies comme SDA = 22 et SCL = 21, ce qui pourrait être confondu avec la configuration typique d’autres cartes ESP32 oùSDA est souvent fixé à 21 et SCL comme 22. Pour résoudre ce problème, j’ai simplement ajusté le Wire.begin() appelez en ajoutant les numéros de broches corrects comme paramètres.

Dans cette démonstration, je vais simplement lire les valeurs de lumière du capteur sans effectuer aucun étalonnage. Les valeurs obtenues du capteur seront sous la forme de uint16_t, acquises à l’aide du readAllChannels() fonction, puis transmis à une autre fonction pour mettre à jour les éléments de l’interface utilisateur. L’interface utilisateur a été conçue à l’aide de SquareLine Studio version 1.3.2, affichant à la fois des graphiques à barres et du texte. Cependant, comme les données des canaux C4 (clair) et C5 (NIR) sont répétées avec les canaux C10 (clair) et C11 (NIR), mon programme n’affichera pas les valeurs de C4 et C5 dans le graphique mais les affichera quand même dans étiquettes, comme le montre l’exemple de conception ci-dessous.

La dernière partie consistait à ajouter du code pour enregistrer les résultats de l’analyse sous forme de fichier CSV pour une utilisation ultérieure. L’utilisation de la carte SD est également pratique et ne pose aucun problème. Cependant, nous devons nous assurer que l’appareil tactile est arrêté pendant l’utilisation de la carte SD. Après avoir écrit le fichier, nous pouvons reprendre la fonctionnalité de l’appareil tactile. De plus, j’ai ajouté l’utilisation de la broche GPIO-25 pour activer une LED externe pendant la numérisation. Les résultats sont présentés dans les exemples d’images ci-dessous.

Autres

Elecrow est un fabricant de matériel open source. En plus des différents codes sources mentionnés ci-dessus, le fabricant fournit également des fichiers de PCB et de schémas de principe que nous pouvons étudier et développer davantage. Toute personne souhaitant en savoir plus sur les circuits peut ouvrir et visualiser les fichiers de PCB et de schémas de principe pour les écrans de 3,5 pouces et 7 pouces dans le dossier SCH+PCB du référentiel GitHub mentionné ci-dessus. Je peux les ouvrir avec la licence Autodesk EAGLE 9.6.2 Education sans aucun problème.

Conclusion

En résumé, les deux jeux d’écrans fonctionnent bien. La programmation avec Arduino IDE est également pratique car les bibliothèques fournies sont assez complètes et peuvent être utilisées immédiatement sans avoir à ajuster la version. Les écrans sont également lumineux et colorés, comme d’habitude pour les écrans LCD TFT. Personnellement, j’aimerais ajouter un port GPIO ou SPI supplémentaire pour prendre en charge plus de fonctionnalités. Pour l’écran de 3,5 pouces, entrer dans le mode de téléchargement en appuyant sur les boutons RESET et BOOT peut se faire d’une seule main, mais cela peut ne pas être très pratique car les fentes du boîtier autour des deux boutons sont un peu trop étroites (ou peut-être mon les doigts sont trop gros, je ne suis pas sûr).

En fait, dans cette test, j’avais l’intention d’utiliser les deux écrans avec la carte SONY Spresense pour afficher diverses informations du système satellite japonais Quasi-Zenith (QZSS), qui est un système mondial de navigation par satellite, similaire au système de positionnement global (GPS). ) des États-Unis. J’avais également prévu de présenter sur les écrans les données d’alerte d’urgence intégrées aux signaux du satellite QZSS. Cependant, en raison de contraintes de temps, je séparerai l’utilisation des écrans avec le SONY Spresense dans un autre article.

Enfin, je voudrais remercier Elecrow de m’avoir fourni l’écran HMI ESP32 de 3,5 pouces et l’écran HMI ESP32 de 7,0 pouces pour les tests. Si quelqu’un est intéressé, il peut acheter directement auprès du fabricant et à partir de maintenant, l’écran de 3,5 pouces examiné ici avec un boîtier en acrylique est au prix de 20,63 USD, et l’écran de 7,0 pouces se vend à 34,53 USD.

Retrouvez l’histoire de Raspberry Pi dans cette vidéo :