Ecran Nextion : Affichage LCD Tactile 7″ Nextion HMI

–

Mise à jour le 14/04/2018 : L’Affichage LCD Tactile 7″ Nextion HMI est une solution de module d’écran LCD homogène à Interface homme-machine (IHM) qui fournit une interface de commande et de visualisation pour tout kit Arduino et Raspberry Pi. Nextion s’implique principalement dans l’IdO ou le domaine de l’électronique grand-public. C’est la meilleur solution pour remplacer les tubes Nixie à DEL et LCD traditionnels

redohm@bertrand-benoit.net>Bertrand BENOIT ( Programme Open source : Décodage complet de tous types de messages de l’écran Nextion )

Sommaire :

Description de l’affichage LCD Tactile 7″ Nextion HMI
Guide de démarrage rapide de l’interface utilisateur
Tutoriel pour la tablette Nextion
- Décodage complet de tous types de messages de l’écran Nextion ( Par Bertrand.B)
  - Objectifs du programme
  - Matériel utilisé pour le tutoriel
  - Vidéo du tutoriel .
  - Paramétrage des différentes composants pour la tablette Nextion
  - Programme pour Arduino Mega ( Bertrand-B )
Retour au menu principal.

Retour au sommaire .

Description de l’affichage LCD Tactile 7″ Nextion HMI

–

Caractéristiques et spécificités :

Modèle : IM150416007
Dimensions d’affichage : 7,0”
Résolution d’affichage : 800 x 480
- 65 K de vraies couleurs RVB
Interface d’affichage : sérielle
Contrôleur d’affichage : non
Extension : socle pour carte SD
Écran : tactile
Dimensions de la carte : 181 x 108 mm
Poids : 337 g
Interface d’affichage TFT : N/C

Retour au sommaire .

Guide de démarrage rapide de l’interface utilisateur

1 : Menu principal .
2 : Composants disponibles
3 : Bibliothèque de polices : Stockage de la police que vous avez créée par l’éditeur de polices.Bibliothèque d’images : importez les ressources d’image dont vous avez besoin.
4 : Zone d’affichage
5 : Zone de page: Modifier la page dans cette zone
6 : Zone d’édition: Permet de modifier les attributs des composants et des pages, tels que la valeur, la couleur d’un composant de texte.
7 : Fenêtre de sortie du compilateur: si des erreurs surviennent, elles seront affichées dans cette zone.
8 : Zone de l’événement: Écrivez quelques codes simples ici. Lorsque l’événement est déclenché, les codes que vous écrivez seront exécutés.

Lien pour le guide de démarrage rapide de l’éditeur Nextion -> https://www.itead.cc/wiki/Nextion_Editor_Quick_Start_Guide

Retour au sommaire .

Décodage complet de tous types de messages de l’écran Nextion

Objectifs du programme :

L’objectif de ce programme, très complet, est d’être capable d’interpréter tous les types de messages de la tablette Nextion. La lecture d’un message complet (Cf. https://www.itead.cc/wiki/Nextion_Instruction_Set#Format_of_Device_Return_Data) est réalisée par la fonction readNextNextionMessage().L’astuce est de lire, et concaténer tous les Octets lus, jusqu’à ce que le motif « 0XFF 0XFF 0XFF » soit atteint.Le décodage est réalisé par la fonction manageMessage(byte* message), qui peut être complété en fonction de vos besoins.Il est ainsi aussi bien possible d’interpréter la pression, ou le relâchement d’un composant sur la tablette Nextion, qu’une valeur envoyée par l’un des composants (e.g. une barre de progression, dans notre exemple).

Dans ce tutoriel, nous stockons la valeur de chacune des 3 barres de progression, dans une variable correspond à la couleur correspondante.Ensuite, à titre d’exemple, on change la couleur RGB d’une LED, avec la valeur stockée pour chacune des couleurs.

Bonus : à savoir que la gestion des tableaux d’Octets sous Arduino est parfois un peu délicate, la méthode printMessage permet d’afficher un message de la tablette Nextion, sous la forme d’un jeu d’héxadécimaux pour que ce soit lisible pour l’humain.

Retour au sommaire .

Matériel utilisé pour le tutoriel :

1 Piece – Carte Arduino MEGA 2560 : La carte Arduino Mega 2560 est basée sur un ATMega2560 cadencé à 16 MHz. Elle dispose de 54 E/S dont 14 PWM, 16 analogiques et 4 UARTs.
1 Piece – Module Grove Mega Shield V1.2 103020027 : Le module Grove Mega Shield de Seeedstudio est une carte d’interface permettant de raccorder facilement, rapidement et sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino Mega. Il est compatible notamment avec les cartes Arduino Mega .
1 Piéce – Affichage LCD Tactile 7″ Nextion HMI : est une solution de module écran LCD homogène à Interface homme-machine (IHM) qui fournit une interface de commande et de visualisation pour tout kit Arduino et Raspberry Pi.
1 Piéce – Led 8 mm RGB Grove V2.0 104020048 : Ce module led RGB 8 mm est compatible Grove et permet d’obtenir une couleur au choix à partir d’une sortie d’une microcontrôleur (Arduino, Seeeduino, etc.). Possibilité de raccorder jusqu’à 1024 modules en cascade.

Retour au sommaire .

Vidéo du tutoriel :

Retour au sommaire .

Paramétrage des différentes composants pour la tablette Nextion ( Bertrand-B )

Page d’initialisation – RedOhm –

Paramétrage pour la barre de progression pour le rouge – RedOhm –

Paramétrage pour la barre de progression pour le vert – RedOhm –

Retour au sommaire .

Programme pour Arduino Mega ( Bertrand-B )
Editeur Arduino 1.8.5

/*
 * 
 * 
 * 
 * 
 * Le 24/03/2018
 * RedOhm Bertrand BENOIT
 * 
 * Programme permettant de décoder certains messages reçue d'une Nextion, 
 * et de modifier en conséquence la couleur d'une LED RGB.
 * 
 * Niveau de difficulté 7/10
 * 
 * Pour information 
 * @author <mailto:redohm@bertrand-benoit.net>Bertrand BENOIT</mailto>
 */

// Cette bibliothèque vous permet de communiquer avec les tablettes Nextion.
#include <Nextion.h>

// Cette bibliothèque vous permet de travailler sur un port Serial Logiciel (Software),
// qui est ici utilisé pour communiquer avec la tablette Nextion.
#include <SoftwareSerial.h>

// Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove.
#include <ChainableLED.h>

// Définition du nombre de LED, et des broches utilisées.
#define NUM_LEDS      1
#define LED_PIN1      6
#define LED_PIN2      7

// Definition des broches de la LED.
ChainableLED leds(LED_PIN1, LED_PIN2, NUM_LEDS);


// Définition de certaines constantes liées au fonctionnement de Nextion.
// Cf. https://www.itead.cc/wiki/Nextion_Instruction_Set#Format_of_Device_Return_Data
#define NETXION_END_PATTERN         0xff    
#define NETXION_BEGIN_TOUCH_EVENT   0x65
#define NETXION_BEGIN_NUMERIC_VALUE 0x71

// Définition des ID des composants qui nous intéressent 
//(à aller chercher sur le programme .HMI de votre Nextion).
#define NETXION_RED_SLIDER_ID           1
#define NETXION_GREEN_SLIDER_ID         4
#define NETXION_BLUE_SLIDER_ID          7

// Definition des broches de la tablette Nextion.
// Très important, sur le Mega 2560, toutes les broches ne peuvent 
// pas être utilisés !
// Cf. https://www.arduino.cc/en/Reference/SoftwareSerial
SoftwareSerial nextionSerial(10, 11); // RX, TX

// Création de l'instance d'objet Nextion permettant de communiquer 
//avec la tablette Nextion.
Nextion nex(nextionSerial);

// Variables globales, permettant de mémoriser les couleurs rouge, vert,
// bleue à appliquer sur la LED
// (elles sont modifiées à la réception des messages de la Nextion).
int redValue = 0;
int greenValue = 0;
int blueValue = 0;

// Fonction coeur permettant de décoder tous les messages de la Nextion;
// ils doivent tous se terminer par le motif 0xFF 0xFF 0xFF
// Le principe est de lire les messages de la Nextion, un par un,
// et de les conserver dans un buffer, jusqu'à ce que le motif de fin apparaisse.
byte* readNextNextionMessage() {
  // Variable permettant de lire les byte, un par un.
  byte _byte;
  // Le buffer contenant le message complet, en cours de construction,
  // avant émission.
  byte byteBuffer[32];
  // Index du prochain byte attendu, dans le buffer.
  int byteIndex = 0;
  // Nombre de fois où le pattern de fin est apparue.
  int endPatternCount = 0;
  // Simple booléen permettant de déterminer si le dernier byte lu 
  // était un motif de fin,
  // cela permet de garantir que les 3 motifs sont consécutifs.
  // Cela est très important, car n'importe quel message peut très
  // bien contenir la valeur 0XFF,
  // et il ne doit donc pas être considéré à tort, comme un motif de fin.
  bool lastByteWasEndPattern = false;

  Serial.println("Reading message from Nextion ...");

  // On boucle, tant que l'on a pas lu 3 fois consécutives, le motif de fin 0xFF
  while(true) {
    // On teste s'il y a au moins un byte à lire, provenant de la Nextion.
    while (nextionSerial.available() <= 0) {
      delay(10);
      continue;
    }

    // On lit un byte, et on l'enregistre dans le buffer.
    _byte = nextionSerial.read();
    byteBuffer[byteIndex++] = _byte;

    // On teste s'il s'agit d'un motif de fin.
    if(_byte == NETXION_END_PATTERN){
      // C'est le cas, on met donc à jour le booléen, on incrémente le nombre 
      // de motif de fin trouvé à la suite,
      //  et on teste s'il s'agissait du 3ème.
      lastByteWasEndPattern = true;
      if (++endPatternCount == 3) {
        // C'est le cas, on sort donc de la boucle, message complet a été lu.
        break;
      }
    } else {
      // Ce n'est pas un motif de fin, donc on met à jour le booléen et le
      //nombre de motif de fin consécutif.
      lastByteWasEndPattern = false;
      endPatternCount = 0;
    }
  }

  // Une fois sortie de la boucle, on envoie le message complet,
  // contenu dans le buffer.
  return byteBuffer;
}

// Fonction permettant d'afficher proprement un message de la Nextion,
// sous la forme d'un hexadecimal, pour chaque byte.
void printMessage(byte *message) {
  // Le byte lu.
  byte nextByte;
  // L'index du byte à lire, dans le buffer passé en paramètre.
  int index = 0;

  // Tant qu'il y a un byte à lire, qui ne soit pas un motif de fin.
  while ((nextByte = message[index++]) != NETXION_END_PATTERN) {
    // Affichage du byte, sous la forme d'un hexadecimal.
    Serial.print("0x");
    Serial.print(nextByte, HEX);
    Serial.print(" ");
  }  
  Serial.println();
}

// Fonction permettant de gérer un message de la Nextion.
void manageMessage(byte* message) {
  Serial.print("Parsing message: ");
  printMessage(message);

  // Déclaration des variables permettant de récupérer l'ID, et la valeur d'un composant.
  int componentID, componentValue;

  // Décodage du type de message, en fonction du premier byte.
  // Cf. https://www.itead.cc/wiki/Nextion_Instruction_Set#Format_of_Device_Return_Data
  switch(message[0]) {
    // Le message indique qu'un composant a été activé sur la tablette Nextion.
    case NETXION_BEGIN_TOUCH_EVENT:
      // Ici on se contente d'afficher un message.
      Serial.println("Touch event message ... ");
      break;

    // Un message "personnalisé" a été émis par la tablette Nextion,
    // il contient une valeur à récupérer.
    case NETXION_BEGIN_NUMERIC_VALUE:
      // Le format des messages numériques envoyés par la Nextion contient 
      // l'ID du composant activé, sur 4 bytes
      //  ainsi que sa valeur, sur les 4 bytes suivants.
      Serial.print("Numeric value message ... ");
      componentID = (int) message[1];
      componentValue = (int) message[5];
      Serial.print(" ID = ");
      Serial.print(componentID);
      Serial.print("; Value = ");
      Serial.println(componentValue);

      // Ici, on change la variable contenant la couleur de la LED à considérer,
      // en fonction de l'ID du composant dont on vient de récupérer la valeur.
      if (componentID == NETXION_RED_SLIDER_ID)
        redValue = componentValue;
      else if (componentID == NETXION_GREEN_SLIDER_ID)
        greenValue = componentValue;
      else if (componentID == NETXION_BLUE_SLIDER_ID)
        blueValue = componentValue;
      break;
  
    default :
      // Dans ce petit programme, on ne gère aucun des autres messages.
      Serial.print("Unknown message ... First Byte=");
      Serial.println(String(message[0], HEX));
      break;
  }  
}

void setup() {
  // Pour des raisons de performances sur les entrées/sorties, 
  // il est préférable de commenter l'initialisation du port Série.
  // Réactivez le, uniquement à des fins de Debug.
  // Serial.begin(9600);

  // Initialisation du Serial logiciel, et de la Nextion.
  nextionSerial.begin(9600);
  nex.init();

  // Récupération de l'ID de la page actuellement affichée sur la Nextion
  // (histoire de tester la communication),
  //  et affichage d'un message informatif.
  int pageid = nex.getCurrentPage();
  Serial.print("Initialisation OK, currentPageID=");
  Serial.print(pageid);
  Serial.println(".");
}

void loop() {
  // Lecture d'un nouveau message de la Nextion.
  byte* instruction = readNextNextionMessage();

  // On prend en compte le message.
  manageMessage(instruction);

  // Enfin, on à jour la couleur RGB de la LED, 
  // en fonction des valeurs qui ont été potentiellement modifiées.
  leds.setColorRGB(0, redValue, greenValue, blueValue);

  delay(100);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

* Le 24/03/2018

* RedOhm Bertrand BENOIT

* Programme permettant de décoder certains messages reçue d'une Nextion,

* et de modifier en conséquence la couleur d'une LED RGB.

* Niveau de difficulté 7/10

* Pour information

* @author <mailto:redohm@bertrand-benoit.net>Bertrand BENOIT</mailto>

// Cette bibliothèque vous permet de communiquer avec les tablettes Nextion.

#include <Nextion.h>

// Cette bibliothèque vous permet de travailler sur un port Serial Logiciel (Software),

// qui est ici utilisé pour communiquer avec la tablette Nextion.

#include <SoftwareSerial.h>

// Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove.

#include <ChainableLED.h>

// Définition du nombre de LED, et des broches utilisées.

#define NUM_LEDS 1

#define LED_PIN1 6

#define LED_PIN2 7

// Definition des broches de la LED.

ChainableLED leds(LED_PIN1, LED_PIN2, NUM_LEDS);

// Définition de certaines constantes liées au fonctionnement de Nextion.

// Cf. https://www.itead.cc/wiki/Nextion_Instruction_Set#Format_of_Device_Return_Data

#define NETXION_END_PATTERN 0xff

#define NETXION_BEGIN_TOUCH_EVENT 0x65

#define NETXION_BEGIN_NUMERIC_VALUE 0x71

// Définition des ID des composants qui nous intéressent

//(à aller chercher sur le programme .HMI de votre Nextion).

#define NETXION_RED_SLIDER_ID 1

#define NETXION_GREEN_SLIDER_ID 4

#define NETXION_BLUE_SLIDER_ID 7

// Definition des broches de la tablette Nextion.

// Très important, sur le Mega 2560, toutes les broches ne peuvent

// pas être utilisés !

// Cf. https://www.arduino.cc/en/Reference/SoftwareSerial

SoftwareSerial nextionSerial(10, 11); // RX, TX

// Création de l'instance d'objet Nextion permettant de communiquer

//avec la tablette Nextion.

Nextion nex(nextionSerial);

// Variables globales, permettant de mémoriser les couleurs rouge, vert,

// bleue à appliquer sur la LED

// (elles sont modifiées à la réception des messages de la Nextion).

int redValue = 0;

int greenValue = 0;

int blueValue = 0;

// Fonction coeur permettant de décoder tous les messages de la Nextion;

// ils doivent tous se terminer par le motif 0xFF 0xFF 0xFF

// Le principe est de lire les messages de la Nextion, un par un,

// et de les conserver dans un buffer, jusqu'à ce que le motif de fin apparaisse.

byte* readNextNextionMessage() {

// Variable permettant de lire les byte, un par un.

byte _byte;

// Le buffer contenant le message complet, en cours de construction,

// avant émission.

byte byteBuffer[32];

// Index du prochain byte attendu, dans le buffer.

int byteIndex = 0;

// Nombre de fois où le pattern de fin est apparue.

int endPatternCount = 0;

// Simple booléen permettant de déterminer si le dernier byte lu

// était un motif de fin,

// cela permet de garantir que les 3 motifs sont consécutifs.

// Cela est très important, car n'importe quel message peut très

// bien contenir la valeur 0XFF,

// et il ne doit donc pas être considéré à tort, comme un motif de fin.

bool lastByteWasEndPattern = false;

Serial.println("Reading message from Nextion ...");

// On boucle, tant que l'on a pas lu 3 fois consécutives, le motif de fin 0xFF

while(true) {

// On teste s'il y a au moins un byte à lire, provenant de la Nextion.

while (nextionSerial.available() <= 0) {

delay(10);

continue;

}

// On lit un byte, et on l'enregistre dans le buffer.

_byte = nextionSerial.read();

byteBuffer[byteIndex++] = _byte;

// On teste s'il s'agit d'un motif de fin.

if(_byte == NETXION_END_PATTERN){

// C'est le cas, on met donc à jour le booléen, on incrémente le nombre

// de motif de fin trouvé à la suite,

// et on teste s'il s'agissait du 3ème.

lastByteWasEndPattern = true;

if (++endPatternCount == 3) {

// C'est le cas, on sort donc de la boucle, message complet a été lu.

break;

}

} else {

// Ce n'est pas un motif de fin, donc on met à jour le booléen et le

//nombre de motif de fin consécutif.

lastByteWasEndPattern = false;

endPatternCount = 0;

}

// Une fois sortie de la boucle, on envoie le message complet,

// contenu dans le buffer.

return byteBuffer;

}

// Fonction permettant d'afficher proprement un message de la Nextion,

// sous la forme d'un hexadecimal, pour chaque byte.

void printMessage(byte *message) {

// Le byte lu.

byte nextByte;

// L'index du byte à lire, dans le buffer passé en paramètre.

int index = 0;

// Tant qu'il y a un byte à lire, qui ne soit pas un motif de fin.

while ((nextByte = message[index++]) != NETXION_END_PATTERN) {

// Affichage du byte, sous la forme d'un hexadecimal.

Serial.print("0x");

Serial.print(nextByte, HEX);

Serial.print(" ");

}

Serial.println();

}

// Fonction permettant de gérer un message de la Nextion.

void manageMessage(byte* message) {

Serial.print("Parsing message: ");

printMessage(message);

// Déclaration des variables permettant de récupérer l'ID, et la valeur d'un composant.

int componentID, componentValue;

// Décodage du type de message, en fonction du premier byte.

// Cf. https://www.itead.cc/wiki/Nextion_Instruction_Set#Format_of_Device_Return_Data

switch(message[0]) {

// Le message indique qu'un composant a été activé sur la tablette Nextion.

case NETXION_BEGIN_TOUCH_EVENT:

// Ici on se contente d'afficher un message.

Serial.println("Touch event message ... ");

break;

// Un message "personnalisé" a été émis par la tablette Nextion,

// il contient une valeur à récupérer.

case NETXION_BEGIN_NUMERIC_VALUE:

// Le format des messages numériques envoyés par la Nextion contient

// l'ID du composant activé, sur 4 bytes

// ainsi que sa valeur, sur les 4 bytes suivants.

Serial.print("Numeric value message ... ");

componentID = (int) message[1];

componentValue = (int) message[5];

Serial.print(" ID = ");

Serial.print(componentID);

Serial.print("; Value = ");

Serial.println(componentValue);

// Ici, on change la variable contenant la couleur de la LED à considérer,

// en fonction de l'ID du composant dont on vient de récupérer la valeur.

if (componentID == NETXION_RED_SLIDER_ID)

redValue = componentValue;

else if (componentID == NETXION_GREEN_SLIDER_ID)

greenValue = componentValue;

else if (componentID == NETXION_BLUE_SLIDER_ID)

blueValue = componentValue;

break;

default :

// Dans ce petit programme, on ne gère aucun des autres messages.

Serial.print("Unknown message ... First Byte=");

Serial.println(String(message[0], HEX));

break;

}

void setup() {

// Pour des raisons de performances sur les entrées/sorties,

// il est préférable de commenter l'initialisation du port Série.

// Réactivez le, uniquement à des fins de Debug.

// Serial.begin(9600);

// Initialisation du Serial logiciel, et de la Nextion.

nextionSerial.begin(9600);

nex.init();

// Récupération de l'ID de la page actuellement affichée sur la Nextion

// (histoire de tester la communication),

// et affichage d'un message informatif.

int pageid = nex.getCurrentPage();

Serial.print("Initialisation OK, currentPageID=");

Serial.print(pageid);

Serial.println(".");

}

void loop() {

// Lecture d'un nouveau message de la Nextion.

byte* instruction = readNextNextionMessage();

// On prend en compte le message.

manageMessage(instruction);

// Enfin, on à jour la couleur RGB de la LED,

// en fonction des valeurs qui ont été potentiellement modifiées.

leds.setColorRGB(0, redValue, greenValue, blueValue);

delay(100);

}

Retour au sommaire .