Sistema Automático de Riego para Plantas: Diseño de Circuito, Código y Reporte de Proyecto

Sistema Automático de Riego para Plantas – Código Fuente Completo, Circuito e Informe de Proyecto – Descarga PDF

Introducción

En las operaciones diarias relacionadas con el riego de plantas, esta es la práctica cultural más importante y la tarea que más mano de obra requiere. Independientemente del clima, ya sea demasiado caluroso, frío, seco o húmedo, es crucial controlar la cantidad de agua que llega a las plantas. Por ello, es eficaz usar un sistema automático de riego que riegue las plantas cuando lo necesiten. Un aspecto importante de este proyecto es: "cuándo y cuánto regar". Para reducir la actividad manual humana en el riego, se adopta la idea de un sistema automático. El método empleado monitorea continuamente el nivel de humedad del suelo y decide si se necesita regar o no, y cuánta agua necesita el suelo de la planta. Este proyecto puede agruparse en subsistemas como: fuente de alimentación, relés, válvula solenoide, shield GSM Arduino, sensor de humedad del suelo y LCD.

Esencialmente, el sistema está diseñado y programado de modo que el sensor de humedad del suelo detecta el nivel de humedad de las plantas en un instante determinado; si el nivel de humedad del sensor es inferior al valor umbral predefinido (según la necesidad de agua de la planta específica), se suministra la cantidad deseada de agua hasta que alcanza el valor umbral predefinido.

El sistema informa de su estado actual y envía mensajes de recordatorio sobre el riego de las plantas y para añadir agua al tanque. Todas estas notificaciones se realizan mediante el shield GSM de Arduino.

Objetivo del Proyecto

Hoy en día, en la era de la tecnología avanzada y la electrónica, el estilo de vida humano debería ser inteligente, más simple, fácil y conveniente. Por tanto, existe la necesidad de muchos sistemas automatizados en la rutina diaria para reducir actividades y trabajos. Aquí, la idea de un sistema automático de riego es muy útil. Muchas personas tienen problemas para regar las plantas del jardín, especialmente cuando están fuera de casa. Este modelo usa tecnologías de sensores con microcontrolador para crear un dispositivo de conmutación inteligente que ayude a millones de personas.

En su forma más básica, el sistema se programa para que el sensor de humedad detecte el nivel de humedad de la planta en un instante; si el nivel es inferior al umbral predefinido según la planta, se suministra agua hasta que el nivel de humedad alcanza el umbral. El sistema incluye sensores de humedad y temperatura que monitorizan la atmósfera actual e influyen en cuándo regar. La válvula solenoide controla el flujo de agua; cuando Arduino lee el valor del sensor de humedad, acciona la válvula según la condición deseada. Además, el sistema informa de su estado y envía recordatorios sobre el riego y recibe SMS del destinatario. Todo esto mediante el shield GSM de Arduino.

Antecedentes del Sistema

Se ha estudiado en la escuela que las plantas son imperativas para la humanidad en muchos aspectos, manteniendo el ambiente limpio produciendo oxígeno fresco. Los sistemas automáticos de riego se han vuelto más comunes con el auge de objetos cotidianos conectados a tecnologías avanzadas, implementándose a gran escala en hogares e industria. Su principal uso es la eficiencia y facilidad de uso.

El sistema de riego permite a los amantes de las plantas cuidar sus plantas de interior mientras están fuera, mediante componentes eficientes y fiables como diferentes tipos de sensores.

Existen varios tipos de sistemas de riego para interior, según el nivel de automatización necesario.

En el informe PDF final (enlace de descarga gratuita al final), se describen detalladamente las siguientes secciones:

• Globos y Puntas de Riego para Plantas
• Sistema de Riego por Goteo Interior
• Tecnología de Sensores
• Sensores de Temperatura y Humedad
• Sensor de Temperatura
• Sensores de Humedad
• Sensores de Humedad del Suelo
• Termostato Bimetálico
• Termistor
• Detectores de Temperatura por Resistencia (RTD)
• Termopares
• CIs de Sensores, LM35
• Sensor Digital de Temperatura (ADT7301)
• DHT11 y DHT22
• Módulo GSM
• Arquitectura GSM
• Relé
• Transistor
• LCD Hitachi 16×2

Especificaciones de Productos y Componentes

ID de Requisito	SRS-GSM-001
Título	Módulo GSM
Descripción	El sistema incluye el módulo GSM, que envía SMS de alerta al destinatario y recibe SMS del usuario.
Versión	Versión 1.0

ID de Requisito	SRS-Microcontrolador-001
Título	ATmega328p
Descripción	El sistema incluye el microcontrolador que suele venir con Arduino Uno. Este lee las lecturas del sensor y controla el sistema general.
Versión	Versión 1.0

ID de Requisito	SRS-Temperatura y Humedad-001
Título	DHT11
Descripción	El sistema incluye el sensor de temperatura y humedad, que monitoriza los valores actuales de temperatura y humedad del entorno y envía la lectura al microcontrolador.
Versión	Versión 1.0

ID de Requisito	SRS-Humedad-001
Título	Sensor de Humedad de Suelo Grove
Descripción	El sistema incluye el sensor de humedad del suelo, que toma la lectura de la humedad del suelo y la envía al microcontrolador.
Versión	Versión 1.0

ID de Requisito	SRS-LCD-001
Título	LCD Hitachi 16×2
Descripción	El sistema incluye la interfaz LCD para el usuario, que muestra las lecturas tomadas por los diferentes sensores del sistema.
Versión	Versión 1.0

Sistema Automatizado de Riego Basado en Arduino

Diagrama de Bloques del Riego Automático

Diagrama Esquemático del Circuito de Riego Automático

Según este sistema hay dos componentes funcionales: sensor de humedad y motor/bomba de agua. En su forma básica, el sensor de humedad detecta el nivel de humedad del suelo. Luego el motor/bomba suministra agua a las plantas.

Haga clic en la imagen para ampliar

El esquema describe el comportamiento general del sistema. El proyecto usa Arduino Uno para controlar el motor. Consiste en un puente H que controla el sentido de giro del servomotor. El sensor de humedad mide el nivel del suelo y envía la señal a Arduino; luego Arduino abre el servomotor si se requiere riego. Entonces el motor/bomba suministra agua a las plantas hasta alcanzar el nivel de humedad deseado.

En el prototipo, el sensor de humedad detecta el nivel y envía la señal a Arduino, que abre la bomba de agua con ayuda del puente H y riega la planta. Esto se hace usando el software Arduino IDE.

Diseño del Proyecto

Esta sección trata sobre el trabajo realizado en diseño de software y hardware. También profundiza en lo que incluye el sistema y por qué se eligieron diferentes componentes para un sistema automatizado de riego completo. Considere el diagrama que muestra el modelo conceptual básico con los componentes elegidos.

La funcionalidad del diagrama de bloques se ilustra a continuación:

• El sistema incluye módulo GSM que envía SMS al destinatario y recibe SMS.
• Usa sensores de humedad del suelo, temperatura y humedad.
• Incluye válvulas solenoides junto con circuito solenoide que controla el flujo de agua a través de ellas.
• El sensor de humedad determina el nivel de humedad de la planta. Este nivel es leído por el microcontrolador, que verifica en bucle si el valor del sensor está por encima del umbral. Si el valor está por encima del predefinido, el módulo GSM está listo para enviar un SMS.
• El sensor de temperatura y humedad determina si hace demasiado calor para la planta o la humedad es demasiado alta. Esto es leído por el chip ATmega328p en Arduino Uno. Estas lecturas se usan para determinar si todas las válvulas solenoides del sistema deben estar Encendidas o Apagadas.

Más detalles de componentes en el archivo PDF (abajo).

Diseño de Hardware

Esquemático de Sensores

La figura muestra el esquema del circuito de sensores. Todos los sensores conectados a pines analógicos A0-A3 de Arduino. Pin A0 reservado para sensor de temperatura y humedad; pines A1-A3 para sensores de humedad. Todos tienen alimentación común 5V y Tierra como se muestra.

Esquemático de LCD

La figura muestra el esquema del LCD. Pines digitales 8–13 reservados para LCD. Pin 1 y 3 son alimentación y tierra; pin 2 es contraste, conectado a potenciómetro. Es crucial conectar pines digitales de Arduino y pines de datos de LCD en el orden correcto, de lo contrario el LCD mostrará basura.

Esquemático de Solenoide

El diagrama muestra el circuito del solenoide. Pines digitales 4–7 reservados para solenoides. El circuito usa relés, transistores, resistencias y LEDs en lugar de solenoides (CadStar no tiene símbolo de solenoide). Los relés usan 5V. 5V también va al canal NA de los relés porque en el esquema los LEDs reemplazan a los solenoides funcionando a 5V seguidos de resistencia de 220 ohmios.

Cuando se aplica voltaje a la base de los transistores, estos conmutean a tierra permitiendo que la bobina del relé se magnetice y conmute a canal NC, encendiendo el LED conectado. Cuando el voltaje en la base cae, el transistor vuelve a su estado normal, la bobina se desmagnetiza y el relé conmuta a canal NA, apagando el LED.

Tras terminar todos los esquemáticos, el siguiente paso es construirlos en placa de tiras (Veroboard). Es importante diseñar el circuito en hoja de planificación de layout de tira de antemano, siguiendo ciertos principios:

1. Marque primero las líneas de alimentación Vs y GND en la esquina superior derecha de la hoja de planificación.
2. Recuerde cortar la pista entre los pines de un CI. Marque los cortes con una X.
3. Intente que resistencias y condensadores axiales queden planos en la placa. Resistencias suelen requerir hueco de 4 agujeros, condensadores de 8.
4. Si es posible, numere los pines de los CIs. El lado inferior de la Veroboard tiene pistas de cobre horizontales. Diferentes diseños de Veroboard de los esquemáticos anteriores se muestran a continuación.

Diseño de Software

Tras completar el hardware, es hora de probarlo con software. En esta sección se describe en detalle la implementación del diseño de software para cada tecnología de automatización usada. Incluye el código de Arduino escrito y subido.

Lo primero fue hacer funcionar el circuito del solenoide y cómo actuaría desde la perspectiva del microcontrolador. Para ello, se hizo un pequeño diagrama de flujo (ver sección de flujo de software).

Se usó Arduino IDE para subir el software. Para el circuito básico del solenoide, se escribió un programa simple que parpadea el LED cada 1 seg. Pines digitales 4, 5, 6 y 7 definidos inicialmente para probar el programa y el circuito. Al ejecutarse, hace todas las inicializaciones, define pines de salida en void setup() y entra en void loop() parpadeando LEDs cada 1 seg.

Después, se escribió y subió un programa que lee los sensores e imprime en el LCD. Para ello, otro diagrama de flujo (ver figura). Al entrar en void loop(), obtiene lecturas, hace cálculos e imprime en LCD.

Luego, se subió el software para el módulo GSM, permitiendo comunicación con el microcontrolador. Se hizo prueba de módem (inicialización básica, librerías GSM, obtención de IMEI y verificación de funcionamiento). Luego prueba de conexión de red (inicializa GSM y muestra redes soportadas).

Una vez probado el GSM, se usa para comunicar con el destinatario: enviar y recibir SMS. Para ello, se escribió y subió otro programa simple. El programa inicializa GSM y envía SMS; otro programa recibe SMS del usuario final.

Finalmente, una vez todo el diseño de software hecho, se fusionan todos en un software final funcional. Se aplicaron diferentes enfoques algorítmicos (ver sección de flujo de software) para que el software final funcione y haga lo que debe. La figura muestra el funcionamiento del software final: toma lectura, envía SMS, recibe SMS y continúa.

Nota: Todo el código de software puede verse en el apéndice abajo.

NOTA: La salida de la prueba de módem y conexión de red no se incluyó en el informe porque el informe real se hizo después de la entrega del hardware.

Construcción y Pruebas de Software del Proyecto

Tras completar con éxito el diseño de hardware y software, llega la construcción y pruebas. En esta sección se detalla cómo se implementaron y probaron los diferentes diseños de hardware. También se habla de problemas ocultos en el código que fue importante solucionar para construir el proyecto con éxito. El proceso paso a paso puede verse en el informe completo en PDF abajo.

Pruebas de Software

La fase de pruebas de software es un aspecto importante del desarrollo. Es un procedimiento de ejecución de un programa con el objetivo de encontrar errores. También puede expresarse como el proceso de validar y verificar que un programa cumple sus requisitos técnicos, funciona como se espera y puede ejecutarse con las mismas características. Para las pruebas se adoptaron diferentes enfoques. Se escribió un documento de Especificación de Requisitos de Software (SRS) que abordaba completamente el comportamiento esperado del sistema.

ID de Requisito	SRS-Sensor-010
Título	Sensor
Descripción	Los sensores del sistema toman lecturas y las envían al microcontrolador.
Versión	V 1.0

ID de Requisito	SRS-Datos-020
Título	Visualización de Datos
Descripción	Cuando el usuario intenta obtener lecturas del sistema, la pantalla debe mostrar datos: temperatura, humedad y lecturas de humedad.
Versión	V1.0

ID de Requisito	SRS-Microcontrolador-030
Título	Microcontrolador
Descripción	El microcontrolador actúa como cerebro del sistema gestionando todo.
Versión	V1.0

ID de Requisito	SRS-Latch-040
Título	Latch
Descripción	El latch expande los pines digitales del microcontrolador.
Versión	V1.0

ID de Requisito	SRS-GSM-050
Título	GSM
Descripción	El sistema reaccionará enviando un SMS de alerta al destinatario cuando el microcontrolador se lo indique.
Versión	V1.0

Tras escribir el documento SRS, el diseño de software pasó a fase de pruebas estáticas, que incluye revisión del documento. Aquí ocurre la verificación de requisitos. Hay cuatro métodos de verificación:

1. Inspección (I): verificación visual o de control
2. Análisis (A): verificación basada en evidencias analíticas
3. Demostración (D): verificación de características operativas, sin medición cuantitativa
4. Prueba (T): verificación de características cuantitativas con medición cuantitativa. Para cada requisito del SRS, se define un método con abreviatura I, A, D, T.

Verificación

ID de Requisito	Título del Requisito	Método
REQ-010	Verificar que los sensores del sistema obtienen lecturas	I
REQ-020	Verificar que los datos se muestran en pantalla	D
REQ-030	Verificar que el microcontrolador gestiona/trabaja correctamente dando 100% resultado para cada petición	D
REQ-040	Verificar que el circuito latch hacía lo supuesto: toma 3 entradas y saca 8 pines	A
REQ-050	Verificar que el SMS ha sido enviado y recibido por GSM	D

Resultados

Todas las pruebas se realizaron con resultados satisfactorios. No hay un resultado particular que documentar. El sistema trabaja con sensores de humedad y DHT11 (temperatura y humedad) que toman lecturas según la temperatura y humedad actuales. Las lecturas del sensor de humedad también dependen del nivel actual de humedad de la planta. En general, el resultado funcional del circuito fue bueno.

Código de Software Final y Completo para Sistemas Automáticos de Riego

Nota: Más códigos relacionados con el proyecto pueden encontrarse en el PDF: código de prueba de válvula solenoide, código de prueba de sensores, código de prueba de módem GSM, código de conexión de red GSM, código de envío de SMS de alerta GSM, código de recepción de SMS GSM.

Código Final del Proyecto Auto Watering Plants

#include <dht.h>
#define dht_dpin A0
dht DHT;
//———————–
#include <LiquidCrystal.h>
LiquidCrystal lcd (8, 9, 10, 11, 12, 13);
//———————————-
int plantPotMoisture[3] = {A1, A2, A3};
//———————
#include <GSM.h>
#define PINNUMBER ""
GSM gsmAccess;
GSM_SMS sms;
char remoteNumber[] = "0899506304";
String moistureMessage = "Moisture is Low on sensor: ";
String SMS_Alert = "Sending SMS!";
String humidityMsg = "Humidity is High. Open All Solenoids";
String tempMsg = "Temperature is too HIGH!..Open ALl Solenoids ";
String messageBuffer = "";
char senderNumber[20];
String stringOne = "Opens1";
String stringTwo = "Opens2";
String stringThree = "Opens3";
String stringFour = "OpenAll";
//—————
#define solenoidData 5
#define solenoidClockster 4
#define solenoidLatch 6
//—————
const int master = 0;
const int slave1 = 1;
const int slave2 = 2;
const int slave3 = 3;
boolean takeReadings = true;
int serialSolenoidOutput = 0;

void setup() {
  pinMode(solenoidData, OUTPUT);
  pinMode(solenoidClockster, OUTPUT);
  pinMode(solenoidLatch, OUTPUT);
  digitalWrite(solenoidLatch, HIGH);
  digitalWrite(solenoidLatch, LOW);
  shiftOut(solenoidData, solenoidClockster, MSBFIRST, 0);
  digitalWrite(solenoidLatch, HIGH);
  //————————-
  Serial.begin(9600);
  lcd.begin (16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Wait Until");
  lcd.setCursor(0, 1);
  lcd.print("GSM Initialized!");
  boolean notConnected = true;
  while (notConnected) {
    if (gsmAccess.begin(PINNUMBER) == GSM_READY)
      notConnected = false;
    else {
      Serial.println("Not connected");
      delay(1000);
    }
  }
}

void loop() {
  if (takeReadings) {
    moistureSensor();
    TempAndHumidity();
    if (DHT.humidity > 50 || DHT.temperature > 25 && takeReadings) {
      takeReadings = false;
      if (DHT.humidity > 50) {
        sendSMS(humidityMsg);
      } else if (DHT.temperature > 25) {
        sendSMS(tempMsg);
      }
      while (!takeReadings) recieveSMS();
    }
    if (plantPotMoisture[0] > 30 || plantPotMoisture[1] > 30 || plantPotMoisture[2] > 30 && takeReadings) {
      takeReadings = false;
      if (plantPotMoisture[0] > 30) {
        sendSMS(moistureMessage + "1");
      } else if (plantPotMoisture[1] > 30) {
        sendSMS(moistureMessage + "2");
      } else {
        sendSMS(moistureMessage + "3");
      }
      while (!takeReadings) recieveSMS();
    }
  }
}

void moistureSensor() {
  for (int i = 0; i < 3; i++) {
    lcd.clear();
    plantPotMoisture[i] = analogRead(i);
    plantPotMoisture[i] = map(plantPotMoisture[i], 550, 0, 0, 100);
    Serial.print("Moisture" + i);
    lcd.print("Moisture" + i);
    Serial.print(plantPotMoisture[i]);
    lcd.print(plantPotMoisture[i]);
    Serial.println("%");
    lcd.print("%");
    delay(1000);
  }
}

void TempAndHumidity() {
  DHT.read11(dht_dpin);
  lcd.setCursor(0, 0);
  lcd.print("Humidity=");
  Serial.print("Current humidity = ");
  Serial.print(DHT.humidity);
  lcd.print(DHT.humidity);
  lcd.print("%");
  Serial.print("%");
  Serial.print("temperature = ");
  Serial.print(DHT.temperature);
  Serial.println("C");
  lcd.setCursor(0, 1);
  lcd.print("temp=");
  lcd.print(DHT.temperature);
  lcd.print("C ");
  delay(1000);
  lcd.clear();
}

void sendSMS(String messageToSend) {
  Serial.print("Sending a message to mobile number: ");
  Serial.println(remoteNumber);
  Serial.println("SENDING");
  lcd.print(SMS_Alert);
  Serial.println();
  Serial.println("Message:");
  Serial.println(messageToSend);
  sms.beginSMS(remoteNumber);
  sms.print(messageToSend);
  sms.endSMS();
  Serial.println("\nCOMPLETE!\n");
  lcd.clear();
  lcd.print("Completed!!!");
}

void recieveSMS() {
  char c;
  if (sms.available()) {
    lcd.clear();
    lcd.print("Message received from:");
    delay(800);
    lcd.clear();
    sms.remoteNumber(senderNumber, 20);
    lcd.print(senderNumber);
    while (c = sms.read()) {
      Serial.println(c);
      messageBuffer += c;
    }
    Serial.println(messageBuffer);
    if (messageBuffer == stringOne) {
      toggleSolenoid1();
      takeReadings = true;
    } else if (messageBuffer == stringTwo) {
      toggleSolenoid2();
      takeReadings = true;
    } else if (messageBuffer == stringThree) {
      toggleSolenoid3();
      takeReadings = true;
    } else if (messageBuffer == stringFour) {
      toggleAll();
      takeReadings = true;
    } else {
      takeReadings = true;
    }
    messageBuffer = "";
    Serial.println("\nEND OF MESSAGE");
    sms.flush();
    Serial.println("MESSAGE DELETED");
  }
  delay(1000);
}

void toggleSolenoid1() {
  solenoidWrite(master, HIGH);
  delay(1000);
  solenoidWrite(slave1, HIGH);
  delay(1000);
  solenoidWrite(slave1, LOW);
  delay(1000);
  solenoidWrite(master, LOW);
  delay(1000);
}

void toggleSolenoid2() {
  solenoidWrite(master, HIGH);
  delay(1000);
  solenoidWrite(slave2, HIGH);
  delay(1000);
  solenoidWrite(slave2, LOW);
  delay(1000);
  solenoidWrite(master, LOW);
  delay(1000);
}

void toggleSolenoid3() {
  solenoidWrite(master, HIGH);
  delay(1000);
  solenoidWrite(slave3, HIGH);
  delay(1000);
  solenoidWrite(slave3, LOW);
  delay(1000);
  solenoidWrite(master, LOW);
  delay(1000);
}

void toggleAll() {
  solenoidWrite(master, HIGH);
  delay(1000);
  solenoidWrite(slave1, HIGH);
  delay(1000);
  solenoidWrite(slave2, HIGH);
  delay(1000);
  solenoidWrite(slave3, HIGH);
  delay(1000);
  solenoidWrite(slave1, LOW);
  delay(1000);
  solenoidWrite(slave2, LOW);
  delay(1000);
  solenoidWrite(slave3, LOW);
  delay(1000);
  solenoidWrite(master, LOW);
  delay(1000);
}

void solenoidWrite(int pin, bool state) {
  if (pin >= 0 && pin < 8) {
    if (state)
      serialSolenoidOutput |= (1 << pin);
    else
      serialSolenoidOutput &= ~(1 << pin);
  }
  digitalWrite(solenoidLatch, LOW);
  shiftOut(solenoidData, solenoidClockster, MSBFIRST, serialSolenoidOutput);
  digitalWrite(solenoidLatch, HIGH);
}

Informe Completo del Proyecto de Riego Automático (PDF) Descarga Gratuita

• Título: Sistema Automatizado de Riego de Plantas
• Formato: PDF
• Tamaño: 4,18 MB
• Páginas: 77
• Descarga: Aquí

Sobre el Autor

- Departamento de Ingeniería, Escuela de Informática e Ingeniería, Instituto de Tecnología, Blanchardstown, Dublín 15