Drahtlose Bodenfeuchtesonde mit Helium und DFRobot

Apps und Onlinedienste

	Arduino-IDE
	Helium-Dashboard

Über dieses Projekt

Geben Sie Ihren Pflanzen eine Stimme mit einem drahtlosen Bodenfeuchtigkeitssensor

Seien wir ehrlich. Pflanzen sterben ständig an mangelnder Bewässerung. Du hast viel zu tun und diese Farne werden ihre Hände nicht heben, wenn sie sich ausgetrocknet fühlen. Für den Pflanzenliebhaber, der unterwegs ist, ist dieser Prototyp einer Bodenfeuchtigkeitssonde Ihre Eintrittskarte für glückliche und gesunde Farne und Ficus.

Was wir behandeln werden

Der gesamte Leitfaden sollte von Ende zu Ende ungefähr 60 Minuten dauern. Hier ist, was wir durchgehen werden:

• Aufbau Ihrer kompletten Bodenfeuchtesonde mit dem DF Robot Gravity Capacitive Soil Moisture Sensor, einem Helium Atom Prototyping Module, einem Helium Arduino Adapter und einem Arduino Board (wir haben uns für die UNO entschieden);

• Registrieren Ihres Heliumelement- und Heliumatom-Prototyping-Moduls im Helium-Dashboard; und Aufbau Ihres eigenen drahtlosen Weitverkehrsnetzwerks mit geringem Stromverbrauch;

• Programmieren Ihrer Bodenfeuchtesonde über die Arduino IDE. Unterwegs installieren wir auch das Helium und ArduinoJson Arduino-Bibliotheken;

• Messen und Senden von Bodenfeuchtigkeitsdaten in nahezu Echtzeit von Ihrer Anlage an das Helium-Dashboard; und leitet es an einen Helium-HTTP-Kanal weiter.

In Ordung. Lasst uns anfangen. Wir müssen Farne retten.

Aufbau Ihrer Bodenfeuchtesonde

Zuerst müssen wir die Sensoreinheit bauen. Das geht schnell und einfach. Wenn Sie fertig sind, sollte Ihre vollständige Sonde so aussehen:

Um dies zu bauen:

• Pinnen Sie zuerst Ihr Helium Atom Prototyping Module in den Helium Arduino Adapter und verbinden Sie dann diese kombinierte Einheit mit Ihrem ausgewählten Arduino Board. Stellen Sie sicher, dass Sie konfigurieren RX und TX Pullover entsprechend je nachdem welches Board du verwendest. Ausführliche Informationen zum Zusammenstecken all dieser Platinen sowie die richtigen Jumper-Konfigurationen finden Sie hier. Sieh es dir an, vervollständige das und komm zurück.

• Als nächstes müssen wir die eigentliche Bodenfeuchtigkeitssonde mit dem Helium-Arduino-Adapter mit dem dreiadrigen Überbrückungskabel verbinden, das mit der DF-Roboter-Bodenfeuchtigkeitssonde geliefert wird. Die drei Kabelfarben sind schwarz , rot , und blau . Auf dem Helium Arduino Adapter ist das schwarze Draht verbindet sich mit GND; das rote Kabel verbindet sich mit 5V; und das blaue Draht verbindet sich mit dem ADO Header. Es gibt ein großartiges Diagramm vom DFRobot-Team, wie diese Verbindung hier funktioniert. Unser Board sieht bei korrekter Verdrahtung so aus:

• Schließen Sie zuletzt die weiße Kopfleiste des Überbrückungskabels an die DF-Roboter-Bodenfeuchtesonde an. Obwohl dies ein bisschen schwierig sein kann, sollte es mit minimalem Aufwand einrasten.

Einsatz Ihres Helium-Elements

Jetzt ist es an der Zeit, Ihr eigenes Helium-Netzwerk aufzubauen. Dies dauert etwa 30 Sekunden. (Wenn Sie mehr darüber erfahren möchten, wie eine End-to-End-Anwendung auf Helium aufgebaut ist und wie wir mit der drahtlosen Netzwerkkomponente umgehen, beginnen Sie mit dieser Architekturübersicht.)

Um das Element bereitzustellen und eine Netzwerkabdeckung für Ihre Atom-basierten Sensoren zu erstellen, schließen Sie es einfach mit den mitgelieferten Kabeln an eine Stromquelle und einen Live-Ethernet-Port an. (Hinweis:Wenn Sie ein zellulargestütztes Element haben, ist die Verwendung der Ethernet-Konnektivität optional, wird jedoch als Backup empfohlen. ) Nach dem Anschließen sehen Sie einige LED-Aktivitäten. Dein Element ist verbunden, wenn die nach vorne gerichtete LED grün leuchtet (Signalisierung der Ethernet-Konnektivität ) oder blaugrün (für Mobilfunkverbindungen ). Hier können Sie ein kurzes Video zum Element und zum Anschließen ansehen.

Registrieren Ihres Helium-Elements und -Atoms im Helium-Dashboard

Nachdem unsere Sensoreinheit gebaut und Ihr Helium-Netzwerk bereitgestellt wurde, ist es an der Zeit, Ihre Hardware im Helium-Dashboard zu registrieren. Dashboard ist die gehostete Benutzeroberfläche von Helium zum Überwachen und Verwalten verbundener Hardwarebereitstellungen. Alle von Helium gelieferte Hardware ist bereits in unserem System registriert, aber wir müssen wissen, wer sie bereitstellt.

• Erstellen Sie zuerst ein Helium Dashboard-Konto, falls Sie dies noch nicht getan haben.

• Um Ihr Atom zu registrieren, wählen Sie zunächst Neues Atom . aus . Fügen Sie in der Benutzeroberfläche einen Namen hinzu (z. B. Fern Saver ) geben Sie dann die letzten vier seiner MAC-Adresse . ein und sein vierstelliger HVV-Code . Klicken Sie auf Speichern und du bist fertig.

• Die Elementregistrierung erfolgt auf die gleiche Weise. Wählen Sie Neues Element, Geben Sie dann einen Namen ein, die letzten vier seiner MAC-Adresse und sein vierstelliger HVV-Code . Stellen Sie außerdem sicher, dass Sie einen Standort für Ihr Element eingeben, damit Dashboard ihn auf einer Karte anzeigen kann.

Sie können überprüfen, ob Ihr Element online ist, indem Sie es sich ansehen Status &Signal im Dashboard:

Bereitstellen des Helium-HTTP-Kanals

Ein Hauptmerkmal der Helium-Plattform sind Kanäle. Dies sind vorgefertigte Konnektoren für Webdienste (wie AWS IoT, Google Cloud IoT und Azure IoT) und Protokolle (wie MQTT und HTTP ). Mit Channels hat Helium die ganze Schwerarbeit für Sie übernommen, wenn es um die Integration mit einem dieser Webdienste oder Protokolle geht. Lassen Sie uns für Fern Saver, unsere Bodenfeuchtigkeitssonde, einen HTTP-Kanal einrichten. Dadurch können wir Daten an jeden Webdienst weiterleiten, der Daten über HTTP akzeptiert. Sie könnten beispielsweise einen HTTP-Kanal verwenden, um diese Daten an IFTTT zu senden und wiederum jedes Mal einen Text zu erhalten, wenn Fern Saver eine Feuchtigkeit unter einem bestimmten Wert meldet.

In diesem Beispiel richten wir einen HTTP-Kanal ein, der Daten an requestb.in sendet, einen praktischen, kostenlosen Webdienst zum Testen von HTTP-Diensten. Beachten Sie, dass wir unten beim Hochladen der Skizze auf den Arduino auf diesen Kanalnamen verweisen, HTTP , im Code, damit wir wissen, wohin die Daten gesendet werden sollen.

So können Sie diesen Kanal schnell und einfach einrichten:

Konfigurieren Ihrer Arduino-IDE und Hochladen der Skizze

Wir können nun mit der Konfiguration Ihrer Arduino-IDE und dem Importieren der erforderlichen Bibliotheken fortfahren. Um loszulegen:

• Stellen Sie sicher, dass Sie die neueste Arduino IDE heruntergeladen haben. Holen Sie es bei Bedarf hier.

• Wir müssen dann zwei Bibliotheken hinzufügen:Helium und ArduinoJson . Sie können Bibliotheken aus der IDE hinzufügen, indem Sie zu Skizze gehen -> Bibliothek einschließen -> Bibliotheken verwalten. Suchen Sie nach "Helium", wählen Sie es aus und klicken Sie auf Installieren . Befolgen Sie denselben Installationsvorgang für die Bibliothek "ArduinoJson". (Wir benötigen diese Bibliothek, da das von uns aufgezeichnete Bodenfeuchtigkeitsdatum im JSON-Format formatiert ist.)

Sobald dies erledigt ist, ist es an der Zeit, die eigentliche Arduino-Programmierung durchzuführen. Die vollständige Quelle für den Sketch, den wir hochladen werden, finden Sie hier auf GitHub. Das Folgende ist die vollständige Soil_Humidity.ino skizzieren.

/* * Copyright 2017, Helium Systems, Inc. * Alle Rechte vorbehalten. Siehe LICENCE.txt für Lizenzinformationen * * Feuchtigkeitsmessungen mit dem kapazitiven Feuchtigkeitssensor SEN0192 *. Verdrahtungsanweisungen:* https://www.dfrobot.com/wiki/index.php/Capacitive_Soil_Moisture_Sensor_SKU:SEN0193 * * Installieren Sie die folgenden Bibliotheken über Sketch->Manage Libraries:* - ArduinoJson * - Helium */ #include "Board.h " #include  #include  #include  #include  // Dieser Kanalname sollte dem Kanal entsprechen, den Sie in Helium bereitgestellt haben// Dashboard, um dies aufzunehmen Daten. #define CHANNEL_NAME "HTTP" // Verzögerung für eine Sekunde #define CHANNEL_DELAY 5000 // Sehr 60 Zyklen (Sekunden) senden #define CHANNEL_SEND_CYCLE 12 Helium helium(&atom_serial); Kanalkanal (&Helium); int channel_counter;void report_status (int status, int result =0) { if (helium_status_OK ==status) { if (result ==0) { Serial.println (F ("Erfolgreich")); aufrechtzuerhalten. Sonst {Serial.print (F ("Fehler - ")); Serial.println (Ergebnis); } } Else {Serial.println (F ( "Failed")); aufrechtzuerhalten. aufrechtzuerhalten. 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 { // Stellen Sie sicher, dass wir verbunden sind connect(); Serial.print (F ( "Kanal erstellen - ")); status =channel.begin(channel_name, &result); // Status und Ergebnis ausgeben report_status(status, result); if (helium_status_OK !=status) { delay(1000); } } while (helium_status_OK !=status || result !=0); aufrechtzuerhalten. Void channel_send (const char * channel_name, void const * data, size_t len) { int status; int8_t Ergebnis; do {// Versuchen Sie, Serial.print (F ( "Senden - ") zu senden); status =channel.send(data, len, &result); report_status(Status, Ergebnis); // Kanal erstellen, wenn Servicefehler zurückgegeben werden if (status ==helium_status_OK &&result !=0) { channel_create(channel_name); aufrechtzuerhalten. Sonst if (status !=helium_status_OK) { Verzögerung (1000); } } while (helium_status_OK !=status || result !=0); aufrechtzuerhalten. Void setup () { Serial.begin (9600); Serial.println (F ("Start")); helium.begin(HELIUM_BAUD_RATE); channel_create(CHANNEL_NAME); channel_counter =0; aufrechtzuerhalten. Float-Lesung =analogRead (A0); Float-Prozent =100 * (1 - (Lesen - WET_VALUE) / HUM_RANGE); Serial.print (Lesen); Serial.print(" - "); Serial.println (Prozent); if (--channel_counter <=0) { StaticJsonBuffer jsonBuffer; JsonObject &root =jsonBuffer.createObject(); root[F("Wert")] =Lesen; root[F("Prozent")] =Prozent; Zeichenpuffer [HELIUM_MAX_DATA_SIZE]; size_t verwendet =root.printTo(buffer, HELIUM_MAX_DATA_SIZE); channel_send(CHANNEL_NAME, Puffer, verwendet); channel_counter =CHANNEL_SEND_CYCLE; } Verzögerung (CHANNEL_DELAY); } 

Mit dem Helium und ArduinoJson Bibliotheken installiert, erstellen Sie eine neue Skizze (Datei -> Neu aus der Arduino IDE) und fügen Sie den obigen Code ein. Drücken Sie dann, während Ihr komplettes Hardwarepaket für die Bodenfeuchtesonde über ein USB-Kabel mit Ihrer Workstation verbunden ist, auf Hochladen Taste.

Die LEDs an Ihrem Atom Prototyping Module sollten nach einigen Augenblicken zu blinken beginnen. Dies ist das Atom, das sich mit dem Helium-Netzwerk verbindet (über das Element, das wir zuvor bereitgestellt haben). Wenn die Arduino IDE beim Hochladen des Codes keine Fehler ausgibt, war dies erfolgreich und die Bodenfeuchtesonde generiert nun Messwerte.

Ein Hinweis zu den Bodenfeuchtedaten

Wie oben erwähnt, erfasst diese Skizze Bodenfeuchtigkeitsdaten und codiert sie als JSON bevor Sie es an die Helium-Plattform senden. Mit der obigen Skizze sieht ein Datenpunkt ungefähr so ​​​​aus (als JSON ):

{ "Wert":433, "Prozent":55,5 } 

Es ist erwähnenswert, dass der DFRobot Gravity Capacitive Soil Moisture Sensor diese Messwerte tatsächlich als analoge Messwerte zwischen einem kalibrierten Trocken- und Nassmesswert erfasst. Ausführliche Informationen zur Implementierung und Kalibrierung finden Sie hier. Vielleicht möchten Sie die Kalibrierung ein wenig optimieren.

Überprüfen der Sensorkonnektivität und -daten im Helium-Dashboard

Nachdem Ihr Sensor nun bereitgestellt wurde, können wir überprüfen, ob er online ist und Daten überträgt. Innerhalb des Dashboards können wir dies auf verschiedene Weise tun, sowohl über die Atom-Benutzeroberfläche Ansicht für den Sensor, den Sie gerade bereitgestellt haben.

• Wenn Ihr Atom online ist, zeigt das Dashboard seinen Status &Signal , zusammen mit verschiedenen anderen Metadaten zu seinem Status. Es wird ungefähr so ​​aussehen:

• Weiter unten in derselben Atom-Benutzeroberfläche zeigen wir auch ein Ereignisprotokoll . an zeigt jeden Datenpunkt vom Sensor und ob er erfolgreich an einen Heliumkanal übertragen wurde oder nicht. Wie oben erwähnt, handelt es sich um vorgefertigte Konnektoren für Webdienste oder Rohprotokolle. Zuvor haben wir einen HTTP-Kanal für Ihre Helium-Organisation bereitgestellt. Und die obige Skizze weist die Bodenfeuchtesonde an, Daten an diesen Kanal zu senden - genannt HTTP . In diesem unten abgebildeten Beispiel senden wir unsere Daten jedoch an den Helium-HTTP-Kanal:

• Wir bieten auch einen Debug Schnittstelle für jedes Atom, das Ihre Messwerte anzeigt, sobald sie eingehen (sobald Sie diese Option aktiviert haben). Hier sind einige Bodenfeuchtigkeitsdaten im Debug-Viewer des Dashboards:

Nächste Schritte und Hilfe

Herzliche Glückwünsche! Das ist das Ende dieser Anleitung. Sie haben Ihren Farn jetzt mit einer drahtlosen Bodenfeuchtigkeitssonde zukunftssicher gemacht. Das ist eine große Sache. Ihre Farne danken Ihnen.

Wenn Sie mehr über Helium erfahren möchten und wie Sie mit dieser Hard- und Software Prototypen Ihrer eigenen Sensoren erstellen können, beginnen Sie hier:

• Helium-Entwicklerdokumentation

• Helium-Entwickler-Slack

• Helium-Entwicklerforum

Code

• Soil_Humidity.ino

Soil_Humidity.inoC/C++

/* * Copyright 2017, Helium Systems, Inc. * Alle Rechte vorbehalten. Siehe LICENCE.txt für Lizenzinformationen * * Feuchtigkeitsmessungen mit dem kapazitiven Feuchtigkeitssensor SEN0192 *. Verdrahtungsanweisungen:* https://www.dfrobot.com/wiki/index.php/Capacitive_Soil_Moisture_Sensor_SKU:SEN0193 * * Installieren Sie die folgenden Bibliotheken über Sketch->Manage Libraries:* - ArduinoJson * - Helium */#include "Board.h "#include #include #include #include #define CHANNEL_NAME "Helium MQTT"// Verzögerung für eine Sekunde#define CHANNEL_DELAY 5000// Sehr senden 60 Zyklen (Sekunden)#define CHANNEL_SEND_CYCLE 12Helium helium(&atom_serial);Channel channel(&helium);int channel_counter;voidreport_status(int status, int result =0){ if (helium_status_OK ==status) { if (result ==0) { Serial.println (F ("Erfolgreich")); aufrechtzuerhalten. Sonst {Serial.print (F ("Fehler - ")); Serial.println (Ergebnis); } } Else {Serial.println (F ( "Failed")); }}voidconnect () { während (! helium.connected ()) { Serial.print (F ( "Verbindung - ")); int-Status =helium.connect(); report_status(status); if (helium_status_OK !=status) { delay(1000); } }}voidchannel_create(const char * channel_name){int8_t result; int-Status; do { // Stellen Sie sicher, dass wir verbunden sind connect(); Serial.print (F ( "Kanal erstellen - ")); status =channel.begin(channel_name, &result); // Status und Ergebnis ausgeben report_status(status, result); if (helium_status_OK !=status) { delay(1000); } } while (helium_status_OK !=status || result !=0);}voidchannel_send(const char * channel_name, void const * data, size_t len){ int status; int8_t Ergebnis; do {// Versuchen Sie, Serial.print (F ( "Senden - ") zu senden); status =channel.send(data, len, &result); report_status(Status, Ergebnis); // Kanal erstellen, wenn Servicefehler zurückgegeben werden if (status ==helium_status_OK &&result !=0) { channel_create(channel_name); aufrechtzuerhalten. Sonst if (status !=helium_status_OK) { Verzögerung (1000); } } while (helium_status_OK !=status || result !=0);}voidsetup () { Serial.begin (9600); Serial.println (F ("Start")); helium.begin(HELIUM_BAUD_RATE); channel_create(CHANNEL_NAME); channel_counter =0;} #define DRY_VALUE 536 // Aufgenommen in der Luft #define WET_VALUE 303 // Aufgenommen in Wasser #define HUM_RANGE (DRY_VALUE - WET_VALUE)voidloop () { Serial.print (F ("Reading - ")); Float-Lesung =analogRead (A0); Float-Prozent =100 * (1 - (Lesen - WET_VALUE) / HUM_RANGE); Serial.print (Lesen); Serial.print(" - "); Serial.println (Prozent); if (--channel_counter <=0) { StaticJsonBuffer jsonBuffer; JsonObject &root =jsonBuffer.createObject(); root[F("Wert")] =Lesen; root[F("Prozent")] =Prozent; Zeichenpuffer [HELIUM_MAX_DATA_SIZE]; size_t verwendet =root.printTo(buffer, HELIUM_MAX_DATA_SIZE); channel_send(CHANNEL_NAME, Puffer, verwendet); channel_counter =CHANNEL_SEND_CYCLE; } Verzögerung(CHANNEL_DELAY);}