Réalisation d’une station météo connectée

Réalisation d’une station météo connectée

Hyperactif depuis tout petit, je suis passionné par l’électronique, la mécanique, l’informatique, les machines, les outils, la récupération, le hacking (et la bonne bouffe) …
Bricoleur né, j’ai besoin de créer, de faire, de produire toujours plus !

L’infrastructure est essentiellement basée sur de la récupération d’éléments simples.
Et quelques fournitures électroniques diverses : plaque à trou 2.54, du fil, des barrettes 2.54 male / femelle, de la gaine thermo rétractable, domino ou bornier à vis pour circuit imprimé, pigtail SMA pour l’antenne.

  1. Pourquoi ce projet ?



    Fan de jardinage et de bonne bouffe, nous avons mis en place avec mon épouse un potager dans notre jardin. Cela nous permet de transmettre à notre tour le goût des bonnes choses à nos enfants.
    Cependant, pour des raisons pratiques et esthétiques, ce dernier n’est pas en pleine terre, mais dans un rectangle de bois construit avec des traverses paysagères en chêne.



    Les premières gelées arrivantes j’avais un gros doute sur la température de ce bac hors terre…

    Une seule solution : mesurer la température du sol et de l’air.



    Comment faire ?



    Acheter un simple thermomètre du commerce, hors de question ! Une petite station météo ? Pffff non, trop facile…



    Il était nécessaire de remettre en cause les acquis et d’aller encore plus loin afin de faire un projet utile, ludique, durable, facile à mettre en place et évolutif.
    À l’heure de l’IoT (internet des objets) il me semble évidant de prendre en considération que cette mini station doit être connectée, communicante et facilement consultable.
  2. Évolutions envisagées




    Coté hardware :


    Le module ESP-04 ne disposant pas d’entrée analogique, nous ne pouvons ni monitorer la tension de la batterie ni la charge du panneau solaire.



    Nous faisons donc confiance à nos calculs et tests durant le développement.



    Pour pallier à ce manque d’information, il serait bon d’interfacer un convertisseur ADC via le bus i2C.




    Ajouter un capteur de tension hydrique du sol afin de connaitre la teneur en eau du sol ceci dans deux buts. Le premier, savoir exactement s’il y a besoin d’un arrosage pour une croissance correcte de la plante. Le second, la préservation des ressources en eau !



    Côté firmware :



    Ajouter la gestion du cloud de données (cloud, clé, intervalle, etc..) afin de ne pas être exclusivement compatible avec ThingSpeak.

    Ajouter la gestion des différents capteurs.



    Designer un PCB, usiner un vrai boitier, faire un produit fini ? Pourquoi pas !
  3. Le hardware

    Le schéma électronique :
  4. Peu de composants sont nécessaires au fonctionnement de ce projet, le schéma est assez simple, mais il mérite quand même quelques explications…



    - Le bouton Sw Reset est pour le reset de l’ESP8266, Le bouton Sw Flash est pour Flasher l’ESP8266.

    - Le bouton Sw WiFi Manager est pour configurer le WiFi de l’ESP8266. Solar ON est un shunt pour isoler le panneau solaire pendant une charge via le port Mini USB du TP4056.
    - Power ON est un shunt pour la mise en route du montage sur la batterie.

    - Le connecteur FTDI 3.3V Prog est pour le flashage et le debugge de l’ESP8266, attention il faut impérativement une tension <= à 3.3V car l’ESP8266 n’est pas 5V tolérant.



    Afin que l’ESP8266 puisse fonctionner en mode faible consommation (deepSleep) vous devez strapper RESET et GPIO16 sur le module à l’aide d’une goutte de soudure, ici représentés en rouge.
  5. L’hébergement de données :



    Nous choisirons d’héberger nos données sur thingspeak car il est simple, facile à mettre en œuvre, complet et gratuit. Tout d’abord, il faut se créer un compte :
    https://thingspeak.com/users/sign_up Ensuite, créer un channel pour accueillir nos données :
    https://thingspeak.com/channels/new Pour notre projet, il faut renseigner les champs suivants : name, Description, Field1, Field2, Field3.
  6. Puis cliquez sur Save Channel. Il est, bien sûr, possible de modifier ces données en cliquant sur l’onglet Channel Setting par la suite. Cela peut être utile si vous souhaitez rendre vos données publiques. Il suffit de cliquer sur Make Public et de sauvegarder en cliquant sur Save Channel.
  7. Maintenant dans l’onglet API KEYS nous allons récupérer la key =>Write API KEY . Cette dernière permet d’envoyer nos données sur notre channel fraîchement créé. Nous renseignons avec la valeur const char* thingspeak_key = “ZXQ4MKPJUZHSAQK4”; dans le firmware, cette valeur est unique pour chaque channel, la vôtre sera donc différente.
  8. Le firmware





    /*
    ESP8266 HTU21D IOT AUTO par Nicolas Buis dans le cadre du concour
    Ambassadeur 2016 Conrad Electronique.
    Ce code, donné à titre d'exemple est dans le dommaine publique
    */
    //Generique Lib
    #include //https://github.com/esp8266/Arduino
    //Wifi manager Lib
    #include
    #include
    #include //https://github.com/tzapu/WiFiManager
    //i2c Lib
    #include
    #include
    #include "DallasTemperature.h" // dans le repertoire source.
    //Sensor Lib
    #include "ESP_HTU21D.h" // dans le repertoire source.
    //Pour le status de la Led
    #include
    Ticker ticker;
    //Definition des constantes.
    const int Led = 2; //Pin d'alimentation de la Led
    const int Rwm = 12; //Pin du boutton de reset des parametres de wifi
    Manager
    const int sda = 12; //Pin Data du bus I2C
    const int scl = 14; //Pin Clock du bus I2C
    const long interval = 6 * 60; //intervale de mesure et de puch sur le cloud
    IOT en seconde
    const long connect_timeout = 4 * 1000; //timeout de connection au réseai wifi
    const char* host = "api.thingspeak.com";
    const char* thingspeak_key = "TS API WRITE KEY";
    //Définition des variables
    String temp = "";
    String hum = "";
    String dtemp = "";
    String wifitime = "";
    long interval_time = 0;
    //Création d'une instance de l'objet ESP_HTU21D
    ESP_HTU21D tu;
    #define ONE_WIRE_BUS 13 // DS18B20 pin
    OneWire oneWire(ONE_WIRE_BUS);
    DallasTemperature DS18B20(&oneWire);
    void tick()
    {
    //toggle led state
    int state = digitalRead(Led); // get the current state of GPIO1 pin
    digitalWrite(Led, !state); // set pin to the opposite state
    }
    // Si erreur sur bus i2c ou mauvaise CRC retourne 0 sinon 1
    boolean readsensor() {
    tu.begin(sda, scl);
    float u = tu.readHumidity();
    float t = tu.readTemperature();
    float d;
    int tomany = 0;
    do {
    tomany++;
    DS18B20.requestTemperatures();
    d = DS18B20.getTempCByIndex(0);
    } while (d == 85.0 || d == (-127.0) && (tomany 997 || t > 997 || d == 85.0 || d == -127.0) {
    Serial.println("Sensor error");
    Serial.println(u);
    Serial.println(t);
    Serial.println(d);
    return 0;
    }
    dtemp = String(d);
    hum = String(u);
    temp = String(t);
    return 1;
    }
    void publish() {
    Serial.print("connection à ");
    Serial.println(host);
    // TCP connection à thingspeak
    WiFiClient client;
    const int httpPort = 80;
    if (!client.connect(host, httpPort)) {
    Serial.println("Erreur connection !");
    return;
    }
    String url = "/update?key=";
    url += thingspeak_key;
    url += "&1=";
    url += temp;
    url += "&2=";
    url += hum;
    url += "&3=";
    url += dtemp;
    url += "&8=";
    url += wifitime;
    Serial.print("URL: ");
    Serial.println(url);
    // Envoie les données vers thingspeak
    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
    "Host: " + host + "\r\n" +
    "Connection: close\r\n\r\n");
    delay(50);
    // Lit et affiche le retour du server
    while (client.available()) {
    String line = client.readStringUntil('\r');
    Serial.print(line);
    }
    Serial.println();
    Serial.println("connection terminée.");
    }
    void setup() {
    interval_time = millis();
    pinMode(ONE_WIRE_BUS, OUTPUT);
    digitalWrite(ONE_WIRE_BUS, HIGH);
    pinMode(Led, OUTPUT);
    digitalWrite(Led, HIGH);
    ticker.attach_ms(50, tick);
    Serial.begin(250000);
    pinMode(Rwm, INPUT_PULLUP);
    if (digitalRead(Rwm) == LOW) {
    ticker.attach_ms(250, tick);
    WiFiManager wifiManager;
    if (!wifiManager.startConfigPortal("Mini-S")) {
    Serial.println("failed to connect and hit timeout");
    delay(3000);
    //reset and try again, or maybe put it to deep sleep?
    ESP.reset();
    delay(3000);
    }
    // cool connecté !
    Serial.println("connecté au nouveau réseau ... :)");
    ESP.reset();
    delay(3000);
    }
    boolean timeout = false;
    while (WiFi.status() != WL_CONNECTED) {
    delay(10);
    //Serial.print(".");
    if ( millis() - interval_time > connect_timeout) {
    timeout = true;
    break;
    }
    }
    if (timeout) {
    ticker.detach();
    digitalWrite(BUILTIN_LED, HIGH);
    Serial.println("");
    Serial.println("Wifi Connection timeout! Reveil dans 3 minutes");
    system_deep_sleep(3 * 60 * 1000000); // réessaye dans 3 minute
    delay(3000);
    }
    interval_time = millis() - interval_time;
    wifitime = String(interval_time);
    Serial.println("");
    Serial.print("Temps connection Wifi: ");
    Serial.println(interval_time);
    // ticker.attach_ms(50, tick);
    ticker.detach();
    digitalWrite(BUILTIN_LED, LOW);
    if (readsensor()) {
    // ticker.attach_ms(25, tick);
    publish();
    }
    //LED off
    digitalWrite(BUILTIN_LED, HIGH);
    interval_time = (interval * 1000 ) - interval_time;
    system_deep_sleep_set_option(0);
    system_deep_sleep(interval_time * 1000);
    delay(1);
    }
    void loop() {
    //rien ici...
    }




    Vous pouvez le télécharger ici. Les librairies utilisées sont disponibles via l’interface de gestion de librairie de l’IDE Arduino. Les librairies modifiées sont directement incluses dans le répertoire du firmware. Pour le flashage du module rien de plus simple. Il suffit de l’alimenter et de connecter l’interface série (TX et RX) via le connecteur FTDI 3.3V Prog. N’oubliez pas de renseigner la valeur const char* thingspeak_key = “votre clé API ThingSpeak’ ” ; ! Vous devez sélectionner les options de la carte suivante afin de compiler la source correctement et pouvoir flasher le module. Le numéro de port com étant différent selon votre configuration.
  9. Appuyez maintenant sur le bouton Sw Flash et le bouton Sw reset, relâchez le bouton Sw reset en maintenant le bouton Sw flash enfoncé. L’ESP8266 est maintenant prêt pour le flashage, cliquez maintenant sur l’icône téléversement de l’IDE Arduino.
    Après le téléversement terminé, vous devez appuyer à nouveau sur le bouton Sw reset afin de relancer l’ESP8266 dans son mode de fonctionnement normal.
  10. Il est maintenant temps de configurer le Wifi : Pour se connecter à son réseau Wifi, il faut appuyer sur les boutons Sw reset et Sw WiFi Manager puis relâcher le bouton Sw reset en maintenant le bouton Sw WiFi Manager enfoncé. La LED rouge clignote alors lentement, nous indiquant que nous sommes dans le mode de Configuration du Wifi. Vous pouvez relâcher le bouton Sw WiFi Manager. À l’aide d’un smartphone, pc, tablette, il faut se connecter au réseau “Mini-S”.
    La connexion effectuée, avec l’aide de vote navigateur préféré connectez-vous à l’adresse suivante : http://192.168.4.1 Vous devriez obtenir la page d’accueil du WiFI Manager. Cliquez maintenant sur Configure WiFi.
  11. La liste des réseaux disponibles est alors affichée. Cliquez sur celui auquel vous souhaitez vous connecter, entrez le mot de passe. Puis sauvegardez en cliquant sur SAVE.
  12. Le WiFi est maintenant configuré. L’ESP8266 redémarre et se connecte au réseau renseigné, la LED rouge clignote rapidement, puis s’allume brièvement pendant l’acquisition des capteurs et la transmission des données sur ThingSpeak. Maintenant, la mini station va mesurer et émettre toutes les 6 minutes environ.
  13. Nous pouvons maintenant consulter les données via l’interface de ThingSpeak.
  14. Fabrication et assemblage de l’infrastructure



    Le pied :



    C’est un tube de Ø30X1.5mm de 120cm de haut. Il sera fendu à la scie à métaux sur un peu plus de la moitié de son diamètre et sur 10 cm de haut. Cela permet de créer une pince élastique pour accueillir un tube de Ø25X1.5mm supportant le boitier et l’abri température.



    Les deux tubes sont en aluminium anodisé afin de résister aux intempéries et à la corrosion. Un trou permettant le passage du câble sera réalisé à la base de la pince. Il faut faire un rétreint à l’étau en dessous de la pince afin que le tube de Ø25mm repose dessus.



    Afin que la terre ne rentre pas dans le tube, mais que l’eau puisse s’écouler nous mettrons un bouchon sur le pied percé au Ø8mm.
  15. L’abri température :



    Vous pouvez en trouver sur le net à partir de 20€ sur des sites spécialisés. Mais attention, la qualité de l’abri et de sa ventilation fera la qualité des mesures, il ne faut pas négliger ce point très important. Car, en cas de fort ensoleillement, sans vent, un mauvais abri peu dériver de plus de 5 degrés !



    Pour ce projet, j’ai utilisé un abri que j’avais en stock. C’est un CES601 réduit, de la marque Cimel. Il donne de bons résultats. Sa fixation sera donc adaptée pour se monter sur le tube de Ø25mm avec un manchon pvc femmelleØ25/femelle taraudé 20-27.
  16. La sonde température humidité de l’air et son support :



    Premièrement, il faut :



    - câbler la sonde HTU21D,

    - assurer l’ensemble avec de la gaine thermo-rétractable en venant à environ 2mm de la sonde,

    - préparer un fil rigide de 2.5mm², une gaine thermo-rétractable de la moitié de la hauteur de votre abri et un bouchon percé au Ø de votre câble + fil rigide.
  17. Mettez le câble et le fil dans la gaine thermo-rétractable et chauffez-là. Passez l’ensemble à travers le trou du bouchon.
  18. Coupez l’excédent du fil rigide et solidarisez avec le bouchon à l’aide d’un pista-colle. Pourquoi tout ça ? Ce montage permet de monter notre sonde sur notre tube de Ø25mm et par sa rigidité d’assurer le bon positionnement de la sonde au centre de l’abri.



    Pourquoi tout ça ?

    Ce montage permet de monter notre sonde sur notre tube de Ø25mm et par sa rigidité d’assurer le bon positionnement de la sonde au centre de l’abri.
  19. Le boîtier :



    Le boîtier est un boîtier de raccordement de type plexo. Il est IP55, donc étanche au ruissellement. Pour sa fixation sur le tube de Ø25mm, utilisez un collier-clip pour tube IRL (gaine rigide électrique).



    Ce dernier sera vissé avec une vis CHC M6x8 et collé avec de la colle époxy.




    Pour la fixation du panneau solaire, formez deux équerres à environ 35° ce qui correspond à l’angle moyen solaire en France en hiver. “Cela permet d’optimiser la charge durant les mois de l’année les moins ensoleillés.”



    Elles sont fixées en premier sur le boîtier avec deux vis CHC M6x8 dans les trous de fixation du boitier plexo. La profondeur est ajustée avec une rondelle plate et une rondelle éventail afin que la vis ne perce pas le fond du boitier. Toute la visserie doit être en inox pour résister aux intempéries et à la corrosion.



    Après la mise en place des équerres sur le boîtier, nous pouvons maintenant procéder au collage du panneau solaire sur les équerres. Il faut préalablement dépolir légèrement avec du papier abrasif les équerres et le panneau solaire afin d’augmenter l’adhérence de la colle.
  20. Intégration de l’électronique dans le boîtier :



    Pour cela, j’ai utilisé une chute d’ABS que j’ai découpé au format intérieur du boîter. Cette contre-plaque est ajustée pour se coincer entre les presse-étoupes. Elle nous servira de support pour tous les composants internes.


    Des encoches seront découpées pour les différents passages de câble. Commencez par coller la batterie puis le bornier de raccordement au pisto-colle.
  21. Ensuite sur l’autre face, il faut coller le TP4056 et le circuit puis réaliser les dernières soudures entre le bornier et le circuit ainsi qu’entre le TP4056 et la batterie.
  22. Tests avant l’intégration finale dans le boîtier



    À ce stade, vérifiez si la batterie charge bien et que le module consomme selon nos tests réalisés pendant le développement de ce circuit. Pour cela mesurez la tension aux bornes Bat+ et Bat- du TP4056 sans alimenter le montage.
  23. Alimentez maintenant le TP4056 via le port mini USB. La LED rouge s’allume et la tension augmente. Lorsque la batterie est totalement chargée la LED verte s’allume.
  24. Maintenant, mesurez la consommation du montage.
    Pour cela, branchez un multimètre (en mode milliampère) de chaque côté du shunt Power On en ayant pris soin de retirer le shunt.
    Vous devez trouver environ 72mA lorsque l’ESP est actif (acquisition, WiFi actif).
  25. Et environ 90µA lorsque l’ESP est en veille (deepSleep).
  26. Installation



    Nous y voilà c’est la dernière ligne droite !


    Montez maintenant la contre-plaque dans le boiter, câblez les capteurs, le panneau solaire. Alimentez le tout et vérifiez la bonne transmission des données !
  27. La mini station sera implantée dans un coin de notre potager. Et le panneau solaire sera orienté Sud-Est afin de charger rapidement dès le soleil du matin. Le pied doit être le plus vertical possible. La sonde de sol sera plantée horizontalement dans notre potager environ 5cm sous la surface.
  28. Bien vérifier la charge de la batterie par le panneau solaire, la LED rouge s’allume dès que le TP4056 est alimenté. Maintenant, c’est à vous de jouer !
Réalisé par
Posté le
Univers
IoT
Temps de fabrication
2h
Niveau de difficulté
Avancé
Matériel(s)
1
ESP8266-Medium de Seeed Studio
1
Accus lithium
1
Module solaire
1
Module capteur SparkFun
1
Régulateur de tension
3
Condensateur tantale
6
Résistance à couche métallique
5
Résistance à couche métallique
2
Résistance à couche métallique
1
LED rouge
3
Bouton poussoir
1
Antenne Wifi
1
Shunt ouvert

Aucun commentaire. Soyez le premier à en écrire un !

Vous devez être connecté pour laisser un commentaire.