Team Group 23:

Matthew Marslender

•

Mljenkins

•

vnaguirre

Published November 28, 2022

UNCC IOT Project (3171 Group 23)

Have you ever had a problem keeping your plant at home healthy? Check out this monitoring system to ensure a healthy plant life.

IntermediateWork in progress236

Things used in this project

Hardware components

Particle Argon

Jumper wires (generic)

Solderless Breadboard Half Size

DFRobot Gravity: Analog Capacitive Soil Moisture Sensor- Corrosion Resistant

Photo resistor

DHT11 Temperature & Humidity Sensor (4 pins)

Resistor 220 ohm

LED (generic)

Software apps and online services

Particle Build Web IDE

Hand tools and fabrication machines

TinyUSB Library by Adafruit

Story

Choosing a topic:

Our group started out by brainstorming common problems that we shared. From there we found that we all have plants that tend to have a short span of life. The idea of a soil moisture sensor came to us when we talked about how we all forget to water our plants. We then narrowed down the list further by deliberating solutions that seemed attainable to implement.One could simply set an alarm to water the plant everyday, but if someone has multiple plants that require different levels of moisture, this would mean setting multiple alarms. However, if one used an Argon to test the moisture level in the soil and set a threshold, the threshold value could be changed specific to the needs of the plant. Technology and information for maximizing soil health was widely abundant on the internet, and we determined it to be possible to use the Argon to accomplish this goal.

Getting started:

We started by researching what sensors could be used to measure soil moisture and what sensors could be used in conjunction with soil moisture. We found both a resistive soil sensor and capacitive soil sensor currently in the market. The capacitive soil sensor was the most manageable to install and conscientious, so we decided to utilize this sensor. As the moisture (water) of the soil increases, the voltage increases.

The second sensor we decided on was the DHT 11 temperature and humidity sensor. We are measuring the temperature and humidity because this is also another important factor in determining how well a plant will grow. The most adequate temperature is a dependent on the plant, which is why the Argon project is ideal because the threshold values can be changed depending on the plant in question.

The third sensor we decided to use was a photoresistor because it could accurately tell the level of sunlight a plant was getting. Knowing the relative amount of sunlight a plant was getting, we could find the optimal spot in a house where the plant gets the daily sunlight it needs.

Once we established these four sensors, we started researching how to employ these sensors in conjunction with the Argons and found codes similar enough to our project to be utilized with minute changes.

Setup:

In this project we are using three different Argons with three different sensors. Argon 1 includes the capacitive soil moisture sensor and initiates the data collection and sends the message to the cloud. Once the other argons receive this message they toggle their LED’s. Argon 2 begins to collect the data while Argon 3 begins to process the data. All three of the Argons are communicating between each other, and the result is a voltage value that is being graphed live with the use of Adafruit. Our setup also includes a photoresistor sensor paired with an LED, and a DHT 11 temperature and humidity sensor. Argon 1 is set up with a photoresistor and a LED, this Argon will also detect whether it is sunny or not outside. The LED will turn on if it is not sunny out and will turn off as soon as it detects light, this message will then be sent to the cloud. Argon 3 also includes the DHT 11 temperature and humidity sensor. The code is set up to detect temperature and humidity and indicate to the cloud whether it is too humid or too hot.

Capacitive soil sensor.

Photo-resistor sensor paired with LED.

DHT 11 temperature and humidity sensor.

Results:

Overall the project was a success and everything is working as it should. Our group was able to successfully plot the readings of the soil moisture sensor using Adafruit.

The photoresistor in conjunction with the LED is also working as expected as the photoresistor will send us “sunny” or “not sunny” depending on the amount of sunlight the plant is receiving. The LED will also turn on when it “is not sunny” and turns off when it is “sunny” for a visual indicator.

Lastly, the DHT 11 temperature and humidity sensor is accurately measuring the temperature of the soil and sends whether the soil is too hot. A lower threshold temperature could also be set if needed.

Conclusion:

We had several plants over the years, and inevitably all of them die because we forget to water them. Using this project, we don’t have to remember to water them because the Argon will tell me. One of the things that make this project so versatile is that someone can utilize the same code and setup for multiple plants by tailoring the threshold values to the specific plant. Furthermore, this project could be taken a step further by integrating an automatic watering system in conjunction with another Argon and water solenoid. This way, you don't have to worry about watering the plants at all. As long as the solenoid is connected to a flowing water source, the valve can open and close depending on the soil moisture measured by the Argon and the threshold values set.

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);
    Particle.subscribe("hook-response/mvoltage_reading ", myHandler, MY_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) {
  //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);
  // data is in counts out of 4096, so it needs to be converted to voltage
  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
  String data = String(mVoltage);
  //Trigger the integration
  Particle.publish("mvoltage_reading ", data, PRIVATE);
            i++;
            
  //Wait 10 seconds
  delay(10000);
        }
    
}
void myHandler(const char *event, const char *data) {
  // integration response
}

//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 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(10000);
  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;

///Photo
int led1 = A5;
int led2 = D7;
int photoresistor = A0;
int analogValue;

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(10000);
                    digitalWrite(D7, LOW);
                
                    Particle.publish("toggle-led", "on", PUBLIC);
                    avg = 0;
            }
            if (avg > 2000) {
                    digitalWrite(D7, HIGH);
                    delay(10000);
                    digitalWrite(D7, LOW);
                    
                    Particle.publish("toggle-led", "off", PUBLIC);
                    avg = 0;
            }
            j = 0;
        }
       delay(60000);
    }
}
    
//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);
    }
}

//LED light connected to A5 and ground 
int led1 = A5; 

//LED on the Argon 
int led2 = D7; 

//Photoresistor connected to A0 pin that detects light 
int photoresistor = A0;
int analogValue;

void setup() {

  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(photoresistor, INPUT);

}

//Loop constructed to read analog value of the photoresistor and digital 
//write to the LEDs in the circuit. Particle.publish is used twice to publish 
//an event both when light is detected and when it is not. 
void loop() {
    analogValue = analogRead(photoresistor);
    
//if statement below can be changed to adjust how sensitive the photoresistor is to light
    if (analogValue > 15) {
        digitalWrite(led1, LOW);
        digitalWrite(led2, LOW);
        Particle.publish("SUNNY", "0", PUBLIC);
        delay(7000);
    } else {
        digitalWrite(led1, HIGH);
        digitalWrite(led2, HIGH);
        Particle.publish("NOT-SUNNY", "1", PUBLIC);
        delay(7000);
    }
}

// This #include statement was automatically added by the Particle IDE.
#include <PietteTech_DHT.h>
#define DHTTYPE  DHT22
#define DHTPIN   D4

PietteTech_DHT DHT(DHTPIN, DHTTYPE);

double serverTempMax = 81;
double serverHumidityMax = 60;
double serverTemp;
double serverHumidity;
bool overheatDetected = false;
bool tooHumid = false;

void setup ()
{
    Particle.variable("serverTemp", &serverTemp, DOUBLE);
Particle.variable("serverHumidity", &serverHumidity, DOUBLE);

}

void loop()
{
     int result = DHT.acquireAndWait(2000);
  
  serverTemp = DHT.getFahrenheit();
  serverHumidity = DHT.getHumidity();
  
  if(serverTemp>=serverTempMax && !overheatDetected){
      Particle.publish("server_temp", "HOT");
      overheatDetected = true;
  }
  else if(serverTemp<serverTempMax && overheatDetected){
      Particle.publish("server_temp", "normal");
      overheatDetected = false;
  }
  
  if(serverHumidity>=serverHumidityMax && !tooHumid){
      Particle.publish("server_humidity", "HUMID");
      tooHumid = true;
  }
  else if(serverHumidity<serverHumidityMax && tooHumid){
      Particle.publish("server_humidity", "normal");
      tooHumid = false;
  }
  
  delay(10000);
}