Group 18 Fall 2023

Intelligent automatic sprinkler system monitors rainfall and ground moisture levels to prevent over watering or watering when it is raining.

AdvancedShowcase (no instructions)91

Things used in this project

Hardware components

Particle Photon 2

Telecontrolli Ceramic Capacitive Rain Sensor

DFRobot Gravity: Analog Soil Moisture Sensor For Arduino

Jumper wires (generic)

Seeed Studio Grove - Relay

Digilent Voltage Regulator Module

Digilent 60W PCIe 12V 5A Power Supply

Li-Ion Battery 1000mAh

5v Solar Panel

TinyCircuits Micro USB cable

Motorized 1 Inch 12v Ball Vavle

Software apps and online services

Particle Build Web IDE

Hand tools and fabrication machines

Soldering iron (generic)

Solder Wire, Lead Free

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Story

This project came along as an idea to conserve water. Standard automatic sprinkler systems run off a programable timer with preset watering cycles. These cycles might look like "water every other day at 7:00pm for 30 minutes". These systems are attractive in their automation for homeowners as they can water a lawn without any homeowner effort. Our design is an improvement on this system in two ways. The first being the utilization of a 1 inch mechanized ball valve to control the flow of the water. This system can be attached to a generic household spigot and a scheduled watering plan can be programmed into the system. This offers affordability and accessibility to a homeowner who is not ready to pay for an entire automatic watering system installation, a project with an average national cost of ~$2500. Instead, by attaching to a spigot, the homeowner can connect the watering system to their own setup of hoses and sprinklers as they see fit at a much lower cost. The second improvement our system adds is active monitoring of environmental and soil conditions. Our Wi-Fi enabled sensor package can be placed anywhere in a yard. It is solar powered with a 5v solar cell and a 3000 mAh battery that will charge under fair weather conditions. This unit is self-contained and self-sufficient. Two sensors are attached to this package, a rainfall sensor and a soil moisture sensor.

The programmed logic of the system works as such. The valve control package controlling the 1-inch ball valve is set to water at a scheduled and adjustable interval. For example, "water every day at 7:00pm for 30 minutes". This is the base logic that will operate if no signal inputs are received from the sensor package in the yard. What the sensor package will be monitoring for is first off, rainfall detection. If the sensor package detects rainfall, it will publish this information to the cloud. The valve control package will receive this information and skip the water cycle for that day pushing its countdown timer forward by 24 hours. The second thing the sensor package will be monitoring is soil moisture. Detecting a range of dry, damp and wet, the moisture sensor will publish to the cloud if the soil moisture is wet. When the valve control receives the information that the soil is wet, it will skip the water cycle for that day pushing its countdown timer forward by 24 hours. Bidirectional communication takes place between the valve control and the sensor package. When the valve control opens to begin a watering cycle, it publishes that a watering cycle has begun. The sensor package receives the information that the watering cycle has started and stops taking sensor measurements. This prevents the rainfall sensor from mistaking sprinkler water for actual rainfall and gives the soil moisture sensor a delay to read the new moisture level after watering.

In effect this system should be ecofriendly as a water conservation system. Additionally, the homeowner will benefit from the cost savings of not watering unnecessarily.

As for this iteration of the project. This is a fully functional prototype. The sensors, coding and functionality are meeting expectation. The primary areas that are lacking and underdeveloped are the housings, wiring and sensor quality. To develop the housing to full functionality it would need to be a weatherproof outdoor hardened casing. ideally this could be a 3d printed housing designed with consideration for the components that would be contained within it. The wiring for the system is still using a breadboard. Further development could be made using soldered connections and insulating any exposed wiring. The sensors that were used are functional but have a limited life span. As voltage is pushed through the sensors regularly, they are prone to corrosion. There are sensors that are designed to be used in sustained outdoor environments, but they are more costly. Implementation of these higher quality sensors would improve practicality of the device but would not affect functionality compared to the prototype.

1 / 6 • The sensor package

1 / 2 • Sensor Control Circuit Diagram

Code

// Constants
//Rain
int rainSensor = A2;
int blueRainLED = D2;
int redRainLED = D3;
//Soil
int soilSensor = A1;
int greenSoilLED = D4;
int yellowSoilLED = D5;
int redSoilLED = D6;
// rainSensor adjust the threshold value
int rainThresholdValue = 4000;

// Sensor 
int defaultSensorWait = 1000 * 5;

// status
bool isWaterValveOpened = false;

void setup(){
  Serial.begin(9600); // Set the serial monitor baudrate to 9600
  pinMode(rainSensor, INPUT);
  pinMode(blueRainLED, OUTPUT);
  pinMode(redRainLED, OUTPUT);
  pinMode(greenSoilLED, OUTPUT);
  pinMode(yellowSoilLED, OUTPUT);
  pinMode(redSoilLED, OUTPUT);
  digitalWrite(blueRainLED, 0);
  digitalWrite(redRainLED, 0);
  digitalWrite(greenSoilLED, 0);
  digitalWrite(yellowSoilLED, 0);
  digitalWrite(redSoilLED, 0);
  
  Particle.subscribe("WaterValveStatus", valveEventHandler);
}

void loop() {
    if (isWaterValveOpened == true) {
        delay(defaultSensorWait);
    }
    // Subscription coding
    
  //  if(read subscribe) says its raining;
  //      digitalWrite(blueRainLED, 0);
  //      digitalWrite(redRainLED, 0);
  //      digitalWrite(greenSoilLED, 0);
  //      digitalWrite(yellowSoilLED, 0);
  //      digitalWrite(redSoilLED, 0);
        
  //      ***3V3Pin OFF
  //      delay(how ever long a watering cycle is + 12 hours)
 //   else{
    
    
  // Read the input on analog pin A0:
    // Read the input on analog pin A1:
  int rainSensorValue = analogRead(rainSensor);
  int soilSensorValue = analogRead(soilSensor);
  Serial.print(rainSensorValue);
  if(rainSensorValue < rainThresholdValue){
    // If sensorValue < rainThresholdValue then it is raining
    // Send a publish to the cloud and turn the blueLED on
    // Send a publish to your devices
    Particle.publish("RainStatus","RainDetected");
        Particle.publish("WateringStatus","WateringStopped");
    Serial.println("Rain Sensor Value:");
    Serial.println(rainSensorValue);
    digitalWrite(blueRainLED, 1);
    digitalWrite(redRainLED, 0);
  }
  
  else {
    // Send a publish to the cloud and turn the redLED on
    // Send a publish to your devices
    //Particle.publish("RainStatus","NoRainDetected");
    Serial.println("Rain Sensor Value:");
        Particle.publish("WateringStatus","WateringNormal");

    Serial.println(rainSensorValue);
    digitalWrite(blueRainLED, 0);
    digitalWrite(redRainLED, 1);
  }
  
    //SOILSTARTSOILSTARTSOILSTART
    
    Serial.print(soilSensorValue);
    if(soilSensorValue >= 1000) {
 //   Serial.println("Sensor is DISCONNECTED");
//            Particle.publish("WateringStatus","WateringNormal");

    //Particle.publish("SoilStatus","SensorDisconnected");
        digitalWrite(greenSoilLED, 1);
        digitalWrite(yellowSoilLED, 1);
        digitalWrite(redSoilLED, 1);
        delay(1000);
        digitalWrite(greenSoilLED, 0);
        digitalWrite(yellowSoilLED, 0);
        digitalWrite(redSoilLED, 0);
        delay(1000);
        digitalWrite(greenSoilLED, 1);
        digitalWrite(yellowSoilLED, 1);
        digitalWrite(redSoilLED, 1);
        delay(1000);
        digitalWrite(greenSoilLED, 0);
        digitalWrite(yellowSoilLED, 0);
        digitalWrite(redSoilLED, 0);
        delay(1000);
        digitalWrite(greenSoilLED, 1);
        digitalWrite(yellowSoilLED, 1);
        digitalWrite(redSoilLED, 1);
    }
    
    if(soilSensorValue < 1000 && soilSensorValue >= 600) { 
    Serial.println("Soil is DRY");
   // Particle.publish("SoilStatus","SoilDry");
  //  Particle.publish("WateringStatus","WateringNormal");

    digitalWrite(greenSoilLED, 0);
    digitalWrite(yellowSoilLED, 0);
    digitalWrite(redSoilLED, 1);
    }
    
    if(soilSensorValue < 850 && soilSensorValue >= 370) {
    Serial.println("Soil is HUMID"); 
    //Particle.publish("SoilStatus","SoilHumid");
    digitalWrite(greenSoilLED, 0);
    digitalWrite(yellowSoilLED, 1);
    digitalWrite(redSoilLED, 0);
    }
    
    if(soilSensorValue < 800) {
    Serial.println("Soil is WET");
    Particle.publish("SoilStatus","SoilWet");
    Particle.publish("WateringStatus","WateringStopped");
    digitalWrite(greenSoilLED, 1);
    digitalWrite(yellowSoilLED, 0);
    digitalWrite(redSoilLED, 0);
  }                                          
  
  delay(2000);
}
//}

void valveEventHandler(const char *event, const char *data) {
    //char* c;
    if (strcmp(data, "ValveOpened") == 0)   {
        // Event msg equals to ValveOpened
        isWaterValveOpened = true;
        //c = "0";
    } else {
        // Event msg is not equals to ValveOpen
        isWaterValveOpened = false;
        //c = "1";
    }
    
    // For troubleshooting
    // Particle.publish("Sensor::ValveEventHandler", c);
    Particle.publish("Sensor::ValveEventHandler - isWaterValveOpened", isWaterValveOpened ? "true" : "false");
}

//ENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDENDEND

//Rain
int powerSupplyOpen = D1;
int powerSupplyClosed = D2;


// WaterSensor
bool isWatering = true;

void setup(){
  Serial.begin(9600); // Set the serial monitor baudrate to 9600
  pinMode(powerSupplyOpen, OUTPUT);
    pinMode(powerSupplyClosed, OUTPUT);

  digitalWrite(powerSupplyOpen, 0);
    digitalWrite(powerSupplyClosed, 1);

  Particle.subscribe("WateringStatus", waterSensorEventHandler);
}

void loop() {
    if (isWatering == true) {
        // Open valve
        digitalWrite(powerSupplyOpen, 1);
            digitalWrite(powerSupplyClosed, 0);

        Particle.publish("WaterValveStatus","ValveOpened");
        
        delay(15000);
        
        // Close Valve
        digitalWrite(powerSupplyOpen, 0);
            digitalWrite(powerSupplyClosed, 1);
            
        delay(10000);

        Particle.publish("WaterValveStatus","ValveClosed");
        
        // Daily cycle
        //     Delay for 24 hours minus the previous watering time
        //delay((1000 * 60 * 60 * 24) - (1000 * 60 * 30));
        delay(15000);
    } else {
        //Delay one day due to rain or soil moisture
        delay(15000);
        //delay(1000 * 60 * 60 * 24);
    }
}
    
void waterSensorEventHandler(const char *event, const char *data) {
    //char* c;
    if (strcmp(data, "WateringStopped") == 0)   {
        // Event msg equals to WateringStopped
        isWatering = false;
        //c = "0";
    } else {
        // Event msg is not equals to WateringStopped
        isWatering = true;
        //c = "1";
    }
    
    // For troubleshooting
    // Particle.publish("Sensor::waterSensorEventHandler", c);
    Particle.publish("Sensor::waterSensorEventHandler - isWatering", isWatering ? "true" : "false");
}