Reporte Final Sistema de Riego WGCL y DLFT

MATERIA: PROGRAMACIÓN ESTRUCTURADA
DOCENTE: SUSANA MÓNICA ROMÁN NÁJERA

EQUIPO:
 CASTILLO LEIJA WENDY GUADALUPE
 FARRET TAPIA DIANA LETICIA
SEMESTRE Y GRUPO: 3C2
PROYECTO: Sistema de riego automatizado con
arduino MEGA
SISTEMA DE RIEGO
AUTOMATIZADO CON
ARDUINO MEGA
2
INDICE
I n t r o d u c c i o n .............................................................................................................................. 4
MARCO TEORICO ................................................................................................................................. 5
CAPITULO UNO “EL PROBLEMA”......................................................................................................... 7
1.1 Planteamiento del problema. ................................................................................................... 7
1.2Delimitación del problema. ............................................................................................................ 7
1.3 OBJETIVOS ..................................................................................................................................... 7
1.3.1 Objetivo general ......................................................................................................................... 7
1.3.4 Objetivos específicos. ................................................................................................................. 8
1.4Justificación .................................................................................................................................... 9
1.5 Hipótesis ........................................................................................................................................ 9
CAPITULO DOS................................................................................................................................... 10
2.1 Introducción a la programación .................................................................................................. 10
2.2 Introducción al Arduino............................................................................................................... 11
2.3 Funcionamiento de un módulo LCD i2c ...................................................................................... 13
2.4 Funcionamiento de un sensor ultrasónico .................................................................................. 16
CAPITULO TRES.................................................................................................................................. 17
3.1 Dispositivos usados en el proyecto ............................................................................................. 17
MATERIALES SECUNDARIOS .............................................................................................................. 21
3.2 DESCRIPCION DE LOS COMPONENTES QUE CONFORMAN EL PROYECTO .................................. 22
[Objeto transparente detectable] .......................................................................................... 25
[Resistente a niebla y suciedad] .......................................................................................... 25
[Objetos de forma compleja detectables] ........................................................................... 25
CAPITULO CUATRO ............................................................................................................................ 26
CONCLUSIONES ................................................................................................................................. 46
BIBLIOGRAFIA .................................................................................................................................... 47
3
Introduccion
Desde la producción y manejo de medios de información , sean voz de

datos, e incluso la internet, la comunicación inalámbrica ha tenido una
gran aceptación como medio de enlace entre diferente dispositivos,
como por ejemplo en el sistema de implementación de redes
telefónicas, o en nuestro caso sistema de implementación de riego
automatizado .
Su aceptación tuvo éxito por su fácil manipulación y el uso que se le
da, es decir, poder movilizar sin molestia alguna debido a que todo
está sumamente manipulado.
Con la programación estructurada y la interrelación del puerto serie y
algunos dispositivos se pudo crear el proyecto “ DISEÑO E
IMPLEMENTACION DE UN SISTEMA DE RIEGO AUTOMATIZADO
CONTROLADO CON ARDUINO MEGA”. El panel principal recibe
datos de humedad, control de nivel, que son procesados y controlados
por un Sensor Ultrasónico para medir la intensidad y el llenado o vacío
del bote para así poder regar a unas plantas, para su comunicación
por otro microcontrolador que envía a encender una bomba y pueda
accionar.
Dada la necesidad en la acuicultura y sobre todo la constancia que
esta conlleva a permanecer en los lugares donde se necesita un
riesgo constante y controlado, para que algún producto de la
naturaleza no se dañe o se pierda en su totalidad surge esta
necesidad de automatizar a través de un sistema de riego, el mismo
que controla y posee interactuando varios sensores que interactúan
con un microcontrolador que tomara las decisiones de riego en el caso
de surgir la necesidad.
Gracias a los sistemas domésticos que se encuentran al alcance de
todos, ya sea en la automatización de viviendas para facilitar el trabajo
en el hogar, surge esta idea del control de riego usando tecnología de
vanguardia, facilita y permite a las personas en el campo para realizar
tareas adicionales o paralelas al mismo tiempo.
4
MARCO TEORICO
El presente trabajo analiza la construcción de un sistema

de riego automatizado con arduino MEGA. El cual está
pensado para realizar el riego de jardines o macetas. Dado
que por lo general normalmente las personas suelen
olvidar de la tarea de regar las plantas a veces por falta de
tiempo o por el descuido de olvidarlas.
Para evitar este inconveniente nos propusimos a
organizarnos e implementamos un sistema de riego
automatizado para el riego de nuestras plantas, este
sistema se encarga de medir la humedad de nuestra
maceta mediante un sensor de humedad, una vez que
llega a cierto nivel de sequedad se abre el riego, y se cierra
cuando se llega a determinado nivel de humedad.
Mostrando las decisiones que se fueron tomando y los
problemas encontrados en el trayecto. Para realizar estos
proyectos se requieren conocimientos básicos de
electrónica y programación.
La historia de la Programación está relacionada
directamente con la aparición de los computadores, que ya
desde el siglo XV tuvo sus inicios con la construcción de
una máquina que realizaba operaciones básicas y raíces
cuadradas (Gottfried Wilheml von Leibniz); aunque en
realidad la primera gran influencia hacia la creación de los
computadores fue la máquina diferencial para el cálculo de
polinomios, proyecto no concluido de Charles
Babbage (1793-1871) con el apoyo de Lady Ada Countess
of Lovelace (1815-1852), primera persona que incursionó
en la programación y de quien proviene el nombre del
lenguaje de programación ADA creado por el DoD
(Departamento de defensa de Estados Unidos) en la
década de 1970.
Un compilador lee todas las instrucciones y genera un
resultado; un intérprete ejecuta y genera resultados línea a
5
línea. En cualquier caso, han aparecido nuevos lenguajes
de programación, unos denominados estructurados y en la
actualidad en cambio los lenguajes orientados a objetos y
los lenguajes orientados a eventos.
6
CAPITULO UNO “EL PROBLEMA”
1.1 Planteamiento del problema.

Este proyecto se da cuando surge la necesidad de superar las
anomalías que se dan en la acuicultura y sobre todo cuando
de una u otra manera no se cuenta con un buen control de
riego en áreas difíciles de alcanzar, aunque en este caso, es
utilizado en el área de jardines.
Tomando en consideración los estándares y códigos que se
requiere para implementar este sistema y a su vez podría
haber mejoría, en ser utilizado en alguna áreas del campo
para mejorar las cosechas de algún producto de consumo
masivo como son las frutas, vegetales. Siendo beneficiados
personas del campo y/o estudiantes de la carrera de
Acuicultura.
1.2Delimitación del problema.

La implementación de un terreno mayor, para la
implementación del sistema de riego, será mas usado en el
verano, ya que recordemos que en los meses de lluvia
como es de Enero hasta Abril no existe mayor necesidad
de riego en la plantación.
1.3 OBJETIVOS
1.3.1 Objetivo general

El objetivo para este proyecto es crear un prototipo del
sensor de nivel de agua. Solucionar, o contribuir con la
solución de alguna problemática de la vida cotidiana. La
electrónica nos facilita a solucionar muchos problemas
7
de la vida cotidiana, inclusive, aquellos que
aparentemente no tienen nada que ver con esta ciencia.
1.3.4 Objetivos específicos.

 Los indicadores de nivel, son los elementos más
comunes dentro de los sistemas de control automático.
Estos dispositivos nos permiten visualizar el nivel de
líquido de cualquier recipiente, de modo, que podamos
diseñar sistemas de cierre o apertura automática de
entrada de líquido o simplemente, obtener información
de primera línea de cuanto lleno está un recipiente.
 El Sensor de nivel es un dispositivo electrónico que
mide la altura del material, generalmente líquido, dentro
de un tanque u otro recipiente.
 Diseñar y evaluar el funcionamiento de los sistemas de
control, sensores y actuadores usando un
Microcontrolador.
8
1.4Justificación
Se desea implementar un sistema de riego automatizado
muy a la vanguardia que permita controlar con ayuda de
sensores y actuadores al sistema de riego por sectores, a
su vez comunicar su estado por medio de una
computadora conectada a un arduino.
La necesidad de implementar este proyecto radica en que
la mayoría de sistemas de riego no son inteligentes o
automatizados, y los que son presentan costos muy
elevados a las necesidades de recurso económico de
algunos usuarios.
1.5 Hipótesis
Dentro de los sistemas de riego existen varios métodos o

formas de realizarlo, pero aprovechando dicho sistema de
riego aseguramos que exista un mejor riego en los jardines
y/o cultivos para ello una mejor producción y así obtener
resultados positivos en las cosechas que se tendrán en los
meses posteriores a la implementación del proyecto.
9
CAPITULO DOS
2.1 Introducción a la programación

La historia de la Programación está relacionada
directamente con la aparición de los computadores,
que ya desde el siglo XV tuvo sus inicios con la
construcción de una máquina que realizaba
operaciones básicas y raíces cuadradas (Gottfried
Wilheml von Leibniz); aunque en realidad la primera
gran influencia hacia la creación de los computadores
fue la máquina diferencial para el cálculo de
polinomios, proyecto no concluido de Charles
Babbage (1793-1871) con el apoyo de Lady Ada
Countess of Lovelace (1815-1852), primera persona
que incursionó en la programación y de quien
proviene el nombre del lenguaje de programación
ADA creado por el DoD (Departamento de defensa
de Estados Unidos) en la década de 1970. Luego los
avances en las ciencias informáticas han sido muy
acelerados, se reemplazó los tubos al vacío por
transistores en 1958 y en el mismo año, se
sustituyeron por circuitos integrados, y en 1961 se
miniaturizaron en chips de silicio. En 1971 apareció
el primer microprocesador de Intel; y en 1973 el
primer sistema operativo CP/M. El primer
computador personal es comercializado por IBM en el
año 1980.
De acuerdo a este breve viaje por la historia, la
programación está vinculada a la aparición de los
computadores, y los lenguajes tuvieron también su
evolución. Inicialmente se programaba en código
binario, es decir en cadenas de 0s y 1s, que es el
lenguaje que entiende directamente el computador,
tarea extremadamente difícil; luego se creó el
lenguaje ensamblador, que aunque era lo mismo que
programar en binario, al estar en letras era más fácil
de recordar. Posteriormente aparecieron lenguajes
10
de alto nivel, que en general, utilizan palabras en
inglés, para dar las órdenes a seguir, para lo cual
utilizan un proceso intermedio entre el lenguaje
máquina y el nuevo código llamado código fuente,
este proceso puede ser un compilador o un
intérprete.
2.2 Introducción al Arduino

Hace unos años apareció un proyecto libre,
llamado arduino, el cual facilitaba el acceso a esta clase de
dispositivos a los estudiantes, dado que es una placa
basada en openhardware (su diseño es libre y es posible
reproducirlo por cualquier persona).
Inicialmente, la placa se conectaba a través de un puerto

USB para programarlo (normalmente se hace en base a su
IDE que lo podemos encontrar aquí). La programación de
arduino no se realizaba a bajo nivel con ensamblador como
muchos microcontroladores (a partir de ahora los
11
llamaremos PICs), sino que se realiza con un lenguaje más
comprensible por la mayoría de nosotros, C/C++ (la
referencia básica al lenguaje la encontramos aquí y
ejemplos en esta ruta).
Con estos elementos, un programador que no sabe de PICs,

sería capaz de programar el arduino en poco tiempo.
La placa de la versión UNO se componía de 14 pines de

E/S digitales, de los cuales, tenía 2 para conexión serie.
Estos pines nos sirven para la mayoría de sensores
básicos, o para relés, accionadores, etc… los cuales solo
tienen 2 estados, encendido o apagado (o con las
constantes de arduino HIGH y LOW). También tiene 6
pines analógicos, capaces de leer hasta 1024 niveles de
tensión, llamados resolución del puerto analógico. Estos
sirven para leer sensores que nos devuelven rangos de
tensiones diferentes dependiendo de su estado, como
pueda ser, una termo resistencia, una resistencia variable,
etc…
Básicamente, con la estructura del arduino UNO, cualquier
persona puede adentrarse en el mundo de la programación
de PICs. Pero, para proyectos más grandes, se necesita
mayor potencia, con lo que los chicos de arduino fueron
creando placas y versiones mejoradas del arduino UNO.
Expongo unas cuantas:
Arduino Leonardo
Es la primera evolución del arduino Mega, de hecho, tiene

los mismos puertos, pero el PIC es diferente, con mayor
capacidad y mayor frecuencia de trabajo. Otra diferencia es
el puerto USB, que, a la vez de ser usado para subir el
programa, el Leonardo es capaz de usar dicho USB como
host, es decir, podemos usarlo de teclado, etc… Otra
inclusión son los puertos SDA y SCL, utilizados para
dispositivos que se comunican a través del protocolo I2C.
12
Arduino Mega 2560
Para los que se les queda corto el Leonardo diseñaron el

arduino Mega 2560, con muchísima más velocidad en el
microcontrolador y muchos más puertos digitales (54 pines)
y analógicos (16 pines). Tenemos los pines para I2C como
el Leonardo (aunque cambian de posición).
De este diseño nace también el Arduino Mega ADK, que es

una placa modificada del Mega 2560, pero se le añade un
puerto USB host.
Arduino YUN
Básicamente, esta placa tiene las mismas características de

pines y procesador que el Arduino Leonardo, pero se le ha
incorporado un microordenador donde reside un pequeño
Unix, el cual nos permite montar servidores web muy
básicos. Esta placa, se usa mayoritariamente para
proyectos en los que los sensores tienen que informar a
través de una red Ethernet de una forma rápida y sencilla.
2.3 Funcionamiento de un módulo LCD i2c

El Módulo adaptador LCD a I2C que usaremos está
basado en el controlador I2C PCF8574, el cual es un
Expansor de Entradas y Salidas digitales controlado
por I2C. Por el diseño del PCB este módulo se usa
especialmente para controlar un LCD Alfanumérico.
La dirección I2C por defecto del módulo puede
ser 0x3F o en otros casos 0x27. Es muy importante
identificar correctamente la dirección I2C de nuestro
modulo, pues de otra forma nuestro programa no
funcionará correctamente. Para identificar la dirección
especifica de nuestro módulo podemos utilizar un
pequeño sketch de prueba llamado: I2C Scanner, el
cual nos permite identificar la dirección I2C del
dispositivo conectado al Arduino. Si en caso existiera
13
la necesidad de trabajar con más de un LCD
podemos modificar la dirección I2C del módulo
adaptador. Para esto es necesario soldar los puentes
A0, A1 y A2 presentes en el módulo, estos tres
puentes son los bits menos significativos de la
dirección I2C del módulo. La dirección 0x3F en
binario sería: 0|0|1|1|1|A2|A1|A0 y la dirección
0x27: 0|0|1|0|0|A2|A1|A0. Por defecto A0, A2, A1
valen 1 pero si soldamos los puentes, estos se
conectan a tierra teniendo un valor 0. Por ejemplo, si
soldamos los tres puentes la nueva dirección sería
0|0|1|0|0|0|0|0 (0x20), para un chip que anteriormente
era 0x27.
Para controlar el contraste de los dígitos en el LCD
solo necesitamos girar el potenciómetro que se
encuentra en el módulo, hasta quedar conformes con
el contraste mostrado.
La luz de fondo se controla principalmente por
software desde el Arduino, pero el módulo también
permite desconectar el Led de la luz de fondo
removiendo un jumper LED.
14
15
2.4 Funcionamiento de un sensor ultrasónico
Los sensores de ultrasonido son muy útiles para medir
distancias y detectar obstáculos.
El funcionamiento es simple, envía una señal ultrasónica

inaudible y nos entrega el tiempo que demoro en ir y venir
hasta el obstáculo más cercano que detecto.
Generalmente están conformados por dos cilindros puestos

uno al lado del otro, uno de ellos es quien emite la señal
ultrasónica, mientras que el otro es quien la recibe, es un
sistema muy simple pero no por eso deja de ser efectivo.
El sensor hc-sr04 en particular tiene una sensibilidad muy

buena del orden de los 3mm, teniendo en cuenta que la
mayoría de las aplicaciones donde este sensor es utilizado
es para medir o detectar obstáculos o distancias mayores a
varios centímetros, podemos decir que su sensibilidad es
muy buena.
Obviamente el sensor por sí solo no sirve de mucho,

necesitamos algún micro controlador para leer los datos que
nos entrega, si lo que queremos desarrollar es de carácter
personal y no tiene que cumplir estrictos requisitos
comerciales, sin duda que la mejor opción que podemos
elegir es arduino.
Su infinidad de librerías y contenido disponible en la web nos

facilita muchísimo el trabajo y nos acorta los tiempos de
desarrollo.
16
CAPITULO TRES
3.1 Dispositivos usados en el proyecto

ARDUINO MEGA
PANTALLA LCD 16X2
DOS BOMBAS DE AGUA DE 120V
LEDS DE COLORES
17
3 RESISTENCIAS DE 1OK
6 RESISTENCIAS DE 330OHMS
UN MODULO LCD I2C
SENSOR DE HUMEDAD
18
SENSOR DE TEMPERATURA
UNA FOTORESISTENCIA
UN PROTOBOARD
CABLES PARA PUENTEAR
19
SENSOR ULTRASONICO
PUSH BOTTON
20
MATERIALES SECUNDARIOS
 Botes de plástico de capacidad 1 litro
 Mangueras de plástico
 Una cajita de madera
21
3.2 DESCRIPCION DE LOS COMPONENTES QUE CONFORMAN EL
PROYECTO
Arduino MEGA
Arduino Mega es una tarjeta de desarrollo open-source construida

con un microcontrolador modelo Atmega2560 que posee pines de
entradas y salidas (E/S), analógicas y digitales. Esta tarjeta es
programada en un entorno de desarrollo que implementa el lenguaje
Processing/Wiring. Arduino puede utilizarse en el desarrollo de
objetos interactivos autónomos o puede comunicarse a un PC a
través del puerto serial (conversión con USB) utilizando lenguajes
como Flash, Processing, MaxMSP, etc. Las posibilidades de realizar
desarrollos basados en Arduino tienen como límite la imaginación.
PANTALLA LCD 16X2

El tipo de pantallas más utilizadas anteriormente son conocidas como displays de siete segmentos,
dispositivos que muestran datos alfanuméricos y algún otro tipo de símbolo o imagen, pero con
grades limitaciones en cuanto a poder, al tipo y número de símbolos y caracteres y con un gran
consumo de energía y un gran tamaño.
Con el paso del tiempo y el gran avance de la ciencia y la tecnología, en este caso específico de la
electrónica, este tipo de pantallas han evolucionado y han dado varios pasos hacia el frente hasta
llegar a los dispositivos LCD 16x2.
Es común que se escuche y conozca la primera parte de este término por las pantallas de
computadoras, tablets, teléfonos celulares y pantallas de televisión, pero sus funciones no son del
todo conocidas sobre todo cuando el uso es diferente al de los artefactos mencionados.
22
LEDS
Todos los diodos LEDs poseen una construcción sólida. La principal característica que los
diferencia de otras fuentes de luz es que no poseen filamento ni partes frágiles de vidrio, lo que les
permite absorber vibraciones extremas y golpes sin llegar a romperse ni estropearse. El chip
emisor de luz es la parte principal de un LED y se encuentra encerrado en una envoltura o cápsula
de resina epoxi transparente o también tintada del mismo color de la luz que emiten, pudiendo
tener formas y tamaños diferentes. Desde el mismo chip que se encuentra encerrado en el interior
de la cápsula parten dos terminales que atraviesan su base y salen al exterior para que se puedan
conectar a un circuito eléctrico de corriente directa (C.D.), de forma tal que el LED quede
polarizado directamente. Cuando el LED es nuevo, el terminal más corto corresponde al polo
negativo (–) del chip, mientras el más largo corresponde al polo positivo (+).
UN MODULO LCD I2C
Con el modulo I2C se puede controlar una Pantalla LCD. El control se hará
mediante el protocolo de comunicación I2C, este permite además conectar 2 o
más módulos I2C en paralelo sin que estos interfieran entre si, de esta manera
con un Arduino podría controlar 2 o más Pantallas LCD y que estas muestren
información distinta.
23
SENSOR DE HUMEDAD
El sensor de humedad es un aparato de lectura utilizado en espacios interiores para

controlar la humedad del aire y la temperatura. Las magnitudes medidas por el sensor de
humedad se transforman en una señal eléctrica normalizada, cuya intensidad suele estar
comprendida entre 4 y 20 mA. Un material semiconductor es el encargado de determinar
con precisión los valores de humedad y temperatura que se corresponden con la señal
emitida. El sensor de humedad manda una señal a las bocas de extracción
higrorregulables situadas en baños, aseos y cocina por donde el aire viciado se extrae
cuando es necesario.
SENSOR DE TEMPERATURA
Los sensores de temperatura se usan para medir la temperatura del aire o la temperatura
superficial de líquidos y sólidos. Nuestra gama de sensores de temperatura es igual de
amplia que las aplicaciones que se le pueden dar. Además de sensores de resistencia
(Pt100) encontrara termoelementos del tipo K (NiCr-Ni). La serie WTR le ofrece para
muchas aplicaciones una solución al problema. Además de los sensores estándar para el
uso industrial, también tiene a disposición versiones para la industria alimentaria.
24
SENSOR ULTRASONICO
Como su nombre lo indica, los sensores ultrasónicos miden la distancia mediante el uso
de ondas ultrasónicas. El cabezal emite una onda ultrasónica y recibe la onda reflejada
que retorna desde el objeto. Los sensores ultrasónicos miden la distancia al objeto
contando el tiempo entre la emisión y la recepción.
Características:
[Objeto transparente detectable]

Dado que las ondas ultrasónicas pueden reflejarse en una superficie de vidrio o
líquido, y retornar al cabezal, incluso los objetos transparentes pueden ser
detectados.
[Resistente a niebla y suciedad]

La detección no se ve afectada por la acumulación de polvo o suciedad.
[Objetos de forma compleja detectables]

La detección de presencia es estable, incluso para objetos tales como bandejas de
malla o resortes.
25
CAPITULO CUATRO
4.1 Diseño, construcción e implementación del sistema de control de riego automatizado
Una vez conocido el componente utilizado para el control electrónico, se conoce la capacidad de
cobertura y control de sistema de riego.
Esquema general del sistema de riego
26
Esquema del sensor de humedad.
27
28
29
30
31
Codigo en general:
#include <SimpleDHT.h>
#include <SPI.h>
#define humidity_sensor_pin A0
#define ldr_pin A5
int pinDHT11 = 2;
SimpleDHT11 dht11;
int ldr_value = 0;
int in1 =22;
int in2 =24;
const int ledManual = 4 ;
const int ledAuto = 10 ;
const int botonLlenadoManual = 8;
const int botonLlenadoAutomatico = 9;
int encendido = 0;
int estado=0;
const int EchoPin = 5;
const int TriggerPin = 6;
const int LedPinVerde = 13;
const int LedPinAmarillo = 12;
const int LedPinRojo = 11;
float distancia;
int tanque;
long tiempo;
#include <LiquidCrystal_I2C.h>
32
#include <Wire.h>
LiquidCrystal_I2C lcd (0x27, 16, 2);
void setup()
Serial.begin(9600);
pinMode( ledManual, OUTPUT) ;
pinMode( ledAuto, OUTPUT) ;
pinMode( botonLlenadoManual , INPUT) ;
pinMode( botonLlenadoAutomatico , INPUT) ;
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
pinMode(LedPinVerde, OUTPUT);
pinMode(LedPinAmarillo, OUTPUT);
pinMode(LedPinRojo, OUTPUT);
pinMode(TriggerPin, OUTPUT);
pinMode(EchoPin, INPUT);
Wire.begin();
lcd.begin(16, 2);
lcd.clear();
lcd.backlight();
void loop()
digitalWrite(TriggerPin, HIGH); //se envía un pulso para activar el sensor
33
delayMicroseconds(100);
digitalWrite(TriggerPin, LOW);
tiempo = (pulseIn(EchoPin, HIGH) / 2);
distancia = float(tiempo * 0.0343);
Serial.print("Distancia: "); // imprime la distancia en el Monitor Serie
Serial.println(distancia);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("QUE DESEA HACER"); //tanque
lcd.print("*"); //Modo manual
lcd.print("+"); //modo automaticO
if(digitalRead(botonLlenadoManual) == HIGH){ // modo manual
estado=!estado;
digitalWrite( ledManual, estado) ;
if(estado == 1){
lcd.clear();
lcd.setCursor(2,0);
lcd.print("MODO MANUAL");
lcd.setCursor(3,1);
lcd.print("ACTIVADO");
digitalWrite(in1,HIGH);
digitalWrite(in2,HIGH);
digitalWrite(ledManual, HIGH);
34
else{digitalWrite(ledManual, LOW);
digitalWrite(in1, LOW);
if(digitalRead(botonLlenadoAutomatico) == HIGH){ //modo automatico
encendido = !encendido;
digitalWrite( ledAuto, encendido) ;
if(encendido == 1){
lcd.clear();
if (distancia <= 10 && distancia > 3) {
lcd.print("TQ:"); //tanque
lcd.print("lleno");
digitalWrite(LedPinVerde , HIGH);
digitalWrite(LedPinAmarillo , LOW);
digitalWrite(LedPinRojo , LOW);
Serial.println("*******************************");
Serial.println("Sample DHT11...");
byte temperature = 0;
byte humidity_in_air = 0;
byte data[40] = {0};
if (dht11.read(pinDHT11, &temperature, &humidity_in_air, data)) {
Serial.print("Read DHT11 failed");
35
return;
Serial.print("Sample RAW Bits: ");
for (int i = 0; i < 40; i++) {
Serial.print((int)data[i]);
if (i > 0 && ((i + 1) % 4) == 0) {
Serial.print(' ');
Serial.println("");
Serial.print("Sample OK: ");
Serial.print("Temperature: ");Serial.print((int)temperature); Serial.print(" *C, ");
Serial.print("Relative humidity in air: ");Serial.print((int)humidity_in_air); Serial.println(" %");
lcd.print("TA: "); //temperatura del aire
lcd.print((int)temperature);
lcd.print(" C");
lcd.print("HA: "); //humedad del aire
lcd.print((int)humidity_in_air);
lcd.print("%");
int ground_humidity_value = map(analogRead(humidity_sensor_pin), 0, 1023, 100, 0);
lcd.print("HT: "); //humedad de la tierra
lcd.print(ground_humidity_value);
lcd.print("%");
int ldr_value = map(analogRead(ldr_pin), 1023, 0, 100, 0);
36
Serial.print("Light: ");
Serial.print(ldr_value);
Serial.println("%");
Serial.println("*******************************");
if( ground_humidity_value <= 50 && ldr_value < 30 && temperature < 30) {
digitalWrite(in1, HIGH);
Serial.println("Irrigate");
else{
Serial.println("Do not irrigate");
delay (1000);
else if (distancia > 12 && distancia <= 17){
lcd.print("medio");
digitalWrite(LedPinVerde , LOW);
digitalWrite(LedPinAmarillo , HIGH);
Serial.println("*******************************");
Serial.println("Sample DHT11...");
byte temperature = 0;
byte humidity_in_air = 0;
byte data[40] = {0};
37
if (dht11.read(pinDHT11, &temperature, &humidity_in_air, data)) {
Serial.print("Read DHT11 failed");
return;
Serial.print("Sample RAW Bits: ");
for (int i = 0; i < 40; i++) {
Serial.print((int)data[i]);
if (i > 0 && ((i + 1) % 4) == 0) {
Serial.print(' ');
Serial.println("");
Serial.print("Sample OK: ");
Serial.print("Temperature: ");Serial.print((int)temperature); Serial.print(" *C, ");
Serial.print("Relative humidity in air: ");Serial.print((int)humidity_in_air); Serial.println(" %");
lcd.print("TA: "); //temperatura del aire
lcd.print((int)temperature);
lcd.print(" C");
lcd.print("HA: "); //humedad del aire
lcd.print((int)humidity_in_air);
int ground_humidity_value = map(analogRead(humidity_sensor_pin), 0, 1023, 100, 0);
lcd.print("HT: "); //humedad de la tierra
lcd.print(ground_humidity_value);
lcd.print("%");
38
int ldr_value = map(analogRead(ldr_pin), 1023, 0, 100, 0);
Serial.print("Light: ");
Serial.print(ldr_value);
Serial.println("%");
Serial.println("*******************************");
if( ground_humidity_value <= 50 && ldr_value < 30 && temperature < 30) {
Serial.println("Irrigate");
else{
Serial.println("Do not irrigate");
delay (1000);
else if (distancia > 19) {
lcd.print("vacio!");
digitalWrite(LedPinRojo , HIGH);
delay(1000);
39
delay(50);
delay(1000);
delay(500);
40
Imágenes de los pasos que se siguió para la realización del proyecto
1.1
1.2
41
1.3
1.4
42
1.5
1.6
43
1.7
44
PASOS
1.1 Se puede observar los cables ya instalados dentro de la caja de madera donde sostendrá el
arduino, y el protoboard.
1.2 En los botes de capacidad de 1 litro realizamos los orificios correspondientes para hacer las
entradas de las mangueras.
1.3 Para hacer los orificios de la tapa de la caja utilizamos un taladro para que se visualice la
pantalla lcd, los push botton y los leds.
1.4 La tapa de la cajita de madera lista para introducir la pantalla lcd.
1.5 Conectamos el sensor de humedad al protoboard
1.6 Conectamos el sensor ultrasónico al protoboard y al arduino mega.
1.7 Conectamos el arduino mega con sus pertenecientes conexiones.
Nuestro sistema de riego automatizado cuenta con dos bombas, que al subir el programa al
arduino, estas comienzan a trabajar.
Al momento de que en la pantalla lcd aparece dos opciones de automático y manual el usuario
puede elegir en esas dos opciones para ver la diferencia de llenado y riego.
Al accionar las bombas comienza su labor de llenado, y el sensor ultrasónico lo marca en la
pantalla, paso después comienza a regar con la ayuda del sensor de temperatura para ver a
que temperatura se encuentra y que el sensor de humedad al introducirlo en tierra seca de la
maceta, está a través de la manguera comience a regar. Y cuando esté completamente
humedad deje de regar.
45
CONCLUSIONES
Con los resultados obtenidos en las pruebas de sistema de riego
automático se puede comprobar que esta funciona en tiempo real ya
que el intervalo en el envió al cargo del arduino funciona
correctamente.
El sensor de humedad funciono de manera aceptable, entregando
valores muy aproximados.
Existen otras maneras de como programar el riego automático para su
ejecución durante el periodo del tiempo.
EL suministro de corriente eléctrica puede ser una pila rectangular de
9v, una batería móvil o un puerto USB del ordenador.
Obtuvimos un resultado favorable al accionar las bombas a la placa de
arduino y al conectarlas.
Gracias al tener conocimientos de programación y electrónica,
pudimos a andar este proyecto de sistema de riego automatizado para
el proyecto final de la materia de Programacion Estructurada.
46
BIBLIOGRAFIA
 REYES,Carlos, Microcontroladores PIC Programacion en Basic,Tercera Edicion, Editorial
Rispergraf, Quito-Ecuador,2008,Volumen Uno.
 HUIDOBRO,Jose,Redes y Telecomunicaciones Varias,Segunda Edicion,Editorial Rama,
España, 2010,volumen uno.
 https://cud.uvigo.es/index.php?option=com_content&view=article&id=403&Itemid=95
 https://dspace.ups.edu.ec/bitstream/123456789/5304/1/UPS-GT000434.pdf
47

Reporte Final Sistema de Riego WGCL y DLFT

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Reporte Final Sistema de Riego WGCL y DLFT

Cargado por

Copyright:

Formatos disponibles

MATERIA: PROGRAMACIÓN ESTRUCTURADA

DOCENTE: SUSANA MÓNICA ROMÁN NÁJERA

Desde la producción y manejo de medios de información , sean voz de

El presente trabajo analiza la construcción de un sistema

1.1 Planteamiento del problema.

1.2Delimitación del problema.

1.3.1 Objetivo general

1.3.4 Objetivos específicos.

Dentro de los sistemas de riego existen varios métodos o

2.1 Introducción a la programación

2.2 Introducción al Arduino

Inicialmente, la placa se conectaba a través de un puerto

Con estos elementos, un programador que no sabe de PICs,

La placa de la versión UNO se componía de 14 pines de

Es la primera evolución del arduino Mega, de hecho, tiene

Para los que se les queda corto el Leonardo diseñaron el

De este diseño nace también el Arduino Mega ADK, que es

Básicamente, esta placa tiene las mismas características de

2.3 Funcionamiento de un módulo LCD i2c

El funcionamiento es simple, envía una señal ultrasónica

Generalmente están conformados por dos cilindros puestos

El sensor hc-sr04 en particular tiene una sensibilidad muy

Obviamente el sensor por sí solo no sirve de mucho,

Su infinidad de librerías y contenido disponible en la web nos

3.1 Dispositivos usados en el proyecto

PANTALLA LCD 16X2

DOS BOMBAS DE AGUA DE 120V

UN MODULO LCD I2C

CABLES PARA PUENTEAR

Arduino Mega es una tarjeta de desarrollo open-source construida

PANTALLA LCD 16X2

UN MODULO LCD I2C

El sensor de humedad es un aparato de lectura utilizado en espacios interiores para

[Objeto transparente detectable]

[Resistente a niebla y suciedad]

[Objetos de forma compleja detectables]

Esquema general del sistema de riego

int in1 =22;

int in2 =24;

const int ledManual = 4 ;

const int ledAuto = 10 ;

const int botonLlenadoManual = 8;

const int botonLlenadoAutomatico = 9;

const int EchoPin = 5;

const int TriggerPin = 6;

const int LedPinVerde = 13;

const int LedPinAmarillo = 12;

const int LedPinRojo = 11;

LiquidCrystal_I2C lcd (0x27, 16, 2);

pinMode( ledManual, OUTPUT) ;

pinMode( ledAuto, OUTPUT) ;

pinMode( botonLlenadoManual , INPUT) ;

pinMode( botonLlenadoAutomatico , INPUT) ;

digitalWrite(TriggerPin, HIGH); //se envía un pulso para activar el sensor

tiempo = (pulseIn(EchoPin, HIGH) / 2);

distancia = float(tiempo * 0.0343);

Serial.print("Distancia: "); // imprime la distancia en el Monitor Serie

lcd.print("QUE DESEA HACER"); //tanque

lcd.print("*"); //Modo manual

lcd.print("+"); //modo automaticO

if(digitalRead(botonLlenadoManual) == HIGH){ // modo manual

digitalWrite( ledManual, estado) ;

if(digitalRead(botonLlenadoAutomatico) == HIGH){ //modo automatico