Draadloze bodemvochtigheidssensorsysteem met Helium & DFRobot – Real-time plantenzorg

Onderdelen en benodigdheden

Apps en online diensten

• Arduino IDE
• Helium Dashboard

Over dit project

Geef je planten een stem met een draadloze bodemvochtigheidssensor

Laten we eerlijk zijn: planten sterven constant door gebrek aan water. Je bent bezig en die varens zullen niet hun handen opsteken wanneer ze dorst hebben. Voor de plantenliefhebber op de goe is dit prototype bodemvochtigheidssensor je ticket naar gelukkige, gezonde varens en ficus.

Wat we behandelen

Deze complete gids duurt ongeveer 60 minuten. Hier is wat we doen:

• Bouwen van je complete bodemvochtigheidssensor met de DF Robot Gravity Capacitive Soil Moisture Sensor, een Helium Atom Prototyping Module, een Helium Arduino Adapter en een Arduino-bord (we gingen voor de UNO);
• Registreren van je Helium Element en Helium Atom Prototyping Module in het Helium Dashboard; en bouwen van je eigen laag-energie, groot-bereik draadloos netwerk;
• Programmeren van je bodemvochtigheidssensor via de Arduino IDE. We installeren ook de Helium- en ArduinoJson-bibliotheken;
• Meten en versturen van bodemvochtigheidsdata in near real-time van je plant naar het Helium Dashboard; en doorsturen naar een Helium HTTP-kanaal.

Oké. Laten we beginnen. We hebben varens te redden.

Je bodemvochtigheidssensor bouwen

Eerst bouwen we de meetunit. Dit is snel en makkelijk. Wanneer je klaar bent, ziet je complete sensor er zo uit:

Om dit te bouwen:

• Steek eerst je Helium Atom Prototyping Module in de Helium Arduino Adapter en verbind deze gecombineerde unit met je gekozen Arduino-bord. Zorg ervoor dat je de RX en TX jumpers correct configureert, afhankelijk van welk bord je gebruikt. Volledige details over het samenstellen en de juiste jumperconfiguraties vind je hier. Bekijk dat, voltooi het en kom terug.
• Vervolgens verbinden we de eigenlijke bodemvochtigheidssensor met de Helium Arduino Adapter met de drie-aders jumperkabel die bij de DF Robot Soil Moisture Probe hoort. De drie draadkleuren zijn zwart, rood en blauw. Op de Helium Arduino Adapter verbindt de zwarte draad met GND; de rode draad met 5V; en de blauwe draad met de ADO-header. Er is een handig diagram van het DFRobot-team over hoe deze verbinding werkt hier. Ons bord ziet er zo uit als de bedrading correct is:

• Ten slotte verbind je de witte header op de jumperkabel met de DF Robot Soil Moisture Probe. Hoewel dit een beetje lastig kan zijn, moet het met minimale moete inklikken.

Je Helium Element implementeren

Nu bouwen we je eigen Helium-netwerk. Dit duurt ongeveer 30 seconden. (Als je meer wilt weten over hoe een end-to-end applicatie op Helium wordt gebouwd en hoe we de draadloze netwerkcomponent hanteren, begin met dit architectuuroverzicht.)

Om het Element te implementeren en netwerkdekking te creëren voor je Atom-gebaseerde sensor(en), plug het gewoon in de stroom en een live Ethernet-poort met de meegeleverde kabels. (Opmerking: Als je een Cellular-backed Element hebt, is Ethernet-connectiviteit optioneel maar aanbevolen als backup.) Eenmaal aangesloten, zie je LED-activiteit. Je Element is verbonden wanneer de front-LED groen wordt (Ethernet-connectiviteit) of blauwgroen (voor cellulair). Je kunt een korte video over het Element en hoe je het aansluit hier bekijken.

Je Helium Element en Atom registreren in Helium Dashboard

Nu onze meetunit gebouwd is en je Helium-netwerk gedeployed is, registreren we de hardware in het Helium Dashboard. Dashboard is Helium's gehoste gebruikersinterface voor het monitoren en beheren van aangesloten hardware-implementaties. Alle hardware die Helium verzendt is al in ons systeem geregistreerd, maar we moeten weten wie het implementeert.

• Maak eerst een Helium Dashboard-account als je er nog geen hebt.
• Om je Atom te registreren, selecteer New Atom. In de UI voeg je een naam toe (bijv. Fern Saver), vul de laatste vier cijfers van het MAC-adres en de viercijferige HVV-code in. Klik op Save en je bent klaar.
• De Element-registratie werkt precies hetzelfde. Selecteer New Element, geef een naam, de laatste vier van het MAC-adres en de viercijferige HVV-code. Zorg ook dat je een locatie invoert voor je Element zodat Dashboard het op een kaart kan tonen.

Je kunt controleren of je Element online is door naar Status & Signal in Dashboard te kijken:

De Helium HTTP-kanaal implementeren

Een grote feature van het Helium-platform zijn Kanalen. Dit zijn vooraf gebouwde connectors naar webservices (zoals AWS IoT, Google Cloud IoT, Azure IoT) en protocollen (zoals MQTT en HTTP). Met Kanalen heeft Helium al alle zware klus geklaard voor integratie met deze diensten of protocollen. Voor Fern Saver, onze bodemvochtigheidssensor, laten we een HTTP-kanaal opstarten. Hiermee kunnen we data naar elke webservice sturen die data via HTTP accepteert. Je kunt bijvoorbeeld een HTTP-kanaal gebruiken om data naar IFTTT te sturen en zo een SMS te krijgen elke keer dat Fern Saver vochtigheid onder een bepaald niveau rapporteert.

In dit voorbeeld stellen we een HTTP-kanaal in dat data naar requestb.in stuurt, een handige, gratis webservice voor het testen van HTTP-diensten. Let op: wanneer we de sketch naar de Arduino uploaden, verwijzen we naar deze kanaalnaam, HTTP, in de code zodat we weten waar de data heen moet.

Zo snel en makkelijk is het om dit kanaal in te stellen:

Je Arduino IDE configureren en de sketch uploaden

We kunnen nu de Arduino IDE configureren en de benodigde bibliotheken importeren. Om te beginnen:

• Zorg dat je de nieuwste Arduino IDE hebt gedownload. Download hier als nodig.
• We voegen twee bibliotheken toe: Helium en ArduinoJson. Je kunt bibliotheken toevoegen vanuit de IDE via Sketch -> Include Library -> Manage Libraries. Zoek naar "helium", selecteer het en klik op Install. Volg hetzelfde proces voor "ArduinoJson". (We hebben deze bibliotheek nodig omdat de bodemvochtigheidsdata als JSON wordt geformatteerd.)

Nu dit gedaan is, kunnen we echt Arduino-programmeren. De volledige broncode voor de sketch die we uploaden vind je hier op GitHub. Hieronder staat de complete Soil_Humidity.ino sketch.

/* 
 * Copyright 2017, Helium Systems, Inc.
 * All Rights Reserved. See LICENCE.txt for license information
 * 
 * Taking humidity readings using the SEN0192 capacitive humidity
 * sensor. Wiring instructions:
 * https://www.dfrobot.com/wiki/index.php/Capacitive_Soil_Moisture_Sensor_SKU:SEN0193
 * 
 * Install the following libraries through Sketch->Manage Libraries:
 * - ArduinoJson
 * - Helium
 */
#include "Board.h"
#include 
#include 
#include 
#include 

// This Channel Name should correspond the Channel you've deployed in Helium
// Dashboard to ingest this data.
#define CHANNEL_NAME "HTTP"
// Delay for one second
#define CHANNEL_DELAY 5000
// Send every 60 cycles (seconds)
#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 // Gemeten in lucht
#define WET_VALUE 303 // Gemeten 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 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);
}

Met de Helium- en ArduinoJson-bibliotheken geïnstalleerd, maak een nieuwe sketch (File -> New in de Arduino IDE) en plak de bovenstaande code. Sluit je complete bodemvochtigheidssensor-hardwarepakket via USB aan op je werkstation en klik op Upload.

De LED's op je Atom Prototyping Module moeten na een paar ogenblikken beginnen te knipperen. Dit is de Atom die verbindt met het Helium-netwerk (via het Element dat we eerder implementeerden). Als de Arduino IDE geen fouten geeft bij het uploaden, was het succesvol en genereert de sensor nu metingen.

Een opmerking over de bodemvochtigheidsdata

Zoals hierboven vermeld, vangt deze sketch bodemvochtigheidsdata op en codeert het als JSON voordat het naar het Helium-platform wordt gestuurd. Met de bovenstaande sketch ziet een datapunt er ongeveer zo uit (als JSON):

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

Het is de moeite waard om op te merken dat de DFRobot Gravity Capacitive Soil Moisture Sensor deze metingen als analoge waarden vastlegt tussen een gecalibreerde droge en natte meting. Je kunt volledige details over de implementatie en calibratie hier vinden. Je wilt misschien de calibratie iets aanpassen.

Sensorconnectiviteit en data verifiëren in Helium Dashboard

Nu je sensor gedeployed is, kunnen we controleren of het online is en data overbrengt. In Dashboard kunnen we dit op een paar manieren doen, beide via de Atom UI-weergave voor de sensor die je zojuist hebt gedeployed.

• Als je Atom online is, toont Dashboard de Status & Signal, samen met diverse andere metadata over de status. Het ziet er ongeveer zo uit:

• Verderop in dezelfde Atom-interface tonen we ook een Event Log die elk datapunt van de sensor laat zien en of het succesvol naar een Helium-kanaal is verzonden. Zoals gezegd, zijn dit vooraf gebouwde connectors naar webservices of ruwe protocollen. Eerder implementeerden we een HTTP-kanaal voor je Helium-organisatie. En de bovenstaande sketch vertelt de bodemvochtigheidssensor om data naar dit kanaal te sturen - genaamd HTTP. In het onderstaande voorbeeld sturen we onze data naar het Helium HTTP-kanaal:

• We bieden ook een Debug-interface voor elke Atom die je metingen toont zodra ze binnenkomen (nadat je deze optie hebt ingeschakeld). Hier is wat bodemvochtigheidsdata in Dashboard's Debug-viewer:

Volgende stappen en hulp

Gefeliciteerd! Dit is het einde van deze gids. Je hebt je varen nu toekomstbestendig gemaakt met een draadloze bodemvochtigheidssensor. Dit is een grote stap. Je varens danken je.

Als je meer wilt leren over Helium en hoe je je eigen sensoren kunt prototypen met deze hardware en software, begin hier:

• Helium Developer Documentation
• Helium Developer Slack
• Helium Developer Forum

Code

Soil_Humidity.ino (C/C++)

De complete Arduino-sketch om bodemvochtigheidsdata van je sensor naar een Helium-kanaal te sturen.

/* 
 * Copyright 2017, Helium Systems, Inc.
 * All Rights Reserved. See LICENCE.txt for license information
 * 
 * Taking humidity readings using the SEN0192 capacitive humidity
 * sensor. Wiring instructions:
 * https://www.dfrobot.com/wiki/index.php/Capacitive_Soil_Moisture_Sensor_SKU:SEN0193
 * 
 * Install the following libraries through Sketch->Manage Libraries:
 * - ArduinoJson
 * - Helium
 */
#include "Board.h"
#include 
#include 
#include 
#include 

#define CHANNEL_NAME "Helium MQTT"
// Delay for one second
#define CHANNEL_DELAY 5000
// Send every 60 cycles (seconds)
#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 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);
}