Capteur d'humidité du sol sans fil avec Helium et DFRobot – Soin des plantes en temps réel

Composants et fournitures

Module Helium Atom XBee	×	1
Point d'accès Helium Element	×	1
DFRobot Gravity : Capteur d'humidité du sol capacitif analogique	×	1
Adaptateur Helium Arduino/mbed	×	1
Arduino UNO	×	1

Applications et services en ligne

• Arduino IDE
• Helium Dashboard

À propos de ce projet

Donnez une voix à vos plantes avec un capteur d'humidité du sol sans fil

Admettons-le. Les plantes meurent tout le temps par manque d'arrosage. Vous êtes occupé et ces fougères ne lèveront pas la main quand elles ont soif. Alors, pour l'amateur de plantes en déplacement, cette sonde d'humidité du sol prototype est votre billet pour des fougères et des ficus heureux et en bonne santé.

Ce que nous allons couvrir

De bout en bout, ce guide complet devrait vous prendre environ 60 minutes. Voici ce que nous allons aborder :

• Construction de votre sonde d'humidité du sol complète en utilisant le capteur capacitif DF Robot Gravity, un module de prototypage Helium Atom, un adaptateur Helium Arduino, et une carte Arduino (nous avons choisi l'UNO) ;
• Enregistrement de votre Helium Element et de votre module de prototypage Helium Atom dans le Helium Dashboard ; et construction de votre propre réseau sans fil à large portée et basse consommation ;
• Programmation de votre sonde d'humidité du sol via l'Arduino IDE. En chemin, nous installerons également les bibliothèques Arduino Helium et ArduinoJson ;
• Mesure et envoi des données d'humidité du sol en temps quasi réel de votre plante vers le Helium Dashboard ; et acheminement vers un canal HTTP Helium.

Très bien. C'est parti. Nous avons des fougères à sauver.

Construction de votre sonde d'humidité du sol

D'abord, nous devons construire l'unité de détection. C'est rapide et facile. Quand vous avez fini, votre sonde complète devrait ressembler à ceci :

Pour construire ceci :

• D'abord, insérez votre module de prototypage Helium Atom dans l'adaptateur Helium Arduino, puis connectez cet ensemble combiné à votre carte Arduino choisie. Assurez-vous de configurer les jumpers RX et TX en conséquence selon la carte que vous utilisez. Tous les détails sur la façon d'assembler ces cartes, ainsi que les configurations de jumpers correctes, peuvent être trouvés ici. Jetez un œil, terminez cela, et revenez.
• Ensuite, nous devons connecter la sonde d'humidité du sol réelle à l'adaptateur Helium Arduino en utilisant le câble de liaison à trois fils fourni avec la sonde DF Robot. Les trois couleurs de fils sont noir, rouge et bleu. Sur l'adaptateur Helium Arduino, le fil noir se connecte à GND ; le fil rouge se connecte à 5V ; et le fil bleu se connecte à l'en-tête ADO. Il y a un excellent diagramme de l'équipe DFRobot sur le fonctionnement de cette connexion ici. Notre carte ressemble à ceci lorsque le câblage est correctement fait :

• Enfin, connectez l'en-tête blanc sur le câble de liaison à la sonde d'humidité du sol DF Robot. Bien que cela puisse être un peu délicat, cela devrait s'emboîter correctement avec un effort minimal.

Déploiement de votre Helium Element

Maintenant, il est temps de construire votre propre réseau Helium. Cela prend environ 30 secondes. (Si vous voulez en savoir plus sur la façon dont une application de bout en bout est construite sur Helium et comment nous gérons le composant de mise en réseau sans fil, commencez par cet aperçu d'architecture.)

Pour déployer l'Element et créer une couverture réseau pour vos capteurs basés sur Atom, branchez-le simplement sur l'alimentation et un port Ethernet actif en utilisant les câbles fournis. (Note : Si vous avez un Element avec connexion cellulaire, l'utilisation de la connectivité Ethernet est optionnelle mais recommandée comme sauvegarde.) Une fois branché, vous verrez une activité LED. Votre Element sera connecté lorsque la LED frontale deviendra verte (signalant la connectivité Ethernet) ou bleue-verte (pour la connectivité cellulaire). Vous pouvez regarder une courte vidéo sur l'Element et comment le connecter ici.

Enregistrement de votre Helium Element et Atom dans Helium Dashboard

Maintenant que notre unité de détection est construite et que votre réseau Helium est déployé, il est temps d'enregistrer votre matériel dans le Helium Dashboard. Dashboard est l'interface utilisateur hébergée de Helium pour surveiller et gérer les déploiements de matériel connecté. Tout le matériel expédié par Helium est déjà enregistré dans notre système, mais nous devons savoir qui le déploie.

• D'abord, créez un compte Helium Dashboard si vous ne l'avez pas déjà fait.
• Pour enregistrer votre Atom, commencez par sélectionner New Atom. Dans l'interface, ajoutez un nom (par ex. Fern Saver), puis saisissez les quatre derniers chiffres de son adresse MAC et son code HVV à quatre chiffres. Cliquez sur Save et c'est fait.
• L'enregistrement de l'Element se fait exactement de la même manière. Sélectionnez New Element, puis fournissez un nom, les quatre derniers chiffres de son adresse MAC et son code HVV à quatre chiffres. Assurez-vous également de saisir un emplacement pour votre Element afin que Dashboard puisse l'afficher sur une carte.

Vous pouvez vérifier que votre Element est en ligne en regardant son Statut & Signal dans Dashboard :

Déploiement du canal HTTP Helium

Une caractéristique majeure de la plateforme Helium est les Canaux (Channels). Ce sont des connecteurs préconstruits vers des services web (comme AWS IoT, Google Cloud IoT et Azure IoT) et des protocoles (comme MQTT et HTTP). Avec les Canaux, Helium a fait tout le travail lourd pour vous en matière d'intégration avec l'un de ces services web ou protocoles. Pour Fern Saver, notre sonde d'humidité du sol, mettons en place un canal HTTP. Cela nous permettra d'acheminer les données vers n'importe quel service web qui accepte les données via HTTP. Par exemple, vous pourriez utiliser un canal HTTP pour envoyer ces données à IFTTT et, à son tour, recevoir un SMS chaque fois que Fern Saver signale une humidité en dessous d'un certain niveau.

Dans cet exemple, nous allons configurer un canal HTTP qui envoie les données vers requestb.in, un service web gratuit et pratique pour tester les services HTTP. Notez que ci-dessous, lorsque nous téléverserons le Sketch sur l'Arduino, nous ferons référence à ce nom de canal, HTTP, dans le code pour savoir où envoyer les données.

Voici à quel point il est rapide et facile de configurer ce canal :

Configuration de votre Arduino IDE et téléversement du Sketch

Nous pouvons maintenant passer à la configuration de votre Arduino IDE et à l'importation des bibliothèques requises. Pour commencer :

• Assurez-vous d'avoir la dernière version de l'Arduino IDE téléchargée. Obtenez-la ici si nécessaire.
• Nous devrons ensuite ajouter deux bibliothèques : Helium et ArduinoJson. Vous pouvez ajouter des bibliothèques depuis l'IDE en allant dans Croquis -> Inclure une bibliothèque -> Gérer les bibliothèques. Recherchez « helium », sélectionnez-le, et cliquez sur Installer. Suivez ce même processus d'installation pour la bibliothèque « ArduinoJson ». (Nous avons besoin de cette bibliothèque car les données d'humidité du sol que nous allons enregistrer sont formatées en JSON.)

Une fois cela fait, il est temps de faire de la vraie programmation Arduino. La source complète du Sketch que nous allons téléverser se trouve ici sur GitHub. Voici le sketch complet Soil_Humidity.ino.

/* 
 * Copyright 2017, Helium Systems, Inc.
 * All Rights Reserved. See LICENCE.txt for license information
 * 
 * Prise de relevés d'humidité en utilisant le capteur capacitif SEN0192.
 * Instructions de câblage :
 * https://www.dfrobot.com/wiki/index.php/Capacitive_Soil_Moisture_Sensor_SKU:SEN0193
 * 
 * Installez les bibliothèques suivantes via Croquis -> Gérer les bibliothèques :
 * - ArduinoJson
 * - Helium
 */

#include "Board.h"
#include <Arduino.h>
#include <ArduinoJson.h>
#include <Helium.h>
#include <Wire.h>

// Ce nom de canal doit correspondre au canal que vous avez déployé dans Helium
// Dashboard pour ingérer ces données.
#define CHANNEL_NAME "HTTP"

// Délai d'une seconde
#define CHANNEL_DELAY 5000

// Envoyer tous les 60 cycles (secondes)
#define CHANNEL_SEND_CYCLE 12

Helium helium(&atom_serial);
Channel channel(&helium);
int channel_counter;

void report_status(int status, int result = 0) {
  if (helium_status_OK == status) {
    if (result == 0) {
      Serial.println(F("Réussi"));
    } else {
      Serial.print(F("Échec - "));
      Serial.println(result);
    }
  } else {
    Serial.println(F("Échec"));
  }
}

void connect() {
  while (!helium.connected()) {
    Serial.print(F("Connexion - "));
    int status = helium.connect();
    report_status(status);
    if (helium_status_OK != status) {
      delay(1000);
    }
  }
}

void channel_create(const char * channel_name) {
  int8_t result;
  int status;
  do {
    // S'assurer que nous sommes connectés
    connect();
    Serial.print(F("Création du canal - "));
    status = channel.begin(channel_name, &result);
    // Afficher le statut et le résultat
    report_status(status, result);
    if (helium_status_OK != status) {
      delay(1000);
    }
  } while (helium_status_OK != status || result != 0);
}

void channel_send(const char * channel_name, void const * data, size_t len) {
  int status;
  int8_t result;
  do {
    // Essayer d'envoyer
    Serial.print(F("Envoi - "));
    status = channel.send(data, len, &result);
    report_status(status, result);
    // Créer le canal si des erreurs de service sont retournées
    if (status == helium_status_OK && result != 0) {
      channel_create(channel_name);
    } else if (status != helium_status_OK) {
      delay(1000);
    }
  } while (helium_status_OK != status || result != 0);
}

void setup() {
  Serial.begin(9600);
  Serial.println(F("Démarrage"));
  helium.begin(HELIUM_BAUD_RATE);
  channel_create(CHANNEL_NAME);
  channel_counter = 0;
}

#define DRY_VALUE 536 // Mesuré dans l'air
#define WET_VALUE 303 // Mesuré dans l'eau
#define HUM_RANGE (DRY_VALUE - WET_VALUE)

void loop() {
  Serial.print(F("Lecture - "));
  float reading = analogRead(A0);
  float percent = 100 * (1 - (reading - WET_VALUE) / HUM_RANGE);
  Serial.print(reading);
  Serial.print(" - ");
  Serial.println(percent);
  
  if (--channel_counter <= 0) {
    StaticJsonBuffer<JSON_OBJECT_SIZE(2) + 100> jsonBuffer;
    JsonObject & root = jsonBuffer.createObject();
    root[F("value")] = reading;
    root[F("percent")] = percent;
    char buffer[HELIUM_MAX_DATA_SIZE];
    size_t used = root.printTo(buffer, HELIUM_MAX_DATA_SIZE);
    channel_send(CHANNEL_NAME, buffer, used);
    channel_counter = CHANNEL_SEND_CYCLE;
  }
  delay(CHANNEL_DELAY);
}

Avec les bibliothèques Helium et ArduinoJson installées, créez un nouveau sketch (Fichier -> Nouveau depuis l'Arduino IDE), et collez le code ci-dessus. Ensuite, avec votre sonde d'humidité du sol complète connectée à votre poste de travail via un câble USB, cliquez sur le bouton Téléverser.

Les LEDs sur votre module de prototypage Atom devraient commencer à clignoter après quelques instants. C'est l'Atom qui se connecte au réseau Helium (via l'Element que nous avons déployé plus tôt). Si l'Arduino IDE ne signale aucune erreur lors du téléversement, cela a réussi et la sonde d'humidité du sol génère maintenant des relevés.

Note sur les données d'humidité du sol

Comme indiqué ci-dessus, ce Sketch capturera les données d'humidité du sol et les encodera en JSON avant de les envoyer à la plateforme Helium. En utilisant le Sketch ci-dessus, un point de données ressemblera à quelque chose comme ceci (en JSON) :

{ "value": 433, "percent": 55.5 }

Il convient de noter que le capteur capacitif d'humidité du sol DFRobot Gravity capture en fait ces relevés sous forme de lectures analogiques entre une lecture sèche et une lecture humide calibrées. Vous pouvez obtenir tous les détails sur la façon dont cela est implémenté et calibré ici. Vous pourriez vouloir ajuster un peu la calibration.

Vérification de la connectivité du capteur et des données dans Helium Dashboard

Maintenant que votre capteur est déployé, nous pouvons vérifier qu'il est en ligne et qu'il transmet des données. Dans Dashboard, nous pouvons faire cela de plusieurs façons, toutes via la vue Atom UI pour le capteur que vous venez de déployer.

• Si votre Atom est en ligne, Dashboard affichera son Statut & Signal, ainsi que diverses autres métadonnées sur son statut. Cela ressemblera à quelque chose comme ceci :

• Plus bas dans la même interface Atom, nous affichons également un Journal d'événements montrant chaque point de données du capteur et s'il a été transmis avec succès vers un canal Helium. Comme nous l'avons noté plus haut, ce sont des connecteurs préconstruits vers des services web ou des protocoles bruts. Plus tôt, nous avons déployé un canal HTTP pour votre organisation Helium. Et le sketch ci-dessus dit à la sonde d'humidité du sol d'envoyer des données à ce canal – appelé HTTP. Dans cet exemple illustré ci-dessous, cependant, nous envoyons nos données vers le canal HTTP Helium :

• Nous fournissons également une interface Debug pour chaque Atom qui affichera vos relevés au fur et à mesure qu'ils arrivent (une fois que vous avez activé cette option). Voici quelques données d'humidité du sol dans le visualiseur Debug de Dashboard :

Prochaines étapes et aide

Félicitations ! C'est la fin de ce guide. Vous avez maintenant protégé votre fougère pour l'avenir avec une sonde d'humidité du sol sans fil. C'est important. Vos fougères vous remercient.

Si vous voulez en savoir plus sur Helium et comment vous pouvez prototyper vos propres capteurs en utilisant ce matériel et ce logiciel, commencez ici :

• Documentation développeur Helium
• Slack développeur Helium
• Forum développeur Helium

Code

Soil_Humidity.ino (C/C++)

Le sketch Arduino complet pour commencer à envoyer les données d'humidité du sol de votre capteur vers un canal Helium.

/* 
 * Copyright 2017, Helium Systems, Inc.
 * All Rights Reserved. See LICENCE.txt for license information
 * 
 * Prise de relevés d'humidité en utilisant le capteur capacitif SEN0192.
 * Instructions de câblage :
 * https://www.dfrobot.com/wiki/index.php/Capacitive_Soil_Moisture_Sensor_SKU:SEN0193
 * 
 * Installez les bibliothèques suivantes via Croquis -> Gérer les bibliothèques :
 * - ArduinoJson
 * - Helium
 */

#include "Board.h"
#include <Arduino.h>
#include <ArduinoJson.h>
#include <Helium.h>
#include <Wire.h>

#define CHANNEL_NAME "Helium MQTT"
// Délai d'une seconde
#define CHANNEL_DELAY 5000
// Envoyer tous les 60 cycles (secondes)
#define CHANNEL_SEND_CYCLE 12

Helium helium(&atom_serial);
Channel channel(&helium);
int channel_counter;

void report_status(int status, int result = 0) {
  if (helium_status_OK == status) {
    if (result == 0) {
      Serial.println(F("Succeeded"));
    } else {
      Serial.print(F("Failed - "));
      Serial.println(result);
    }
  } else {
    Serial.println(F("Failed"));
  }
}

void connect() {
  while (!helium.connected()) {
    Serial.print(F("Connecting - "));
    int status = helium.connect();
    report_status(status);
    if (helium_status_OK != status) {
      delay(1000);
    }
  }
}

void channel_create(const char * channel_name) {
  int8_t result;
  int status;
  do {
    // Ensure we're connected
    connect();
    Serial.print(F("Creating Channel - "));
    status = channel.begin(channel_name, &result);
    // Print status and result
    report_status(status, result);
    if (helium_status_OK != status) {
      delay(1000);
    }
  } while (helium_status_OK != status || result != 0);
}

void channel_send(const char * channel_name, void const * data, size_t len) {
  int status;
  int8_t result;
  do {
    // Try to send
    Serial.print(F("Sending - "));
    status = channel.send(data, len, &result);
    report_status(status, result);
    // Create the channel if any service errors are returned
    if (status == helium_status_OK && result != 0) {
      channel_create(channel_name);
    } else if (status != helium_status_OK) {
      delay(1000);
    }
  } while (helium_status_OK != status || result != 0);
}

void setup() {
  Serial.begin(9600);
  Serial.println(F("Starting"));
  helium.begin(HELIUM_BAUD_RATE);
  channel_create(CHANNEL_NAME);
  channel_counter = 0;
}

#define DRY_VALUE 536 // Taken in air
#define WET_VALUE 303 // Taken in water
#define HUM_RANGE (DRY_VALUE - WET_VALUE)

void loop() {
  Serial.print(F("Reading - "));
  float reading = analogRead(A0);
  float percent = 100 * (1 - (reading - WET_VALUE) / HUM_RANGE);
  Serial.print(reading);
  Serial.print(" - ");
  Serial.println(percent);
  
  if (--channel_counter <= 0) {
    StaticJsonBuffer<JSON_OBJECT_SIZE(2) + 100> jsonBuffer;
    JsonObject & root = jsonBuffer.createObject();
    root[F("value")] = reading;
    root[F("percent")] = percent;
    char buffer[HELIUM_MAX_DATA_SIZE];
    size_t used = root.printTo(buffer, HELIUM_MAX_DATA_SIZE);
    channel_send(CHANNEL_NAME, buffer, used);
    channel_counter = CHANNEL_SEND_CYCLE;
  }
  delay(CHANNEL_DELAY);
}