UnifiedWater v1

Acerca de este proyecto

Descripción general

Ríos. Esencial para nuestra supervivencia, comercio, etc. Se han realizado grandes esfuerzos en la última década para reducir nuestra contaminación de las masas de agua del mundo. Los ríos son la fuente de la contaminación, ya que la gente no va al mar a tirar la basura. Lo tiran a los ríos.

Estos ríos luego se derraman en el mar, el océano y, por lo tanto, el cepillo de dientes que una vez fue arrojado a un río atraviesa el mundo y aterriza al otro lado de él.

En un mundo que intenta combatir la contaminación, los datos son cruciales. Debería ser fácil para las empresas y las empresas colaborar en un proyecto global para reducir la contaminación del agua. Aquí es donde entra UnifiedWater.

Un dispositivo lo suficientemente barato y escalable que puede recopilar y analizar fácilmente estos datos, tan necesarios para saber qué tan contaminado está un río. WaterAid viene en 2 modos, uno para empresas y otro para particulares.

Varios dispositivos pueden funcionar juntos, colocados en diferentes puntos a través de un arroyo o en diferentes cuerpos de agua. Estos dispositivos recopilan datos en un intervalo de tiempo enviándolos a la misma base de datos. Esto permite que la empresa verifique el estado del río o lago que se está monitoreando con solo hacer clic en un botón.

También está disponible una versión portátil del dispositivo. En esta versión, el individuo puede llevar consigo el dispositivo y cuando desea tomar una muestra de agua, presiona un botón en el dispositivo y lo coloca en agua durante 30 segundos. Los datos estarán disponibles en un panel en línea.

Al recopilar la temperatura, el pH y la humedad del agua, así como la temperatura y la humedad atmosféricas, WaterAid incluye todos los sensores que necesitaría para controlar la contaminación del río.

Video

Imágenes

Funcionalidad

WaterAid permite al usuario, a una empresa o un particular recopilar datos de forma segura y precisa y visualizar todos estos datos en un solo lugar gracias a la nube de Soracom. El proyecto se compone de un front-end y un backend.

Frente Fin

La parte frontal del proyecto es el dispositivo físico que se utiliza para recopilar los datos y enviarlos a la nube. El dispositivo se puede configurar en el modo 1 o 2. En el modo 1, el dispositivo registra un conjunto de datos con solo presionar un botón, útil para monitorear ocasionalmente una masa de agua. El Modo 2 configura el dispositivo para tomar lecturas en un intervalo de tiempo definido y enviar estos datos a la nube.

Se utiliza un MKR GSM para la interfaz, ya que es fácil de usar y confiable. También puede acceder a Soracom a través de GSM. A continuación, se muestran los pasos que sigue el dispositivo al recopilar datos.

Batería

El dispositivo se puede alimentar de varias formas. Puede ser alimentado por una batería LiPo a través del puerto provisto en el dispositivo, por un banco de energía o conectando una batería a través del puerto VIN en el dispositivo.

La vida útil del dispositivo depende en gran medida de la energía de la batería. El dispositivo entra en modo de suspensión entre lecturas para conservar la mayor cantidad de energía posible.

LED Anillo

El dispositivo también está equipado con un anillo LED. Esto proporciona al usuario información sobre lo que está haciendo el dispositivo en ese momento. Hay 3 modos en los que puede estar el anillo.

• Multicolor indica que el dispositivo se está configurando o está procesando datos
• Rojo intermitente una advertencia, que generalmente significa que el dispositivo debe colocarse en el agua, aunque también podría indicar un error
• Progresando azul o verde indica que el dispositivo está tomando una muestra y debe colocarse en agua.

Tomando una muestra

Todos los sensores del dispositivo deben colocarse en el agua cuando el dispositivo está tomando una muestra. Se coloca un retraso de 6 segundos antes de tomar la muestra para calentar los sensores. Para obtener los mejores resultados, los sensores deben sumergirse durante el calentamiento.

Análisis de datos

Los datos deben enviarse a Soracom en forma de una cadena JSON. Esto le da un valor a todas las claves utilizadas. Entonces, los datos serán fáciles de interpretar por el backend. A continuación se muestra un ejemplo de una carga útil que se enviaría.

  {
 "Latitud":53.3474617, 
 "Longitud":- 6.2514529, 
 "waterpH":7.30, 
 "waterTurbidity":94, 
 "waterTemp":12.10, 
 "atmoTemp":14.50, 
 "atmoHum":82, 
 "deviceID":1, 
 "deviceName":"device1", 
 "época":1559392636, 
 "modo":2 
}  

El Backend

El backend del proyecto se refiere a Soracom. Los datos se recopilan y visualizan en el backend de los paneles. Estos paneles se crean utilizando Soracom Lagoon.

El panel

El tablero resume todos los datos recopilados del dispositivo. Traza los lugares de los que se recopilaron los datos en un mapa, el color varía según la contaminación del agua. Luego, los datos se grafican en gráficos lineales debajo de eso y luego se resumen completamente en una tabla.

El usuario también recibirá alertas por correo electrónico si el valor del pH o la turbidez del agua es anormal. A continuación se muestran algunas capturas de pantalla del panel.

Escalabilidad

El dispositivo puede ser fácilmente escalable y todos los datos se pueden recopilar e ilustrar en el mismo tablero. Múltiples dispositivos pueden transmitir datos al Soracom y visualizar los datos en el tablero.

El precio del dispositivo y la extrema facilidad para construirlo y programarlo facilitan el uso de una flota de dispositivos. Estos dispositivos también se pueden registrar fácilmente en Soracom utilizando herramientas como Soracom Krypton.

Cada empresa o individuo tendrá su tablero personalizado donde se visualizarán los datos recolectados por sus dispositivos. Con suerte, las personas podrán colaborar en el mismo panel y compartir sus datos entre sí en un futuro próximo.

Beneficios

La persona o empresa que utilice este producto se beneficiará en:

• Costos de funcionamiento reducidos ya que el dispositivo es muy autosuficiente.
• Fácilmente escalable, el dispositivo puede funcionar fácilmente solo o en una flota de decenas de personas más.
• Recopilación rápida de datos que permite enviarlos a la nube y visualizarlos en tiempo real.
• Fácil visualización, los datos se pueden visualizar en cualquier lugar y en cualquier momento mediante el panel de control en línea.

Construyendo el Proyecto

Paso 1:Aparato requerido

Este proyecto requiere una gran cantidad de sensores que monitorearán muchos parámetros relacionados con el agua y la atmósfera colocados. A continuación se muestra una lista de todos los materiales necesarios.

• 1, Arduino MKR GSM
• 1 anillo de LED RGB de 16 LED
• 1, módulo de temperatura y humedad GY-21
• 1, sensor de turbidez
• 1, sensor de temperatura impermeable
• 1, sensor de pH y módulo
• 1, botón
• 1, resistencia (220Ω)
• Cables de puente

Paso 2:conexión del circuito

Los componentes deben soldarse juntos. Para facilitar la comprensión de los esquemas, se ha utilizado una placa de pruebas. los esquemas están a continuación.

Preparación del MKR GSM

Una vez que los sensores se han soldado al dispositivo, la tarjeta SIM, la antena GSM y la batería deben conectarse al dispositivo. Estoy alimentando la placa con 2 pilas AA a través del puerto VIN. Los pasos se encuentran a continuación.

Paso 3:reconocimiento del código

Hay 4 secciones principales en el código del proyecto.

• Recopile datos del sensor
• Obtener la fecha y la hora
• Procesar datos
• Enviar datos

Todas estas secciones se describen y detallan a continuación.

Recopilar datos del sensor

  Serial.println ("Tomando muestra"); 
 Serial.println ("________________________________________"); 
 Serial.println ("Tomando muestra"); 
 Serial.println ("OK - Calentando"); 
 retraso (6000); // retraso para la calibración del sensor 
 colourLED (50); 
 Serial.println ("OK - Tomando muestra"); 
 Serial.print (""); 
 for (int i =0; i <16; i ++) 
 {
 if (modo ==1) 
 {
 strip.setPixelColor (i, strip.Color (0, 255, 0 )); 
 strip.show (); 
} 
 else 
 {
 strip.setPixelColor (i, strip.Color (0, 0, 255)); 
 strip.show (); 
} 
 // vamos a tomar varias muestras de agua - los sensores no son tan precisos 
 waterTurbidity + =getWaterTurbidity (); 
 waterPh + =getWaterPh (); 
 if (i> 14) 
 {
 // tomar una sola muestra para sensores de alta precisión 
 waterTemperature =getWaterTemp (); 
 atmoTemperature =getAtmoTemp (); 
 atmoHumidity =getAtmoHumidity (); 
} 
 Serial.print ("."); 
 delay (500); 
} 
 Serial .println (""); 
 Serial.println ("Correcto - Muestras tomadas"); 
 para (int i =0; i <=16; i ++) 
 {
 strip.setPixelColor (i, strip.Color (0, 0, 0)); 
 strip.show (); 
 delay (30); 
} 
 Serial.println ("________________________________________"); 
 Serial.println (""); 
 retraso (500);  

La sección de código anterior comienza esperando 6 segundos para que los sensores se calibren en el agua. Luego, el dispositivo se repite 16 veces, un nuevo LED enciende el anillo en cada bucle.

Los datos de los sensores que tienen valores fluctuantes se recopilan 16 veces y luego se calcula la media. Los sensores de alta precisión se leen en el último bucle.

Obtener fecha y hora

  void getCredentials () 
 {
 Serial.println ("[1/2] Time"); 
 Serial.println ("OK - Obteniendo el tiempo de RTC"); 
 currentEpoch =processTime (); 
 colourLED (50); 
 Serial.println ("[2/2] Geolocalización"); 
 Serial.println ("OK - Obteniendo Geolocalización desde GPRS "); 
 while (! GetLocation ()); 
 Serial.print (" Correcto - La geolocalización es "); Serial.print (latitud, 7); Serial.print (","); Serial.println (longitud, 7); 
 colourLED (50); 
} 
 
 bool getLocation () 
 {
 if (location.available ( )) 
 {
 latitude =location.latitude (); 
 longitude =location.longitude (); 
 delay (500); 
 return true; 
} 
 else 
 {
 delay (500); 
 return false; 
} 
}  

El primer ciclo maneja las credenciales. La hora se extrae del RTC integrado, ya que se sincronizó con la red GSM en la configuración. La geolocalización se extrae de GPRS.

Procesar datos

  void processData () 
 {
 Serial.println ("OK - Obtener la media del pH y la turbidez del agua"); 
 waterPh =(waterPh / 16); 
 waterTurbidity =(waterTurbidity / 16); 
 Serial.println ("OK - Volcando datos a serial"); 
 Serial.println (""); 
 Serial.print ("[ Agua] pH "); Serial.println (waterPh); 
 Serial.print ("[Agua] Turbidez"); Serial.println (waterTurbidity); 
 Serial.print ("Temperatura [Agua]"); Serial.println (temperatura del agua); 
 Serial.print ("[Atmo] Temperature"); Serial.println (atmoTemperature); 
 Serial.print ("[Atmo] Humedad"); Serial.println (atmoHumidity); 
 Serial.println (""); 
 Serial.println ("Correcto - Datos procesados"); 
 colourLED (50); 
} 
 
 String makeLine () 
 {
 Serial.println ("OK - Making String"); 
 String dataReturned; dataReturned + ="{"; dataReturned + ="\ n"; 
 dataReturned + ="\" Latitud \ ":" + Cadena (latitud, 7); dataReturned + =", \ n"; 
 dataReturned + ="\" Longitud \ ":" + Cadena (longitud, 7); dataReturned + =", \ n"; 
 dataReturned + ="\" waterpH \ ":" + String (waterPh); dataReturned + =", \ n"; 
 dataReturned + ="\" waterTurbidity \ ":" + String (waterTurbidity); dataReturned + =", \ n"; 
 dataReturned + ="\" waterTemp \ ":" + String (waterTemperature); dataReturned + =", \ n"; 
 dataReturned + ="\" atmoTemp \ ":" + String (atmoTemperature); dataReturned + =", \ n"; 
 dataReturned + ="\" atmoHum \ ":" + String (atmoHumidity); dataReturned + =", \ n"; 
 dataReturned + ="\" deviceID \ ":" + String (deviceID); dataReturned + =", \ n"; 
 dataReturned + ="\" deviceName \ ":"; dataReturned + =String ("\" "); dataReturned + =String (nombre del dispositivo); dataReturned + =String (" \ ""); dataReturned + =", \ n"; 
 dataReturned + ="\" época \ ":" + String (currentEpoch); dataReturned + =", \ n"; 
 dataReturned + ="\" modo \ ":" + Cadena (modo); dataReturned + ="\ n"; 
 dataReturned + ="}"; 
 Serial.println ("OK - Los datos están debajo"); 
 Serial.println (""); 
 Serial.println (dataReturned); 
 Serial.println (""); 
 Serial.println ("Correcto - La cadena está lista"); 
 colourLED (50); 
 return dataReturned; 
}  

processData () obtiene la media de los datos recopilados de los sensores que tendían a fluctuar y luego vuelca todos los datos al Monitor en serie.

makeLine () compila todos los datos en la cadena JSON que se envía a Soracom. Todos los valores se analizan en un búfer JSON listo para enviarse al backend.

Enviar datos

  void parseData (String dataToSend) 
 {
 Serial.println ("OK - Configurando la conexión"); 
 if (client.connect (url, 80)) 
 {
 Serial.println ("OK - Conexión establecida, análisis de datos"); 
 client.println ("POST / HTTP / 1.1"); 
 client.println ("Host :harvest.soracom.io "); 
 client.println (" Usuario-Agente:Arduino / 1.0 "); 
 client.println (" Conexión:cerrar "); 
 client.print ("Content-Length:"); 
 client.println (dataToSend.length ()); 
 client.println (""); 
 client.println (dataToSend); 
 Serial.println ("OK - Datos analizados"); 
} 
 Serial.println ("OK - Obteniendo respuesta"); 
 Serial.println (""); 
 while (1) 
 {
 if (client.available ()) 
 {
 char c =client.read (); 
 Serial.print (c); 
} 
 if (! client.connected ()) 
 {
 break; 
} 
} 
 Serial.println ("Correcto - Los datos se analizan "); 
}  

Finalmente, los datos se envían a Soracom. El dispositivo estableció una conexión con el servidor y luego prepara las credenciales. Luego, los datos se envían al servidor y la respuesta se imprime en Serial Monitor.

Luego, el dispositivo entra en suspensión hasta que un disparador lo despierta repitiendo los pasos nuevamente.

Paso 4:configuración de las variables

Hay ciertas variables que deben editarse antes de poder utilizar el proyecto. Estos se enumeran a continuación. Las instrucciones para configurarlos también se encuentran a continuación.

• modo el modo del dispositivo dicta si toma muestras periódicamente o si toma muestras con la acción de un botón. Si esta variable se establece en 1, el dispositivo deberá activarse mediante un botón. Si el modo se establece en 2, el dispositivo tomará muestras periódicamente.
• deviceID y deviceName estas son variables personalizadas que se utilizan para identificar el dispositivo si se está utilizando una flota de dispositivos. Cada dispositivo utilizado debe recibir una identificación y un nombre únicos para que puedan identificarse fácilmente.
• sleepTime almacena la cantidad de tiempo que el dispositivo duerme entre lecturas, se establece en 5 segundos en el código que es apropiado para la prueba, pero debe cambiarse cuando se usa en el campo. Se puede tomar una muestra a intervalos de 15 minutos.
• proDebug se usa al depurar, se establece en falso en el código, pero si se necesita el monitor en serie al depurar, se debe establecer en verdadero. Tenga en cuenta que el dispositivo seguirá imprimiendo en serie incluso si la depuración está desactivada. Si la depuración está activada, el dispositivo no se ejecutará a menos que el monitor en serie esté activado.

Paso 5:carga del código

Antes de configurar el backend, se le deben enviar datos.

Para hacer esto, conecte su MKR GSM a su computadora y cargue el código en el dispositivo, asegúrese de que el modo del dispositivo esté configurado en 1 para esta configuración. Una vez que se haya cargado el código, coloque todos los sensores en agua.

Ahora presione el botón en el dispositivo y espere a que los datos se recopilen y envíen. Repita esto un par de veces para completar Soracom Air.

Paso 6:configuración de Soracom

Este paso se divide en 2 secciones, la primera cubrirá la creación de una cuenta con Soracom y el registro de su SIM, mientras que la otra cubrirá la configuración de Soracom Harvest para recopilar los datos de Air. Si ya tiene una cuenta con Soracom, omita la primera sección.

Sección 1:Creación de una cuenta

Sección 2:Grupos y cosecha

Paso 7:configuración de Lagoon

Lo último que debemos configurar en Soracom es Lagoon, esta es la herramienta que usaremos para visualizar nuestros datos y crear alertas por correo electrónico si los datos no son buenos. Siga los pasos a continuación.

Calibration Problems

The turbidity and pH sensors have to be calibrated to be used precisely, you might find that when running the code, the turbidity might by 105% or the pH of water 3. In this case, the sensors have to be calibrated. A quick guide into calibrating them is below.

• pH Sensor The pH sensor can be calibrated using the potentiometers on the module, place the probe in still bottled water of pH 7 and wait for 5 minutes, now develop a code that prints the pH from the sensor to the serial monitor. Twist the potentiometer until the pH is 7.
• Turbidity Sensor The turbidity sensor is not very precise and so a relative percentage, compared to pure water is taken. To refine the value of pure water, if your readings exceed 100% turbidity, you will need to place the turbidity sensor in pure water and develop a code that prints the voltage on the analog pin of the pH sensor to the serial monitor. A variable named calibration is found in sensors.h , change the value of that variable to the voltage received when the probe was placed in pure water.

Libraries

• ArduinoLowPower (c) 2016 Arduino LLC GNU Lesser General Public Licence this library is in the public domain
• Adafruit_Neopixel (c) Phil Burges Lesser General Public Licence this library is in the public domain
• MKRGSM (c) 2016 Arduino AG GNU Lesser General Public Licence this library is in the public domain
• Wire (c) 2006 Nicholas Zambetti GNU Lesser General Public Licence this library is in the public domain
• OneWire (c) 2007 Jim Studt GNU General Public Licence this library is in the public domain
• DallasTemperature GNU General Public Licence this library is in the public domain
• RTCZero (c) 2015 Arduino LLC GNU Lesser General Public Licence this library is in the public domain

Final

Finally, I got an enclosure done for the project that could be easily portable but be fixed to collect samples both in mode 1 and 2. Steps are below.

Finally, ensure that the mode is set accordingly and start using the device on the field. Check out your local river or lake and see how clean it is. Play around with the dashboard and see what other widgets it has.

Background

Today, data is the new currency and collecting it easily and efficiently is key to a better environment. By measuring the pollution of rivers and lakes collectively, we can raise awareness that the waters are getting dirtier and something has to be done.

I was thinking of an idea for the Soracom contest and I felt like I had to make something beneficial for the environment, the idea of people and companies working together on collective dashboards to visualise the status of rivers and lakes globally inspired me to take this project on.

What will you do to stop water pollution? Because action has to be taken today, and tomorrow is a day too late.

Esquemas

schematics_e7TRP6KJKI.fzz