SoilSense adaptive soil moisture sensor

Soil moisture sensor reading relative moisture according to borders for high and low moisture which can be set by the user.

IntermediateWork in progress3 hours10

Things used in this project

Hardware components

Arduino UNO R4 WiFi

Seeed Studio Grove - Capacitive Soil Moisture Sensor

Software apps and online services

Arduino IDE

MQTT

Eclipse IoT Eclipse Mosquitto

Arduino MQTT Library

Story

Introduction

We are a team of students from Esslingen University specializing in Media Informatics. In an increasingly urbanized and sustainability-driven world, efficient use of water and smart plant care are becoming more important than ever. With our IoT-based soil moisture monitoring system, we aim to support healthy plant growth while reducing unnecessary water consumption in cities, cemeteries, and private households. This is just the current status of the project as we intend to improve it by testing in real world applications.

Project Idea

Our concept is a smart soil moisture monitoring solution that continuously measures the moisture level in the soil and transmits the data wirelessly to a cloud platform. The information can be accessed via Home Assistant or a web-based dashboard, allowing users to monitor plant conditions in real time. The system can be integrated into flower pots, urban green infrastructure, and cemetery planting areas, providing a flexible and scalable solution for different environments. Additionally, users can define individual moisture threshold values depending on the specific type of plant, ensuring optimal care for a wide variety of plant species.

Sketch of the project idea

Why is it Important?

Plants play a vital role in improving air quality, enhancing urban environments, and creating spaces of relaxation and remembrance. However, improper watering is one of the most common reasons for plant stress and failure. Too little water leads to drought stress, while too much water can cause root rot and plant death. Our solution helps prevent both by enabling precise, data-driven watering. This not only improves plant health but also conserves water resources and reduces maintenance efforts—benefiting municipalities, caretakers, and private users alike.

Concept & Technical Implementation

1 / 2 • Wiring on the Arduino UNO R4 WiFi

In order to calculate the relative moisture value, the absolute measured moisture and some reference point has to be known. The absolute moisture is measured by the analog sensor connected to the microcontroller. The microcontroller takes 5 measurements over the course of 5 seconds and calculated the average value to rule out random spikes that can occur when drops or bubbles of moisture form. Then, the relative moisture is calculated. Therefore, the refenrence points lower border and upper border are used. They are the minimum and maximum absolute value and represent 0% and 100% relative moisture. If the measurement exceeds the value range between these borders the relative moisture is set to 0% or 100% according to the border which has been exceeded. If the absolute measurement is in the specified range, the relative value between the borders is calculated.

The upper and lower borders can be set by the user using MQTT. For more info on how MQTT is used and how to communicate with the sensor follows in the paragraph "Communication". The upper border should be set a couple of minutes after the plant has been watered to allow for the whole soil to get wet before. The lower border should be set when the soil is very dry, e.g. right before watering. In the graphic below you can see an example for adaption of moisture borders for a cactus.

Moisture adaption cactus

Because the sensor has been used with a normal plant before, it measures low moisture for the soil of the cactus. But it is a freshly watered cactus, so in reality the relative moisture is at its peak. So we set the upper border to the current absolute moisture. This is when in the graph displays a rise in moisture from 20% to 100%. From now on a far lower absolute moisture is calculated to be a higher relative moisture, which is exactly what a cactus needs.

Communication

The sensor uses MQTT to be widely compatible with any system that has MQTT support. The sensor automatically subscribes to the relevant topics. The exact names topics can be changed as global variables in the code. The required MQTT topics are:

mqttAvailabilityTopic: A topic where the sensor publishes its availability as „online“ or „offline“
mqttStateTopic: A topic where the sensor publishes the relative moisture value
brokerAvailabilityTopic: A topic where the MQTT broker publishes its online state
upperBorderTopic: A topic where the sensor publishes its upper border absolute value
lowerBorderTopic: A topic where the sensor publishes its lower border absolute value
setUpperBorderTopic: A topic where the upper border can be set to the currently measured absolute moisture
setLowerBorderTopic: A topic where the lower border can be set to the currently measured absolute moisture
setLowerBorderValueTopic: A topic where the upper border can be set to an absolute value
setUpperBorderValueTopic: A topic where the lower border can be set to an absolute value

The sensor detects when it is not connected to the WiFi or the MQTT broker and automatically performs a reconnect. The WiFi and MQTT details and credentials can be set als global variables in the code.

Quick Deployment

Sensor Code

#include "WiFiS3.h"
#include "MQTT.h"

#define SensorPin A0

char ssid[] = "Malte-Laptop";
char pass[] = "ABCDEFGHIJ";

char mqttClientId[] = "Feuchtesensor1";
//char mqttUsername[] = "malte";
//char mqttPassword[] = "J*9snh!a6MfEKv#tEvwgdn^A";

char mqttAvailabilityTopic[] = "feuchtesensor/s1/avail";
char mqttStateTopic[] = "feuchtesensor/s1/value";
char brokerAvailabilityTopic[] = "homeassistant/status";
char upperBorderTopic[] = "feuchtesensor/s1/upperBorder";
char setUpperBorderTopic[] = "feuchtesensor/s1/setUpperBorder";
char setLowerBorderTopic[] = "feuchtesensor/s1/setLowerBorder";
char setLowerBorderValueTopic[] = "feuchtesensor/s1/setLowerBorderValue";
char setUpperBorderValueTopic[] = "feuchtesensor/s1/setUpperBorderValue";

char lowerBorderTopic[] = "feuchtesensor/s1/lowerBorder";

bool isBrokerOffline = false;  // Von aktivem Broker ausgehen, nur wenn Broker Last Will sendet wird Bool true

IPAddress mqttBrokerIP = "192.168.137.1";

WiFiClient net;
MQTTClient client;

int status = WL_IDLE_STATUS;

double upperBorderValue = 200;
double lowerBorderValue = 600;

void setup() {
  // put your setup code here, to run once:
  pinMode(SensorPin, INPUT);
  Serial.begin(115200);
  //while(!Serial) {}
  //Serial.println("Serial gestartet!");
  connectWiFi();
  connectMQTT();
  client.onMessage(messageHandler);
}


void loop() {
  // berprfe WiFi und MQTT Verbindung
  mqttKeepAlive();
  client.loop();
  double moisture = calc_rel_moisture(get_abs_moisture());  // Messe Feuchte und Berechne relative Feuchte
  //moisture = calc_rel_moisture(moisture)
  Serial.print("Feuchte: ");
  Serial.println(moisture);
  publishMqttDouble(moisture, mqttStateTopic);
  delay(1000);
}


// Funktion nimmt 5 Messungen in 1 Sekunde und gibt absolutes Ergebnis als int zurck
double get_abs_moisture () {
  double measurement = 5;
  for (int n_measurements = 0; n_measurements < 5; n_measurements++) {  // Nehme 5 Messungen in einer Sekunde
    measurement += analogRead(SensorPin); // Addiere Analog-Werte
    delay(1000); // Warte 200ms
  }
  Serial.print("Gemessener Analogwert: ");
  Serial.println(measurement/5);
  return measurement/5; // Gebe Durchschnitt der Messungen zurck
}

// Funktion um die relative Feuchte aus der absoluten Feuchte zu berechnen
double calc_rel_moisture (double abs_moisture) {
  double rel_moisture = 0;
  if (abs_moisture <= upperBorderValue) {  // Falls absolute Feuchte ber 500 also maximal
    rel_moisture = 100; // Setze relative Feuchte auf 100
    return rel_moisture;
  }
  else if (abs_moisture >= lowerBorderValue) { // Falls absolute Feuchte ber 900 also nicht vorhanden
    rel_moisture = 0; // Setze relative Feuchte auf 0
    return rel_moisture;
  }
  else {
    double onePercentMoisture = (lowerBorderValue - upperBorderValue) / 100;
    double moistureBelowLowerBorder = (lowerBorderValue - abs_moisture);
    rel_moisture = (moistureBelowLowerBorder/onePercentMoisture);  // Relative Feuchte nach dem Dreisatz oben ausrechnen
    //rel_moisture = round(rel_moisture); // Relative Feuchte runden
    return rel_moisture;
  }
}


// Prft ob WiFi verbunden ist und ob Client ordnungsgem verbunden ist, besttigt Online-Status in Topic
void mqttKeepAlive() {
  if(!isWiFiConnected()) {
    Serial.println("Keepalive: WiFi nicht verbunden");
    connectWiFi();
  }
  if(!isMQTTConnected()) { // Falls client nicht verbunden oder Broker nicht verfgbar
    Serial.println("Keepalive: MQTT nicht verbunden");
    connectMQTT();
  }
  client.publish(mqttAvailabilityTopic, "online");
  Serial.println("Keepalive abgeschlossen");
  return;
}

// Prft ob WiFi verbunden ist
bool isWiFiConnected() {
  if((WiFi.localIP() != "0.0.0.0") && (WiFi.status() == WL_CONNECTED)) { // Falls IP zugewiesen und der WiFi Status connected ist
    return true;
  } else {
    return false;
  }
}

// Verbindet mit in Globalen Konstanten festgelegten WiFi-Konnektivittsdaten
void connectWiFi() {
  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("Kommunikation mit WiFi Modul fehlgeschlagen!");
    while (true);
  }
  String fv = WiFi.firmwareVersion();
  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
    Serial.println("Wifi-Firmware-Update verfgbar!");
  }
  Serial.print("Versuche mit SSID ");
  Serial.print(ssid);
  Serial.println(" zu verbinden!");
  do {
    WiFi.begin(ssid, pass);
    Serial.print(".");
    delay(5000);
  } while (!isWiFiConnected());
  
  print_Wifi_Status();
  return;
}

// Funktion zur Ausgeb von WiFi-Konnektivittsdaten
void print_Wifi_Status() {
  // Gebe SSID aus
  Serial.println("WiFi verbunden mit folgenden Verbindungsdetails:");
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // Gebe IP-Adresse aus
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Addresse: ");
  Serial.println(ip);

  // Gebe Signalstrke aus
  long rssi = WiFi.RSSI();
  Serial.print("Signalstrke (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
  return;
}

// Prft ob MQTT Client verbunden ist und ob Broker offline
bool isMQTTConnected() {
  if(client.connected() && !isBrokerOffline) {  // Falls Client verbunden und Broker nicht offline
    return true;
  } else {
    return false;
  }
}

// Verbindet mit in Globalen Variablen festgelegten MQTT Verbindungsdaten
void connectMQTT() {
  Serial.println("Verbinde mit MQTT Broker");
  client.begin(mqttBrokerIP, net);  // Starte MQTT Client mit IP des Brokers und dem Wifi-Client
  client.setWill(mqttAvailabilityTopic, "offline");
  do {
    client.connect(mqttClientId); // client.connect(mqttClientId, mqttUsername, mqttPassword);
    Serial.print(".");
    delay(1000);
  } while (!isMQTTConnected());
  Serial.println("Verbindung zu MQTT Broker hergestellt");
  delay(3000);  // Warte 3s damit Home Assistant komplett starten kann vor Birth Nachricht
  client.subscribe(upperBorderTopic);
  client.subscribe(lowerBorderTopic);
  client.subscribe(setUpperBorderValueTopic);
  client.subscribe(setUpperBorderTopic);
  client.subscribe(setLowerBorderValueTopic);
  client.subscribe(setLowerBorderTopic);
  client.publish(mqttAvailabilityTopic, "online");
  publishMqttDouble(lowerBorderValue, lowerBorderTopic);
  publishMqttDouble(upperBorderValue, upperBorderTopic);
  isBrokerOffline = false;
  return;
}

// Sendet double an MQTT Topic
void publishMqttDouble(double msg, String topic) {
  char msgString[16]; // Erstelle char Array
  dtostrf(msg, 6, 1, msgString);  // Konvertiere double in char Array
  client.publish(topic, msgString);  // Verffentliche Wert in passendem Topic
  //client.publish(mqttStateTopic, "1");
  return;
}

// Prft ob Broker Last Will sendet
void messageHandler(String &topic, String &payload) {
  Serial.println(payload);
  if((topic == brokerAvailabilityTopic) && (payload == "offline")) {  // Falls Broker Last Will sendet
    isBrokerOffline = true;
  } else if(topic == setUpperBorderValueTopic) { // Wenn obere Grenze manuell auf Wert gesetzt wird
    upperBorderValue = payload.toFloat();
    Serial.println("obere Grenze auf ");
    Serial.print(upperBorderValue);
    Serial.print(" gesetzt");
    publishMqttDouble(lowerBorderValue, lowerBorderTopic);
    publishMqttDouble(upperBorderValue, upperBorderTopic);
  } else if(topic == setLowerBorderValueTopic) { // Wenn untere Grenze manuell auf Wert gesetzt wird
    lowerBorderValue = payload.toFloat();
    Serial.println("untere Grenze auf ");
    Serial.print(lowerBorderValue);
    Serial.print(" gesetzt");
    publishMqttDouble(lowerBorderValue, lowerBorderTopic);
    publishMqttDouble(upperBorderValue, upperBorderTopic);
  } else if (topic == setUpperBorderTopic) { // Wenn obere Grenze manuell auf aktuellen Wert gesetzt wird
    upperBorderValue = get_abs_moisture();
    Serial.println("obere Grenze auf");
    Serial.print(upperBorderValue);
    Serial.print(" gesetzt");
    publishMqttDouble(lowerBorderValue, lowerBorderTopic);
    publishMqttDouble(upperBorderValue, upperBorderTopic);
  } else if (topic == setLowerBorderTopic) {  // Wenn untere Grenze manuell auf aktuellen Wert gesetzt wird
    lowerBorderValue = get_abs_moisture();
    Serial.println("untere Grenze auf ");
    Serial.print(lowerBorderValue);
    Serial.print(" gesetzt");
    publishMqttDouble(lowerBorderValue, lowerBorderTopic);
    publishMqttDouble(upperBorderValue, upperBorderTopic);
  }
  return;
}