Overview
Video Overview and Demonstration with ThinkSpeak integration
Development
Remote Monitoring via Thinkspeak

Published April 25, 2021 © GPL3+

Remote Plant Monitor

Simple IoT project with two Particle Argons. One measures soil moisture, the other raises an alert flag.

BeginnerFull instructions provided2 hours158

Things used in this project

Hardware components

Particle Argon

SparkFun Soil Moisture Sensor (with Screw Terminals)

Solderless Breadboard Full Size

SG90 Micro-servo motor

Mechanical Endstop Limit Switch

JBtek Breadboard PSU 3.3V/5V

12V DC power adapter 5.5mm x 2.1mm barrel plug

3D Printed Casing

Software apps and online services

Particle Build Web IDE

ThingSpeak API

Fritzing Circuit Design

Solidworks

Hand tools and fabrication machines

3D Printer (generic)

Story

Overview

Inspired by our inability to keep houseplants alive, and enabled by a course at UNCC (MEGR 3171), we developed a system to notify you when your plant needs watering. Our system consists of 2 parts. Part 1 uses a Sparkfun soil moisture sensor to monitor the plants moisture. When part 1 determines the soil is dry, it send a signal using particle.publish to the second part of the system. Part 2 consists of a flag on a servo and a limit switch, which raises the flag if the soil is deemed too dry by the first part of the system. When the limit switch is tripped on part 2, part 1 is reset and will resume looking for when the soil is dry.

1 / 4 • Both the moisture sensor and notification flag system

Video Overview and Demonstration with ThinkSpeak integration

Development

Our development process consisted of independently developing the 3D printed parts and the Argon code. The code development consisted to leaning how to uses each aspect of the final product independently. This included testing servo control, particle.publish/subscribe, and the moisture sensor independently. The most important testing that took place was the tests on the moisture sensor because it is critical to the success our project. As a result, we performed two tests on the moisture sensor, one test to simulate a relatively constant soil moisture and another to simulate the moisture loss of an actual plant. The first test consisted of a moisture sensor connected to an Argon that sent the raw moisture data to the Particle Console every hour. The sensor was placed indoors in a non-humidity controlled environment, in heavily saturated clay soil.

As shown in the graphed results, several hours of sensor data was lost due to the Particle Console not saving data sent to it when the computer running the console is not constantly awake. This test also demonstrated that the sensor had high variance and is somewhat dependent on humidity, as the environmental humidity increased at the start of day 3. Test 2 took place indoors in a sunny, humidity controlled environment and the plant was watered at the start of day 3. The code for this test was identical to the previous test.

Like the previous test, some data was lost due to the Particle Console. This test also showed the moisture sensor had a high degree of variance. As a result, we concluded that a form of signal processing was needed. We also concluded that, for that particular plant and composition of soil, a sensor values of around 3130 is considered dry soil. We decided that 3 out of the last 5 sensor values must be below the set threshold to activate the notification flag in order to prevent false positives.

Once this test was competed, the individual parts of the final code was combined to form that is the final code. In the final code for the moistures sensor Argon, the Argon reads the sensor value every hour and determines if 3 of the last 5 sensor values are below the threshold. If the that is true, the Argon sends a signal that tells the other Argon that the soil is dry. The moisture sensor argon repeats that signal every hour to safeguard against the notification Argon missing the first dry flag and never activating.

The once the notification Argon receives the dry flag from the sensor Argon though particle.subscibe, the servo activates and puts the flag up to notify the user that the plant is dry. Around every hour, the servo returns to its intended position, up or down, in order to prevent confusion if the flag gets moved accidentally. The moisture sensor resets when the flag is manually rotated down and touches the limit switch. The servo then moves up slightly to indicate that the reset is received.

Remote Monitoring via Thinkspeak

View of our thinkspeak channel

An important tool for remote monitoring it the ability to remotely view the status of the system. In this project we used Thinkspeak integration and Particle Webhooks. We are outputting the percentage of the threshold in order to prevent confutation if the user does not remember his/her threshold. As such, any value under 100% is under the threshold.

Schematics

Code

int threshold = 3130; //sensor value where soil is considered dry 
int dry = 0;// 
int count_1 = 4000; //setting inital values for the stored sensor values well above threshold to stop the dry flag from triggering of the inital values 
int count_2 = 4000; // each of these counts represent a moisture sensor value for one loop
int count_3 = 4000; // each loop, the current sesor calues is moved to the next count and the next sensor value is assigned to count_1
int count_4 = 4000;
int count_5 = 4000;
int moisture_percent = 100;
int num_under = 0; // number of the past 5 sensor values that are under the  dry threshold 

void setup() {//Runs once upon initialization
  pinMode(18, INPUT);// Connect Moisture sensor to A1
  Particle.subscribe("restart", restart);// listen for restart flag from other argon 
  // when flag is recieved 
}

void loop() {//Runs Repeatedly 
    num_under = 0;//resets the number of sensor values under 
    count_5 = count_4;  // Assign the previous sensor value to the next count. 
    count_4 = count_3;  // Ex . [1300, 4000, 40000, 0, 0] --> [1300, 1300, 0, 0, 0]
    count_3 = count_2;  
    count_2 = count_1;
    count_1 =  analogRead(18); // Read sensor  value and assign it to count 1 Ex. [1400, 1300]
    moisture_percent = 100 * count_1 / threshold;
    Particle.publish("moisture sensor", String(moisture_percent));
    delay(100); 

    if (dry == 0){ // only runs if the dry flag is not activated 
        if (count_1 <= threshold){ // counts the number of sensor values under threshold 
            num_under = num_under + 1; // Ex count 1 less than or equal to threshold --> num_under increaces by one 
        }
        if (count_2 <= threshold){
            num_under = num_under + 1;
        }
        if (count_3 <= threshold){
            num_under = num_under + 1;
        }
        if (count_4 <= threshold){
            num_under = num_under + 1;
        }
        if (count_5 <= threshold){
            num_under = num_under + 1;
        }
        if (num_under >= 3){ // if the total number of sensor values under threshold is greater than or equal to 3... 
            dry = 1;         // the dry flag is set to 1 (true)
        } 
    }
    
    Particle.publish("Dry flag", String(dry)); 
    // the status of the dry flag is always sent to the other argon every loop so if the other argon is 
    // not conncted when the flag switchs from false (0) to true (1), the other argon will still activate the servo nofification

    delay(3600000); // 10 sec loop time

}



void restart(const char *event, String data){ // Runs only when the restart flag is updated by the other argon which is when the flag is detect to be placed in the down position 

   dry = 0; //sets the dry flag to false(0)
   //the argon will continue counting sensor values under threshold with dry set back to false 
   count_1 = 4000;  
   count_2 = 4000; 
   count_3 = 4000; 
   count_4 = 4000;
   count_5 = 4000;
}

Servo myservo;
int servo_up = 0; // a True/False variable indication of if the servo should be in the up or down position
int cycle = 0; // number of cycles for 
 
void setup() {
 pinMode(8, INPUT); // pin D8 limit switch wiring 
 myservo.attach(A1);// servo pwm connected to in A1
 Particle.subscribe("Dry flag", servoup); //listen for the dry flag to be updated then run the servoup function 
}

void loop() { 
    int restartinv =  digitalRead(8); // for the button I'm using to test, 0 is pressed and 1 is unpressed 
    int restart;                      // uninverted restart variable
    if (restartinv == 0){ // these if fuctions convert the inverted restart variable to the expected 1 == true and 0 == false
       restart = 1;
    }
    if (restartinv == 1){
       restart = 0;
    }
    
    cycle = cycle + 1; // redundancy if the flag is moved down or up unintentionally 
                       // we do not want the servo to move back to its intended position every loop so 
    if (cycle == 3600){  // this function only runs every n number of cycles (activates every hour) 
        cycle = 0; // restart cycle number
        if (servo_up == 0){ // if servo is suppose to be down, move the servo down
            myservo.attach(A1); // attach the servo the A1 
            myservo.write(10); //move the servo position down 
            delay(1000); // allow 1 sec for the servo to move
            myservo.detach(); // diconnect the servo so it can be moved by hand
        }
        if (servo_up == 1){ // repeat of previous loop but for the up position
            myservo.attach(A1);
            myservo.write(90); 
            delay(1000);
            myservo.detach();
        }
    }
    if (restart == 1){//this part of the code sends the signal for the other argon to look for dry soil again and move the notification servo up 
        delay(5000); //delay to allow the user to be clear from the servo before it moves
        Particle.publish("restart", String(restart)); // send the restart flag to the other argon
        myservo.attach(A1);    // moving the servo 
        myservo.write(10);     // set servo to a positon slightly above the switch to indicate the reset is recieved 
        delay(1000);           // allow time for the servo to move
        myservo.detach();      // diconnect the servo so it can be moved by hand
        servo_up = 0;          // sets servo position to down 
        delay(20000);          // allows dry flag to reset on the other argon before resuming looking for button press will need to be modified if the other argons loop time is increaced 
    }
    delay(1000);// changes loop time, about 1 sec 
}

void servoup(const char *event, String data){
    int dry = String(data).toInt(); // converting the published string to an integer
    if (dry == 1 && servo_up == 0 ){// if the other argon says the soil is dry and the servo is down 
        myservo.attach(A1);// put the servo up
        myservo.write(90); 
        delay(1000);
        myservo.detach();
        servo_up = 1; 
    }
}

Credits

cody davis

1 project • 0 followers

Krishna Mathavan

1 project • 0 followers

Remote Plant Monitor