Soil Moisture Project Particle Argon

Ever forget when to water your plants??? Worry no more, we got the solution for you!!!! Know exactly when to water your plants.

IntermediateFull instructions provided10 hours1,790

Things used in this project

Hardware components

Particle Argon

Jumper wires (generic)

DFRobot Gravity: Analog Capacitive Soil Moisture Sensor- Corrosion Resistant

Solderless Breadboard Half Size

Software apps and online services

Particle Build Web IDE

IFTTT Maker service

Google Sheets

Link to Live graphs: https://docs.google.com/spreadsheets/d/1FmpJWwDeWeu7zhu90j0x8TXOyHkESLquWZoLICd29Sw/edit?usp=sharing

Story

Project Overview

We set out with the mission to eliminate the stress of finding the correct timing in watering your plants. So after detailed research, we determined the best sensor to measure the moisture levels within the soil that will last more than a couple months. In the end, a capacitive moisture sensor accomplished the requirements of our required sensor the best. This project will alleviate the stress of worrying about when to water your plants or if you simply forget to sometimes after a busy day. When the variable that processes data determines that the plant needs to be watered, the If This Then That software will send a notification to your phone telling you if your plant needs to be watered or not. More information on how the project works can be found below if you are interested.

Working Towards a Solution

Choosing a Sensor

We researched what sensors are best for use in measurement of the moisture content in soil. We came across two major types of sensors: capacitive and resistive moisture sensors. We decided to go with the capacitive moisture sensors since they are more corrosion resistance than their resistive counterparts. They also feature on-board voltage regulation, and operate from ~3.3-5.5V, which is perfect for the Particle Argons specifications

Calibration and Data Collection

We calibrated the sensor based on the limit of how dry the soil can get before the plant needs to be watered. The sensor usually gives a reading of 2700 mV, so we chose a limit of 2000 mV for the plant to be watered. As the soil gets dryer, the voltage reading of the moisture sensor decreases, which will eventually cause it to reach the threshold limit and send a signal that the plant should be watered at that point. Data collection works by taking in a bit count out of 4096. The measurement is then divided by 4096 to get a ratio and then multiplied by the supply voltage of 3.3 V to get a sensor reading in millivolts. This data can then be further processed and used to get a reading on whether the plant should be watered or not. It should be known that if you build this project, your sensor values may be different based on the sensor you buy and the soil type you use, as some soil types offer more drainage than others. This may require you to water the plant more frequently if it drains fast. You can also change the indicator level in case you want your plant to dry out for a while before watering so it does not start getting pests or nasty fungi making a home in your plant or soil due to over-watering.

1 / 4

Communication between the Argon devices

Particle Argon 1 initiates the data collection and processing by sending/publishing an event to the particle cloud. The message sent is to toggle the led’s on. Once the data collector argon and data process argon receive message, they turn on their led's. Argon 2 has a capacitive soil sensor connected to it and it begins to collect readings from the soil. It publishes this data to the particle cloud. Argon 3 will wait for this data and then start summing the data. Once it receives enough data points, it will get the average based on how many data readings it received. Then, depending on the value of the average, it will publish a couple of messages to the particle cloud. One message will publish whether to water or not water the plants and another message will toggle the led's off so that data collection stops. Through the use of IFTTT, the readings published from particle argon 2 will be added to an excel spreadsheet to provide a “live” graph. Also through IFTTT, when Argon 3 publishes the event to water or not water the plant, a text message will be sent to the a phone indicating the need to water the plant or not.

1 / 2

Video and Practical Application

Live Chart

Code

//Set Moisture Sensor to Analog 0 Pin
int Moisture = A1;
int analogMoisture = 0;
int mVoltage = 0;
int i = 0;

void setup() {

    pinMode(D7, OUTPUT);
    Particle.subscribe("toggle-led", toggleLed, ALL_DEVICES);
    
    //Set pinmode as INPUT so that we read the data from the Moisture sensor
    pinMode(Moisture, INPUT);
    
}



void loop() {
    //Connect to Particle Clould check
    if (Particle.connected() == false) {
        Particle.connect();
    }
    
    //For single device testing, set pin D7 to HIGH : digitalWrite(D7, HIGH);
    //if (digitalRead(D7) == HIGH) {
        //While loop to run a specified number times when initialized
        while (i < 50 && digitalRead(D7) == HIGH) {
            //Read Moisture Sensor and send data to analogMoisture Variable, this data is in counts out of 4096, so it needs to be converted to voltage
            analogMoisture = analogRead(Moisture);
            mVoltage = (analogMoisture*3300)/4096;
            
            //Publish mVoltage variable which is the output voltage in mV of the moisture sensor
            Particle.variable("mVoltage", mVoltage);
            
            //Publish Voltage in millivolts
            Particle.publish("mvoltage_reading", String(mVoltage), PUBLIC);  // publish voltage values to cloud
            i++;
            
            //Wait 10 seconds
            delay(10000);
        }
    
}

//this function turns on LED
void toggleLed(const char *event, const char *data) {
    
    if (digitalRead(D7) == LOW && String(data).equals("on")) {
        digitalWrite(D7, HIGH);
    }
    else if (digitalRead(D7) == HIGH && String(data).equals("off")){
        digitalWrite(D7, LOW);
    }
}

int i = 0;
void setup() {
    pinMode(D7, OUTPUT);
    Particle.subscribe("toggle-led", toggleLed, ALL_DEVICES);
    
    //Connect to a WiFi network check
    if (WiFi.ready() == false) {
        WiFi.setCredentials("Galaxy_Jay", "800989865");
        WiFi.on(); WiFi.connect();
    }
    
    //Connect to Particle Clould check
    if (Particle.connected() == false) {
        Particle.connect();
    }
    Particle.subscribe("water-plant", water, ALL_DEVICES);
}

void loop() {
    if (digitalRead(D7) == LOW && i < 1) {
        delay(10000);
        Particle.publish("toggle-led", "on", PUBLIC);
        delay(2000);
        i++;
    }

}

String water(const char *event, const char *data) {
    return String(data);
}

//this function turns on LED
void toggleLed(const char *event, const char *data) {
    
    if (digitalRead(D7) == LOW && String(data).equals("on")) {
        digitalWrite(D7, HIGH);
    }
    else if (digitalRead(D7) == HIGH && String(data).equals("off")){
        digitalWrite(D7, LOW);
    }
}

int sum = 0;
int temp = 0;
String value;
int avg = 0;
int j = 1;

void setup() {
    pinMode(D7, OUTPUT);
    Particle.subscribe("mvoltage_reading", mVoltage, ALL_DEVICES);
    Particle.subscribe("toggle-led", toggleLed, ALL_DEVICES);
    
}

void loop() {
    //Connect to Particle Clould check
    if (Particle.connected() == false) {
        Particle.connect();
    }
    
    //For single device testing, set pin D7 to HIGH : digitalWrite(D7, HIGH);
    if (digitalRead(D7) == HIGH) {
        
        if (j > 20) {
            avg = sum / j;
            if (avg < 2000 && avg > 0) {
                    digitalWrite(D7, HIGH);
                    delay(1000);
                    digitalWrite(D7, LOW);
                    Particle.publish("avg_voltage_reading", String(avg));
                    Particle.publish("water-plant", "watered", PUBLIC);
                    Particle.publish("toggle-led", "off", PUBLIC);
                    avg = 0;
            }
            if (avg > 2000) {
                    digitalWrite(D7, HIGH);
                    delay(1000);
                    digitalWrite(D7, LOW);
                    Particle.publish("avg_voltage_reading", String(avg));
                    Particle.publish("water-plant", "not watered", PUBLIC);
                    Particle.publish("toggle-led", "off", PUBLIC);
                    avg = 0;
            }
            j = 0;
        }
       delay(10000);
    }
}
    
//this function sums the voltage values it recieves/collects
int mVoltage(const char *event, const char *data) {
    
    value = atoi(data);
    sum = sum + value.toInt();
    j++;
        
    return sum; 
}

//this function turns on LED
void toggleLed(const char *event, const char *data) {
    
    if (digitalRead(D7) == LOW && String(data).equals("on")) {
        digitalWrite(D7, HIGH);
    }
    else if (digitalRead(D7) == HIGH && String(data).equals("off")){
        digitalWrite(D7, LOW);
    }
}