Sistema de riego automático

Muchas veces me ha surgido la necesidad de regar las plantas que tenía en casa mientras estaba fuera unos días. Por desgracia algunas de ellas han perecido por no ser regadas cada poco tiempo.

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 bidón 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. Yo he usado el de sure electronics.

La placa gobernada por un pic 16f628a es la que activará o desactivará la bomba de agua mediante un relé. Puede ser configurado mediante jumpers tanto el tiempo de riego como el intervalo. También se puede activar el riego manualmente mediante un botón.

Los componentes de la placa que he usado son:

Microcontrolador PIC 16F628A
2 diodos led
2 resistencias de 220 ohm.
1 resistencia de 68K ohm.
1 transistor BC237
1 diodo 1N4148
Un relé de 12 voltios RA12W-K
Un botón
Un regulador 7805
Un condensador de 1000 uf
Un condensador de 100 uf
2 bornes de 2 tomas y uno de 3 tomas.
Pines y jumpers
Fuente de alimentación de 12 V. y 0,5A.

Es importante que las pistas (o los cables de una placa de topos) que van a los contactos del relé sean más anchos para soportar la intensidad de la corriente.

Para no tener que pelar el cable de la bomba de agua, he usado un alargador que será al que se enchufe la bomba, pero que está cortado por uno de sus cables para poder engancharlo al relé:

El código fuente del PIC:

main.h

#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 <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

main.c

#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;
      }
   }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

#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;

}

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.

Finalmente un video de cómo funciona el conjunto:

94 comentarios en “Sistema de riego automático”

Jehiner Santiago Contreras Rojas 3 agosto 2022 a las 15:33

Me podrías pasar el diseño del PCB para la conexion

Responder ↓
caren 24 agosto 2022 a las 14:39

me puedes dejar ver el circuito de la vaquelita

Responder ↓

SISTEMAS O.R.P

Blog sobre informática, electrónica, robótica y otros temas

Sistema de riego automático

94 comentarios en “Sistema de riego automático”

Deja una respuesta Cancelar la respuesta