Sonda inalámbrica de humedad del suelo con helio y DFRobot

Acerca de este proyecto

Dale voz a tus plantas con un sensor de humedad del suelo inalámbrico

Seamos sinceros. Las plantas mueren todo el tiempo por falta de riego. Estás ocupado y esos helechos no van a levantar la mano cuando se sientan sedientos. Entonces, para el entusiasta de las plantas en movimiento, este prototipo de sonda de humedad del suelo es su boleto para helechos y ficus felices y saludables.

Qué cubriremos

De principio a fin, toda esta guía debería llevarle unos 60 minutos. Esto es lo que repasaremos:

• Construyendo su sonda completa de humedad del suelo usando el sensor de humedad del suelo capacitivo de gravedad del robot DF, un módulo de prototipos de átomos de helio, un adaptador de helio Arduino y una placa Arduino (fuimos con el UNO);

• Registrar su elemento de helio y su módulo de creación de prototipos de átomo de helio en el panel de control de helio; y construir su propia red inalámbrica de área amplia y de bajo consumo;

• Programación de la sonda de humedad del suelo a través del IDE de Arduino. En el camino también instalaremos Helium y ArduinoJson Bibliotecas Arduino;

• Medición y envío de datos de humedad del suelo casi en tiempo real desde su planta al Panel de control de helio; y conectarlo a un canal HTTP de helio.

Bien. Hagámoslo. Tenemos helechos para salvar.

Construcción de su sonda de humedad del suelo

Primero necesitamos construir la unidad sensora. Esto es fácil y rápido. Cuando haya terminado, su sonda completa debería verse así:

Para construir esto:

• Primero, inserte su módulo de prototipos de átomo de helio en el adaptador de helio Arduino y luego conecte esta unidad combinada a la placa Arduino que elija. Asegúrese de configurar el RX y TX puentes en consecuencia dependiendo de la placa que estés usando. Los detalles completos sobre cómo fijar todas estas placas juntas, junto con las configuraciones correctas de los puentes, se pueden encontrar aquí. Echa un vistazo, completa eso y vuelve.

• A continuación, debemos conectar la sonda de humedad del suelo real al adaptador Arduino de helio utilizando el cable puente de tres hilos que se proporciona con la sonda de humedad del suelo del robot DF. Los tres colores de los cables son negro , rojo y azul . En el adaptador de helio Arduino, el negro el cable se conecta a GND ; el rojo el cable se conecta a 5V ; y el azul el cable se conecta al ADO encabezamiento. Hay un gran diagrama del equipo de DFRobot sobre cómo funciona esta conexión aquí. Nuestra placa se ve así cuando el cableado se realiza correctamente:

• Por último, conecte el cabezal blanco del cable de puente a la sonda de humedad del suelo del robot DF. Aunque esto puede ser un poco complicado, debería encajar con el mínimo esfuerzo.

Implementación de su elemento de helio

Ahora es el momento de crear su propia red de helio. Esto tarda unos 30 segundos. (Si desea saber más sobre cómo se construye una aplicación de extremo a extremo en Helium y cómo manejamos el componente de red inalámbrica, comience con esta descripción general de la arquitectura).

Para implementar Element y crear cobertura de red para sus sensores basados ​​en Atom, simplemente conéctelo a la energía y a un puerto Ethernet activo usando los cables provistos. ( Nota:si tiene un elemento con respaldo celular, el uso de la conectividad Ethernet es opcional, pero se recomienda como respaldo. ) Una vez enchufado, verá algo de actividad LED. Tu Element estará conectado cuando el LED frontal se vuelva verde ( señalización de conectividad Ethernet ) o verde azulado ( para conectividad celular ). Puede ver un video corto sobre el Element y cómo conectarlo aquí.

Registro de su elemento de helio y átomo en Helium Dashboard

Ahora que nuestra unidad de detección está construida y su red de helio está implementada, es hora de registrar su hardware en Helium Dashboard. Dashboard es la interfaz de usuario alojada de Helium para monitorear y administrar implementaciones de hardware conectado. Todo el hardware que envía Helium ya está registrado en nuestro sistema, pero necesitamos saber quién lo está implementando.

• Primero, cree una cuenta de Helium Dashboard si aún no lo ha hecho.

• Para registrar su Atom, comience por seleccionar Nuevo Atom . En la interfaz de usuario, agregue un nombre (p. Ej., Fern Saver ) luego ingrese los últimos cuatro de su Dirección MAC y su Código HVV de cuatro dígitos . Pulsa Guardar . y tu estas listo.

• El registro del elemento se realiza exactamente de la misma manera. Seleccione Nuevo elemento, luego proporcione un nombre, los últimos cuatro de su Dirección MAC y su Código HVV de cuatro dígitos . También asegúrese de ingresar una ubicación para su elemento para que Dashboard pueda mostrarlo en un mapa.

Puede verificar que su Element está en línea mirándolo Estado y señal en el panel:

Implementación del canal HTTP de helio

Una característica importante de Helium Platform son los canales. Estos son conectores prediseñados para servicios web (como AWS IoT, Google Cloud IoT y Azure IoT) y protocolos (como MQTT y HTTP ). Con Channels, Helium ha hecho todo el trabajo pesado por usted cuando se trata de integrarse con uno de estos servicios o protocolos web. Para Fern Saver, nuestra sonda de humedad del suelo, activemos un canal HTTP. Esto nos permitirá canalizar datos a cualquier servicio web que acepte datos a través de HTTP. Por ejemplo, puede usar un canal HTTP para enviar estos datos a IFTTT y, a su vez, recibir un mensaje de texto cada vez que Fern Saver informa que la humedad está por debajo de cierto nivel.

En este ejemplo, configuraremos un canal HTTP que envía datos a requestb.in, un útil servicio web gratuito para probar servicios HTTP. Tenga en cuenta que a continuación, cuando carguemos el Sketch en Arduino, haremos referencia a este nombre de canal, HTTP , en el código para que sepamos dónde enviar los datos.

A continuación, le mostramos lo rápido y fácil que es configurar este canal:

Configurando su Arduino IDE y cargando el boceto

Ahora podemos pasar a configurar su IDE de Arduino e importar las bibliotecas necesarias. Para comenzar:

• Asegúrese de tener descargado el IDE de Arduino más reciente. Consíguelo aquí si es necesario.

• Luego, necesitaremos agregar dos bibliotecas: Helium y ArduinoJson . Puede agregar bibliotecas desde el IDE yendo a Sketch -> Incluir biblioteca -> Administrar bibliotecas. Busque "helio", selecciónelo y presione Instalar . Siga este mismo proceso de instalación para la biblioteca "ArduinoJson". (Necesitamos esta biblioteca porque la fecha de humedad del suelo que registraremos está formateada como JSON).

Una vez hecho esto, es hora de hacer una programación real de Arduino. La fuente completa del Sketch que cargaremos se puede encontrar aquí en GitHub. El siguiente es el Soil_Humidity.ino completo bosquejo.

  / * * Copyright 2017, Helium Systems, Inc. * Todos los derechos reservados. Consulte LICENCE.txt para obtener información sobre la licencia. * * Toma de lecturas de humedad con el sensor capacitivo de humedad * SEN0192. Instrucciones de cableado:* https://www.dfrobot.com/wiki/index.php/Capacitive_Soil_Moisture_Sensor_SKU:SEN0193 * * Instale las siguientes bibliotecas a través de Sketch-> Administrar bibliotecas:* - ArduinoJson * - Helium * / #include "Board.h "#include  #include  #include  #include  // Este nombre de canal debe corresponder al canal que ha implementado en Helium // Dashboard para ingerir este datos. #define CHANNEL_NAME "HTTP" // Retraso de un segundo #define CHANNEL_DELAY 5000 // Envía muy 60 ciclos (segundos) #define CHANNEL_SEND_CYCLE 12 Helio helio (&atom_serial); Canal de canal (&helio); int channel_counter; void report_status (int status, int result =0) {if (helium_status_OK ==status) {if (result ==0) {Serial.println (F ("Correcto")); } else {Serial.print (F ("Falló -")); Serial.println (resultado); }} else {Serial.println (F ("Fallido")); }} void connect () {while (! helium.connected ()) {Serial.print (F ("Conectando -")); int status =helium.connect (); report_status (estado); if (helium_status_OK! =estado) {retraso (1000); }}} void channel_create (const char * channel_name) {int8_t resultado; estado int; do {// Asegúrate de que estamos conectados connect (); Serial.print (F ("Creando canal -")); status =channel.begin (channel_name, &result); // Imprimir estado y resultado report_status (estado, resultado); if (helium_status_OK! =estado) {retraso (1000); }} while (helium_status_OK! =estado || resultado! =0); } void channel_send (const char * channel_name, void const * data, size_t len) {int status; resultado int8_t; do {// Intenta enviar Serial.print (F ("Enviando -")); status =channel.send (datos, longitud y resultado); report_status (estado, resultado); // Cree el canal si se devuelve algún error de servicio if (status ==helium_status_OK &&result! =0) {channel_create (channel_name); } else if (status! =helium_status_OK) {retraso (1000); }} while (helium_status_OK! =estado || resultado! =0); } configuración vacía () {Serial.begin (9600); Serial.println (F ("Iniciando")); helium.begin (HELIUM_BAUD_RATE); channel_create (CHANNEL_NAME); channel_counter =0; } #define DRY_VALUE 536 // Tomado en el aire #define WET_VALUE 303 // Tomado en el agua #define HUM_RANGE (DRY_VALUE - WET_VALUE) void loop () {Serial.print (F ("Lectura -")); lectura flotante =analogRead (A0); porcentaje flotante =100 * (1 - (lectura - WET_VALUE) / HUM_RANGE); Serial.print (lectura); Serial.print ("-"); Serial.println (porcentaje); if (--channel_counter <=0) {StaticJsonBuffer  jsonBuffer; JsonObject &root =jsonBuffer.createObject (); root [F ("valor")] =lectura; raíz [F ("porcentaje")] =porcentaje; búfer de caracteres [HELIUM_MAX_DATA_SIZE]; size_t utilizado =root.printTo (búfer, HELIUM_MAX_DATA_SIZE); channel_send (CHANNEL_NAME, búfer, usado); channel_counter =CHANNEL_SEND_CYCLE; } retraso (CHANNEL_DELAY); }  

Con el Helio y ArduinoJson bibliotecas instaladas, cree un nuevo boceto ( Archivo -> Nuevo desde dentro del IDE de Arduino) y pegue el código anterior. Luego, con el paquete completo de hardware de la sonda de humedad del suelo conectado a su estación de trabajo mediante un cable USB, presione Cargar botón.

Los LED de su módulo de creación de prototipos Atom deberían comenzar a parpadear después de unos momentos. Este es el Atom que se conecta a la red Helium (a través del Elemento que implementamos anteriormente). Si el IDE de Arduino no arroja ningún error al cargar el código, esto fue exitoso y la sonda de humedad del suelo ahora está generando lecturas.

Una nota sobre los datos de humedad del suelo

Como se señaló anteriormente, este boceto capturará los datos de humedad del suelo y los codificará como JSON antes de enviarlo a la plataforma Helium. Usando el Sketch anterior, un punto de datos se verá así (como JSON ):

  {"value":433, "percent":55.5}  

Vale la pena señalar que el sensor capacitivo de humedad del suelo por gravedad DFRobot en realidad captura estas lecturas como lecturas analógicas entre una lectura seca y húmeda calibrada. Puede obtener detalles completos sobre cómo se implementa y calibra aquí. Es posible que desee modificar un poco la calibración.

Verificación de la conectividad y los datos del sensor en Helium Dashboard

Ahora que su sensor está implementado, podemos verificar que esté en línea y transmitiendo datos. Dentro de Dashboard podemos hacer esto de varias formas, tanto a través de la IU de Atom vista para el sensor que acaba de implementar.

• Si su Atom está en línea, Dashboard mostrará su Estado y señal , junto con otros metadatos sobre su estado. Se verá así:

• Más abajo en la misma interfaz de Atom, también mostramos un Registro de eventos mostrando cada punto de datos del sensor y si se transmitió con éxito o no a un canal de helio. Como mencionamos anteriormente, estos son conectores prediseñados para servicios web o protocolos sin formato. Anteriormente, implementamos un canal HTTP para su organización Helium. Y el boceto anterior le dice a la sonda de humedad del suelo que envíe datos a este canal, llamado HTTP . Sin embargo, en este ejemplo que se muestra a continuación, estamos enviando nuestros datos al canal HTTP de helio:

• También proporcionamos una depuración interfaz para cada Atom que mostrará sus lecturas a medida que ingresan (una vez que haya habilitado esta opción). Aquí hay algunos datos de humedad del suelo en el visor de depuración de Dashboard:

Pasos siguientes y ayuda

¡Felicidades! Ese es el final de esta guía. Ahora ha preparado su helecho para el futuro con una sonda de humedad del suelo inalámbrica. Este es un gran problema. Tus helechos te lo agradecen.

Si desea obtener más información sobre el helio y cómo puede crear prototipos de sus propios sensores con este hardware y software, comience aquí:

• Documentación para desarrolladores de helio

• Desarrollador de helio Slack

• Foro de desarrolladores de helio

 / * * Copyright 2017, Helium Systems, Inc. * Todos los derechos reservados. Consulte LICENCE.txt para obtener información sobre la licencia. * * Toma de lecturas de humedad con el sensor capacitivo de humedad * SEN0192. Instrucciones de cableado:* https://www.dfrobot.com/wiki/index.php/Capacitive_Soil_Moisture_Sensor_SKU:SEN0193 * * Instale las siguientes bibliotecas a través de Sketch-> Administrar bibliotecas:* - ArduinoJson * - Helium * / # include "Board.h "#include  #include  #include  #include  #define CHANNEL_NAME" Helium MQTT "// Retraso por un segundo # define CHANNEL_DELAY 5000 // Envía muy 60 ciclos (segundos) #define CHANNEL_SEND_CYCLE 12Helio helio (&atom_serial); Canal canal (&helium); int channel_counter; voidreport_status (int status, int result =0) {if (helium_status_OK ==status) {if (result ==0) { Serial.println (F ("Correcto")); } else {Serial.print (F ("Falló -")); Serial.println (resultado); }} else {Serial.println (F ("Fallido")); }} voidconnect () {while (! helium.connected ()) {Serial.print (F ("Conectando -")); int status =helium.connect (); report_status (estado); if (helium_status_OK! =estado) {retraso (1000); }}} voidchannel_create (const char * channel_name) {int8_t resultado; estado int; do {// Asegúrate de que estamos conectados connect (); Serial.print (F ("Creando canal -")); status =channel.begin (channel_name, &result); // Imprimir estado y resultado report_status (estado, resultado); if (helium_status_OK! =estado) {retraso (1000); }} while (helium_status_OK! =status || result! =0);} voidchannel_send (const char * channel_name, void const * data, size_t len) {int status; resultado int8_t; do {// Intenta enviar Serial.print (F ("Enviando -")); status =channel.send (datos, longitud y resultado); report_status (estado, resultado); // Cree el canal si se devuelve algún error de servicio if (status ==helium_status_OK &&result! =0) {channel_create (channel_name); } else if (status! =helium_status_OK) {retraso (1000); }} while (helium_status_OK! =estado || resultado! =0);} voidsetup () {Serial.begin (9600); Serial.println (F ("Iniciando")); helium.begin (HELIUM_BAUD_RATE); channel_create (CHANNEL_NAME); channel_counter =0;} # define DRY_VALUE 536 // Tomado en el aire # define WET_VALUE 303 // Tomado en el agua # define HUM_RANGE (DRY_VALUE - WET_VALUE) voidloop () {Serial.print (F ("Lectura -")); lectura flotante =analogRead (A0); porcentaje flotante =100 * (1 - (lectura - WET_VALUE) / HUM_RANGE); Serial.print (lectura); Serial.print ("-"); Serial.println (porcentaje); if (--channel_counter <=0) {StaticJsonBuffer  jsonBuffer; JsonObject &root =jsonBuffer.createObject (); root [F ("valor")] =lectura; raíz [F ("porcentaje")] =porcentaje; búfer de caracteres [HELIUM_MAX_DATA_SIZE]; size_t utilizado =root.printTo (búfer, HELIUM_MAX_DATA_SIZE); channel_send (CHANNEL_NAME, búfer, usado); channel_counter =CHANNEL_SEND_CYCLE; } retraso (CHANNEL_DELAY);}