SENSORES EN ARDUINO

UNO Y SU APLICACIÓN EN
RIEGO AUTOMATIZADO
 AGRADECIMIENTO

Un agradecimiento especial a mis compañeros de la Universidad Nacional de Juliaca ,con quienes se

realizo el proyecto “IMPLEMENTACIÓN DEL SISTEMA DE RIEGO AUTOMATIZADO CON AR-
DUINO EN EL INVERNADERO DE LA UNIVERSIDAD NACIONAL DE JULIACA-2019”

Yana Huarancca Gabriela

Mendoza Mamani Liz Sandra
Chambi Quispe Sheila Elenny
Vilca Vilca Hitsson
Mamani Gil Elvis Edicson
Ancana Guizada Leslie Diana
Mamani Quispe Jesus
Mamani Chuyo Alexsander
Luque Luque Jose Angel
Soto Huaman Alex.
Con quienes no se podría haber realizado el proyecto, gracias totales.
 Programación con Arduino UNO para riego automatizado

Arduino es una compañía de desarrollo de soft-

ware y hardware libres, fue introducida el 2005.
El software libre son los programas informáti-
cos cuyo código es accesible por cualquiera para
que quien quiera pueda utilizarlo y modificarlo.
El Arduino es una placa basada en un microcon-
trolador ATMEL. Los microcontroladores
son circuitos integrados en los que se pueden gra-
bar instrucciones, las cuales las escribes con el
lenguaje de programación que puedes utilizar en
el entorno Arduino IDE.
Las placas Arduino también cuentan con otro tipo Placa Arduino UNO, precio 30 soles
de componentes llamados Escudos (Shields) o
mochilas. Se trata de una especie de placas que
se conectan a la placa principal para añadirle una
infinidad de funciones, como GPS, relojes en
tiempo real, conectividad por radio, pantallas tác-
tiles LCD, placas de desarrollo, y un larguísimo
etcétera de elementos.

Para nuestro objetivo, necesitaremos la placa Ar-

duino UNO (precio S/.45 aprox ) y descargar el
software de su página web:
https://www.arduino.cc/en/Main/Software
También necesitaremos los sensores que vaya- Placaboard, precio 10 soles
mos a utilizar,

Sensor de pH Para Arduino, Sensor de Conductividad Eléctrica Analógico Para

precio 40 dólares Arduino . Precio 70 dólares
https://www.aliexpress.com/item/32481414450.html
 Sensor de humedad del suelo HL-69

El código que copiaremos al Arduino será :

#define sensor A0

void setup(){
pinMode(sensor, INPUT);
Serial.begin(9600);
}

void loop(){

//Se hace la lectura analoga del pin A0 (sensor) y se pasa por

la funcion
//map() para ajustar los valores leidos a los porcentajes que
queremos utilizar
int valorHumedad = map(analogRead(sensor), 0, 1023,
100, 0);
Precio del Sensor es de S/.15
Serial.print("Humedad: "); La cual puedes encontrar en las
Serial.print(valorHumedad); tiendas del Jr. San Martin con Jr.
Serial.println("%"); Gonzales Prada en Juliaca

delay(5000);
}

Para cargar el código y la librería después que todo este

conectado hacemos clic en
El sensor y el Arduino deben estar conectados de la
siguiente manera:

Para visualizar los datos registrados por el sensor vamos

a la opción HERRAMIENTAS y hacemos clic en la op-
ción Monitor serie
 Sensor de temperatura y humedad ambiental DHT11

El código que copiaremos al Arduino será :

#include <dht.h>
dht DHT;
#define DHT11_PIN 8

void setup(){

Serial.begin(9600);
}

void loop()
{
DHT.read11(DHT11_PIN);

//TEMPERATURA//
Serial.print("Temperatura = ");
Serial.print(DHT.temperature);
Serial.println(" C");
Precio del Sensor es de S/.13
//HUMEDAD RELATIVA// La cual puedes encontrar en las
Serial.print("Humedad = "); tiendas del Jr. San Martin con Jr.
Serial.print(DHT.humidity); Gonzales Prada en Juliaca
Serial.println(" %");
delay(2000);
}

Después de copiar el código , vamos a añadir una librería, la cual vamos a descargar de:
https://drive.google.com/file/d/1iwL4bp-kUvf1MpfDM06SSGTNeBtq0FHb/view
Luego de extrae el fichero tendremos las siguientes carpetas:

vamos al programa ARDUINO y hacemos clic en programa, ya vamos a la opción incluir librería

El sensor y el Arduino deben estar conectados de la

siguiente manera:

Para cargar el código y la librería después que todo este

conectado hacemos clic en

Para visualizar los datos registrados por el sensor vamos

a la opción HERRAMIENTAS y hacemos clic en la op-
ción Monitor serie
El uso de varios sensores usando la placaboard es posible , un ejemplo:

int luzValue = 0;
int temValue = 0; // cambiamos por lluvValue
int humValue = 0;
int soniValue = 0; // cambiamos por humeVule
int nivValue = 0;
int temperatura;
int humedad;
int luz;
int sonido;
int niveldeagua;
int regarPin = 2;
#include <dht.h>
int sensortemperatura = A5;
int sensorhumedad = A5;
int sensorLuz = A4;
int sensorsonido = A3;
int sensorniveldeagua = A2;
dht DHT;
#define DHT11_PIN 8
void setup() {
pinMode(regarPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
luzValue = analogRead(sensorLuz);
temValue = analogRead(sensortemperatura);
humValue = analogRead(sensorhumedad);
soniValue = analogRead(sensorsonido);
nivValue = analogRead(sensorniveldeagua);
delay(1500);
// ----------------------------------------------------
// Imprimir valores
// ----------------------------------------------------
temperatura = (100.0 * temValue) / 1024;
Serial.print("temperatura:");
Serial.print(temperatura);
Serial.println("C");
humedad = (100.0 * humValue) / 1024;
Serial.print("humedad:");
Serial.print(humedad);
Serial.println("%");
luz = (100.0 * luzValue) / 1024;
Serial.print("Luz:");
Serial.print(luz);
Serial.println("%");
sonido = (100.0 * soniValue) / 1024;
Serial.print("sonido:");
Serial.println(sonido);
niveldeagua = (100.0*nivValue) / 1024;
Serial.println("nivel de agua:");
Serial.println(niveldeagua);
Serial.println("%");
Serial.println
("=======================================================================");
// ----------------------------------------------------
// Chequeo si debo regar
// ----------------------------------------------------
if (temperatura == HIGH) {
Serial.println("NO Detectada lluvia");

if( temperatura <= 50 && luz < 70 ) {

digitalWrite(regarPin, HIGH);
Serial.println("Debe regar");
}
}
else{
digitalWrite(regarPin, LOW);
Serial.println("NO debe regar");
}
Serial.println
("=======================================================================");
}
Cuando estamos desarrollando nuestros “inventos” a menudo sentimos la necesidad de poder encender y apa-
gar aparatos eléctricos de nuestro entorno. Por ejemplo, imaginemos que queremos bajar o subir las persianas
utilizando un motor eléctrico, necesitaríamos activar o desactivar dicho motor, que habitualmente funciona a
220V . Para poder realizar esto necesitaríamos un interruptor que pudiéramos activar y desactivar desde nuestra
placa ARDUINO. Pues bien, ese interruptor se llama relé. El código que utilizaremos para prender el relé es:

int ledPin = 9; // Piezo on Pin 8

int ldrPin = 0; // LDR en el pin analogico 0
int ldrValue = 0;

void setup() {
Serial.begin(9600);
pinMode(ledPin,OUTPUT);

void loop() {

ldrValue = analogRead(ldrPin);
Serial.print(ldrValue);
if (ldrValue >= 1010){
digitalWrite(ledPin,HIGH);
}

else { El relé 12V , precio 7 soles

digitalWrite(ledPin,LOW);

delay(500);
}

El relé y el Arduino deben estar conectados de la si-

guiente manera:
Lo interesante es que la placa ARDUINO te permite guardar la información , por lo cual se puede dejar en el
invernadero o lugar donde se tomarán los datos, solo necesitaría de energía la cual se puede adaptar pequeños
paneles solares y mediante una transmisión inalámbrica se puede enviar la información para activar la electro-
bomba y el riego sea automático. También se puede acoplar una pantalla para observar los datos registrados
por los sensores, es preciso mencionar que para realizar el riego es necesario poner en el código a que hume-
dad del suelo se va a iniciar el riego, también se debe programar cada cuanto tiempo será la toma de datos por
parte de los sensores , además cuantos segundos se necesitará para prender y para cuantos valores.

Placa base, se encargará de reci-

bir los datos y abrir la electrovál-
vula

Placa emisora, se encargará de

enviar los datos mediante una
antena inalámbrica
Invernadero donde se hará el
riego por aspersión usando el
sensor de humedad con AR-
DUINO, el sensor de humedad y
temperatura ambiente solo como
indicadora de datos.

Diagrama P&ID del sistema de

riego

Diagrama de bloques del sistema

de riego
Código de la placa base :
#include <SoftwareSerial.h> if(last_min != minutes && sync_var){
#include <SPI.h> paint.SetWidth(16);
#include "epd2in13b.h" paint.SetHeight(32);
#include "epdpaint.h" draw_values(false);
last_min = minutes;
#define REF_RATE 2000 sync_var = false;
#define RX_PIN A2 }
#define TX_PIN A3 // Aqui van las decisiones
#define NUM_DIG 5 if(sync_var){
#define GND_MIN_HUM 800 if(chan[0] < 1000 ){//si el sensor esta desconectado muestra valores
#define BOMBA_OUT 2 mayores a 1000
#define BOMBA_SECS 10 if(chan[0] > GND_MIN_HUM){
#define MISTKS 3 chan_mistakes[0]++;
if(chan_mistakes[0] > MISTKS){
#define COLORED 0 Serial.println("Se encenderá la bomba 10 segundos.");
#define UNCOLORED 1 String(String(chan[2])+"%").toCharArray(charBuf,5);
draw_values(true);
digitalWrite(BOMBA_OUT , HIGH);
unsigned char image[1024]; delay(BOMBA_SECS*1000);
Paint paint(image, 16,200 ); digitalWrite(BOMBA_OUT , LOW);
Epd epd; chan_mistakes[0]=0;
SoftwareSerial rfSerial(RX_PIN , TX_PIN); relay_used = true;
//Obtenemos los valores en buffer
void setup(){ update_channel_values();
rfSerial.begin(9600); delay(10000);
Serial.begin(9600); //Aqui recien actualiza
pinMode(BOMBA_OUT , OUTPUT); update_channel_values();
draw_values(false);
if (epd.Init() != 0) { }
Serial.print("e-Paper init failed"); }else{
return; chan_mistakes[0]=0;
} }
paint.SetRotate(ROTATE_90); }
epd.ClearFrame(); sync_var = false;
/* Deep sleep */ }
//epd.Sleep(); update_time_counters();
}
paint.Clear(UNCOLORED);
paint.DrawStringAt(0, 0, "SUELO", &Font16, COLORED); /////////////////////////////////////////////////
epd.SetPartialWindowBlack(paint.GetImage(),80, 7, void update_channel_values(){
paint.GetWidth(), paint.GetHeight()); sync_var = false;
paint.Clear(UNCOLORED); while(rfSerial.available()>0){
paint.DrawStringAt(0, 0, "Humedad:", &Font12, COLORED); tmp = rfSerial.readStringUntil('\n');
epd.SetPartialWindowBlack(paint.GetImage(),65, 7,
paint.GetWidth(), paint.GetHeight()); if (tmp.length() == 32){
if ( tmp[0] == '{' && tmp[30]=='}' ){
paint.Clear(UNCOLORED); for (int n = 0; n<5; n++){
paint.DrawStringAt(0, 0, "AMBIENTE", &Font16, COLORED); chan[n]=tmp.substring((NUM_DIG*n)+(n+1),(NUM_DIG*n)+
epd.SetPartialWindowBlack(paint.GetImage(),50, 7, (n+NUM_DIG+1)).toInt()-10000;
paint.GetWidth(), paint.GetHeight()); Serial.println("Canal "+ (String) (n+1) + ": " + (String) chan[n]);
paint.Clear(UNCOLORED); }
paint.DrawStringAt(0, 0, "Humedad: Temperatura:", &Font12, Serial.println();
COLORED); sync_var = true;
epd.SetPartialWindowBlack(paint.GetImage(),35, 7, }
paint.GetWidth(), paint.GetHeight()); }
} }
}
int chan[] = {0,0,0,0,0}, chan_mistakes[]={0,0,0,0,0}; //chan[0]
Almacena el sensor de humedad de piso void update_time_counters(){
long days = 0, hours = 0, minutes = 0, seconds = 0, high_millis if(millis() >= 3000000000){
= 0, rollover = 0, last_min = -1; high_millis=1;
String tmp;
char charBuf[7]; }
bool sync_var = false, relay_used = false; if(millis() <= 100000&&high_millis==1){
rollover++;
void loop(){ high_millis=0;
// Recibimos los datos de los sensores }
while(!sync_var) long secs_up = millis()/1000;
update_channel_values(); seconds = secs_up%60;
minutes = (secs_up/60)%60;
if(sync_var && relay_used){ hours = (secs_up/(60*60))%24;
draw_values(false); days = (rollover*50)+(secs_up/(60*60*24));
sync_var = false; }
relay_used = false;
}
void draw_values(bool regando){
if(regando){ Código de la placa emisora:
paint.SetWidth(16);
paint.SetHeight(48);
String(String(chan[0])+"u").toCharArray(charBuf,5);
#include <DHT.h>
paint.Clear(UNCOLORED);
epd.SetPartialWindowBlack(paint.GetImage(),65, 65, //#include <SoftwareSerial.h>
paint.GetWidth(), paint.GetHeight());
paint.DrawStringAt(0, 0, charBuf, &Font12, COLORED);
epd.SetPartialWindowRed(paint.GetImage(),65, 65, paint.GetWidth
#define REF_RATE 1000 //Refresh rate in millise-
(), paint.GetHeight()); conds
#define GND_HUM_PIN A4
paint.SetWidth(16); #define AIR_HT_PIN 2
paint.SetHeight(24);
String(String(chan[1])+"%").toCharArray(charBuf,5);
#define DHTTYPE DHT11
paint.Clear(UNCOLORED);
paint.DrawStringAt(0, 0, charBuf, &Font12, COLORED); DHT dht(AIR_HT_PIN, DHTTYPE);
epd.SetPartialWindowBlack(paint.GetImage(),35, 65,
paint.GetWidth(), paint.GetHeight());
String(String(chan[2])+"%").toCharArray(charBuf,5);
int gnd_hum;
paint.Clear(UNCOLORED); int air_hum,air_tm,air_tm_hit;
paint.DrawStringAt(0, 0, charBuf, &Font12, COLORED); void setup() {
epd.SetPartialWindowBlack(paint.GetImage(),35, 180, Serial.begin(9600);
paint.GetWidth(), paint.GetHeight());
paint.SetWidth(16);
dht.begin();
paint.SetHeight(100); }
paint.Clear(UNCOLORED);
paint.DrawStringAt(0, 0, "Regando...", &Font16, COLORED); void loop() {
epd.SetPartialWindowRed(paint.GetImage(),20, 30, paint.GetWidth
(), paint.GetHeight());
gnd_hum = analogRead(GND_HUM_PIN);
epd.DisplayFrame(); air_hum = dht.readHumidity();
}else{ air_tm = dht.readTemperature();
paint.SetWidth(16); air_tm_hit = dht.computeHeatIndex(air_tm, air_hum,
paint.SetHeight(48);
String(String(chan[0])+"u").toCharArray(charBuf,5);
false);
paint.Clear(UNCOLORED);
epd.SetPartialWindowRed(paint.GetImage(),65, 65, paint.GetWidth Serial.print("{");
(), paint.GetHeight()); Serial.print(gnd_hum+10000);
paint.DrawStringAt(0, 0, charBuf, &Font12, COLORED);
epd.SetPartialWindowBlack(paint.GetImage(),65, 65,
Serial.print(",");
paint.GetWidth(), paint.GetHeight()); Serial.print(air_hum+10000);
Serial.print(",");
paint.SetWidth(16); Serial.print(air_tm+10000);
paint.SetHeight(24);
String(String(chan[1])+"%").toCharArray(charBuf,5);
Serial.print(",");
paint.Clear(UNCOLORED); Serial.print(air_tm_hit+10000);
paint.DrawStringAt(0, 0, charBuf, &Font12, COLORED); Serial.println(",10000}");
epd.SetPartialWindowBlack(paint.GetImage(),35, 65, delay(REF_RATE);
paint.GetWidth(), paint.GetHeight());
String(String(chan[2])+"@").toCharArray(charBuf,5);
}
paint.Clear(UNCOLORED);
paint.DrawStringAt(0, 0, charBuf, &Font12, COLORED);
epd.SetPartialWindowBlack(paint.GetImage(),35, 180,
paint.GetWidth(), paint.GetHeight());
paint.SetWidth(16);
paint.SetHeight(100);
paint.Clear(UNCOLORED);
epd.SetPartialWindowRed(paint.GetImage(),20, 30, paint.GetWidth
(), paint.GetHeight()); Librerías usadas:
epd.DisplayFrame();
}
}
DISCUSIÓN
Los sistemas de riego modernos se podrían utilizar de manera efectiva para regar las plantas cuando lo
necesiten, la medición de la humedad del suelo, la humedad y la luz solar son importantes para adminis-
trar los cultivos de manera eficiente (Zaragoza & Kim, 2017), pero este proceso manual de riego requiere
dos aspectos importantes a tener en cuenta, cuándo y cuánto regar. Para reemplazar las actividades ma-
nuales y facilitar el trabajo en la agricultura, se crea un sistema de riego automático Arduino UNO donde
se usa el sensor de humedad del suelo para evitar la deshidratación de las plantas (Shifa, 2018). Para me-
jorar la eficiencia del riego se puede utilizar una mayor cantidad de sensores: humedad, temperatura,
presión y flujo de agua (Gilarranz, Altares, & Loizu, 2017), en otros trabajos se ha incluido el sensor de
pH del suelo, ya que el suelo es uno de los recursos más frágiles cuya propiedad de pH del suelo se usa
para describir el grado de acidez o basicidad, que afecta la disponibilidad de nutrientes y, en última ins-
tancia, el crecimiento de las plantas (Minz, Saha, & Dev, 2019), se puede incluir un servidor web para el
almacenamiento de medidas en una base de datos en MySQL además de permitir la consulta y manipu-
lación estadística de dichas variables (Perea Palacios, 2016), también se puede hacer uso del Bluetooth
para establecer una comunicación entre el Arduino y una aplicación móvil para realizar el riego automáti-
co en tiempo real (Guijarro-rodr, Torres, Preciado-maila, Nagib, & Manzur, 2018).En el invernadero ha
sido utilizado con éxito el sensor de humedad del suelo la cual funciona de la siguiente manera: el sensor
de humedad envía la señal a la placa Arduino que activa la bomba de agua para encender y suministrar
el agua a la planta respectiva utilizando la plataforma giratoria. Cuando se alcanza el nivel de humedad
deseado, el sistema se detiene por sí solo y la bomba de agua se apaga (Ojha, Mohite, Kathole, & Tarwa-
re, 2016), los dispositivos inalámbricos se les puede incluir una fuente de alimentación para asegurar la
alimentación continua del dispositivo (Rodrigo & Livizaca, 2016), para la prueba del riego automático
con Arduino es posible construir una maqueta para hacer la prueba (Barroso Garcia, 2015), se puede
mejorar el sistema incluyendo un instrumento virtual como el LabVIEW para el monitoreo y control re-
moto en el invernadero (Guadalupe & Vaca-rosas, 2017).

BIBLIOGRAFIA
Barroso Garcia, A. (2015). Control y monitorización de un invernadero a través de una aplicación móvil.
Gilarranz, A. C., Altares, S., & Loizu, M. (2017). Intelligent Irrigation System Based on Arduino, (1), 2–7.
Guadalupe, N., & Vaca-rosas, C. (2017). Diseño e implementación de un prototipo de automatización y
control sustentable para invernadero, 3(10), 1–10.
Guijarro-rodr, A. A., Torres, L. J. C., Preciado-maila, D. K., Nagib, B., & Manzur, Z. (2018). Sistema de
riego automatizado con arduino.
Minz, S., Saha, A., & Dev, M. R. (2019). Arduino Based Automatic Irrigation System, 3(1), 31–36.
Ojha, M., Mohite, S., Kathole, S., & Tarware, D. (2016). MICROCONTROLLER BASED AUTOMATIC
PLANT WATERING SYSTEM, 5(3), 25–36.
Perea Palacios, J. W. (2016). Diseño de un sistema de monitoreo, registro y control de temperatura y hu-
medad para el cultivo de invernadero.
Rodrigo, R., & Livizaca, B. (2016). Implementación de invernadero con sis- tema de control y monitoreo
inalámbricos 424.16.9.
Shifa, T. K. (2018). Moisture Sensing Automatic Plant Watering System Using Arduino Uno Tasneem
Khan Shifa American Journal of Engineering Research ( AJER ), (7), 326–330.
Zaragoza, M. G., & Kim, H. (2017). Comparative Study of PLC and Arduino in Automated Irrigation
System, 10(6), 207–218.

DATO: Se podría utilizar sensores de pH y electroconductividad en lugares donde se requiere el monitoreo de

estos parámetros y enviar los datos inalámbricamente en tiempo real a los personas que lo requieran e imple-
mentar un app