Riego Automatico

Buenas, hace poco me compre una Arduino UNO r3 y ando trasteando con ella.

Tengo algun conocimiento de electronica y alguno de programacion (Visual Basic y Python).

Bien el tema es que estaba empecinado en hacerme un sistema de riego automatico para mi planta.

Mi idea era leer la humedad que hay en el sustrato de la planta, si es menos de lo que necesitaria (un parametro añadido por mi), comprobaria que el plato estuviera seco, y actuara una bomba durante unos 5 segundos y despues parar durante unos 3 minutos para que pudiera drenar el agua hasta el plato. Y asi sucesivamente hasta que detectara agua en el plato y parara todo el sistema.

Bueno, como no se me ocurre ninguna manera de comprobar la humedad del sustrato(podria usar dos clavos en el sustrato, aplicarles tension y comprobar la resistencia entre ambas para calcular la humedad. El primer problema que le veia a este sistema era la oxidacion de los clavos y dado a la electrolisis que se me quedaran los nutrientes pegados a los clavos y la planta no absorviera bien los nutrientes.

Tambien pense en usar un sensor de humedad, pero como no tengo ni idea de si funcionaria me decante por la accion humana.

YO (persona fisica) compruebo como se ha echo toda la vida la humedad del sustrato, metiendo el dedo, y decido si esta seco o humedo.

Si lo encuentro seco, aprieto el pulsador y comienza el funcionamiento del programa, que es el siguiente:

Compruebo pulsador

Si pulsado

Compruebo luz

Si luz es menor de parametro establecido

Enciendo bomba durante 5 seg y paro 3 min.

Basicamente esa es la logica del sketch.

Esto es lo que tengo ahora mismo, completamente funcional(al menos en las pruebas que yo he hecho, ya que todo esta probado con una maceta sin planta, solo sustrato, y forzandole yo la oscuridad.

  /*      RIEGO AUTOMATICO CON SENSOR DE LUZ
      
      Con este pequeño codigo podras regar tu maceta automaticamente,
      preocupandote unicamente de que no le falte agua al deposito.
      
      Para activarlo, unicamente pulsaremos el boton que indica al 
      programa que tiene que regar.
      
      El programa lo primero que comprobara es que sea de noche, mediante
      un sensor de luz.
      
      Confirmado que no hay luz, comprobara que el sensor del plato de 
      la maceta este seco (circuito abierto), y procedera a encender la 
      bomba durante 5 segundos, despues hara una pausa de unos 5 minutos
      para darle tiempo al agua a que se filtre en el sustrato.
      
      Pasados esos 5 minutos vuelve a comprobar que el plato este seco. 
      Si es asi volvera a encender la bomba durante otros 5 segundos y la
      volvera a apagar durante otros 5 minutos.

      Una vez que el programa detecta que el plato esta mojado (circuito cerrado)
      para la bomba y hace un reset de la placa para vaciar todas las variables
      y esperar a que vuelvas a pulsar el boton de inicio.*/

int humedad = 0;
int luz = 1000; 
int pulsado = 0;

void setup(){
  Serial.begin(9600);
  pinMode(12, OUTPUT);
  pinMode(9, OUTPUT);    //este pin lo utilizamos para encender la bomba, a través del relé.
  pinMode(5, INPUT);      //este pin sirve para detectar si hay humedad o no. Si detecta energia, es que hay humedad. 
  pinMode(3, INPUT);      //Este pin lee el estado del pulsador de inicio de riego. 
                          //también se usa el pin A0, que servirá para detectar la cantidad de luz que hay en el exterior, a través de un sensor de luz.
}

void loop() {  
  if (digitalRead(3) == 1) { //comprobamos que el pulsador esta presionado.
    pulsado = 1;
    digitalWrite(12, HIGH); //Encendemos un led que nos indica que el pulsador se a presionado.
  }
  pulsador();
}

void pulsador() { 
  int intensidad = analogRead (A0); //se guarda en la variabla la "cantidad de luz" que hay en el exterior
  Serial.println("Intensidad: ");
  Serial.println(intensidad); //esto me sirvio a mi para ver las salidas cuando estuve haciendo el programa.
  Serial.println("\n");
  delay(1000);
  if (pulsado == 1) {
    Serial.println("Pulsador: SI");   //Lo mismo, esto es para cuando estuve aciendo el trasto xD+
    if (intensidad > luz) { //analiza la luz exterior es inforior al límite que hemos marcado. si esto pasa, se cumple el condicional (se supondrá que es de noche)
        delay(5000);    
        if (intensidad > luz){ //se esperan 5 segundos y se vuelve a analizar si es de noche o no. esto sirve para evitar que el sistema reconozca como noche una sombra de una persona, etc
          pulsado = 1;
          riego();
        }
      }else {
         digitalWrite(10, LOW); //si no hay luz (es de dia), el riego se apaga.
         //pulsado = 0;
       
         }
  }else {
    Serial.println("Pulsador: NO");}
}

void riego() {
      if (digitalRead(5) == 0) { //en el caso en que se confirme que es de noche, se analizará si hay humedad o no, en el caso en que no haya, se cumple el condicional
          delay(2000);
          humedad = 0; //se establece en la variable de humedad, que no la tierra no está húmeda
          Serial.println ("Maceta:"); Serial.println(humedad); //mas de lo mismo
          digitalWrite(9, HIGH); //se encienda la válvula y comienza el riego
          Serial.println("Bomba ON");
          delay(25000);
          digitalWrite(9, LOW); // se para durante 5 minutos
          Serial.println("Bomba OFF");
          delay(120000);
          riego();    //volvemos a iniciar la funcion rieego para que compruebe la humedad del plato.
       }
       else {digitalWrite (9, LOW);
       humedad = 1; //se se detecta que hay humedad, se establece que hay humedad en la variable y se apaga el riego
       Serial.println("Maceta: ");
       Serial.println(humedad); 
       software_Reset();    //resetamos la placa para liberar las variables.
       }
}

void software_Reset() //Hacemos parpadear el led y resetamos la placa.
{
  Serial.println("RESET");
  pulsado = 0;
  digitalWrite(12, LOW);
  delay(100);
  digitalWrite(12, HIGH);
  delay(100);
  digitalWrite(12, LOW);
  delay(100);
  digitalWrite(12, HIGH);
  delay(100);
  digitalWrite(12, LOW);
  delay(100);
  digitalWrite(12, HIGH);
  delay(100);
  digitalWrite(12, LOW);
  delay(100);
  digitalWrite(12, HIGH);
  delay(100);
  digitalWrite(12, LOW);
  delay(2000);
  asm volatile ("  jmp 0");
}

Bueno esto es lo que tengo.

Seguramente se podra optimizar y mejorar, por eso queria preguntaros a los expertos de que manera se podria mejorar ese codigo.

Os subo tambien un esquematico del sistema por si alguien quiere hacerlo.

Pistas.png

Componentes.png

Yo comprobaría la humedad de esta forma:

Usando el código del sensor de oscuridad, pondría en vez de un ldr, dos clavos en la maceta. Monitorizo las lecturas y echo agua...según se vaya secando apunto los valores.
Así se cuando está más o menos húmeda.

( Es mi simple y humilde opinión..Supongo que con otro código sería más sofisticado)

Hola,
Veo varias posibilidades:

  • en lugar de dos clavos, que se van a oxidar rápidamente, podrías colocar en un soporte rígido dos varillas de inoxidable (por ejemplo, de parrilla de barbacoa que esté hecha de ese material), en paralelo a una distancia de 1-2 cm, e ir probando la resistencia, como ha sugerido PascuaL.
    El método de meter el dedo en el tiesto no es nada coherente con un sistema de "riego automático" basado en Arduino, es como si para medir la dirección del viento uno propusiera levantar el dedo humedecido con saliva (método muy utilizado popularmente)...

  • Otra alternativa, si buscas en ebay soil moisture meter salen unos aparatitos chinos a 3€, que a lo mejor se podrían craquear.

  • Hay sondas baratas, como esta Gravity: Analog Soil Moisture Sensor for Arduino - DFRobot
    que está protegida de la oxidación por un baño de oro, vale 4€

Yo voy a hacer el proyecto. Para evitar la electrólisis temporizaré las mediciones de humedad.

Realmente hacer dos electrodos con varilla de Inoxidable es la mejor solucion. Los extremos de dichas varillas han de conectarse a un puente de medida wheatstone, es decir, dos electrodos han de estar en un eje del puente y dos resistencias variables en el otro.
Este puente te da una referencia de tension que es dependiente de la conductividad del sustrato, y por ende, de su humedad absoluta
Este puente ha de ser alimentado por una tension muy estable y continua, ya que nos va a suministrar una tension exacta de referencia. la cual la hemos de introducir por los dos termiales de tension analogica del Arduino

Por un pin se introduce una tension de referencia, y por el otro la tension de referencia suministrada por el puente.
Mediante la conversion A/D interna del Arduino encontraremos el valor float correspondiente a esta rension de referencia.
ya solo es cuestion de programacion para obtener el resultado que estamos buscando.

Saludos

Me podrias explicar un poco ese sistema??

Me parece interesante esa manera de co
Probar la humedad, pero no me ha quedado del
Todo claro

Un saludo

me gusta la idea, yo estoy buscando algo parecido!

Tengo el mismo proyecto entre manos, echale un ojo al blog de la firma a ver si te ayuda a algo!!