Utilizando la plataforma IoT NoCAN para regar las plantas del jardín

Construir un sistema de riego automatizado es conceptualmente sencillo:

• Construir una red de tuberías que lleve agua a las plantas,
• Utilice un microcontrolador que controle la válvula solenoide para iniciar o detener el flujo de agua.
• Activar el riego en horarios predefinidos a través del microcontrolador (por ejemplo una vez cada 2 días durante 20 minutos).

Analizaremos la construcción de un sistema de riego automatizado con la plataforma IoT Omzlo NoCAN , que se basa en un conjunto de nodos compatibles con Arduino administrados por una Raspberry Pi . Nuestra configuración general se muestra en la figura anterior:

• Un nodo CANZERO compatible con Arduino está conectado a una válvula, que se enciende y se apaga para regar las plantas.
• El nodo CANZERO está conectado a una Raspberry-Pi con un cable tanto para alimentación como para red.
• La Raspberry-Pi (equipada con un PiMaster HAT) se utiliza para enviar instrucciones al CANZERO, para riego automático y manual.

Para simplificar las cosas, limitaremos las funciones descritas en este proyecto. Sin embargo, es fácil aprovechar este ejemplo para agregar compatibilidad con el control del riego con un teléfono inteligente o mediante el protocolo MQTT .

Hardware

Lo esencial

Existen multitud de tipos de válvulas de agua, que utilizan distintos voltajes, con o sin enclavamiento, adaptadas a diferentes topologías, etc. Una de las válvulas de agua más sencillas es la electroválvula de plástico de 12 V de 13 mm (1/2″) que aparece en la siguiente imagen y que puedes encontrar a buen precio en Adafruit o en eBay .

Esa válvula está «normalmente cerrada» y cuando no se aplica corriente al solenoide, la válvula simplemente se cierra y detiene el flujo de agua. Requiere una presión de agua mínima para funcionar (0,02 Mpa): sin esa presión, la válvula no cerrará bien. Como tal, estas válvulas no son bidireccionales: esperan que el agua fluya en una dirección específica, como se indica con una flecha en el cuerpo de plástico de la válvula. Si bien está clasificada para 12 V, funciona sin problemas a 9 V o incluso menos. Se necesita una corriente de 200 mA a 300 mA para mantener la válvula abierta, permitiendo que fluya el agua.

Una de las formas más sencillas de controlar esta válvula solenoide es con un interruptor Mosfet del lado bajo (canal N), como se ilustra en la siguiente figura.

Se utiliza un pin de E/S del microcontrolador para controlar el Mosfet M1 . Cuando se aplica un voltaje suficiente a la compuerta de M1, la corriente fluye a través del solenoide y abre la válvula. Por el contrario, cuando el voltaje de la compuerta baja a 0, el Mosfet deja de permitir que la corriente fluya a través de él, cerrando así el solenoide. El
Mosfet seleccionado debe ser «compatible a nivel lógico» de modo que el voltaje de 3,3 V proporcionado por un microcontrolador sea suficiente para encender completamente el Mosfet. Como siempre con una carga inductiva como un solenoide, se agrega un «diodo flyback» D1 para proteger el circuito de picos de voltaje. Además, se debe colocar una resistencia pull-down débil (no se muestra) entre la compuerta de M1 y GND. Esto asegura que la compuerta del M1 esté en un estado predefinido cuando el microcontrolador no esté encendido o esté defectuoso.

Un último punto a considerar es que una fuente de alimentación de 12 V debe suministrar corriente al solenoide.

Usando un nodo CANZERO

Nuestro objetivo es controlar nuestro sistema de riego con un nodo CANZERO en una red NoCAN, permitiéndonos posteriormente programarlo directamente desde la línea de comandos en una Raspberry-Pi o a través de una interfaz web.

Las redes NoCAN utilizan un solo cable para conectar una serie de nodos. El cable proporciona tanto la alimentación como la red (CANbus). Una red NoCAN puede utilizar cualquier voltaje entre 6 y 28 V, pero utilizar 12 V o 24 V es un enfoque clásico. Dado que podemos construir una red NoCAN con 12 V, podemos hacer una simplificación interesante aquí: podemos alimentar tanto el solenoide como los nodos de red con la misma fuente, simplificando nuestro cableado al evitar una fuente de alimentación de 12 V adicional y un cable para el solenoide. Tenga en cuenta que si su red NoCAN utiliza cables largos con cables pequeños, entonces la activación del solenoide generará corriente y dará como resultado una pequeña caída de voltaje debido a la resistencia del cable. En la mayoría de los entornos, esto no es un problema.

Con esto en mente, el circuito de conmutación Mosfet de lado bajo descrito anteriormente es muy fácil de construir en una placa de pruebas o incluso en un prototipo de protector que se pueda conectar a un nodo CANZERO.

Pero somos perezosos y hay una solución aún más sencilla: utilizar el shield Omzlo GO-24V , que es un shield compatible con Arduino MKR que está diseñado para interconectar un microcontrolador con sistemas de 24 V (y, por supuesto, de 12 V). Se muestra en la imagen de abajo, encima de un Arduino MKR-Zero clásico.

El shield GO-24V tiene 4 salidas de sumidero controladas por MOSFET, exactamente como en el interruptor de lado bajo que describimos anteriormente.
Conectamos el conector VIN (12 V) del shield a un conector de la válvula y conectamos el otro conector de la válvula a la primera salida de sumidero del shield, ambos identificados con una flecha en la figura siguiente.

Solo nos falta añadir el diodo flyback y listo. Una forma sencilla de hacerlo es construir el siguiente cable, diseñado por un lado para conectarse al blindaje a través de bloques de terminales y por el otro lado al solenoide con terminales de crimpado de desconexión hembra que se ajustan al solenoide, integrando un diodo 1N4007. El cátodo del diodo debe estar conectado al lado de 12V, el ánodo a GND.

La válvula, el CANZERO y el protector GO-24 se pueden colocar en una caja y conectar a la red NoCAN, así como a las tuberías de agua.

Software

Boceto de Arduino

Crearemos dos canales para controlar nuestro sistema de riego en el nodo CANZERO:

• Un canal llamado «riego/válvula»: enviar «1» (o «abrir») al canal abre la válvula mientras que enviar «0» (o «cerrar») cierra la válvula.
• Un canal llamado «riego/temporizador»: al enviar una cadena numérica mayor que 0 a ese canal, se abrirá la válvula durante la duración correspondiente en segundos.

Además, estos canales tendrán las siguientes propiedades:

• Enviar «0» al canal «riego/válvula» cancelará cualquier temporizador de riego en curso.
• Si se configura un temporizador, el nodo CANZERO actualizará el canal «riego/temporizador» con el tiempo de riego restante cada 10 segundos, proporcionando información al usuario.

La compuerta del Mosfet que controla el solenoide estará conectada al pin 0 de CANZERO/Arduino. También utilizaremos la librería Arduino RTC para fines de temporización, aprovechando la oscilación del cristal de 32.768K del CANZERO.

Esto nos proporciona el siguiente esquema.

#include <nocan.h>
#include <RTCZero.h> #define SOLENOID_PIN 0
NocanChannelId valve_cid ; NocanChannelId timer_cid ; uint32_t inicio , duración , último ; RTCZero rtc ;

String msg_to_string ( NocanMessage & msg )
{
// Los mensajes nocan siempre tienen una longitud <= 64 bytes
char buf [ 65 ];

para ( int i = 0 ; i < msg . data_len ; i ++ )
{
buf [ i ] = msg . data [ i ];
}
buf [ msg . data_len ] = 0 ;
devolver String ( buf );
}

void open_valve ( )
{
digitalWrite ( PIN_SOLENOID , ALTO );
Nocan.led ( verdadero ) ; }

void close_valve ( )
{
Nocan.led ( false ); digitalWrite ( SOLENOID_PIN , BAJO ); if ( duración > 0 ) Nocan.publishMessage ( timer_cid , » 0 » ) ; duración = 0 ; }

void setup () { //
Inicializa el RTC
rtc.begin ( );

Nocan.open ( ); Nocan.registerChannel ( » riego/ válvula » , & valve_cid ) ; Nocan.subscribeChannel ( valvula_cid ) ;

Nocan . registerChannel ( «riego/temporizador» , & timer_cid );
Nocan . subscribeChannel ( timer_cid );

pinMode ( SOLENOID_PIN , SALIDA );

cerrar_valvula ();
}

void loop () {
// coloca tu código principal aquí, para ejecutarlo repetidamente:
NocanMessage msg ;

si ( Nocan . recivePending ())
{
Nocan . reciveMessage ( & msg );

si ( msg . channel_id == valve_cid )
{
Cadena valve_str = msg_to_string ( msg );

si ( valve_str == String ( «cerrar» ) || valve_str == String ( «0» ))
{
cerrar_valvula ();
}

si ( válvula_str == String ( «abrir» ) || válvula_str == String ( «1» ))
{
abrir_valvula ();
}
}

si ( msg . channel_id == timer_cid )
{
Cadena duración_cadena = msg_to_string ( msg );

duración = duración_str . toInt ();

si ( duración > 0 ) {
último = inicio = rtc . getEpoch ();
open_valve ();
Nocan . publishMessage ( valve_cid , «1» );
}
}
}

si ( duración > 0 )
{
uint32_t ahora = rtc . getEpoch ();

if ( ahora – inicio >= duración ) {
cerrar_valvula ();
Nocan.publishMessage ( valvula_cid , «0» ) ; } de lo contrario { if ( ultimo != ahora && ( duración – ahora + inicio ) % 10 == 0 ) { Nocan.publishMessage ( timer_cid , String ( duración – ahora + inicio , DEC ) .c_str ( ) ); ultimo = ahora ; } } }

retraso ( 100 );
}

Con la última versión del IDE de Arduino, cargar el boceto al nodo es fácil: simplemente seleccione el nodo correcto en el submenú Herramientas/Puerto y haga clic en el botón «cargar».

Para obtener más detalles sobre cómo cargar bocetos, consulte la sección correspondiente en nuestro gran tutorial .

Pruebas

Nuestro sistema se puede probar con la interfaz web o desde la línea de comandos.

En la línea de comando, al nocancejecutarse en la puerta de enlace NoCAN de Raspberry-Pi: – escribir nocanc publish «watering/valve» 1debería abrir la válvula. – escribir nocanc publish «watering/valve» 0debería cerrar la válvula. – escribir nocanc publish «watering/valve» 0debería cerrar la válvula.

También podemos utilizar la interfaz de usuario web incorporada para controlar el sistema de riego. Inicie sesión en la puerta de enlace de Raspberry Pi y ejecute la interfaz de usuario web, por ejemplo, con el siguiente comando:

nocanc webui –web-server=»:8080″

Suponiendo, como ejemplo, que el gateway de Raspberry Pi tiene la dirección 192.168.0.32, puedes apuntar un navegador a http://192.168.0.32:8080 , donde encontrarás una pantalla similar a la siguiente:

Al hacer clic en los canales numerados 0 («riego/válvula») o 3 («riego/temporizador») podemos controlar el sistema de riego de la misma manera que podemos hacerlo en la línea de comandos.

Notas: nuestra propia configuración tiene muchos canales, incluido un conjunto de canales de temperatura/humedad/presión basados ​​en un sensor BME280 .

Programación del riego

La red NoCAN está controlada por una computadora Raspberry Pi equipada con un PiMaster HAT. ¡Este es el lugar perfecto para automatizar la programación de su sistema de riego con solo una línea de código!

Los sistemas Linux, como la distribución Raspbian que se ejecuta en muchas máquinas Raspberry Pi, ofrecen una herramienta muy sencilla para programar tareas de forma periódica: cron. El sitio web de Raspberry-Pi ya ofrece un tutorial rápido y útil sobre cómo programar tareas cron, por lo que no entraremos en detalles aquí.

Suponiendo que la nocancherramienta ha sido instalada en el /usr/local/bin/nocancdirectorio y que el temporizador de riego está controlado por el canal llamado watering/timer, podemos programar una sesión de riego de 10 minutos todos los días a las 8:00 AM, utilizando la siguiente entrada creada con crontab -e:

0 8 * * * /usr/local/bin/nocanc publicar «riego/temporizador» 600

Yendo más allá

Agregar más nodos

¿Qué sucede si tenemos varios nodos que controlan cada uno una (o más) válvulas? Cada nodo tendría que crear canales con un nombre diferente para distinguir las diferentes válvulas, por ejemplo, «riego1/válvula», «riego2/válvula», etc. Esto significaría que tendríamos que escribir una versión ligeramente diferente de nuestro boceto para cada nodo, cambiando el nombre de los canales en cada boceto.

Afortunadamente, hay un pequeño truco que podemos usar para simplificarnos la vida: si insertamos la cadena $(ID)en un nombre de canal utilizado en NoCAN, esa parte del nombre del canal se reemplazará por el ID de nodo real del nodo CANZERO que crea el canal. Por lo tanto, en nuestro boceto, podemos reemplazar la siguiente línea:

Nocan.registerChannel(«riego/válvula», &valve_cid);

con:

Nocan.registerChannel(«riego/$(ID)/válvula», &valve_cid);

Si el nodo que crea el canal es el número de nodo ‘6’, entonces el canal creado será watering/6/valve. Si 3 nodos diferentes ejecutan el mismo boceto, crearán 3 canales, cada uno con un nombre diferente según su identificador de nodo. Los identificadores de nodo permanecen constantes a lo largo de los reinicios del nocandservidor, por lo que, por ejemplo, podemos usar el canal watering/6/valveen nuestro script crontab ya que no cambiará.

Procederíamos de manera similar para el canal watering/timerque sería reemplazado porwatering/$(ID)/timer

¡Solo necesitamos escribir un boceto de Arduino y podemos implementarlo en tantos nodos como sea necesario!

Reflexiones finales

Para simplificar las cosas, en esta entrada del blog se presentó un sistema de riego básico pero funcional basado en la plataforma NoCAN IoT. Es fácil ampliarlo agregando una bonita interfaz web para controlar y programar las operaciones de riego. También puedes conectar este sistema a blynk para controlar el riego de las plantas con un teléfono inteligente, ¡incluso si estás lejos de tu jardín!

Como siguiente paso, intentaremos añadir un sensor capacitivo de humedad del suelo para programar el riego en función de la humedad del suelo. ¡Pero esto es para otra entrada del blog!