IHM FLProg + Nextion. Leçon 2



Dans la dernière leçon, j'ai parlé du panneau Nextion HMI et de la création de projets pour ce panneau dans l'éditeur Nextion.
Dans ce tutoriel, je vais vous montrer comment contrôler ce panneau à l'aide du programme FLProg à partir d'une carte Arduino. Par exemple, collectons la station météo la plus simple, qui lira les données du capteur de température et d'humidité DHT-22 et les affichera sur le panneau. Un graphique de l'évolution de ces paramètres sera également tracé. La luminosité du rétroéclairage de l'écran du panneau sera modifiée à l'aide d'une résistance variable.

Disposition du banc d'essai.


Vous devez d'abord télécharger le projet dans le panneau (le fichier de projet dans l'archive est un lien vers lequel à la fin de l'article est Lesson2.hmi).
Ce projet se compose de trois écrans.
Le premier écran permet d'afficher la température (page «page0» index - 0).



Il se compose des éléments suivants:
1 - Image avec l'image d'un thermomètre à alcool.
2 - L'élément "Barre de progression". Avec son aide, le thermomètre est simulé.

Paramètres de l'élément.


Je recommande les éléments avec lesquels il est prévu de toujours rendre global via UART (l'attribut «vccope» est défini sur «global») et de leur attribuer en conséquence des noms uniques (l'attribut «objname») tout au long du projet. Cela accélère le travail du contrôleur Arduino et réduit le code correspondant. Je vais vous expliquer pourquoi.
Lorsque vous essayez d'écrire l'attribut d'un élément local, vous devez d'abord demander la page actuelle au panneau (il s'agit d'une demande distincte qui prend au moins 20 ms). Si la page est celle à laquelle appartient l'élément, alors la valeur est envoyée au panneau; sinon, la valeur destinée à l'envoi est écrite dans la variable (pour laquelle le même espace mémoire est nécessaire). Lorsque vous accédez à une page avec un élément, vous devez immédiatement mettre à jour ses attributs avec les dernières valeurs réelles, car lors du rendu d'une page, les variables locales sont initialisées avec les valeurs spécifiées lors de la création du projet. Et s'il y a beaucoup d'éléments contrôlés depuis le contrôleur sur la page, alors lors du passage à celui-ci, ce contrôleur sera occupé à mettre à jour tous les éléments pendant longtemps.
Pour un élément global, tout est beaucoup plus simple. Vous pouvez enregistrer des valeurs d'attribut à tout moment et les dernières valeurs sont utilisées lors du rendu de la page. Cela signifie qu'il n'est pas nécessaire de demander un numéro de page avant l'envoi et qu'il n'est pas nécessaire de modifier pour stocker la valeur.
Mais bien sûr, tout dépend du projet. Si le projet du panneau est très volumineux et qu'il n'y a pas assez d'espace pour les éléments globaux, vous pouvez, pour ainsi dire, prendre la mémoire du contrôleur et les rendre locaux.
3. Zone de texte pour afficher la température.

Paramètres de l'élément.


L'image coupée est sélectionnée comme arrière-plan (attribut "sta" valeur "recadrer l'image"). Et en tant qu'image utilisée pour la découpe, la même que celle utilisée pour l'arrière-plan de la page entière (l'attribut «picc» est l'index de l'image de la bibliothèque d'images). Grâce à cela, le tex est obtenu avec un fond transparent.
Comme je l'ai déjà écrit dans la dernière leçon, le panneau ne sait pas comment travailler avec des nombres fractionnaires et négatifs, et pour la température, c'est possible. Par conséquent, pour afficher la valeur de la température, un champ de texte est utilisé, dans lequel la ligne terminée sera envoyée immédiatement depuis le contrôleur.
4. L'image coupée.

Paramètres de l'élément.


Avec l'aide de cet élément, le soleil sera affiché lorsque la température dépasse une limite prédéterminée. En fait, il était possible d'utiliser une image ordinaire et de changer sa visibilité, mais depuis l'exemple de formation, j'ai décidé d'utiliser cet élément particulier. J'ai moi-même depuis longtemps compris l'idéologie de cet élément, je vais essayer de montrer comment cela fonctionne. Pour son travail, j'ai fait deux photos, l'une avec le soleil, l'autre sans soleil.





L'élément affiche la partie de l'image qui lui est attachée (l'attribut «picc» est l'index de l'image dans la bibliothèque d'images). Le coin supérieur gauche de cette section est dans les coordonnées d'insertion de l'élément (attributs «x» et «y») et a la largeur et la hauteur de l'élément (attributs «w» et «h»). Pendant le fonctionnement du programme du contrôleur, si nécessaire, la liaison de l'élément à l'image changera.

5. Bouton.

Paramètres de l'élément.


Lorsque vous cliquez sur le bouton, il passe à la page suivante. J'ai utilisé une image comme arrière-plan pour le bouton. J'ai utilisé la même image pour les deux états (les attributs "pic" et "pic2" sont les index des images dans la bibliothèque d'images) car l'état pressé ne sera jamais visible, lorsque vous cliquez sur le bouton, il passe directement à la page suivante. Comme nous ne changerons rien dans ce bouton, je l'ai laissé local et le nom par défaut.

Code dans l'événement «Touch Press Event».


Le deuxième écran est utilisé pour afficher l'humidité (page «page1» index - 1).


Pour le fond de la page, j'ai utilisé une image avec une image préparée de l'échelle de l'hygromètre.


Considérez les éléments inclus dans la page.

1. L'élément «Gaude», qui simulera le fonctionnement d'un hygromètre.

Paramètres de l'élément.


Puisque nous allons le contrôler depuis le contrôleur, il est rendu global. L'image coupée (l'attribut «sta») est sélectionnée comme arrière-plan et l'image d'arrière-plan de la page (l'attribut «picc») est sélectionnée comme arrière-plan.

2. Champ numérique.

Paramètres de l'élément.


La valeur d'humidité sera affichée dans ce champ. Étant donné que le panneau ne prend pas en charge le travail avec des nombres fractionnaires, nous afficherons la valeur d'humidité sans partie fractionnaire. L'image coupée est sélectionnée comme arrière-plan (attribut "sta" valeur "recadrer l'image"). Et en tant qu'image utilisée pour la découpe, la même que celle utilisée pour l'arrière-plan de la page entière (l'attribut «picc» est l'index de l'image de la bibliothèque d'images). Pour des raisons de beauté d'affichage, j'ai réglé l'alignement vers la droite (valeur d'attribut «xcen» - 2), et à côté, j'ai mis un champ de texte (3) avec la valeur «%». Les paramètres d'arrière-plan de celui-ci sont similaires aux paramètres du champ numérique.

Options de champ de texte (3).


4 et 5. Boutons page précédente et page suivante. Lorsque vous appuyez sur le bouton 4, vous accédez à la première page et lorsque vous appuyez sur le bouton 5, vous passez à la suivante. Les paramètres d'affichage des boutons sont similaires à ceux de la première page.

Paramètres du bouton 4 («Page précédente»)


Code dans le «Touch Press Event» pour le bouton 4 («Page précédente»).


Paramètres du bouton 5 («Page suivante»)


Code dans le «Touch Press Event» pour le bouton 5 («Page suivante»).


Troisième page - Graphique des changements de température et d'humidité (index «page2» - 2).


Sur cette page sera affiché un graphique des changements de température et d'humidité. Considérez les éléments inclus dans la page.

1. L'élément Waveform.

Paramètres de l'élément.


Dans la dernière leçon, j'ai déjà écrit que cet élément ne peut pas (j'espère jusqu'à présent) devenir global, c'est-à-dire que la valeur d'attribut peut être changée, mais cela ne mènera à rien. Je l'ai donc laissé local (qui sait, mais du coup il mange toujours la mémoire des variables globales). Il y aura deux canaux d'affichage dans cet élément (attribut «ch» valeur - 2).

2 et 3 sont simplement des champs de texte montrant l'axe des graphiques.

4 - Bouton arrière. Il est similaire au même bouton sur l'écran précédent, à l'exception du code dans le gestionnaire d'événements.

Le code dans le «Touch Press Event» pour le bouton 4 («Page précédente»).


Nous avons compris le panneau, maintenant occupons-nous du contrôleur. Je ne dirai pas comment ouvrir le programme FLProg, créer un projet et dessiner un diagramme. Tout cela, je l'ai dit dans les leçons précédentes (leçon 1 , leçon 2 ), et en outre, beaucoup d'informations à ce sujet se trouvent dans le centre de formation sur le site Web du projet. Par conséquent, je vais immédiatement montrer les circuits imprimés prêts à l'emploi et dire ce qui se passe sur eux.

Carte 1. Lecture des données du capteur.


Pour obtenir les valeurs de température et d'humidité avec le capteur DHT-22, le bloc B1 est utilisé - «DHT11, DHT21, DHT22» (bibliothèque d'éléments, dossier «Capteurs»).

Paramètres de blocage (appelés en double-cliquant dessus).


Dans les paramètres, la broche est affectée à laquelle la sortie «Données» du capteur est connectée, le type de capteur et la présence de sorties de température et d'humidité. Le mode d'interrogation du capteur est également sélectionné. J'ai configuré l'interrogation du capteur toutes les 5 secondes.

Étant donné que les contrôleurs Arduino ne fonctionnent pas très bien avec les nombres à virgule flottante et que travailler avec eux consomme beaucoup de mémoire, je traduis immédiatement toutes les valeurs au format Integer. Pour ce faire, utilisez les blocs B3 et B4 - «Convertir flottant en entier» (bibliothèque d'éléments, dossier «Conversion de type»), qui coupent la partie fractionnaire du nombre. Afin de ne pas perdre des dixièmes de degré, la valeur de température obtenue du capteur est d'abord multipliée par 10 à l'aide du bloc B2 - «MUL (*)» (bibliothèque d'éléments, dossier «Mathématiques»).
Ensuite, les valeurs obtenues au format Integer sont entrées dans les variables correspondantes.

Carte 2. Affiche la valeur de température sur le panneau.


Dans ce projet, j'utilise des connexions nommées. Vous pouvez en apprendre plus à leur sujet dans la leçon correspondante .
Afin de limiter la charge sur le contrôleur, il est logique d'envoyer des données au panneau uniquement lorsque les données ont changé. Par conséquent, nous déterminons d'abord que les données ont changé. Pour ce faire, utilisez le bloc B5 - «Détecteur de changement de nombre» (bibliothèque d'éléments, dossier - «Blocs de base»). Cette unité contrôle le nombre «Valeur» à son entrée et, lorsqu'elle est modifiée, génère une impulsion de sortie d'un cycle d'exécution de programme à la sortie.
Après cela, nous préparons une chaîne à envoyer au champ de texte du panneau. Tout d'abord, divisez la valeur de température, multipliée par 10, par une constante de type Float avec une valeur de 10. Ainsi, nous obtenons la valeur de température avec une partie fractionnaire. Pour ce faire, nous utilisons le bloc B6 - «DIV (/)» (bibliothèque d'éléments, dossier «Mathématiques»). Ensuite, nous transformons la valeur obtenue au format Float en une chaîne en utilisant le bloc B7 - «Conversion de chaîne» (bibliothèque d'éléments, dossier «Conversion de type»). Ensuite, nous connectons la chaîne résultante avec la constante de chaîne "C" en utilisant le bloc B8 - "Addition de lignes" (bibliothèque d'éléments, dossier "Lignes"). La ligne résultante est envoyée à l'entrée de l'unité pour écrire la valeur d'attribut dans le panneau Nextion HMI B9 - «Définir les paramètres» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Éléments»).
Ce bloc écrit la valeur dans l'attribut spécifié.

Paramétrage de bloc.

En double-cliquant sur le bloc, la fenêtre de l'éditeur de blocs s'ouvre.


Si aucun panneau n'a encore été créé dans le projet, vous devez créer un panneau. Si le panneau nécessaire a déjà été créé, il peut être sélectionné dans la liste déroulante en appuyant sur le bouton 3. Le panneau sélectionné peut être modifié à l'aide du bouton «Changer de panneau» (2). Pour créer un panneau, cliquez sur le bouton "Ajouter un panneau" (1). La fenêtre de création du panneau s'ouvre.


Dans cette boîte de dialogue, sélectionnez le port de connexion du panneau (dans notre leçon - SoftwareSerial). Si vous sélectionnez SoftwareSerial, vous devez également sélectionner les broches affectées en tant que signaux RX et TX du port UART (dans notre cas, 2 et 3). Il est également nécessaire d'attribuer un nom de panneau. Elle doit être unique. Plusieurs panneaux peuvent être connectés dans un projet, tant qu'il y a suffisamment de ports UART libres. Le nom de chaque panneau doit être unique dans le projet. Dans la même boîte de dialogue, vous pouvez ajouter les pages incluses dans le panneau. Que ferons-nous. Cliquez sur le bouton Ajouter une page. La fenêtre de création de page s'ouvre.


Dans cette fenêtre, nous devons entrer le nom de la page et son ID. Ces informations peuvent être tirées du projet dans l'éditeur Nextin.


Par défaut, la page de démarrage (ouverte au démarrage du contrôleur) sera une page avec un ID de 0, mais vous pouvez cocher la case "Page de démarrage" dans les propriétés de n'importe quelle page et elle deviendra la page de démarrage.
Dans cette fenêtre, vous pouvez ajouter les éléments qui nous intéressent qui se trouvent sur cette page. Cliquez sur le bouton "Ajouter un élément".
La fenêtre de création d'élément s'ouvre.


Ici, nous devons sélectionner le type et le type de l'élément, entrer son nom, son index et, si l'élément est global, cocher la case correspondante. Toutes ces données sont visibles dans le projet dans l'éditeur Nextin.


Après avoir renseigné toutes les données, cliquez sur «Terminer», puis dans la fenêtre de création de page de la même manière ajoutez tous les éléments qui nous intéressent sur cette page.


Après avoir créé tous les éléments de la page, on clique également sur le bouton «Terminer» dans la fenêtre de création de page et dans la fenêtre de création d'un panneau utilisant le même scénario, créer le reste de la page.






Nous finissons de créer le panneau avec le bouton familier «Terminer».
Dans l'éditeur de blocs, sélectionnez l'élément de page «page0» «Texte» avec le nom «tnt» et son attribut «Texte (txt)». Comme valeur, sélectionnez l'entrée.


Le bloc est configuré.
Nous examinons le schéma plus loin.
Sur le plan empirique, il a été définitivement déterminé qu'une valeur de -40 degrés d'un thermomètre dessiné correspond à une valeur de 10 dans l'élément "Barre de progression" qui s'y trouve, et une valeur de 50 degrés à un thermomètre correspond à une valeur de 91 bar de progression. Conformément à cela, nous mettons à l'échelle la valeur avec la variable «Température x10» en utilisant le bloc B10 - «Échelle» (bibliothèque d'éléments, dossier «Mise à l'échelle») sans oublier que nous avons la valeur de température multipliée par 10. Paramètres de ce bloc.


La valeur de température mise à l'échelle est envoyée au panneau à l'aide du bloc B11 - "Set Parameter" (bibliothèque d'éléments -> dossier "Panel Nextion HMI" -> dossier "Elements"). Paramètres de ce bloc.


Le bloc suivant B12 - «Comparateur» (bibliothèque d'éléments, dossier «Comparaison») détermine si la température actuelle dépasse le point de consigne par la valeur par défaut de la variable «Point de consigne - Chaud». Il est de 290 (n'oubliez pas que partout nous avons des températures multipliées par 10).


Le bloc B12 est configuré pour sortir une unité logique à sa sortie lorsque la valeur à l'entrée "I1" dépasse la valeur à l'entrée "I2".


Les blocs B13, B14 et B15 forment des circuits de détection de changement de signal discrets. Les blocs B13 et B14 - Rtrig (bibliothèque d'éléments, dossier «Déclencheurs»), lorsqu'un front montant d'un signal discret apparaît, émettent une impulsion de sortie d'une durée de 1 cycle du programme. Le bloc B14, du fait d'une inversion à son entrée, détecte le front arrière du signal "Dépassement du seuil". Le bloc B15 –OR (bibliothèque d'éléments, dossier «Éléments de base»), s'il y a une unité logique à l'une des entrées, envoie une unité logique à sa sortie. Ainsi, un signal est formé "Envoi de données lorsque le seuil est dépassé". Sur le bord d'attaque de ce signal, une commande est envoyée pour changer la couleur de police du champ de texte affichant la température actuelle. L'envoi se fait à l'aide du bloc B17– "Set Parameter" (bibliothèque d'éléments -> dossier "Nextion HMI Panel" ->Dossier Éléments). Paramètres de ce bloc.


La valeur transmise dans la commande est sélectionnée à l'aide du bloc B16 - «Switch» (bibliothèque d'éléments, dossier «Switch»). Ce bloc avec un niveau logique bas à son entrée transfère la valeur de l'entrée "0" à la sortie, et avec un niveau haut, de l'entrée "1". Les valeurs de couleur fournies aux entrées du commutateur sont définies à l'aide des blocs B44 et B45 - «Color constant Hight Color» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Color»). La couleur est sélectionnée dans l'éditeur de blocs (double-cliquez sur le bloc).


Pour sélectionner une couleur, cliquez sur le bouton "Changer". Le sélecteur de couleurs s'ouvre.


Dans celui-ci, en définissant la valeur des composants R (rouge), G (vert) et B (bleu), la couleur nécessaire est sélectionnée.
De plus, sur le bord d'attaque du signal "Envoi de données lorsque le seuil est dépassé", une commande est envoyée pour modifier la liaison de l'image découpée. Cela se produit à l'aide du bloc B19 - «Set Parameter» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Elements»).
Paramètres de ce bloc.


L'index d'image est sélectionné à l'aide du bloc B18 - «Switch» (bibliothèque d'éléments, dossier «Switch»). Son travail a été décrit ci-dessus. La valeur d'index de l'image requise peut être affichée dans le projet Nextion Editor de la bibliothèque d'images.

Une fois le transfert des données de température terminé. Passons à l'humidité.

Tableau 3. Conclusion de l'humidité.


Comme dans le cas de la température, nous créons tout d'abord un signal «Envoi de données lorsque l'humidité change». Pour ce faire, nous utilisons le bloc B20 - «Détecteur de changement de nombre» (bibliothèque d'éléments, dossier - «Blocs de base»). Le fonctionnement de cet appareil a été décrit précédemment. Ce signal envoie la valeur à un champ numérique qui affiche l'humidité. Pour ce faire, utilisez le bloc B21– «Définir les paramètres» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Elements»).
Paramètres de ce bloc.


Empiriquement, il a été clairement déterminé que pour la valeur d'humidité de 0% de l'échelle hygromètre dessinée dans la conception du panneau, l'élément «Gayge» qui dessine la flèche est 314 et pour 100% d'humidité il est 226. En même temps, la flèche dépasse la valeur 0. Lorsqu'elle est convertie en valeurs linéaires, nous obtenons continu de -46 (0%) à 226 (100%). Conformément à ces données, nous configurons le bloc B22 - «Echelle».
Paramètres de bloc.


Étant donné que les valeurs de l'élément "Gauge" ne peuvent pas être négatives, pour calculer l'angle de la flèche à ces valeurs, dans le cas d'une valeur négative, la valeur 360 y est ajoutée. Nous le faisons en utilisant le bloc B23- "SUMM (+)" (bibliothèque d'éléments, Dossier Maths). Nous déterminons que le nombre est inférieur à 0 à l'aide du bloc B26 - «Comparateur» (bibliothèque d'éléments, dossier «Comparaison»). Sa sortie contrôle le commutateur B24 - «Switch» (bibliothèque d'éléments, dossier «Switch») et la valeur sélectionnée est envoyée au panneau à l'aide du bloc B25 - «Set Parameter» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Elements» )
Paramètres de ce bloc.


Le tableau suivant affiche un graphique des changements de température et d'humidité.


Comme je l'ai écrit au début de la leçon, l'élément Waveform ne sait pas comment être un élément global et est redessiné à chaque fois que vous ouvrez la page sur laquelle il se trouve. Nous devons contourner cette limitation. Tout d'abord, déterminez le numéro de la page actuellement chargée sur le panneau. Pour ce faire, utilisez le bloc B27 - «Obtenir l'identifiant de la page en cours» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Page»). Dans les paramètres de ce bloc, il vous suffit de sélectionner le panneau auquel nous accéderons avec cette demande.


Le numéro de page obtenu à partir de ce bloc est comparé à l'index de la page dont nous avons besoin (2) à l'aide du bloc B28 - «Comparateur» (bibliothèque d'éléments, dossier «Comparaison»). Si la page souhaitée est ouverte, l'unité logique est écrite dans la variable «Ouvrir la page du graphique», sinon, un zéro logique.
A l'aide du bloc B29 - «Générateur» (bibliothèque d'éléments, dossier «Timers»), un signal est généré pour enregistrer le point suivant sur la carte. Ce bloc génère des impulsions avec une durée d'impulsion et une pause données.
Bloquer les paramètres.


Le type de générateur sélectionné est "Multivibrateur symétrique", ce qui signifie que la durée d'impulsion est égale à la durée de la pause. Lors du réglage de la durée d'impulsion sur 5 secondes, respectivement, la pause sera la même de 5 secondes. Le bord d'attaque de l'impulsion viendra toutes les 10 secondes. Cette façade est mise en évidence par le bloc B30 - «Rtrig» (bibliothèque d'éléments, dossier «Déclencheurs»), et est écrite dans la variable «Commande pour enregistrer le point suivant».
Sur le bord d'attaque du signal «Ouvrir la page du graphique», qui sera sélectionné à l'aide du bloc B31 - «Rtrig» (bibliothèque d'éléments, dossier «Déclencheurs»), le signal «Envoyer l'historique du graphique» sera généré. Par ce signal, le contenu des tableaux sera envoyé au panneau sur le graphique, dans lequel les valeurs des points affichant le graphique de changement sont stockées. Pour la température, cela se fera à l'aide du bloc B32 - «Envoi du tableau au graphe» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Graph»). Le bloc est configuré à l'aide de l'éditeur de blocs.


Vous devez d'abord créer un tableau dans lequel l'historique du graphique de température sera stocké. Pour ce faire, cliquez sur le bouton "Créer". La fenêtre de création de la baie s'ouvre.


Dans cet océan, vous devez entrer le nom du tableau, tapez (utilisez Byte, car l'élément Waveform prend une valeur maximale de 255). La taille est prise égale à la largeur du graphique (330).
Après la création, sélectionnez le panneau, la page, l'élément et le canal sur lesquels le graphique sera dessiné.


De la même manière, nous configurons le bloc pour l'envoi d'un tableau contenant des données d'humidité au panneau B33 - «Envoi du tableau au graphique» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Graph»). Dans ses paramètres, nous créons un autre tableau pour stocker ces données.


Vous devez maintenant préparer les données pour le graphique de température. Ce graphique aura une ligne le long de son axe à une hauteur de 160 points à partir du bas du graphique. Afin de rendre les changements de température plus visibles, nous divisons la valeur de la variable «Température x10» par 5 (c'est-à-dire comme si nous multiplions la valeur réelle de la température par 2) à l'aide du bloc B35 et y ajoutons le décalage à l'aide du bloc B36. Le résultat sera entré dans la variable "Température avec un décalage pour le graphique".
En utilisant le bloc B37 - "Stack" (bibliothèque d'éléments, dossier "tableaux"), l'impulsion de la variable "Commande pour enregistrer le point suivant" est écrite dans le tableau par la température avec un décalage pour le graphique en utilisant le principe de la pile (le premier élément du tableau est supprimé, les autres sont décalés de un et la dernière valeur est écrite). Le bloc est paramétré à l'aide de l'éditeur de blocs.


Dans l'éditeur, sélectionnez le tableau souhaité en cliquant sur le bouton "Sélectionner".
De la même manière, nous configurons le bloc B34 - «Stack» (bibliothèque d'éléments, dossier «tableaux») pour écrire les valeurs d'humidité dans le tableau en le sélectionnant dans le tableau correspondant.
Si la page du graphique est ouverte, le transfert des tableaux vers le graphique est terminé et la commande d'enregistrement du point suivant est reçue, puis les valeurs des nouveaux points sont envoyées aux graphiques correspondants. Cela est nécessaire pour que les graphiques continuent d'être créés pendant que la page s'affiche. Le respect de ces conditions est contrôlé à l'aide du bloc B38 - «ET» (bibliothèque d'éléments, dossier «Eléments de base»). Ce bloc émet une unité à sa sortie s'il y a une unité logique à toutes ses entrées. La prochaine valeur de température avec décalage est envoyée au graphique à l'aide du bloc B40 - «Ajouter un point au graphique» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Graph»).
Bloquer les paramètres.


Le bloc d'envoi de la prochaine valeur d'humidité au graphique B39 est également configuré - «Ajouter un point au graphique» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Chart»).


Terminé avec la conclusion du calendrier.

Carte 5. Réglez la luminosité du rétroéclairage.


La valeur du rétroéclairage réglé à l'aide d'une résistance variable est lue à l'aide du bloc d'entrée analogique «Luminosité». Étant donné que la valeur de luminosité du rétroéclairage du panneau est définie dans la plage de 0 à 100, nous modifions la valeur de lecture de la plage 0-1023 à la plage 0-100 à l'aide du bloc B41 - «Échelle».
Bloquer les paramètres.


Ensuite, nous déterminons le fait d'un changement de cette valeur à l'aide du bloc B42 - «Détecteur pour changer le nombre». Ce bloc a un peu de paramètres non standard.


Afin de ne pas modifier la luminosité pour chaque mouvement de la résistance variable, la zone morte est définie dans l'unité avec une valeur de 5. Autrement dit, l'unité fonctionnera lorsque la valeur d'entrée change de plus de 5 dans les deux sens. Lorsque l'unité est déclenchée, une commande sera envoyée au panneau pour définir une nouvelle luminosité de rétroéclairage à l'aide du bloc B43 - «Définir le niveau de rétroéclairage» (bibliothèque d'éléments -> dossier «Nextion HMI Panel» -> dossier «Système»).
Paramètres de blocage Le


travail sur le programme du contrôleur est terminé.

Pour ceux qui sont intéressés par le code du skoller de croquis résultant.
#include <SoftwareSerial.h>
#include "DHT.h"
DHT _dht1(4, DHT22);

SoftwareSerial Serial100(2, 3);

byte _FLPArray142003126[330] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
byte _FLPArray239384258[330] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int _SUETFLPATemp = 0;
byte _nextionSaveDataVAL_P0_E2;
long _nextionSaveDataPCO_P0_E3;
String _nextionSaveDataTXT_P0_E3;
byte _nextionSaveDataPICC_P0_E4;
int _nextionSaveDataVAL_P1_E2;
long _nextionSaveDataVAL_P1_E4;
String _nextionCommandTempString;
struct _nextionLissenStruct {
  char code;
  String result;
  long number;
};
_nextionLissenStruct _nextionTempLissen;
int nextionGetPageIdTempVar = 0;
int NextionPanel_47525121_PageIdOut = 0;
int _hasNumberChangeInTemp = 0;
int _gtv1;
int _gtv2;
int _gtv3 = 290;
bool _gtv4 = 0;
bool _gtv5 = 0;
int _gtv6;
unsigned long _dht1Tti = 0UL;
float _dht1t = 0.00;
float _dht1h = 0.00;
bool _changeNumber1_Out = 0;
int _changeNumber1_OLV;
bool _nextionSetAttr1_isNU = 0;
bool _nextionSetAttr1_oldState = 0;
bool _nextionSetAttr2_isNU = 0;
bool _nextionSetAttr2_oldState = 0;
bool _trgrt1 = 0;
bool _trgrt1I = 0;
bool _trgrt2 = 0;
bool _trgrt2I = 0;
bool _nextionSetAttr3_isNU = 0;
bool _nextionSetAttr3_oldState = 0;
long _swi1;
bool _nextionSetAttr4_isNU = 0;
bool _nextionSetAttr4_oldState = 0;
byte _swi2;
bool _nextionSetAttr5_isNU = 0;
bool _nextionSetAttr5_oldState = 0;
bool _changeNumber2_Out = 0;
int _changeNumber2_OLV;
int _swi3;
bool _nextionSetAttr6_isNU = 0;
bool _nextionSetAttr6_oldState = 0;
bool _trgrt3 = 0;
bool _trgrt3I = 0;
bool _gen1I = 0;
bool _gen1O = 0;
unsigned long _gen1P = 0UL;
bool _trgrt5 = 0;
bool _trgrt5I = 0;
bool _nextionAddPointToWave1_OldState = 0;
bool _nextionAddPointToWave2_OldState = 0;
bool _SFLPAS1;
bool _SFLPAS2;
bool _nextionSendArraytToWave1_OldState = 0;
bool _nextionSendArraytToWave2_OldState = 0;
bool _nextionSetLighting1_OldStae = 0;
bool _changeNumber3_Out = 0;
int _changeNumber3_OLV;
void setup()
{
  Serial100.begin(9600);
  _dht1.begin();
  nextionSendCommand("", 100);
  nextionAck(100);
  nextionSendCommand("page 0", 100);
  delay(100);
  nextionAck(100);
}
void loop()
{ nextionGetPageIdTempVar = nextionAskPageNamper(100);
  if ( ! (nextionGetPageIdTempVar < 0) ) {
    NextionPanel_47525121_PageIdOut = nextionGetPageIdTempVar;
  };
  if (_isTimer(_dht1Tti, 5000)) {
    _dht1Tti = millis();
    float tempDht4;
    tempDht4 = _dht1.readTemperature();
    if (!(isnan(tempDht4))) {
      _dht1t = tempDht4;
    }
    tempDht4 = _dht1.readHumidity();
    if (!(isnan(tempDht4))) {
      _dht1h = tempDht4;
    }
  }



  _gtv1 = (int((_dht1t) * (10)));
  _gtv2 = (int(_dht1h));
  if ((_gtv1) > (_gtv3)) {
    if (_trgrt1I) {
      _trgrt1 = 0;
    } else {
      _trgrt1 = 1;
      _trgrt1I = 1;
    }
  } else {
    _trgrt1 = 0;
    _trgrt1I = 0;
  };
  if ((_gtv1) > (_gtv3))
  {
    _swi1 = 63488;
  }
  else
  {
    _swi1 = 2016;
  }
  if (!((_gtv1) > (_gtv3))) {
    if (_trgrt2I) {
      _trgrt2 = 0;
    } else {
      _trgrt2 = 1;
      _trgrt2I = 1;
    }
  } else {
    _trgrt2 = 0;
    _trgrt2I = 0;
  };
  if ((_gtv1) > (_gtv3))
  {
    _swi2 = 2;
  }
  else
  {
    _swi2 = 0;
  }
  if (_changeNumber1_Out) {
    _changeNumber1_Out = 0;
  } else {
    _hasNumberChangeInTemp = _gtv1;
    if (_hasNumberChangeInTemp != _changeNumber1_OLV) {
      _changeNumber1_OLV = _hasNumberChangeInTemp;
      _changeNumber1_Out = 1;
    }
  }
  if (_changeNumber1_Out) {
    if (! _nextionSetAttr1_oldState ) {
      _nextionSetAttr1_oldState = 1;
      _nextionSetAttr1_isNU = 1;
      _nextionSaveDataTXT_P0_E3 =  ((( _floatToStringWitRaz((_gtv1) / (10.00), 1))) + (String(" C"))) ;
    }
  } else {
    _nextionSetAttr1_oldState = 0;
  } if (_nextionSetAttr1_isNU) {
    _nextionCommandTempString = String("page0.tnt.txt=\"") + _nextionSaveDataTXT_P0_E3 + String("\"");
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr1_isNU = 0;
  } if (_changeNumber1_Out) {
    if (! _nextionSetAttr2_oldState ) {
      _nextionSetAttr2_oldState = 1;
      _nextionSetAttr2_isNU = 1;
      _nextionSaveDataVAL_P0_E2 =  (map((_gtv1), (-400), (500), (10), (91))) ;
    }
  } else {
    _nextionSetAttr2_oldState = 0;
  } if (_nextionSetAttr2_isNU) {
    _nextionCommandTempString = String("page0.tpb.val=") + String(_nextionSaveDataVAL_P0_E2);
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr2_isNU = 0;
  } if (( (_trgrt1) || (_trgrt2) )) {
    if (! _nextionSetAttr3_oldState ) {
      _nextionSetAttr3_oldState = 1;
      _nextionSetAttr3_isNU = 1;
      _nextionSaveDataPCO_P0_E3 =  _swi1 ;
    }
  } else {
    _nextionSetAttr3_oldState = 0;
  }
  if (nextionAskPageNamper(100) == 0) {
    if (_nextionSetAttr3_isNU) {
      _nextionCommandTempString = String("page0.tnt.pco=") + String(_nextionSaveDataPCO_P0_E3);
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionCommandTempString = "ref tnt";
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionSetAttr3_isNU = 0;
    }
  } else {
    _nextionSetAttr3_isNU = 1;
  }
  if (( (_trgrt1) || (_trgrt2) )) {
    if (! _nextionSetAttr4_oldState ) {
      _nextionSetAttr4_oldState = 1;
      _nextionSetAttr4_isNU = 1;
      _nextionSaveDataPICC_P0_E4 =  _swi2 ;
    }
  } else {
    _nextionSetAttr4_oldState = 0;
  }
  if (nextionAskPageNamper(100) == 0) {
    if (_nextionSetAttr4_isNU) {
      _nextionCommandTempString = String("page0.tci.picc=") + String(_nextionSaveDataPICC_P0_E4);
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionCommandTempString = "ref tci";
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionSetAttr4_isNU = 0;
    }
  } else {
    _nextionSetAttr4_isNU = 1;
  }
  if (((map((_gtv2), (0), (100), (-46), (226)))) < (0))
  {
    _swi3 = ((map((_gtv2), (0), (100), (-46), (226)))) + (360);
  }
  else
  {
    _swi3 = (map((_gtv2), (0), (100), (-46), (226)));
  }
  if (_changeNumber2_Out) {
    _changeNumber2_Out = 0;
  } else {
    _hasNumberChangeInTemp = _gtv2;
    if (_hasNumberChangeInTemp != _changeNumber2_OLV) {
      _changeNumber2_OLV = _hasNumberChangeInTemp;
      _changeNumber2_Out = 1;
    }
  }
  if (_changeNumber2_Out) {
    if (! _nextionSetAttr5_oldState ) {
      _nextionSetAttr5_oldState = 1;
      _nextionSetAttr5_isNU = 1;
      _nextionSaveDataVAL_P1_E4 =  _gtv2 ;
    }
  } else {
    _nextionSetAttr5_oldState = 0;
  } if (_nextionSetAttr5_isNU) {
    _nextionCommandTempString = String("page1.humN.val=") + String(_nextionSaveDataVAL_P1_E4);
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr5_isNU = 0;
  } if (_changeNumber2_Out) {
    if (! _nextionSetAttr6_oldState ) {
      _nextionSetAttr6_oldState = 1;
      _nextionSetAttr6_isNU = 1;
      _nextionSaveDataVAL_P1_E2 =  _swi3 ;
    }
  } else {
    _nextionSetAttr6_oldState = 0;
  } if (_nextionSetAttr6_isNU) {
    _nextionCommandTempString = String("page1.humG.val=") + String(_nextionSaveDataVAL_P1_E2);
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr6_isNU = 0;
  } if (1) {
    if (! _gen1I) {
      _gen1I = 1;
      _gen1O = 1;
      _gen1P = millis();
    }
  } else {
    _gen1I = 0 ;
    _gen1O = 0;
  }
  if (_gen1I) {
    if ( _isTimer ( _gen1P , 5000 )) {
      _gen1P = millis();
      _gen1O = ! _gen1O;
    }
  }
  if (_gen1O) {
    if (_trgrt5I) {
      _trgrt5 = 0;
    } else {
      _trgrt5 = 1;
      _trgrt5I = 1;
    }
  } else {
    _trgrt5 = 0;
    _trgrt5I = 0;
  };
  if (_gtv4) {
    if (_trgrt3I) {
      _trgrt3 = 0;
    } else {
      _trgrt3 = 1;
      _trgrt3I = 1;
    }
  } else {
    _trgrt3 = 0;
    _trgrt3I = 0;
  };
  _gtv4 = (NextionPanel_47525121_PageIdOut) == (2);
  _gtv5 = _trgrt5;
  if (_trgrt3) {
    if ( ! _nextionAddPointToWave1_OldState) {
      _nextionAddPointToWave1_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        for (int nextionSATWTemp = 0;  nextionSATWTemp < 330;  nextionSATWTemp ++) {
          _nextionCommandTempString = String ("add 1,1,") + String (_FLPArray142003126[nextionSATWTemp]);
          nextionSendCommand(_nextionCommandTempString.c_str(), 100);
        } delay (50);
      }
    }
  } else {
    _nextionAddPointToWave1_OldState = 0;
  }

  if (_trgrt3) {
    if ( ! _nextionAddPointToWave2_OldState) {
      _nextionAddPointToWave2_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        for (int nextionSATWTemp = 0;  nextionSATWTemp < 330;  nextionSATWTemp ++) {
          _nextionCommandTempString = String ("add 1,0,") + String (_FLPArray239384258[nextionSATWTemp]);
          nextionSendCommand(_nextionCommandTempString.c_str(), 100);
        } delay (50);
      }
    }
  } else {
    _nextionAddPointToWave2_OldState = 0;
  }

  if (_gtv5) {
    if (!_SFLPAS1) {
      _SFLPAS1 =  1;
      for (_SUETFLPATemp = 0; _SUETFLPATemp < 329; _SUETFLPATemp = _SUETFLPATemp + 1 ) {
        _FLPArray239384258[_SUETFLPATemp ] = _FLPArray239384258[_SUETFLPATemp + 1];
      }  _FLPArray239384258[329] = _gtv2;
    }
  }  else {
    _SFLPAS1 = 0;
  }
  _gtv6 = ((_gtv1) / (5)) + (160);
  if (_gtv5) {
    if (!_SFLPAS2) {
      _SFLPAS2 =  1;
      for (_SUETFLPATemp = 0; _SUETFLPATemp < 329; _SUETFLPATemp = _SUETFLPATemp + 1 ) {
        _FLPArray142003126[_SUETFLPATemp ] = _FLPArray142003126[_SUETFLPATemp + 1];
      }  _FLPArray142003126[329] = _gtv6;
    }
  }  else {
    _SFLPAS2 = 0;
  }
  if (( (_gtv5) && (!(_trgrt3)) && (_gtv4) )) {
    if ( ! _nextionSendArraytToWave1_OldState) {
      _nextionSendArraytToWave1_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        _nextionCommandTempString = String ("add 1,0,") + String (_gtv2);
        nextionSendCommand(_nextionCommandTempString.c_str(), 100); delay (50);
      }
    }
  } else {
    _nextionSendArraytToWave1_OldState = 0;
  }

  if (( (_gtv5) && (!(_trgrt3)) && (_gtv4) )) {
    if ( ! _nextionSendArraytToWave2_OldState) {
      _nextionSendArraytToWave2_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        _nextionCommandTempString = String ("add 1,1,") + String (_gtv6);
        nextionSendCommand(_nextionCommandTempString.c_str(), 100); delay (50);
      }
    }
  } else {
    _nextionSendArraytToWave2_OldState = 0;
  }

  if (_changeNumber3_Out) {
    _changeNumber3_Out = 0;
  } else {
    _hasNumberChangeInTemp = (map(( (analogRead (0))), (0), (1023), (0), (100)));
    if (((_hasNumberChangeInTemp > _changeNumber3_OLV) && ((_hasNumberChangeInTemp - _changeNumber3_OLV ) > 5)) || ((_hasNumberChangeInTemp < _changeNumber3_OLV) && ((_changeNumber3_OLV - _hasNumberChangeInTemp ) > 5) ))
    {
      _changeNumber3_OLV = _hasNumberChangeInTemp;
      _changeNumber3_Out = 1;
    }
  }
  if (_changeNumber3_Out) {
    if (!(_nextionSetLighting1_OldStae)) {
      _nextionSetLighting1_OldStae = 1;
      _nextionCommandTempString = String("dim=") + String((map(( (analogRead (0))), (0), (1023), (0), (100))));
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);
    }
  } else {
    _nextionSetLighting1_OldStae = 0;
  }




}
bool _isTimer(unsigned long startTime, unsigned long period )
{
  unsigned long currentTime;
  currentTime = millis();
  if (currentTime >= startTime) {
    return (currentTime >= (startTime + period));
  } else {
    return (currentTime >= (4294967295 - startTime + period));
  }
}
String  _floatToStringWitRaz(float value, int raz)
{
  float tv;
  int ti = int(value);
  String ts = String(ti);
  if (raz == 0) {
    return ts;
  }
  ts += ".";
  float tf = abs(value - ti);
  for (int i = 1; i <= raz; i++ )
  {
    tv = tf * 10;
    ti = int(tv);
    ts += String(ti);
    tf = (tv - ti);
  }
  return ts;
}
void nextionSendCommand(const char* cmd, byte port )
{
  while (Serial100.available()) {
    Serial100.read();
  }
  Serial100.print(cmd);
  Serial100.write(0xFF);
  Serial100.write(0xFF);
  Serial100.write(0xFF);
}
boolean nextionAck( byte port )
{
  uint8_t bytes[4] = {0};
  Serial100.setTimeout(20); if (sizeof(bytes) != Serial100.readBytes((char *)bytes, sizeof(bytes))) {
    return 0;
  }

  if ((bytes[1] == 0xFF) && (bytes[2] == 0xFF) && (bytes[3] == 0xFF)) {
    switch (bytes[0]) {
      case 0x00:
        return false; break;
      case 0x01:
        return true; break;
      default:
        return false;
    }
  }
}
struct _nextionLissenStruct nextionListen( byte port )
{
  char _bite;
  char _end = 0xff;
  String cmd;
  _nextionLissenStruct temp;
  int countEnd = 0;
  delay(10);
  while (Serial100.available() > 0) {
    if (Serial100.available() > 0) {
      _bite = Serial100.read();
      cmd += _bite;
      if (_bite == _end) {
        countEnd++;
      }
      if (countEnd == 3) {
        break;
      }
    }
  }
  temp.result = "";
  temp.code = 'z';
  temp.number = 0;
  switch (cmd[0]) {
    case 'e':
      temp.code = 'e';
      countEnd = 0;
      for (uint8_t i = 0; i < cmd.length(); i++) {
        if (cmd[i] == _end) {
          countEnd++;
        }
        temp.result += String(cmd[i], HEX);
        if (countEnd == 3) {
          return temp;
        }
        temp.result += " ";
      }
      break;
    case 'f':
      temp.code = 'f';
      temp.result = String(cmd[1], DEC);
      return temp;
      break;
    case 'g':
      temp.code = 'g';
      temp.result = String(cmd[2], DEC) + "," + String(cmd[4], DEC) + "," + String(cmd[5], DEC);
      return temp;
      break;
    case 'h':
      temp.code = 'h';
      temp.result = String(cmd[2], DEC) + "," + String(cmd[4], DEC) + "," + String(cmd[5], DEC);
      temp.result = "68 " + temp.result;
      return temp;
      break;
    case 'p':
      temp.code = 'p';
      temp.result = cmd.substring(1, cmd.length() - 3);
      return temp;
      break;
    case 'q':
      temp.code = 'q';
      temp.number = (cmd[4] << 24) | (cmd[3] << 16) | (cmd[2] << 8) | (cmd[1]);
      return temp;
      break;
    default:
      return temp;
      break;
  }
  return temp;
}
int nextionAskPageNamper(byte port)
{
  int result;
  _nextionLissenStruct temp;
  nextionSendCommand("sendme", port);
  temp = nextionListen(port);
  if ((temp.code == 'f') && (temp.result != "")) {
    result = temp.result.toInt();
  } else {
    result = -1;
  }
  return result;
}


Une courte vidéo avec une démonstration.


Archivez avec le projet pour le panneau et le projet pour le contrôleur.
Dans la prochaine leçon, nous apprendrons comment contrôler le contrôleur Arduino à partir du panneau.

Source: https://habr.com/ru/post/fr392685/


All Articles