Regar por intervalos de tiempo

El paso del agua a la manguera del sistema de riego lo regula una electroválvulaElectroválvulaActuador que permite o interrumpe el paso de un fluido. Se acciona a través de su propia alimentación, por lo que tiene únicamente dos pines: sus estados posibles son activada o no, y se puede controlar mediante una salida digital y un relé.: una válvula que se controla eléctricamente, como las que suelen encontrarse en los lavarropas. Cuando no recibe corriente, la válvula está normalmente cerrada; al energizarse, abre y deja pasar el agua.

La electroválvula tiene dos conectores para manguera (uno de entrada y otro de salida de agua) y dos terminales eléctricos tipo pala. Lo primero que haremos es instalar las mangueras correspondientes: la de entrada irá conectada a una canilla y la de salida será la que lleve el agua directamente a las plantas.

Como los terminales de la válvula manejan más tensión de la que entrega la placa, no la conectamos directamente al Arduino: usamos un reléReléDispositivo electromagnético que funciona como un interruptor controlado por un circuito eléctrico: un electroimán abre o cierra contactos de otros circuitos independientes. Permite controlar con bajo voltaje dispositivos que utilizan mayor voltaje. como intermediario. El relé es un interruptor comandado por la placa con una señal chica (5 V en el UNO, 3,3 V en el ESP32), que abre o cierra el circuito de potencia de la válvula. El código que subamos controlará el relé y, en consecuencia, la apertura y el cierre de la electroválvula.

¡Atención! Agua y electricidad no se llevan bien. Todas las conexiones eléctricas van fuera del recorrido del agua y por encima de su nivel, y siempre que manipules el circuito hacelo con las manos secas y con el sistema desenchufado. El original trabajaba directamente con 220 V; en esta reedición la válvula es de 12 V (o se trabaja la lógica con el simulador), pero los hábitos de seguridad se practican igual, porque son los que te protegen cuando la instalación es real.

La conexión tiene dos partes:

• El circuito de potencia: la fuente de baja tensión, el relé y la electroválvula. Conectamos la fuente a la bornera COM del relé, la bornera NO a un terminal de la válvula, y el otro terminal de la válvula de vuelta al otro polo de la fuente. Así, la válvula solo recibe energía cuando el relé cierra el contacto. En el esquema original, esta rama es la que llega al enchufe de 220 V; acá va a la fuente de baja tensión.
• El circuito de control: la señal del relé hacia la placa, con un cable dupont.

La programación la realizaremos directamente en el lenguaje de Arduino (C++), usando el Arduino IDE en su versión 2.x, que se descarga gratis desde arduino.cc/en/software. Un programa de Arduino se llama sketch y tiene dos bloques: setup(), que se ejecuta una sola vez al inicializarse el dispositivo, y loop(), que se ejecuta repetidamente después. Los comentarios (todo lo que sigue a //) no tienen efecto en el programa: están para que el código sea más fácil de interpretar.

Para asegurarnos de que el sistema funcione, empezamos con una prueba simple: mantener la válvula abierta un rato y luego cerrada otro rato, en un ciclo que se repite. En el código, al poner la salida del relé en VALVULA_ABIERTA (estado ALTO) enviamos corriente al relé, que permite el paso de energía a la electroválvula para que se abra y riegue; al ponerla en VALVULA_CERRADA (estado BAJO) cortamos esa energía y la válvula se cierra.

Los tiempos de cada tramo están en dos constantes al comienzo del programa, DURACION_RIEGO_MS (cuánto riega) y DURACION_ESPERA_MS (cuánto espera entre riegos), expresadas en milisegundos. El programa las usa con delay(), que detiene todo hasta que se cumple el tiempo: en este primer nivel es la herramienta más simple y hace que el código se lea igual que la secuencia real.

// Riego por tiempo: una electroválvula, controlada por un relé, se abre
// durante un rato para regar y luego se cierra durante un rato más largo,
// en un ciclo que se repite para siempre. No hay sensores todavía: el
// riego depende solo del reloj interno (los delay).
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua. La electroválvula
// del original es de lavarropas (220 V): en el aula se usa una válvula de
// baja tensión (12 V) o se simula la carga, y la conexión a 220 V queda
// reservada al docente o a una instalación supervisada, nunca sobre la
// protoboard (desvío pedagógico acordado).
//
// Plataforma: Arduino UNO.
// Conexión (la del esquema original): entrada "S" del módulo relé de la
// electroválvula → pin 2.
//
// Basado en: Fragmentos de código 1 y 2 — Sistema de Riego Automatizado,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay,
// _loop) por C++ idiomático de Arduino con constantes nombradas.
//
// Nota pedagógica: la ficha de insumos del PDF menciona un "módulo reloj"
// (RTC), pero el código del original NO lo usa: temporiza con delay. Un
// RTC sería la evolución natural (regar a horas fijas del día, no cada X
// tiempo desde el encendido), pero queda fuera del alcance de este nivel.

// Relé que controla la electroválvula de entrada de agua.
const int PIN_RELE_VALVULA = 2;

// Módulo relé activo-alto, como en el original (HIGH = válvula abierta,
// pasa el agua). Si tu módulo es activo-bajo, invertí solo estas dos.
const int VALVULA_ABIERTA = HIGH; // riega
const int VALVULA_CERRADA = LOW;  // corta el agua

// Tiempos del ejemplo del original (Fragmento 2): riega 2 minutos y luego
// espera 1 hora. OJO en el aula: una hora es una eternidad para probar;
// bajá estos valores a segundos (por ejemplo 5000 y 10000) mientras
// verificás el circuito, y recién después poné los tiempos reales de tu
// huerta. En el nivel intermedio, el higrómetro reemplaza este reloj fijo.
const unsigned long DURACION_RIEGO_MS  = 120000UL;  // 2 minutos regando
const unsigned long DURACION_ESPERA_MS = 3600000UL; // 1 hora sin regar

void setup() {
  pinMode(PIN_RELE_VALVULA, OUTPUT);
}

void loop() {
  // delay() detiene todo el programa: en este nivel es la herramienta que
  // ya conocemos y hace que el código se lea igual que la secuencia real.
  digitalWrite(PIN_RELE_VALVULA, VALVULA_ABIERTA);
  delay(DURACION_RIEGO_MS);
  digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  delay(DURACION_ESPERA_MS);
}

// Riego por tiempo: una electroválvula, controlada por un relé, se abre
// durante un rato para regar y luego se cierra durante un rato más largo,
// en un ciclo que se repite para siempre. No hay sensores todavía: el
// riego depende solo del reloj interno (los delay).
//
// SEGURIDAD: agua y electricidad no se llevan bien. Todas las conexiones
// eléctricas van fuera y POR ENCIMA del nivel del agua. La electroválvula
// del original es de lavarropas (220 V): en el aula se usa una válvula de
// baja tensión (12 V) o se simula la carga, y la conexión a 220 V queda
// reservada al docente o a una instalación supervisada, nunca sobre la
// protoboard (desvío pedagógico acordado).
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: entrada "S" del módulo relé de la electroválvula → GPIO 16.
// Nota eléctrica: el ESP32 trabaja a 3,3 V (no 5 V como el UNO). Elegí un
// módulo relé cuya entrada acepte señal de 3,3 V (la mayoría la aceptan
// aunque se alimenten con 5 V) y nunca inyectes 5 V en un GPIO.
//
// Basado en: Fragmentos de código 1 y 2 — Sistema de Riego Automatizado,
// Saberes Digitales (INET/EDUCAR 2019)
// Modernización: se reemplazó el código generado por mBlock3 (_delay,
// _loop) por C++ idiomático con constantes nombradas, y se portó a ESP32
// con un GPIO seguro (el original usaba el pin 2 del UNO).
//
// Nota pedagógica: la ficha de insumos del PDF menciona un "módulo reloj"
// (RTC), pero el código del original NO lo usa: temporiza con delay. Un
// RTC sería la evolución natural (regar a horas fijas del día), pero queda
// fuera del alcance de este nivel.

// Relé que controla la electroválvula de entrada de agua.
const int PIN_RELE_VALVULA = 16;

// Módulo relé activo-alto, como en el original (HIGH = válvula abierta,
// pasa el agua). Si tu módulo es activo-bajo, invertí solo estas dos.
const int VALVULA_ABIERTA = HIGH; // riega
const int VALVULA_CERRADA = LOW;  // corta el agua

// Tiempos del ejemplo del original (Fragmento 2): riega 2 minutos y luego
// espera 1 hora. OJO en el aula: una hora es una eternidad para probar;
// bajá estos valores a segundos (por ejemplo 5000 y 10000) mientras
// verificás el circuito, y recién después poné los tiempos reales de tu
// huerta. En el nivel intermedio, el higrómetro reemplaza este reloj fijo.
const unsigned long DURACION_RIEGO_MS  = 120000UL;  // 2 minutos regando
const unsigned long DURACION_ESPERA_MS = 3600000UL; // 1 hora sin regar

void setup() {
  pinMode(PIN_RELE_VALVULA, OUTPUT);
}

void loop() {
  // delay() detiene todo el programa: en este nivel es la herramienta que
  // ya conocemos y hace que el código se lea igual que la secuencia real.
  digitalWrite(PIN_RELE_VALVULA, VALVULA_ABIERTA);
  delay(DURACION_RIEGO_MS);
  digitalWrite(PIN_RELE_VALVULA, VALVULA_CERRADA);
  delay(DURACION_ESPERA_MS);
}

El programa viene con los tiempos del ejemplo del original (riega 2 minutos y luego espera 1 hora). Para probar en el aula, una hora es una eternidad: bajá provisoriamente esas constantes a segundos (por ejemplo unos pocos miles de milisegundos) mientras verificás el circuito, y recién después cargá los tiempos reales de tu huerta, que vas a definir en el paso 3.

Podés ver el comportamiento —la válvula abriendo y cerrando por intervalos— en el simulador, antes de tocar el agua real:

Para subir el código a la placa, conectala a la computadora con el cable USB, elegí en el Arduino IDE 2.x la placa y el puertoPuerto COMPuerto de comunicaciones por el cual el sistema operativo se comunica con un dispositivo externo, como la placa. Se asigna automáticamente al conectarla por USB y puede cambiar de número; en el IDE hay que indicar cuál usar. (en el IDE 2.x se eligen juntos en el menú desplegable de la barra superior) y apretá el botón Subir (la flecha →). Al terminar, aparece el mensaje de carga completada en la barra inferior.

En el programa anterior, la válvula regaba y esperaba tiempos de ejemplo. Ahora hay que ajustarlos a la realidad de tus plantas.

La frecuencia de riego necesaria varía según la necesidad de las plantas seleccionadas, las condiciones climáticas, el tipo de suelo y su cobertura (por ejemplo, si tiene hojarasca o no), y la cantidad de agua aportada en cada evento de riego. En este sentido, es interesante que los estudiantes investiguen previamente acerca de las necesidades de las plantas elegidas, mediante la búsqueda de información en distintas fuentes o la realización de entrevistas a personas expertas en el tema.

Una vez determinado el tiempo de riego más adecuado, hay que expresarlo en milisegundos y cargarlo en las constantes DURACION_RIEGO_MS y DURACION_ESPERA_MS. Por ejemplo, si querés que riegue 2 minutos y luego espere 1 hora, esos tiempos son 120000 y 3600000 milisegundos, respectivamente (1 segundo son 1000 milisegundos). Volvé a subir el programa con tus valores.