Vous êtes ici:

Menu

Stacks Image 36912
Certainement un éième tutoriel sur le NodeMCU-ESP8266, je ne vais pas vous présenter ce microcontrôleur mais je vais plutôt orienter mon tuto sur les problématiques réseaux avec la mise à jour par OTA et le moyen d'être autonome sans le brancher sur un ordinateur.
Je me suis procuré ce NodeMCU version ESP-12F sur le site d'AZ-Delivery. Ce modèle est plus compact que le NodeMCU V3 que j'avais précédemment mais au détriment de la visibilité des libellés des pins.

1 OTA la mise à jour "par les airs"

Je trouvais fastidieux de faire les téléchargement via le port USB pour deux raisons :
- d'abord le manque de place sur mon bureau. J'ai toujours deux portables et deux raspberry, mes montages n'ont plus beaucoup de place ou gênent le déplacement de ma souris.
- deuxièmement, la lenteur du téléchargement par la liaison série.
Je travaille avec Linux, donc pas de souci pour le prérequis nécessaire au fonctionnement de l'OTA. J'utilise Linux Mint, dérivé d'Ubuntu v 20.04, il intègre python et le protocole mDNS. Il faudra néanmoins installé le premier programme avec la liaison série. Voici le modèle utilisée.
/************************************************************
 *Projet      : Modele OTA ESP8266                          *
 *              basé sur Hackable Magazine n°21             *
 *Auteur      : Sugarbug                                    *
 *Date        : 24-octobre-2020                             * 
 *Version     : 1.00                                        *
 *                                                          *
 * *********************************************************/
#include <ESP8266WiFi.h> //bibliothèque ESP8266
#include <ESP8266mDNS.h> //bibliothèque protocole mDNS
#include <ArduinoOTA.h>  //bibliothèque OTA


/******************Prerequis OTA*****************************/
/*SSID et Password*/
const char* ssid = "ssidBoxWifi";  // SSID
const char* password = "MotdePasseWifi";  // Password

/* nom d'hôte pour l'ESP 8266 */
const char* hostString = "esptestOTA1";

//mot de passe OTA
const char* otapass = "123456";

//gestion du temps pour le calul de ma mise à jour
unsigned long otamillis;
/******************fin Prequis OTA**************************/

/******************initialisation variables*****************/

/******************fin initialisation variables*************/

/*******************fonction OTA****************************/
void confOTA() {
  //port 8266 par défaut
  ArduinoOTA.setPort(8266);

  //hostname défaut
  ArduinoOTA.setHostname(hostString);

  //mot de passe OTA
  ArduinoOTA.setPassword(otapass);

  //lancé au début de la mise à jour
  ArduinoOTA.onStart([]() {
    Serial.println("/!\\ MaJ OTA");
    otamillis=millis();
  });

  //lancé en fin de la mise à jour
  ArduinoOTA.onEnd([]() {
    Serial.print("\n/!\\ Maj terminee en ");
    Serial.print((millis()-otamillis)/1000.0);
    Serial.println(" secondes");
  });

  //lancé lors de la progression de la mise à jour
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("Progression: %u%%\r", (progress / (total / 100)));
  });

  //En cas d'erreur
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("Erreur[%u]: ", error);
    switch(error) {
      //erreur d'authentification, mauvais mot de passe OTA
      case OTA_AUTH_ERROR: 
        Serial.println("OTA_AUTH_ERROR");
        break;
      //erreur lors du démarrage de la MaJ (flash insuffisante)
      case OTA_BEGIN_ERROR: 
        Serial.println("OTA_BEGIN_ERROR");
        break;
      //impossible de se connecter à l'IDE Arduino
      case OTA_CONNECT_ERROR: 
        Serial.println("OTA_CONNECT_ERROR");
        break;
      //erreur réception des données
      case OTA_RECEIVE_ERROR: 
        Serial.println("OTA_RECEIVE_ERROR");
        break;
      //erreur lors de la confirmation de la MaJ
      case OTA_END_ERROR: 
        Serial.println("OTA_END_ERROR");
        break;
      //erreur inconnu
      default:
        Serial.print("Erreur inconnue ");
        Serial.println(error);
    }
  });

  // Activation de la fonctionnalité OTA
  ArduinoOTA.begin();
}
/********************fin fonction OTA***********************/


void setup() {
  // Moniteur Série
  Serial.begin(115200);
  // démarrage
  Serial.println("\r\nBoot...");

  // mode Wifi Client
  WiFi.mode(WIFI_STA);

  //connexion
  WiFi.begin(ssid, password);
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    //impossible de se connecter au point d'accès
    // reboot après 5s
    Serial.println("Erreur connexion Wifi ! Reboot...");
    delay(5000);
    ESP.restart();
  }

  // configuration OTA
  confOTA();
  // tout est prêt, on affiche notre IP
  Serial.print("Adresse IP: ");
  Serial.println(WiFi.localIP());

  /*************Setup du programme*********************/
  
  /****************************************************/
}

void loop() {
  
  //gestion OTA
  ArduinoOTA.handle();

  /*************Corps du programme*********************/

  /****************************************************/

}
Il faudra renseigner le ssid de votre réseau local et votre mot de passe. Le mot de passe est 123456 pour télécharger les programmes via OTA. Le nom d'hôte utilisé par le protocole mDNS est défini par la constante hostString. Le microcontrôleur sera accessible à l'adresse suivante : esptestOTA1.local.
Stacks Image 969988
Grâce à la fonctionnalité mDNS, le nodeMCU sera accessible via le réseau Wifi dans l'IDE Arduino. Il suffira de sélectionner le port réseau. Attention, à l'activation de ce port, vous ne pourrez plus utiliser le Moniteur Série pour déboguer.

2 Premier programme : Clignotement d'une LED

Maintenant testons notre mise à jour via Wifi. Seule contrainte, ne pas toucher au programme initiale et éviter de supprimer la fonction dans loop. Nous allons faire un test tout simple du clignotement d'une LED et de la led interne via le pin 2 (D4).
Stacks Image 970257
premier montage tout simple
Stacks Image 970262
le schéma
Le programme est "on ne peut plus simple", j'afficherai seulement les bouts de code à rajouter dans le modèle précédents. Tout d'abord, l'initialisation des variables.
/******************initialisation variables*****************/
const int redLEDpin = 2;
/******************fin initialisation variables*************/
On défini la fonction du pin dans la fonction setup.
void setup() {
  ....

  /*************Setup du programme*********************/
  pinMode(redLEDpin,OUTPUT);
  /****************************************************/
}
On fait clignoter les deux LEDs avec ce bout de condé dans la fonction loop.
void loop() {
  ....  

  /*************Corps du programme*********************/
  digitalWrite(2,HIGH);
  delay(400);
  digitalWrite(2,LOW);
  delay(400);
  /****************************************************/
}
La mise à jour via wifi se fait très facilement et c'est très rapide.
Stacks Image 970265
Il faudra saisir le mot de passe indiqué dans le programme
Stacks Image 970268
La mise à jour est réalisée
00:00  /  00:00

3 Rendre le montage autonome

Maintenant, nous rendre notre montage complètement autonome avec une batterie Lipo 3.7v 1000mAh acheté sur Amazon. Pour charger cette batterie, je vais utiliser un petit montage spécifique à base de TP4056 trouvé sur Amazon. Il permet, en outre, d'alimenter le montage par une autre source externe comme un panneau solaire. Voici le montage.
Stacks Image 970273
Lors de mes vérifications avec un multimètre, j'ai été très étonné de la tension de la batterie qui délivre 4,2 V en pleine charge. Heureusement le NodeMCU a un régulateur permettant d'absorber cette tension. Nous utiliserons le diviseur de tension intégré à la broche AO, seule entrée analogique sur le NodeMCU. Après quelques essais et lecture sur le net, j'en suis arrivé à la conclusion suivante : Je mesure la tension délivrée par le régulateur (sa valeur max étant de 3.2 V) pour l'ESP et j'applique un coefficient multiplicateur de 0,003027 pour obtenir cette tension avec la broche A0. C'est un peu empirique comme solution mais ça me convient.
Pour des explications nettement plus détaillées, allez lire l'excellent article de la Frambroise au potager.
Voici le montage :
Stacks Image 970280
Comme je n'ai plus accès au moniteur série pour vérifier mes valeurs, je vais confectionner un serveur Web qui m'affichera la valeur de la broche et la valeur de la tension résultante. Nous allons rajouter ce code pour la déclaration des variables.
#include <ESP8266WebServer.h> //bibliothèque serveur Web

/******************initialisation variables*****************/
//pin pour la LED Rouge
const int redLEDpin = 2;


float volt =0.0;
float temp=0.0;

// mode lecture externe pour la broche analogique
ADC_MODE(ADC_TOUT);

ESP8266WebServer server(80); //initialisation du serveur Web
/******************fin initialisation variables*************/
La fonction setup initialise le serveur Web
  /*************Setup du programme*********************/
  pinMode(redLEDpin,OUTPUT);

  //démarrage serveur Web
  server.on("/", handle_OnConnect);
  server.onNotFound(handle_NotFound);
  server.begin();
  
  /****************************************************/
Nous rajoutons ces fonctions nécessaires au fonctionnement de notre serveur Web.
  void handle_OnConnect() {
  server.send(200, "text/html", SendHTML(hostString, volt, temp)); 
}

void handle_NotFound(){
  server.send(404, "text/plain", "Not found");
}

String SendHTML(String hostStringstat, float voltV, int pin){
  String ptr = "<!DOCTYPE html> </html>\n";
  ptr +="<head>\n";
  ptr +="<title>ESP8266 Test</title>\n";
  ptr +="<style>html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
  ptr +="body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;}\n";
  ptr +="p {font-size: 24px;color: #444444;margin-bottom: 10px;}\n";
  ptr +="</style>\n";
  ptr +="</head>\n";
  ptr +="<body>\n";
  ptr +="<div id=\"webpage\">\n";
  ptr +="<h1>";
  ptr +=hostStringstat;
  ptr +=" NodeMCU Test";
  ptr +="</h1>\n";
  ptr +="<p>Tension: ";
  ptr +=voltV;
  ptr +=" V</p>";
  ptr +="<p>Valeur AO: ";
  ptr +=pin;
  ptr +=" </p>";
  
  ptr +="</div>\n";
  ptr +="</body>\n";
  ptr +="</html>\n";
  return ptr;
}
Et nous finirons par la lecteur de la broche analogique et le calcul de la tension.
  /*************Corps du programme*********************/
  //appel au serveur Web
  server.handleClient();

  digitalWrite(2,HIGH);
  delay(400);
  digitalWrite(2,LOW);
  delay(400);

  /* Lecture de la broche A0 */
  int analogvalue = analogRead( A0 );
  temp = analogvalue;
  volt = analogvalue * 0.003027;
  /****************************************************/
Après téléchargement, vous devriez avoir cette vue à cette url : http://esptestota1.local. Actuellement mon programme fonctionne sur la batterie et indique 2.83 V et je mesure environ 2.88 V à la broche 3V3 et 4.01 V à l'entrée Vin.
Stacks Image 970237
En branchant l'alimentation secteur, je me retrouve avec une tension de 3.10 V sur la broche 3v3 et 4.23 V à l'entrée Vin. On constate que nous sommes au maximum de la valeur analogique de la broche A0.
Stacks Image 970299
Ce tutoriel n'est pas complètement terminé, il me reste à vérifier l'autonomie de la batterie et le mode sommeil de l'ESP 8266. En parallèle, le prochain tuto sera un montage pour simuler le fonctionnement d'un passage à niveau pour les amateurs de modélisme ferroviaire.
 Vous êtes ici:

Nous utilisons des cookies pour nous permettre de mieux comprendre comment le site est utilisé. En continuant à utiliser ce site, vous acceptez cette politique.