Ça y est ! j’en ai enfin terminé avec cet anémomètre ! J’ai fait une pierre 4 coups ! Après avoir réalisé la chaîne d’information, conçu les pièces en 3D et imprimé les pièces, je me suis attaqué à l’électronique et à la programmation de l’objet ! C’est parti !

Si vous ne savez pas de quoi je parle, je vous invite à lire la partie 1 du projet !
Mon objectif étant de réaliser un anémomètre connecté à coupelles pour moins de 50 euros !

La vidéo de l’objet

Comment récupérer l’information ?

Un anémomètre c’est bien, connecté c’est mieux. Pour récupérer l’information, mon anémomètre se connectera en WiFi à mon Raspberry Pi 3 sous Raspbian Stretch. Pour se faire j’ai effectué les étapes décrites dans mes précédents articles, à savoir :
– 5 minutes pour créer son hotspot Wifi sur Raspberry Pi !
– Mosquitto et Node-RED : Le couple parfait pour vos objets connectés !
– InfluxDB et Grafana sur Raspberry Pi !

Et le petit rappel de l’architecture qui ne fait pas de mal :

Une architecture dont le centre névralgique est Mosquitto. L’architecture peut aisément être mise en place grâce à Node-RED.

Aujourd’hui on va se concentrer sur l’ESP8266. C’est le microcontrôleur qui va s’occuper de la mesure de la vitesse du vent dans l’anémomètre. L’ESP8266 va compter chaque impulsion qu’il reçoit sur une de ses broches. A chaque tour qu’effectuera l’axe de l’anémomètre, l’aimant passera devant le capteur à effet Hall. Cela aura pour effet d’envoyer à chaque tour une impulsion au microcontrôleur.

Schéma de l’axe de l’anémomètre avec le capteur à effet Hall.

Le microcontrôleur (ESP8266), quant à lui, en déduira le nombre de tour qu’effectuera l’axe pendant un certain laps de temps (ici 5 secondes). Il pourra ensuite, par calcul, en déduire le nombre de tours par minutes puis la vitesse en km/h et m/s.

Ces données de vitesses sont ensuite publiées sur deux topics MQTT se trouvant sur le Raspberry Pi (voir l’article traitant le sujet ici) :

Maintenant que l’on sait où on va, regardons de plus près l’électronique de l’objet…

Partie électronique de l’anémomètre

Pour la partie électronique, il faut bien prendre en compte les différents « étages d’alimentation ». En effet, les panneaux solaires sont donnés pour une tension pouvant aller jusqu’à 6 V maximum. Or notre batterie a une tension de 2.8 V à vide et 4.2 V en pleine charge. Pour recharger une telle batterie, il faut que la tension des panneaux solaires soit supérieure à la tension de la batterie (chose que je n’ai pas pris en compte dans mes premières estimations dans la partie 1). Le contrôleur de charge que j’utilise (facilement trouvable sur Ebay) s’adapte en fonction de la tension d’entrée pour délivrer le courant nécessaire avec la bonne tension à la batterie. Il ne reste plus qu’à raccorder notre circuit en parallèle sur notre batterie. Et c’est là que ça se complique… Notre microcontrôleur ESP8266 ne fonctionne plus au-delà de 3.5V. Il est donc important de réguler la tension à 3,3V afin d’éviter de cramer notre composant ! D’après les datasheets, l’ESP8266 et le capteur à effet hall fonctionnent bien entre 2.8 V et 3.3 V.

Afin d’avoir une tension lissée, on ajoute quelques condensateurs dans le montage du régulateur 3,3 V (LD1117V33). En effet, l’ESP8266 n’aime pas les perturbations.

Ce qui nous donne à la fin, avec le contrôleur de charge TP4056, les panneaux solaires, la batterie et la régulation de la tension en 3,3 V pour notre montage :

Eh beh… Passons au montage avec l’ESP8266 et le capteur à effet hall. J’ai pris une carte électronique toute faite qui contenait déjà le capteur à effet Hall. Pour le montage de l’ESP8266, c’est bien plus complexe que sur Arduino. Il faut savoir que l’alimentation ou la mise à la masse de certaines broches définissent le mode de fonctionnement de l’ESP8266. Je reviendrai sur le sujet dans un futur article ! Le programme utilise principalement 3 broches sur l’ESP8266 : RST, GPIO16 et GPIO4. Cette dernière broche sera notre signal de la présence ou non de l’aimant sur notre capteur à effet Hall. Pour les pins RST et GPIO16, ce sont les broches qui nous permettrons de réveiller le microcontrôleur lorsque celui-ci se sera mis en veille.

Programmation

Pour la partie programmation, pas tellement de chose à commenter, le programme se situe ci-dessous :

/*
 * Anémomètre connecté avec ESP8266
 *  
 * Librairies nécessaires :
 *  - ESP8266Wifi
 *  - PubSubClient
 * 	Les librairies sont téléchargeables avec ESP8266 Community et PubSubClient dans le Gestionnaire de cartes
 *  Ne pas oublier d'ajouter cet URL dans l'URL du gestionnaire de cartes dans les préférences de l'IDE Arduino :
 *  http://arduino.esp8266.com/staging/package_esp8266com_index.json
 *  
 * 
 * https://bentek.fr
 * Licence : MIT
 * 
  */
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
/*
 * Variables et paramètres de connexion WiFi
 * 
*/
#define wifi_ssid "BenTeK_secure" // Le SSID de mon hotspot WiFi sur le Raspberry Pi
#define wifi_password "jeNeDonneraiPasMonMotDePasse_MaisTuPeuxMettreLeTiens" // :-D
#define mqtt_server "10.3.141.1" // IP du Raspberry sur son réseau HotSpot
#define mqtt_user "guest"     //s'il a été configuré sur Mosquitto
#define mqtt_password "guest" //idem

long lastMsg = 0;     //Horodatage du dernier message publié sur MQTT
long lastRecu = 0;

#define vitessems_topic "anemometre/vitesseVentMS"        // Topic Vitesse du vent (en m/s)
#define vitessekmh_topic "anemometre/vitesseVentKMH"      // Topic Vitesse du vent (en km/h)


//Création des objets
   
WiFiClient espClient;
PubSubClient client(espClient);

volatile int rpmcount = 0;
volatile float vitVentMS = 0;
volatile float vitVentKMH = 0;
float vitVentKMHOld = 1000;
int repeatCount = 0;
int rpm = 0;
unsigned long lastmillis = 0;
bool debug = false;

int pinHall = 4;
int pinReveil = 16;

int dureeMesVitVent = 5000; // en ms, durée de mesure de la vitesse du vent. Choisir un multiple de 1000 pour le calcul de la vitesse du vent

void setup() {
  
  // put your setup code here, to run once:
  Serial.begin(115200);
  attachInterrupt(pinHall, rpm_vent, FALLING);
  pinMode(pinReveil,OUTPUT);
  digitalWrite(pinReveil, HIGH);

  setup_wifi();           //On se connecte au réseau wifi
  client.setServer(mqtt_server, 1883);    //Configuration de la connexion au serveur MQTT
  client.setCallback(callback);  //La fonction de callback qui est executée à chaque réception de message   
  
  Serial.print("GO");
}

//Connexion au réseau WiFi
void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Connexion a ");
  Serial.println(wifi_ssid);

  WiFi.begin(wifi_ssid, wifi_password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("Connexion WiFi etablie ");
  Serial.print("=> Addresse IP : ");
  Serial.print(WiFi.localIP());
}

//Reconnexion
void reconnect() {
  //Boucle jusqu'à obtenur une reconnexion
  while (!client.connected()) {
    Serial.print("Connexion au serveur MQTT...");
    if (client.connect("ESP8266Client", mqtt_user, mqtt_password)) {
      Serial.println("OK");
    } else {
      Serial.print("KO, erreur : ");
      Serial.print(client.state());
      Serial.println(" On attend 5 secondes avant de recommencer");
      delay(5000);
    }
  }
}

void loop() {
  digitalWrite(pinReveil, HIGH);
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  
  getVitesseVent();
  
  client.publish(vitessems_topic, String(vitVentMS).c_str(), true);   // Publie la vitesse du vent en m/s
  client.publish(vitessekmh_topic, String(vitVentKMH).c_str(), true); // La vitesse du vent en km/h

 
  //int vitVentKMHint = vitVentKMH*100;
  //int vitVentKMHOldint = vitVentKMHOld*100;

  if(vitVentKMH==vitVentKMHOld){
    repeatCount++;
  }
  else{
    repeatCount=0;
  }

  if(repeatCount==5){   //Si on a 5x de suite la même valeur, l'ESP8266 se met en veille.
    repeatCount=0;
    Serial.println("Activation Deep Sleep");
    ESP.deepSleep(1 * 1000000);
    delay(500); //attente activation du deep sleep
    Serial.begin(115200);
  }
  digitalWrite(pinReveil, HIGH);
  vitVentKMHOld=vitVentKMH;
  
  delay(2000);
}


void getVitesseVent() {
  if (millis() - lastmillis >= dureeMesVitVent ){ 
    detachInterrupt(pinHall); 

    rpm = rpmcount * ( 60 / ( dureeMesVitVent / 1000 ) ); 
    
    if ( rpm > 0 ) {
      vitVentKMH = ( rpm * 0.0015 );
      vitVentMS = ( ( ( rpm * 0.0015 )) * 1000 ) / 3600; 
    } else {
      vitVentKMH = 0;
      vitVentMS = 0;
    }
    Serial.println(vitVentKMH);

    rpmcount = 0;           // Redémarre le compte tour
    lastmillis = millis();  // et réinitialise le chrono
    attachInterrupt(pinHall, rpm_vent, FALLING); // Relance l'interruption du compte tour

  }


}

void rpm_vent(){ 
  rpmcount++;
}


void callback(char* topic, byte* payload, unsigned int length) {

}

Grossière calibration

Pour la calibration, j’ai utilisé mon compresseur avec un détendeur sur ma ligne d’air. J’ai pu calibrer directement en sortie de tube en lisant le débit de l’air sur le débitmètre du compresseur. J’ai ainsi pu tracer la courbe et linéariser ma valeur. Après, comme l’air s’applique vraiment en un point de chaque coupelle, cette mesure n’est pas des plus précises. Mais je pense avoir une assez bonne approximation à 5 km/h près.

Conclusion

Coûts de l’objet

Erreurs commises

Trop, voilà le mot !

Ah ! Que je suis dur avec moi-même ! 😛 Plus sérieusement, ma principale erreur sur cet objet est de vouloir apporter trop de nouveautés d’un coup par rapport aux 2 objets précédents. Ces nouveautés que je mets en avant sur le blog sont aussi des nouveautés pour moi, non pas dans le sens que je n’avais pas les connaissances nécessaires, mais que je n’avais jamais pratiqué avec. Je parle entre autre de :
– Fabriquer un objet en mouvement, un capteur faisant appel à la mécanique.
– Concevoir un objet avec de multiples pièces à assembler et à coller.
– Se passer de l’environnement Arduino dont j’ai l’habitude pour passer sur un ESP8266 (qui est beaucoup plus galère à manier en phase de prototypage).
– Réaliser un flux de données fonctionnel sur Raspberry Pi dans la dernière version de Raspbian (à l’heure actuel, je suis le seul sur le web francophone à avoir réalisé cette chaîne ESP8266 communiquant vers un Raspberry Pi sous Raspbian Stretch avec Mosquitto<->Node-RED<->InfluxDB<->Grafana). Et ce n’est pas aussi simple que sous les anciennes versions ! (A quand le réveil des devs chez Mosquitto ? :-P)
– Mettre en œuvre un capteur à effet Hall radial. C’est beaucoup plus simple sur la théorie qu’en pratique !
– Calibrer son capteur de manière totalement archaïque ! Je dois avoir une précision de +/- 7 km/h je pense…

Voilà, voilà… J’ai vu un peu grand pour un objet qui… finalement ne va mesurer qu’une vitesse de vent. Mais au moins, ce projet est une base solide sur laquelle m’appuyer pour les futurs objets en préparation !

N’hésitez pas à commenter 😉

Benoît Jellimann.