Découvrir les possibilités et la philosophie des écrans Nextion
Je ne vais pas détailler toutes les opérations nécessaires à l'utilisation des écrans Nextion, je vais simplement vous faire part de ma découverte
de cette nouvelle approche de codage. Quand on utilise un Arduino une des principales préoccupations est de surveiller l'occupation mémoire du code et des variables.
Avec l'arrivée des Esp-8266 et Esp-32, la préoccupation sur la mémoire restante est devenue moins préoccupante, mais cependant pour exploiter
des images, voire de la vidéo avec ces processeurs reste compliqué, il faut mettre en oeuvre la mémoire SPIFFS...
Pour ce test ma principale préoccupation a donc été de voir si les écrans Nextion pouvaient faciliter cela...
Les possibilités que j'ai découverte avec ces écrans sont vraiment nouvelles (en tout cas pour moi !) :
Seulement deux sorties Gpio sont nécessaire, toutes les autres entrées sorties restent donc disponible pour le projet !
Toute la partie IHM (Interface Homme Machine) est codée coté écran à l'aide d'une interface sur PC très ergonomique. Cela veut donc dire que
comme le code est stocké coté écran il reste presque toute la mémoire disponible pour le projet coté processeur.
Le fait que l'affichage soit réalisé derrière une liaison série va par contre interdire certains projets ou la vitesse est primordiale,
si vous avez besoin d'afficher un dialogue qui, arrive sur une autre entrée série à 115200 bauds ça va coincer (même si vous pouvez régler le
dialogue entre l'UC et l'Ecran à cette même vitesse !).
En résumé je pense que ce type d'écran est vraiment génial sur certains projets mais qu'il faut parfois revenir à des écrans plus traditionnels.
En tout cas pour les débutants ce type d'écran est TOP, codage basique avec une interface graphique sur PC (ni linux ni Mac) !
Fin du blabla on découvre l'interface entre l'UC et l'écran
Voici donc les deux écrans Nextion 4.3 inch et 2.4 inch que j'ai à dispo. Le plus grand est un modèle "Enhanced"
et le petit un "Basic". Il est important de bien repérer le Numéro qui est gravé sur le CI en (1) la lettre T représente le type basic
et en (2) la lettre K le Enhanced. Ce numéro va être nécessaire pour identifier le type dans l'appli sur PC Nextion...
Chaque écran est livré (3) avec un petit adaptateur usb vers deux pins d'alim et un petit câble en (4) pour la connexion.
Il faut récupérer sur internet avec le lien Nextion le fichier zip qui contient "L'interface PC".
Une fois le fichier dezipé, faire "Nouveau" et suivre les choix du type de matériel avec le type et le numéro vu précédemment.
Ensuite en (1) c'est la vue de votre futur écran, en (2) vous aurez les paramètres de l'objet que vous aurez choisi en (3).
En (4) vous allez pouvoir charger des fonts et les images que vous souhaitez utiliser plus tard... Il faut commencer par ajouter au moins une font, c'est facile
vous sélectionnez l'onglet font (en bas) puis le (+) et vous suivez les écrans (facile) indispensable pour utiliser des objets "Texte".
Même démarche pour les images Si vous désirez utiliser une image de fond il faut la charger en premier sinon son index ne sera pas bon !
La zone (5) vous permettra de gérer plusieurs pages... (Je ne vous donne là que les grandes lignes, a vous de découvrir...)
Pour chaque objet que vous allez ajouter sur l'écran vous avez la possibilité de régler certains paramètres, ceux en vert pourront être
modifié lors de l'exécution par le code coté arduino/esp les autres non ! Suivant le type d'écran que vous avez acheté (Basic, Enhanced ou Intelligent)
vous allez avoir plus ou moins de paramètre en vert !!! Certaines fonctions ne seront carrément pas active suivant le type choisi.
Alors en (1) vous pouvez choisir un "nom" pour votre objet, en (2) le système lui a attribué un numéro d'identification (il est intéressant de prendre
un petit papier et de noter les noms et numéros d'id de tous vos objets, cela sera utile plus tard... (attention si vous supprimez un objet tous les numéro
d'id peuvent changer donc reprendre ses notes !!!
Le (3) et le (4)sont spécifiques aux objets "Texte" le (3) Vous permet d'initialiser le contenu du champs texte et le (4) pour choisir la font que vous aurez
chargé (les polices sont repérées par des numéros d'id de chargement).
Si vous avez des objets bouton ne pas oublier de cocher la petite case dans fenetre du bas "Send component" (choix apuui ou relaché).
Une fois que vous vous sentez prêt à tester, vous pouvez lancer débug.
Bouton debug (1) ouvre fenêtre (2), chaque appui sur l'un de vos boutons (3) si vous avez bien coché "Send component" va générer un code (4) du genre
"65 0 3 1 ff ff ff" le 0 c'est num de page le 3 c'est le numéro d'id et le 1 c'est actif à l'état haut.
Si vous avez des erreurs dans votre construction vous en serez informé dans la fenêtre de débogage en bas à gauche.
Deux solutions pour entrer le code créé dans l'appli Nextion sur l'écran, soit avec une carte SD soit par l'interface série.
Avec la carte SD vous la formatez en fat32 puis vous transférez le ficher hmi de votre projet, ensuite vous redémarrez votre écran avec la carte SD...
Une fois terminé il faut retirer la carte SD.
Par l'interface série c'est aussi simple et pas besoin de carte SD !
Il est temps de brancher votre écran suivre le schéma, rien de compliqué il faut avoir sous la main un adaptateur usb <> TTL mais
ça on en a forcément quand on bricole avec l'Arduino !
Une fois la connexion établie on lance l'upload de l'écran (1) la fenêtre (2) s'ouvre, on valide, le système va détecter le port COM
sur lequel est connecté l'écran et il trouve la vitesse (en principe 115200 bauds) c'est plutôt bien fait !
Vous pouvez préparer votre écran pour l'utilisation en programmation de l'UC depuis le PC ou en exécution !
Il est important dans le cas de l'utilisation avec un esp directement alimenté par usb comme les Wemos de ne pas utiliser le 5 volts de sortie de l'esp
l'intensité nécessaire à l'écran n'est pas suffisante! il faut alimenter l'écran de façon indépendante avec une autre alim (le petit connecteur fournit avec l'écran peut trouver son utilité ici !
Attention comme vous allez avoir deux alimentations différentes vous devez impérativement relier les deux masses.
Il faut maintenant trouver la librairie pour piloter ce nouvel écran, deux solutions, vous allez l'utiliser avec un Arduino Uno le plus simple est dans ce cas de charger
la librairie qui est dispo sur le site Nextion (elle utilise un port série logiciel). Mais si vous allez utiliser un système disposant d'un 2eme port matériel (voir un 3eme)
vous avez intérêt à charger la librairie disponible à cette adresse et
à réaliser les modifs décrites dans le fichier read de la librairie. Pour trouver le fichier à modifier (dans mon cas)
C:\Users\...\Documents \Arduino\libraries\ nextion-master\Nextion.h
Perso j'ai carrément enlevé toutes les lignes qui faisaient référence à une interface logiciel et j'ai spécifié dans mon exemple
#include "HardwareSerial.h" (ça doit fonctionner sans !).
L'exemple que je vous livre ici est fait à partir d'un Esp32 Wemos Mini Kit, le brochage est disponible ici
Cet esp dispose de trois interfaces séries (Uart) matériel (il est de plus possible sur un esp32 d'affecter des Gpio de son choix à ce type d'interface).
Dans mon cas j'ai choisi d'utiliser l'Uart 2 (l'Uart 0 est réservé pour l'interface de programmation de l'IDE Arduino) Donc j'utilise Gpio 16 et 17 qui correspondent dans le code à Serial2.
Sur l'esp32 dans cette config minimum de l'exemple nous n'utiliserons que 3 broches (Grd, Tx et Rx). Difficile de faire plus simple !
Il est important de mettre en commun les deux masses (celle de l'alimentation de l'écran avec celle de l'esp).
Le code est vraiment très simple, ceci grâce à la librairie il faut définir l'Uart Serial2 (dans mon cas) et la vitesse
(9600, restons simple) pour initialiser l'objet Nextion. On définit ensuite une variable par bouton (type bool vrai ou faux).
Dans le setup on initialise l'objet. Dans la boucle loop on va attendre les sollicitations de l'écran (message du genre "65 0 5 0 ff ff ff")
et en fonction du message on déclenche une action. Pour simplifier j'ai défini une petite fonction qui permute les photos suivant les boutons.
Il est temps de transférer le code dans l'esp32 comme habituellement avec l'IDE Arduino (Type de carte : "Wemos D1 Mini esp32")
préciser le port COM, la vitesse est renseignée automatiquement en fonction du type de carte.
Voilà c'est ok que quelques fils et quelques lignes de code, c'est pas cool !
Le code de base qui doit vous permettre de démarrer pour vos propres projets...
// Exemple utilisation écran Nextion avec un Wemos esp32 kit mini
// Mars 2020
// Castoo https://castoo.fr
// Code libre de droit
//
#include "HardwareSerial.h"
#include "Nextion.h" // Librairie a modifier pour utiliser interface serie matériel
#define nextion Serial2 // sur esp 32 gpio 16 et 17
Nextion myNextion(nextion, 9600); // Déclaration de l'objet
// On déclare une variable par bouton
boolean b_diapo;
boolean bd;
boolean bg;
int v_cpt = 1;
void setup() {
myNextion.init(); // Initialisation de la cnx avec l'écran
}
// Affiche la photo v_cpt en x=10 et y=20
// Pour trouver le détail de la commande "pic" ainsi que de nombreuses autres commandes
// Voir dans la doc Nextion sur leur site.
void aff_diapo(){
char str_cpt[1];
char str_cmd[12];
dtostrf(v_cpt, 1,0, str_cpt);
sprintf( str_cmd, "pic 10,20,%s", str_cpt);
// sendCommand permet de passer divers commandes mais attention suivant le type d'écran (Basic, Enhanced ou Intelligent)
// vous n'avez pas droit à toutes les commandes et vous n'aurez pas de message d'erreur ici, simplement l'opération
// ne se réalisera pas ! C'est un peu déroutant !
myNextion.sendCommand(str_cmd);
}
void loop() {
String message = myNextion.listen(); //Lecture de l'entrée de l'écran si appuit sur un bouton message va se remplir avec code
// Le 0 page 0 le 5 c'est l'id bouton droit dans mon cas le 0 actif lors du relachement
if (message == "65 0 5 0 ff ff ff") {
myNextion.buttonToggle(bd, "bd", 0, 5);
v_cpt++;
// Initialisation du champ numérique sur l'écran (juste pour l'exemple)
myNextion.setComponentValue("val_diapo", v_cpt);
aff_diapo();
}
// Autres boutons............
if (message == "65 0 6 0 ff ff ff") {
myNextion.buttonToggle(bg, "bg", 0, 6);
v_cpt--;
myNextion.setComponentValue("val_diapo", v_cpt);
aff_diapo();
}
if (message == "65 0 3 1 ff ff ff") {
myNextion.buttonToggle(b_diapo, "b_diapo", 0, 3);
v_cpt = 1;
myNextion.setComponentValue("val_diapo", v_cpt);
aff_diapo();
}
delay(100);
}
Un écran qui permet très simplement d'explorer des domaines inhabituelles avec des petits systèmes comme l'arduino ou l'esp. Bonne découverte
à vous, en tout cas moi, je vais creuser car ce type de matos est intéressant, même s'il ne remplacera pas toujours nos écrans traditionnels.
