Anthias
mail

nextion

Domotique Nextion

Page en début de construction, réalisée à 25%

Nextion


Introduction
Cahier des charges
Simulateur Arduino

 

Domotique Arduino arduino

Retour page principale Nextion arduino

Maj : 24/06/19

Abstract :
This page describe transfert of my data acquisition system, recording a lot of sensors and displaying curves on a Nextion "intelligent" display.
It is running now with an ESP32, and alone in an Arduino simulator mode.

Résumé :
Cette page décrit le transfert de mon système d’acquisition de données, l’enregistrement de nombreux capteurs et l’affichage des courbes sur un écran "intelligent" de Nextion.
Il fonctionne maintenant avec un ESP32
, et seul avec un mode simulateur Arduino.

nextion  Introduction

Application domotique gérant divers capteurs, et présentée avec un simulateur de données permettant de faire une première évaluation sans brancher un Arduino.

Une autre page montrera l’application duale et complémentaire sur Arduino permettant de fonctionner avec de vrais capteurs et interagir avec le chauffage et les alarmes de la maison.

Le document « Domotique Arduino arduino » est à lire en premier pour comprendre la philosophie du système et le cahier des charges.

Cette autre page décrit le hardware associé pour piloter le Nextion : Carte ESP32 vers Nextion arduino

baro

 Haut de page

nextion  Cahier des charges

Le cahier des charges de base est strictement identique à la version « Domotique Arduino arduino » et ne sera pas repris ici.


Les changements fondamentaux sont liés au choix de l’IHM (interface homme-machine)
Dans la version « Domotique Arduino arduino », l’afficheur ili9481 en 480*320 est lié à une carte DUE par 14 fils et sa gestion est totalement intégrée dans mon firmware.

(Le logiciel sera mis en ligne quand cette page sera plus avancée)

Dans cette version « Domotique Nextion », j’ai totalement changé de paradigme pour l’IHM.
Le firmware ne gère plus l’affichage, il ne s’occupe que de la partie acquisition des données des capteurs, gestion de la base de données et attend des ordres émis par l’interface tactile du Nextion.
Quand le Nextion demande par exemple à afficher une courbe sur une durée, l’Arduino prépare la table de données et envoie tout le paquet en série 115 kb pour créer le graphisme sur le Nextion.

Il y a bien maintenant séparation totale entre le corps de métier domotique et l’IHM, et la communication entre les deux blocs totalement isolés est réduite à sa plus simple expression :
 L ’IHM réagit à une commande utilisateur et envoie une demande au corps de métier sous forme d’une simple ligne.
 Le corps de métier met en forme la réponse et renvoie la longue séquence attendue par l’IHM pour afficher un nouvel écran.

Cela a un immense avantage, car l’Arduino peut gérer plusieurs clients, et envoyer ses courbes à l'identique quel que soit le demandeur, soit directement en série sur le Nextion, soit en Wi-Fi vers un PC distant (qui affiche en Processing), soit vers un smartphone ou tablette Android en Bluetooth.

 Je résume le principe retenu :

La partie corps de métier se charge de tous les calculs.
Pour les ordonnées (verticale), les résultats apparaissent sous forme de tableau de 360 mots de 16 bits, le minimum à zéro le maximum à 0xFFFFF représentant la courbe des données corrigées. En plus de ce tableau, le corps de métier fournira la valeur minimum, le pas et le nombre de pas.
Pour les abscisses (horizontale), le top actuel, et la plage (24 heures, 1 jour, …, 1 an).
Ces données sont nécessaires et suffisantes pour tracer la courbe sur n'importe quel affichage, il suffira au dernier moment d’ajuster les données par un facteur diviseur proportionnel à la résolution de l'afficheur.

Voici un exemple de la courbe sortie sur un écran PC en 1920x1076, le dialogue ancien était fait sous Processing via l'USB et l'envoi simultané vers l’afficheur graphique.


Aujourd’hui, avec l’ESP32, la tendance est d’envoyer sur demande, directement en série au Nextion (qui est un client comme un autre pour la partie affichage) et de diffuser par Wi-Fi et Bluetooth aux autres périphériques clients.

PC

Dans la démo sans Arduino, la courbe simulée s’affiche instantanément, mais avec les vrais capteurs, c’est l’Arduino qui envoie les données à afficher. Dans ce cas, apparaît une limite du Nextion !
Les gros calculs côté Arduino prennent moins d’une milliseconde, mais il faut envoyer, en plus de toutes les étiquettes et graduations, 360 fois une ligne du type :
« line X0,Y0,X1,Y1,couleur,fermer la chaîne… », etc..
Toutes ces opérations sont très longues et prennent 0.7 seconde à 115 kb, ce qui se voit sur l’affichage, heureusement que les courbes ne sont rafraîchies que toutes 4 minutes sans action tactile. Raccourcir cet intervalle n’est pas nécessaire, la courbe ne bouge pas pendant ce temps, seul le petit cartouche d’affichage de la valeur instantanée est rafraîchi.

Haut de page

nextion  L'étrange programme

Voici mon programme actuel qui peut sembler étrange, mais il y a une explication :


#include "board… appelle le fichier spécifique au hardware qui contient toutes les définitions, adresses et paramètres des matériels utilisés. Il suffit de changer ce fichier pour adapter un hardware totalement différent (carte Arduino, afficheur…).
Ce fichier appelle aussi une bibliothèque Nextion personnelle qui regroupe toutes mes fonctions spécifiques à cet afficheur.


Dans le setup, initialisation des deux ensembles très distincts, les interfaces et le métier comme déjà expliqué.
Evidemment ces initialisations appellent des dizaines d’autres routines, mais qui restent indépendantes du matériel seulement défini dans la première ligne d'include.


Le loop est vide, toutes les actions étant déclenchées par des interruptions.

#include "board_ESP32_Nextion.h"
// ***************************
void setup()
{
ihm_init () ; // Interfaces init
job_init () ; // "Corps de métier"
}
// ***************************
void loop()
{
}
// ***************************

Entre les interruptions, le microcontrôleur est mis en sommeil.
Cela pose le problème que l’on évoquera ultérieurement, le Nextion consomme 500 mA en 5V, en baissant ou coupant son alimentation, il plante et il faut tout réinitialiser, la baisse de consommation de la mise en sommeil est complétement perdue, mais c’est pour la beauté du système.

Le système est réveillé par diverses interruptions externes et internes :
 La RTC (Real time clock) DS3231, donne l’heure très précise de référence, le top toutes les quatre minutes déclenche de multiples actions.
 Un appui sur un des boutons ou par une commande tactile donne un ordre.
 Toutes les 10 secondes, un timer interne déclenche les lectures de capteurs et rafraîchit les données.
 En cas de plantage (11 secondes sans réarmement), un chien de garde réinitialise tout.

Il existe néanmoins une panne fatale, si la RTC plante et ne redémarre pas sur le reset du chien de garde, tout se bloque par perte de l’heure de référence.
C’est un cas peu fréquent, mais je l’ai déjà eu plusieurs fois sur mes collections d’automates sans pouvoir l’expliquer. En reprogrammant les heure et date perdues dans la RTC, tout repart.

Haut de page

nextion  Simulateur Arduino

Avec cette application, le Nextion est déchargé de tout calcul, son utilisation principale et donc d'attendre des commandes par l'intermédiaire des menus tactiles, d'envoyer la commande reçue à l’Arduino, et de récupérer en retour les nouvelles actions à effectuer, changement de page changement de courbe, etc..
La mise à l’heure de son horloge interne sera reprise dans une page spécifique « Horloge RTC Nextion », car cela s’est avéré plus compliqué que prévu, mais elle ne sert à rien dans cette application  !

L'application est fonctionnelle avec la chaîne complète Nextion + Arduino et tous ses périphériques, mais j'ai rajouté un émulateur d'Arduino pour ceux qui veulent faire les premiers essais en utilisant le Nextion tout seul.
Il faut donc simuler le dialogue vers l'Arduino pour afficher les courbes et faire fonctionner les menus.  Il existe dans le logiciel une option simulateur, quand elle est activée, il est possible de tout faire fonctionner sans le moindre Arduino branché. Un générateur pseudo-aléatoire fabriquera les courbes de la manière la plus réaliste possible et tout fonctionnera comme dans la réalité. Cela permet de mettre au point la partie IHM et de la séparer totalement du développement côté Arduino qui assure la gestion des capteurs et de la fabrication des données.

.

à suivre. . .

Tous les détails sont dans les logiciels joints.

Vous trouverez tous les logiciels à jour dans cette page :

eclate

Haut de page

© Christian Couderc 1999-2019     Toute reproduction interdite sans mon autorisation


* Page vue   145   fois       IP : 3.231.212.98

 Haut de page         Dernière retouche le 27 Juin 2019 à 15 h         Retour page précédente

   Collector