SISTEMA DE RIEGO AUTOMATICO

Me ha entrado la idea al estar en la casa de mi tía la cual tiene plantas que tiene que estar
regando durante tiempo determinado. Pero siempre se le olvida cada que sale de su casa
regarlas y por esta razón han desaparecido.
De esa necesidad surge este proyecto y para llevarlo a cabo he usado una bomba de agua, un
bidón, un detector de nivel y una placa basada en un pic 16f628 con un relé.
La bomba de agua puede ser la que se usa para renovar el agua de una pecera o para mantener
el chorro de una pequeña fuente. Sólo hay que conectarla a la alimentación de la casa para que
empiece a bombear agua. Es muy importante que cuando esté enchufada tenga siempre agua,
porque si no el motor se puede llegar a quemar. Por otro lado, la altura de la manguera que va
desde la bomba hasta el tiesto no puede ser mayor de un metro, ya que estos motores van
perdiendo fuerza de bombeo a medida que crece la altura por donde tienen que enviar el agua.
El recipiente para líquidos que he usado en el proyecto es uno de los de agua mineral de 5 litros
de cualquier marca. Al ser de plástico es fácilmente manejable para poder hacer un agujero y
meter el detector de nivel.
El detector de nivel es necesario para evitar que la bomba siga extrayendo agua y se queme el
motor por no tener agua que bombear.

PROGRAMA
#include <16F628A.h>

#FUSES NOWDT //No Watch Dog Timer

#FUSES INTRC_IO //Internal RC Osc, no CLKOUT
#FUSES NOPUT //No Power Up Timer
#FUSES NOPROTECT //Code not protected from reading
#FUSES NOBROWNOUT //No brownout reset
#FUSES NOMCLR //Master Clear pin used for I/O
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD //No EE protection

#use delay(clock=4000000)
#use fast_io(A)
#use fast_io(B)
#define CUANTAS 15
#include "main.h"
int inicio = -1;
int32 segundos = 0;
int interrupciones = CUANTAS;
int32 repeticiones [] = {7 * 24 * 3600, 6 * 24 * 3600, 5 * 24 * 3600, 4 * 24 * 3600, 3 * 24 * 3600, 2
* 24 * 3600, 24 * 3600, 12 * 3600};
int16 duraciones [] = {16000, 14000, 12000, 10000, 8000, 6000, 4000, 2000};

// Cuenta los segundos que van pasando para la activación automática del
// riego
#INT_RTCC
void cronometro ()
{
If (--interrupciones == 0)
{
++segundos;
interrupciones=CUANTAS;
}
}
// La interrupción es lanzada cuando el nivel del agua detectado por
// el sensor está por debajo de este y activamos el led de alarma
#INT_RB
void nivel ()
{
delay_ms (20);
if(input(PIN_B4) == 1)
{
output_high(PIN_A0);
 output_low(PIN_A3);
}
else
{
output_low(PIN_A0);
}
}

// La interrupción es lanzada cuando se pulsa el botón

#INT_EXT
void empiece ()
{
delay_ms (20);
if (inicio == 0)
{
inicio = 1;
}
}

void main ()
{
int contador;

set_timer0(0);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
port_b_pullups(TRUE);
set_tris_a(0);
output_low(PIN_A0);
output_low(PIN_A1);
output_low(PIN_A3);
enable_interrupts(INT_RTCC);
enable_interrupts(INT_RB);
enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);
delay_ms (1000);
inicio = 0;
for (; ;)
{
If (inicio == 1)
{
// No dejamos que se pulse de nuevo el botón mientras dure el proceso
disable_interrupts(INT_EXT);
// Parpadeamos durante 4 segundos el led de trabajo
for (contador = 0; contador < 8; contador++)
{
if (contador % 2 == 0)
{
output_high(PIN_A1);
}
else
{
output_low(PIN_A1);
}
delay_ms (1000);
}
 // Si el nivel del agua está por encima del sensor activamos la bomba
if(input(PIN_B4) == 0)
{
output_high(PIN_A1);
output_high(PIN_A3);
delay_ms(duraciones[input_b () >> 5]);
}
output_low(PIN_A1);
output_low(PIN_A3);
enable_interrupts(INT_EXT);
delay_ms (1000);
interrupciones = CUANTAS;
segundos = 0;
inicio = 0;

}
// Si el contador de segundos ha llegado a 0 es que hay que empezar
// el proceso de riego
else if (segundos >= repeticiones [(input_b () & 0x0F) >> 1])
{
inicio = 1;
}
}
}
 EXPLICACION

En el array repeticiones se ponen los milisegundos que dura el intervalo entre riegos, para poder
seleccionarlo luego con los jumpers. En el array duraciones se ponen los milisegundos que dura
el riego, para poder seleccionarlo luego con los jumpers.

Nada más arrancar el sistema empieza a contar los segundos que quedan para el siguiente riego,
según esté configurado en los jumpers. Cuando llega ese momento o se pulsa el botón, el led de
trabajo parpadea 4 segundos, permaneciendo encendido al igual que el relé para que funcione
la bomba de agua mientras dure el tiempo de riego, según este configurado en los jumpers.
Después el led se apaga, se desactiva el relé (y por consiguiente la bomba) y se espera de nuevo
al evento de activación (por tiempo o hasta que se pulse de nuevo el botón).
Si el nivel del agua cae por debajo del sensor mientras se está regando se para automáticamente
el riego desactivando el relé y encendiendo el led de alarma, que no se apagará hasta que el
nivel esté otra vez por encima del sensor. Las siguientes veces que salte el evento por tiempo o
por el botón, no activará el relé, protegiendo así a la bomba de estropearse.

Bibliografía
https://es.slideshare.net/luispalaciostafur/desarrollo-de-sistemas-en-tiempo-real