Eco-irrigate

Technical report
Maadi STEM High School for Girls
Group no.11321
Codes
// Pin Definitions
#define LED_BUILTIN 2
// Onboard LED used for system status indication.
#define Buzzer 16
// Buzzer pin for alerting users in case of high turbidity or other
conditions.
#define WATER_FLOW_SENSOR_PIN 27
// Digital pin connected to the water flow sensor.
#define TURBIDITY_SENSOR_PIN 35
// Analog pin connected to the turbidity sensor to monitor water
quality.
#define SOIL_MOISTURE_SENSOR_PIN 32
// Analog pin connected to the soil moisture sensor to measure water
content in the soil.
#define BLYNK_TEMPLATE_ID "TMPL2jNyz9NsQ"
// Blynk template ID for the project.
#define BLYNK_TEMPLATE_NAME "SoilTeam"
// Blynk template name for the project.
#define BLYNK_AUTH_TOKEN
"DGMYUK7Um7vHyFUyNkOUQ6x1NeIF0Ww6"
// Authentication token for connecting to the Blynk app.

1|Page
#include <BlynkSimpleEsp32.h>
// Library for connecting the ESP32 to Blynk.
#include <WiFi.h> // WiFi library for ESP32.
#include <WiFiClient.h> // WiFi Client library for network
communication.
#define BLYNK_PRINT Serial
// Enables Blynk debugging messages via serial monitor.

const int relay = 33;

// Pin connected to the relay module to control the water pump.
char auth[] = "*";
// Placeholder for the Blynk authentication token.
char ssid[] = "momo"; // WiFi SSID.
char pass[] = "123456789"; // WiFi password.

// Constants and Variables for Water Flow Sensor

long currentMillis = 0; // Tracks the current time for flow sensor
calculations.
long previousMillis = 0; // Tracks the previous time for flow
sensor calculations.
int flowInterval = 1000; // Interval for calculating water flow rate
(1 second).
float calibrationFactor = 4.5; // Calibration factor for converting
pulses to flow rate.

2|Page
volatile byte pulseCount; // Tracks the pulse count from the
water flow sensor.
byte pulse1Sec = 0; // Stores the number of pulses in one second.
float flowRate; // Stores the calculated water flow rate.
unsigned int flowMilliLitres; // Stores the volume of water in
milliliters.
unsigned long totalMilliLitres; // Tracks the total volume of
water used.

// Constants for Turbidity Sensor

const int turbidityThreshold = 50; // Threshold for water
turbidity in NTU.

// Variables for Soil Moisture Sensor

int soilMoistureValue; // Stores the soil moisture reading.

// Function for Water Flow Sensor Interrupt

void IRAM_ATTR pulseCounter() {
pulseCount++;
// Increments the pulse count for every pulse detected by the flow
sensor.
}

3|Page
void setup() {
// Initialize Serial Communication
[Link](115200);
// Start serial communication at 115200 baud rate for debugging.
[Link](BLYNK_AUTH_TOKEN, ssid, pass,
"[Link]", 80);
// Connect to Blynk cloud server.

// Setup Water Flow Sensor

pinMode(LED_BUILTIN, OUTPUT); // Configure onboard
LED as output.
pinMode(WATER_FLOW_SENSOR_PIN,
INPUT_PULLUP);
// Set water flow sensor pin as input with pull-up.
pinMode(Buzzer, OUTPUT); // Configure buzzer pin as
output.
pulseCount = 0; // Initialize pulse count.
flowRate = 0.0; // Initialize flow rate.
flowMilliLitres = 0; // Initialize water volume.
totalMilliLitres = 0; // Initialize total water volume.
previousMillis = 0; // Reset previous time.

attachInterrupt(digitalPinToInterrupt(WATER_FLOW_SE

4|Page
NSOR_PIN), pulseCounter, FALLING); // Attach interrupt to
count pulses.

// Initialize sensors
[Link]("Initializing sensors...");
pinMode(relay, OUTPUT); // Configure relay pin as output.
}

void loop() {
[Link](); // Run Blynk for real-time monitoring.

// Handle Water Flow Sensor

currentMillis = millis();
if (currentMillis - previousMillis > flowInterval) {
pulse1Sec = pulseCount; // Capture pulse count for the
interval.
pulseCount = 0; // Reset pulse count.

flowRate = ((1000.0 / (millis() - previousMillis)) *

pulse1Sec) / calibrationFactor; // Calculate flow rate.
previousMillis = millis(); // Update previous time.

5|Page
 flowMilliLitres = (flowRate / 60) * 1000; // Convert flow rate
to milliliters.
totalMilliLitres += flowMilliLitres;
// Accumulate total water volume.

// Debugging output for flow rate and volume

[Link]("Water Flow Rate: ");
[Link](int(flowRate)); // Integer part of flow rate.
[Link](" L/min\t");
[Link]("Total Volume: ");
[Link](totalMilliLitres);
[Link](" mL");
}

// Handle Turbidity Sensor

int turbidityValue =
analogRead(TURBIDITY_SENSOR_PIN);
// Read analog value from turbidity sensor.
turbidityValue = map(turbidityValue, 0, 4096, 100, 0);
// Map sensor value to NTU range.
[Link]("Turbidity Value: ");
[Link](turbidityValue);

6|Page
 turbidityValue > turbidityThreshold ? digitalWrite(Buzzer,
HIGH) : digitalWrite(Buzzer, LOW);
// Activate buzzer if turbidity exceeds threshold.

// Handle Soil Moisture Sensor

soilMoistureValue =
analogRead(SOIL_MOISTURE_SENSOR_PIN);
// Read soil moisture value.
soilMoistureValue = map(soilMoistureValue, 0, 4096, 100,
0);
// Map soil moisture to percentage.
[Link]("\nThe Relay will go on or off.....\n");
if (soilMoistureValue <= 20) {
digitalWrite(relay, LOW); // Turn on relay to start pump.
} else {
digitalWrite(relay, HIGH); // Turn off relay to stop pump.
}
[Link]("Soil Moisture: ");
[Link](soilMoistureValue);
[Link]("%");

// Send data to Blynk app

7|Page
 [Link](V0, soilMoistureValue); // Soil moisture
data.
[Link](V1, turbidityValue); // Turbidity data.
[Link](V2, flowRate); // Water flow rate data.

// Add delay to manage overall loop timing

[Link]();
[Link](soilMoistureValue);
[Link](",");
[Link](turbidityValue);
[Link](",");
[Link](flowRate);
[Link]();
delay(3000); // Wait for 3 seconds before the next loop iteration.
}

8|Page
Abstract
The Smart Irrigation System is a cutting-edge solution designed to optimize the use
of water in agriculture. With increasing global water scarcity and the need for more
sustainable farming practices, this project aims to provide an automated system for
irrigation that responds to the real-time conditions of the soil. The system utilizes
ESP32 microcontroller technology in combination with soil moisture, water flow,
and turbidity sensors to ensure that crops receive adequate water without over-
watering.
The project employs Blynk, a mobile app, to monitor and control the irrigation
system remotely. The system activates a water pump based on soil moisture levels,
which helps conserve water and improves overall farming efficiency. This project
not only addresses the challenge of water conservation but also demonstrates how
IoT (Internet of Things) technology can be applied to agriculture, enhancing
productivity while minimizing environmental impact.

Methods
The system consists of several key components and follows a structured approach
for its implementation:

1. ESP32 Microcontroller: The ESP32 serves as the central controller for the
system, managing sensor data, processing it, and sending commands to the
water pump.
2. Sensors:
o Soil Moisture Sensor: Measures the amount of moisture in the soil
and activate the water pump if the moisture reaches 20 % which is
dry.
o Water Flow Sensor: determine how much water is being used in
irrigation and check for blockage or any irregularities in flow.
o Turbidity Sensor: check water quality. If the turbidity reaches 50
NTU, the system triggers a buzzer to alert users about contamination.
3. Blynk Application: The Blynk app allows users to remotely monitor the
soil moisture levels, water flow, and turbidity in real-time. It also enables
manual control of the irrigation system and the water pump.
4. Water Pump: The water pump is triggered automatically when the soil
moisture drops below a preset threshold, activating the irrigation process.
5. System Integration: The sensors are connected to the ESP32, which
processes the sensor data and sends it to the Blynk app. The system is
9|Page
 powered by a stable power source, and the components are connected using
appropriate wiring and communication protocols.

Results

10 | P a g e
Analysis

11 | P a g e
12 | P a g e
Recommendation
To enhance the Smart Irrigation System, several improvements can be made. First,
integrating weather forecasting data would help adjust irrigation based on rainfall,
temperature, and humidity, preventing overwatering. Advanced soil sensors can
improve moisture monitoring across different soil types for better precision.
Remote monitoring through mobile apps or web interfaces would give farmers
more flexibility to manage schedules and receive real-time alerts. To optimize
energy usage, adding solar panels could reduce costs and make the system more
sustainable. Additional sensors, like temperature and pH, could provide more
detailed insights into crop health and soil conditions. Using machine learning to
predict irrigation needs based on data would further improve water efficiency. A
filtration system would help protect both the sensors and plants by ensuring clean
water. Regular maintenance, updates, and offering training to farmers would also
increase adoption and ensure optimal performance.

Conclusion
our Smart Irrigation System met its objectives successfully. It automates irrigation,
saves water, and ensures clean water delivery to crops. The sensors worked
accurately, with soil moisture and water flow tests showing high reliability. The
system is affordable and scalable, making it ideal for farms in water-scarce areas.
By using this technology, we can improve crop health, conserve water, and
promote sustainable agriculture.

13 | P a g e