UNIVERSIDAD MAYOR DE SAN ANDRÉS

FACULTAD DE TECNOLOGÍA
CARRERA DE ELECTRONICA Y TELECOMUNICACIONES

PROYECTO

INFORME

DOCENTE: ING. ARTURO MARIN THAMES

UNIVERSITARIOS: JUAN MAMANI

CI: 9102220

INVERNADERO
AUTOMATIZADO

La Paz –Bolivia

2017

INVERNADERO AUTOMATIZADO
 POR ARDUINO

OBJETIVO:

 Diseñar y construir una maqueta representativa de un invernadero, que

integre los sensores y actuadores necesarios para poder llevar a cabo las
tareas de control y monitorización. Se llevará a cabo el control de :
temperatura y seguridad , control de iluminación a travez de internet
también se controlara una carpa en la maqueta.
 Desarrollo del software para la placa Arduino que controla todos los
componentes del invernadero
 Desarrollo de un servidor para la recepción de datos y control del
invernadero, almacenamiento de los valores en una base de datos y que a
su vez ofrezca los servicios necesarios para su monitorización y control
remoto.
 Desarrollo de una pagina a travez de la programación HTML

CONTROL DEL INVERNADERO

Este elemento es el pilar básico en el control ambiental, basado en manejar de
forma adecuada todos aquellos sistemas instalados en el invernadero: sistema de
calefacción, sistema humidificador y de ventilación, para mantener los niveles

adecuados de temperatura, humedad relativa y calidad del aire. Con ello conseguir
la mejor respuesta del cultivo y por tanto, mejoras en el rendimiento, precocidad,
calidad del producto y calidad del cultivo. El usuario introduce las condiciones
ambientales deseadas y el microcontrolador actúa sobre sus salidas para
conseguirlas, corrigiendo sus decisiones gracias a la labor de los sensores, los
cuales permiten cerrar El lazo de control. De esta forma, puede crearse un
microclima con unas condiciones determinadas de temperatura, humedad y
calidad de aire en el invernadero.

Otra tarea importante que ocupa el controlador, además de establecer la relación

entre entradas y salidas, es la de otorgar información al usuario sobre el estado de
sus variables. La monitorización de variables permite una ventana de visualización
al operario sobre la evolución y el estado de los parámetros del invernadero . Este
proceso es de suma importancia, pues permite un vínculo entre el usuario y el
sistema, de manera que el individuo pueda realizar una labor de supervisión y, en
caso de requerirse, de actuación sobre el invernadero.
Mediante un sistema de adquisición de datos, un equipo informático obtiene
información sobre el estado de las variables del sistema, comunicándose con el
microcontrolador. Una correcta representación y una interfaz clara proporcionan
una herramienta fundamental y determinante al usuario, el cual puede conocer el
estado del sistema en todo momento

Emplean para ello un equipo PC con conexión

a Internet capaz de enviar por la red los datos
recopilados por el microcontrolador, y a su vez
permite escuchar instrucciones provenientes
de los terminales Android de forma remota.
Mediante el uso del protocolo HTTP, se
establece un intercambio de mensajes cliente-
servidor para recopilar toda la información
necesaria en la aplicación móvil. Las órdenes
dadas desde el terminal móvil son cargadas en
el microcontrolador, elemento que regula los
actuadores del cultivo. Cada vez es mayor el
uso de sistemas descentralizados de control de invernaderos.
Algunas de las principales características que han motivado el continuo
desarrollado de este tipo de aplicaciones bajo soporte Android son Plataforma
realmente abierta.

 Es una plataforma de desarrollo libre basada en Linux y de código abierto.

Una de sus grandes ventajas es que se puede usar y “customizar” el
sistema sin pagar royalties.
 Portabilidad asegurada. Las aplicaciones finales son desarrolladas en
Java, lo que nos asegura que podrán ser ejecutadas en una gran variedad
de dispositivos, tanto presentes como futuros.
 Esto se consigue gracias al concepto de máquina virtual. Arquitectura
basada en componentes inspirados en Internet.

ESTRUCTURA DE LA MAQUETA

El material empleado para la construcción de la maqueta es el siguiente: Madera

de samba para formar la estructura principal inferior. Alambre de 1mm de diámetro
para formar la cúpula superior. Forro de plástico para confeccionar las paredes y
techos. Fieltro, velcro, pegamento para madera, celofán, cinta adhesiva… y demás
materiales de unión para realizar los empalmes necesarios entre las distintas
partes.
PLACA DE ARDUINO MEGA

El Arduino Mega es probablemente el microcontrolador más capaz de la familia

Arduino. Posee 54 pines digitales que funcionan como entrada/salida; 16 entradas
análogas, un cristal oscilador de 16 MHz, una conexión USB, un boton de reset y
una entrada para la alimentación de la placa.

Voltaje de Entrada(límites): 6-20V

Pines digitales de Entrada/Salida: 54 (de los cuales 15 proveen salida PWM)

Pines análogos de entrada: 16

Corriente DC por cada Pin Entrada/Salida: 40 mA

Corriente DC entregada en el Pin 3.3V: 50 mA

Memoria Flash: 256 KB (8KB usados por el bootloader)

SRAM: 8KB
EEPROM: 4KB

Clock Speed: 16 MHz

Alimentación

Arduino Mega puede ser alimentado mediante el puerto USB o con una fuente
externa de poder. La alimentación es seleccionada de manera automática.

Cuando se trabaja con una fuente externa de poder se debe utilizar un convertidor
AC/DC y regular dicho voltaje en el rango operativo de la placa. De igual manera
se puede alimentar el micro mediante el uso de baterías. Preferiblemente el voltaje
debe estar en el rango de los 7V hasta los 12V.

Arduino Mega posee algunos pines para la alimentación del circuito aparte del
adaptador para la alimentación:

VIN: A través de este pin es posible proporcionar alimentación a la placa.

5V: Podemos obtener un voltaje de 5V y una corriente de 40mA desde este pin.

3.3V: Podemos ubtener un voltaje de 3.3V y una corriente de 50mA desde este
pin.

GND: El ground (0V) de la placa.

Arduino puede ser programado de una manera muy fácil utilizando el lenguaje
propio de Arduino junto con la interfaz Arduino IDE.

SENSOR DE TEMPERATURA Y HUMEDAD

La captación de los valores de temperatura y humedad en ICRA se ha realizado

con un único accesorio, el sensor DHT22. Los sensores DHT11 o DHT22 son
unos pequeños dispositivos que permiten medir la temperatura y la humedad. A
diferencia de otros sensores, éstos han de conectarse a pines digitales, ya que la
señal de salida es digital al integrar un pequeño microcontrolador para hacer el
tratamiento de la señal. Los sensores de gama DHT se componen de un sensor
capacitivo para medir la humedad y de un termistor, ambos sensores ya calibrados
por lo que no es necesario añadir ningún circuito de tratamiento de señal. Esto es,
sin duda, una ventaja ya que simplifican las conexiones a realizar en la placa.
Además, como los DHT han sido calibrados en laboratorios, presentan una gran
fiabilidad
Ambos sensores funcionan con ciclos de operación de duración determinada (1s
en el caso del DHT11 y 2s en el caso del DHT22). En este tiempo, el
microcontrolador externo (Arduino), y el microcontrolador que lleva integrado el
sensor, se hablan entre sí de la siguiente manera:

VENTILADORES

La ventilación del recinto es un aspecto

fundamental. Realizar una renovación del
aire en el interior, para conseguir unos
valores adecuados de O2 y CO2 es crucial.
El ventilador permite eliminar del invernadero
sustancias nocivas en el ambiente, que
puedan dañar el correcto crecimiento de la
plantación. Las características principales del
aparato son las siguientes (Ver “Figura 19”):
Tensión alimentación: 12VC Consumo de
corriente: 0.06A Diámetro: 40mm Mediante
la implementación de un pequeño circuito de
control, basado en un transistor bipolar NPN
2N2222, se han establecido cuatro modos de ventilación.

SISTEMA DE CALECFACION

Una de las variables fundamentales en el crecimiento de la plantación es la

temperatura. Los invernaderos permiten crear un rango de temperatura óptimo
para la evolución de las plantas que albergan. En ICRA se ha representado ese
circuito de calor mediante dos bombillas incandescentes de casquillo pequeño,
cada una con una potencia eléctrica de 2W. Dado que la placa Arduino no está
pensada para ser conectada a
elementos que consuman una
potencia media-alta, se ha
 utilizado un relé de conexión para llevar a cabo el control del encendido del
sistema calorífico

ESQUEMA DEL CIRCUITO

LCD1
LM016L

ARD1
ARDUINO MEGA2560 R3

VDD
VSS

VEE

RW
RS

D0
D1
D2
D3
D4
D5
D6
D7
E
RV1
1k

1
2
3

4
5
6

7
8
9
10
11
12
13
14
RESET
AREF
13
PB7/OC0A/OC1C/PCINT7
12
PB6/OC1B/PCINT6
R3 A0 PB5/OC1A/PCINT5
11
10k PF0/ADC0 10
A1 PB4/OC2A/PCINT4
PF1/ADC1 9
A2 PH6/OC2B
PF2/ADC2 8
A3 PH5/OC4C
PWM
PF3/ADC3
A7
PF7/ADC7/TDI 7
A6 PH4/OC4B
ANALOG IN

PF6/ADC6/TDO 6
A5 PH3/OC4A
PF5/ADC5/TMS 5
ATMEGA2560

A4 PE3/OC3A/AIN1
16AU 1126

PF4/ADC4/TCK 4
PG5/OC0B
1

3
A8 PE5/OC3C/INT5
LDR1 A9
PK0/ADC8/PCINT16
PE4/OC3B/INT4
2
TORCH_LDR PK1/ADC9/PCINT17 1
A10 TX0 PE1/TXD0/PDO

[Link].
PK2/ADC10/PCINT18 0
A11 RX0 PE0/RXD0/PCINT8
PK3/ADC11/PCINT19
COMUNICATION

A12
PK4/ADC12/PCINT20 14
A13 TX3 PJ1/TXD3/PCINT10
2

PK5/ADC13/PCINT21 15
A14 RX3 PJ0/RXD3/PCINT9
PK6/ADC14/PCINT22 16
A15 TX2 PH1/TXD2
PK7/ADC15/PCINT23 17
RX2 PH0/RXD2
TX1 PD3/TXD1/INT3
18 D1 D2
19 R1 R2 LED-BIGY LED-BLUE
RX1 PD2/RXD1/INT2
20
PB2/MOSI/PCINT2
PB3/MISO/PCINT3

SDA PD1/SDA/INT1
PB1/SCK/PCINT1

21
PB0/SS/PCINT0

SCL PD0/SCL/INT0 10k 10k

DIGITAL
PL5/OC5C
PL3/OC5A
PL4/OC5B
PL0/ICP4
PL1/ICP5

PG2/ALE

PA7/AD7
PA6/AD6
PA5/AD5
PA4/AD4
PA3/AD3
PA2/AD2
PA1/AD1
PA0/AD0
PC2/A10

PC4/A12
PC5/A13
PC6/A14
PC7/A15
PG0/WR

PC3/A11
PG1/RD

PC0/A8
PC1/A9
PD7/T0
PL2/T5

PL6
PL7

U1
53
52
51
50
49
48
47
46
45
44
43
42
41
40
39
38
37
36
35
34
33
32
31
30
29
28
27
26
25
24
23
22

1
VDD
2 > 81
DATA
4 31
GND
%RH °C

DHT11

U2 M1
9
COM
1 16
1B 1C
2 15
2B 2C
3 14
3B 3C
4 13 +88.8
4B 4C
5 12 MOTOR-BLDCM
5B 5C
6 11
6B 6C
7 10
7B 7C
ULN2003A

LCD1
LM016L
VDD
VSS

VEE

RW
RS

D0
D1
D2
D3
D4
D5
D6
D7
E
1
2
3

4
5
6

7
8
9
10
11
12
13
14

RV1
1k
DIAGRAMA DE BLOQUES

CONTROL TEMPERATURA
MOSTRAR POR

PROGRAMA DE LCD

LDR TEMPERATURA

C/S&&S/L

ABRIR CERRAR
CONTROL
CONTROL
A A

CONTROL DEL
ILUMINACION
USUARIO INTERNET

SEGURIDAD
CODIGO FUENTE

/ librerias requeridas

#include <LiquidCrystal.h>

#include <DHT.h>

#include <SPI.h>

#include <Ethernet.h>

#include <Servo.h>

#define motor1 2 // pin 1 del ULN2003, corresponde a Azul del motor (pin 1)

#define motor2 3 // pin 2 del ULN2003, corresponde a Rosa del motor (pin 2)

#define motor3 4 // pin 3 del ULN2003, corresponde a Amarillo del motor (pin 3)

#define motor4 5 // pin 4 del ULN2003, corresponde a Naranja del motor (pin 4)

// El cable rojo del 28BYJ48 (pin 5) se conecta a VCC

#define LED 13 // para encender LED en el pin13

int velocidadmotor = 1000; //variable para velocidad de pasos del motorto set
stepper speed

int conta = 0; // variable para llevar la cuenta de los pasos

int cuentas360g = 1280; //

//Array para excitar al ULN2003 que a su vez ataca al motor

int nivelesSalida[8] = {B01000, B01100, B00100, B00110, B00010, B00011,

B00001, B01001};

Servo microservo;
int pos = 0;

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //Direccion Fisica MAC

byte ip[] = { 192, 168,0, 153 }; // IP Local que usted debe configurar

byte gateway[] = { 192, 168, 0, 1 }; // Puerta de enlace

byte subnet[] = { 255, 255, 255, 0 }; //Mascara de Sub Red

EthernetServer server(80); //Se usa el puerto 80 del servidor

String readString;

const int dht11Pin = 8; // pin desde el sensor temperatura

const int botonMasPin = 9; // pin desde el boton mas

const int botonMenosPin = 10; // pin desde el boton menos

const int relayPin = 13; // pin al relay

const int venti = 12; // pin al relay

// variables para trabajar con los botones

boolean lastBotonMas = LOW;

boolean currentBotonMas = LOW;

boolean lastBotonMenos = LOW;

boolean currentBotonMenos = LOW;

// variables medidas

float temperatura = 0;

float humedad = 0;

float indiceCalor = 0;

// temperatura de control

int temperaturaControl = 0;
long previousMillis = 0; // tiempo en milisegundos para tarea en segundo plano

long interval = 2000; // intervalo de tiempo para obtener medidas

LiquidCrystal lcd(2, 3, 4, 5, 6, 7); // objeto lcd

DHT dht11(dht11Pin, DHT11); // objeto DHT11

// caracteres personalizados

byte grados[8] = {

B00110, B01001, B01001, B00110, B00000, B00000, B00000, B00000,

};

byte flechas[8] = {B00100,B01110,B11111,B00000,

B00000,B11111,B01110,B00100,

};

byte fanOn[8] = {B00100, B10101,B01110, B11111, B01110, B10101, B00100,

B00000,

};

byte fanOff[8] = {B01110,B10001, B10001, B10001,B10001, B10001, B01110,

B00000,

};

byte barra[8] {B11111,B11111,B11111,B11111,B11111, B11111, B11111,

B11111,

};

void setup()

[Link](9600); // Inicializa el puerto serial

 while (!Serial) { // Espera a que el puerto serial sea conectado, Solo necesario
para el Leonardo

pinMode(2,OUTPUT); // Se configura como salidas los puerto 2

[Link](7); // Se configura como Servo el Puerto 7

[Link](mac, ip, gateway, subnet); // Inicializa la conexion Ethernet y el

servidor

[Link]();

[Link]("El Servidor es: ");

[Link]([Link]()); // Imprime la direccion IP Local

//[Link](9600);

[Link](16, 2); // inicializa el LCD

[Link]();

// configurar pines

pinMode(dht11Pin, INPUT);

pinMode(relayPin, OUTPUT);

pinMode(botonMasPin, INPUT);

pinMode(botonMenosPin, INPUT);

pinMode(venti, OUTPUT);

digitalWrite(relayPin, HIGH); //prendido el foco

digitalWrite(venti, LOW); //Apagado el ventilador

// crear caracteres
 [Link](0, grados);

[Link](1, flechas);

[Link](2, fanOn);

[Link](3, fanOff);

[Link](4, barra);

// barra de progreso inicializar da tiempo para que el sensor se estabilize

[Link](0,0);

[Link]("INVERNADERO...");

for (int i = 0; i <= 15; i++) {

[Link](i, 1);

[Link]((byte)4);

delay(250);

delay(250);

[Link]();

delay(500);

// obtener temperatura - humedad - indice de calor

// pausa de dos segundos para estabilizar el DHT11

temperatura = [Link](); // obtiene la temperatura ambiente en ºC

humedad = [Link](); // obtiene la humedad ambiente

indiceCalor = [Link]([Link](true),
humedad); // calcula el indice de calor

// comprueba la lectura, si falla vuelve a intentar

if (isnan(humedad) || isnan(temperatura)) {

//debugging
 //[Link]("Fallo la lectura del sensor...");

return;

// establece la temperatura de control

temperaturaControl = temperatura + 1;

desplegarInformacion();

void loop()

// Crea una conexion Cliente

EthernetClient client = [Link]();

if (client) {

while ([Link]()) {

if ([Link]()) {

char c = [Link]();

//Lee caracter por caracter HTTP

if ([Link]() < 100) {

//Almacena los caracteres a un String

readString += c;

// si el requerimiento HTTP fue finalizado

 if (c == '\n') {

[Link](readString); //Imprime en el monitor serial

[Link]("HTTP/1.1 200 OK"); //envia una nueva pagina en

codigo HTML

[Link]("Content-Type: text/html");

[Link]();

[Link]("<HTML>");

[Link]("<HEAD>");

[Link]("<h1 align='center'>INVERNADERO</h1><h1
align='center'>AUTOMATIZADO</h1><h2 align='center'>**===-----CONTROL-----
===**</h2>");

[Link]("</b>");

[Link]("</HEAD>");

[Link]("<BODY >");

[Link]("<hr />");

[Link]("<div style='text-align:center;'>");

[Link]("<h2 align='center'>ILUMINACION</h2>");

[Link]("<button onClick=[Link]='./?button2on\'
style='margin:auto;background-color: #FF0000;color: snow;padding: 10px;border:
1px solid #990000;width:65px;'>");

[Link]("ON");

[Link]("</button>");

[Link]("<button onClick=[Link]='./?button2off\'
style='margin:auto;background-color: #FF0000;color: snow;padding: 10px;border:
1px solid #990000;width:65px;'>");
 [Link]("OFF");

[Link]("</button>");

[Link]("<br />");

[Link]("<br />");

[Link]("<hr />");

[Link]("<h2 align='center'>CONTROL DE GARRAGE </h2>");

[Link]("<button onClick=[Link]='./?right\'
style='margin:auto;background-color: #FF0099;color: snow;padding: 10px;border:
2px solid #990066;width:65px;'> ");

[Link]("ON");

[Link]("</button>");

[Link]("<button onClick=[Link]='./?left\'
style='margin:auto;background-color: #FF0099;color: snow;padding: 10px;border:
2px solid #990066;width:65px;'> ");

[Link]("OFF");

[Link]("</button>");

[Link]("<br />");

[Link]("<hr />");

[Link]("<h1><marquee>REALIZADO POR EL ALUMNO: Juan Mamani

</marquee></h1>");

[Link]("</BODY>");

[Link]("</HTML>");

delay(1);

//detiene el cliente servidor

 [Link]();

//control del arduino si un boton es presionado

if ([Link]("?button2on") >0){

digitalWrite(2, HIGH);

if ([Link]("?button2off") >0){

digitalWrite(2, LOW);

if ([Link]("?left") >0){

for(pos = 0; pos < 90; pos += 3) // Giro de 0 a 90 grados

[Link](pos);

delay(15); // Espera 15 ms para que el servo llege a la

posicion

if ([Link]("?right") >0){

for(pos = 90; pos>=0; pos-=3) //Giro de 90 a 0 grados

[Link](pos);

delay(15); // Espera 15 ms para que el servo llege a la

posicion

}
 // Limpia el String(Cadena de Caracteres para una nueva lectura

readString="";

// leer entrada de usuario

currentBotonMas = digitalRead(botonMasPin);

currentBotonMenos = digitalRead(botonMenosPin);

// subir temperatura de control

if (currentBotonMas == HIGH && lastBotonMas == LOW) {

delay(15); // debouncing time

if (digitalRead(botonMasPin)) {

temperaturaControl++;

// [Link](temperaturaControl);

lastBotonMas = HIGH;

else {

lastBotonMas = digitalRead(botonMasPin);

// bajar temperatura de control

if (currentBotonMenos == HIGH && lastBotonMenos == LOW) {

delay(15); // debouncing time

if (digitalRead(botonMenosPin)) {

temperaturaControl--;

//[Link](temperaturaControl);

lastBotonMenos = HIGH;

else {

lastBotonMenos = digitalRead(botonMenosPin);

[Link](6,1);

[Link]((byte)1);

[Link](7,1);

[Link](temperaturaControl);

[Link](10,1);

[Link]("Buf");

if (temperatura >= temperaturaControl) {

[Link](15,1);

[Link]((byte)2);

digitalWrite(relayPin, LOW);

else {
 [Link](15,1);

[Link]((byte)3);

digitalWrite(relayPin, HIGH);

if (temperatura < temperaturaControl) {

//[Link](15,1);

//[Link]((byte)2);

digitalWrite(venti, LOW);

else {

//[Link](15,1);

//[Link]((byte)3);

digitalWrite(venti, HIGH);

// en segundo plano obtener medidas cada 2 segundos

unsigned long currentMillis = millis();

if(currentMillis - previousMillis > interval) {

// se ejecuta en segundo plano

// guardar el utlimo instante de lectura

previousMillis = currentMillis;

// obtener temperatura - humedad - indice de calor

temperatura = [Link](); // obtiene la temperatura ambiente en

ºC
 humedad = [Link](); // obtiene la humedad ambiente

indiceCalor = [Link]([Link](true),
humedad); // calcula el indice de calor

// comprueba la lectura, si falla vuelve a intentar

if (isnan(humedad) || isnan(temperatura)) {

//debugging

//[Link]("Fallo la lectura del sensor...");

return;

desplegarInformacion();

/**

* desplegar informacion en el LCD

*/

void desplegarInformacion()

[Link](0, 1);

[Link]("T:");

[Link](2, 1);

[Link]((int)temperatura);

[Link](4, 1);

[Link]((byte)0);

[Link](0, 0);
 [Link]("H:");

[Link](2, 0);

[Link]((int)humedad);

[Link](4, 0);

[Link]("%");

/*[Link](6, 0);

[Link]("IC:");

[Link](9, 0);

[Link](indiceCalor); */

CONCLUSION:
La maqueta construida ha permitido simular las condiciones ambientales que
tienen lugar en el interior de un invernadero, y por consiguiente se han podido
llevar a cabo los objetivos propuestos en este trabajo.

Se han cubierto todas las fases de desarrollo propuestas y se ha conseguido el

objetivo principal del proyecto que era conseguir implementar una aplicación
remota, capaz de efectuar un control y una monitorización sobre un invernadero.

La programación del microcontrolador Arduino se ha realizado siguiendo una

programación orientada a objetos, con lo que se facilita la incorporación de nuevos
periféricos o modificaciones en los ya existentes.

Las tareas principales que lleva a cabo la aplicación servidor se han desarrollado
empleando funciones y clases, lo que repercute en una aplicación versátil y
fácilmente escalable. Propuestas como recibir una nueva variable del invernadero,
ampliar el mensaje de comunicación o crear un nuevo campo en la base de datos
son fácilmente asumibles

Finalmente se ha podido desarrollar todo el software pero no se acabo como lo

pensábamos pero al final se implementó y se logró los objetivos.

BIBLIOGRAFIA:

 Torrente Artero, Oscar. ARDUINO Curso práctico de formación. 2013.

 A Low Cost Architecture for Remote Control and Monitoring of Greenhouse
Fields. Daniel Moga, Dorin Petreus, Nicoleta Stroia. Cluj-Napoca, Romania :
Technical University of Cluj-Napoca, 2011.
 Introducción a JSON. [En línea] [Citado el: 15 de 04 de 2015.]
[Link]
 Arduino. Arduino Proyect. [En línea] [Citado el: 1 de 12 de 2014.]
[Link]
 González Gómez, Juan. Wiki-Robotics. [En línea] 2010. [Citado el: 12 de 12
de 2014.] [Link]
title=Tutorial:_Puerto_serie_en_Linux_en_C%2B%2B.
 [Link]