UnifiedWater v1 – Kit Completo de Sensor de Qualidade da Água com Arduino

Componentes e Materiais

Arduino MKR GSM 1400	×	1
Anel Adafruit NeoPixel: WS2812 5050 RGB LED	×	1
GY21 Temperatura e Umidade	×	1
Sensor de Turbidez, Saída Fototransistor	×	1
Sensor de Temperatura Digital DS18B20 à Prova d'Água Adafruit	×	1
DFRobot Gravity: Kit Sensor pH Analógico Tipo Lança / Medidor	×	1
Chave Pushbutton 12mm SparkFun	×	1
Fios Jumper (genéricos)	×	1
Resistor 220 ohm	×	1

Ferramentas e Máquinas Necessárias

Ferro de Solda (genérico)

Aplicativos e Serviços Online

Arduino Web Editor

Plataforma de Conectividade IoT SORACOM Air

SORACOM Harvest

SORACOM Lagoon

Sobre o Projeto

Visão Geral

Rios. Essenciais para nossa sobrevivência, comércio e assim por diante. Grandes esforços foram feitos na última década para reduzir nossa poluição nos corpos d'água do mundo. Os rios são a fonte da poluição, pois as pessoas não vão ao mar para jogar lixo. Eles jogam nos rios.

Estes rios então desembocam no mar, no oceano e assim a escova de dentes que uma vez foi jogada em um rio faz seu caminho pelo mundo e aterrissa do outro lado.

Em um mundo tentando combater a poluição, dados são cruciais. Deveria ser fácil para empresas e negócios colaborarem em um projeto global para reduzir a poluição da água. É aqui que o UnifiedWater entra.

Um dispositivo barato o suficiente e escalável que pode facilmente coletar e analisar estes dados, tão necessários para saber o quão poluído um rio é. O WaterAid vem em 2 modos, um para empresas e outro para indivíduos.

Múltiplos dispositivos podem funcionar juntos, colocados em diferentes pontos de um rio ou em diferentes corpos d'água. Estes dispositivos coletam dados em um intervalo de tempo enviando para o mesmo banco de dados. Isso permite que a empresa verifique o status do rio ou lago monitorado com um clique.

Uma versão portátil do dispositivo também está disponível. Nesta versão, o indivíduo carrega o dispositivo e quando deseja coletar uma amostra de água, pressiona um botão no dispositivo e o coloca na água por 30 segundos. Os dados ficam então disponíveis em um painel online.

Coletando temperatura da água, pH e umidade, bem como temperatura e umidade atmosférica, o WaterAid vem com todos os sensores necessários para monitorar a poluição do rio.

Vídeo

Imagens

Funcionalidade

O UnifiedWater permite ao usuário, empresa ou indivíduo coletar dados de forma segura e precisa e visualizar todos estes dados em um só lugar graças à nuvem da Soracom. O projeto é composto por um front-end e um back-end.

Front-End

O front-end do projeto é o dispositivo físico usado para coletar os dados e enviá-los para a nuvem. O dispositivo pode ser configurado no modo 1 ou 2. No modo 1, o dispositivo registra um conjunto de dados com o pressionar de um botão, útil para monitoramento ocasional de um corpo d'água. O modo 2 configura o dispositivo para fazer leituras em um intervalo de tempo definido e enviar estes dados para a nuvem.

Um MKR GSM é usado no front-end pois é fácil de usar e confiável. Também pode acessar a Soracom via GSM. Abaixo estão os passos realizados pelo dispositivo ao coletar dados.

Bateria

O dispositivo pode ser alimentado de várias formas: por bateria LiPo pela porta fornecida no dispositivo, por power bank, ou conectando uma bateria pela porta VIN no dispositivo.

A vida útil do dispositivo depende muito da potência da bateria. O dispositivo entra em modo sleep entre leituras para economizar o máximo de energia possível.

Anel LED

O dispositivo também possui um anel LED. Isso fornece feedback ao usuário sobre o que o dispositivo está fazendo no momento. Existem 3 modos para o anel:

• Multicolorido indica que o dispositivo está configurando ou processando dados
• Vermelho Piscando um aviso, geralmente significando que o dispositivo deve ser colocado na água, embora também possa indicar erro
• Azul ou Verde Progressivo indica que o dispositivo está coletando uma amostra e deve ser colocado na água.

Coletando uma Amostra

Os sensores do dispositivo devem ser todos colocados na água quando o dispositivo está coletando uma amostra. Um atraso de 6 segundos é colocado antes da coleta para aquecer os sensores. Para melhores resultados, os sensores devem estar submersos durante o aquecimento.

Processando Dados

Os dados devem ser enviados para a Soracom na forma de uma string JSON. Isso dá a todas as chaves usadas um valor. Os dados ficam então fáceis de interpretar pelo back-end. Abaixo um exemplo de payload enviado.

{ 
 "Latitude":53.3474617, 
 "Longitude":-6.2514529, 
 "waterpH":7.30, 
 "waterTurbidity":94, 
 "waterTemp":12.10, 
 "atmoTemp":14.50, 
 "atmoHum":82, 
 "deviceID":1, 
 "deviceName":"device1", 
 "epoch":1559392636, 
 "mode":2 
}

O Back-End

O back-end do projeto refere-se à Soracom. Dados são coletados e visualizados no back-end em painéis. Estes painéis são criados usando o Soracom Lagoon.

O Painel

O painel resume todos os dados coletados do dispositivo. Plota os locais onde dados foram coletados em um mapa, a cor varia de acordo com o quão poluída a água está. Os dados são então grafados em gráficos de linha abaixo e totalmente resumidos em uma tabela.

O usuário também receberá alertas por email se o valor de pH ou turbidez da água forem anormais. Abaixo algumas capturas do painel.

Escalabilidade

O dispositivo pode ser facilmente escalável e todos os dados podem ser coletados e ilustrados no mesmo painel. Múltiplos dispositivos podem enviar dados para a Soracom e ter os dados visualizados no painel.

O preço do dispositivo e a extrema facilidade de construí-lo e programá-lo tornam fácil usar uma frota de dispositivos. Estes também podem ser facilmente registrados na Soracom usando ferramentas como Soracom Krypton.

Cada empresa ou indivíduo terá seu painel personalizado onde os dados coletados por seus dispositivos serão visualizados. Esperamos que no futuro próximo as pessoas possam colaborar no mesmo painel e compartilhar seus dados uns com os outros.

Benefícios

O indivíduo ou empresa utilizando este produto se beneficiará em:

• Custos operacionais reduzidos pois o dispositivo é muito auto-suficiente.
• Facilmente escalável, o dispositivo pode funcionar sozinho ou em uma frota de dezenas de outros.
• Coleta rápida de dados permitindo envio para a nuvem e visualização em tempo real.
• Visualização fácil, dados podem ser visualizados em qualquer lugar e a qualquer momento usando o painel online.

Construindo o Projeto

Passo 1: Aparelhos Necessários

Este projeto requer muitos sensores que monitorarão muitos parâmetros relacionados à água e à atmosfera. Abaixo a lista de todos os materiais necessários.

• 1 Arduino MKR GSM
• 1 Anel LED RGB de 16 LEDs
• 1 Módulo de temperatura e umidade GY-21
• 1 Sensor de turbidez
• 1 Sensor de temperatura à prova d'água
• 1 Sensor de pH e módulo
• 1 Pushbutton
• 1 Resistor (220Ω)
• Fios Jumper

Passo 2: Conectando o Circuito

Os componentes devem ser soldados. Para facilitar o entendimento dos esquemáticos, uma protoboard foi usada. Os esquemáticos estão abaixo.

Preparando o MKR GSM

Após os sensores serem soldados ao dispositivo, o cartão SIM, antena GSM e bateria devem ser conectados ao dispositivo. Estou alimentando a placa com 2 pilhas AA pela porta VIN. Os passos estão abaixo.

Passo 3: Entendendo o Código

Existem 4 seções principais no código do projeto.

• Coletar Dados dos Sensores
• Obter Hora e Data
• Processar Dados
• Enviar Dados

Todas estas seções são descritas e detalhadas abaixo.

Coletar Dados dos Sensores

Serial.println("Taking Sample");
 Serial.println("________________________________________");
 Serial.println("Taking Sample");
 Serial.println(" OK - Warming Up");
 delay(6000); // atraso para calibração dos sensores
 colourLED(50);
 Serial.println(" OK - Taking Sample");
 Serial.print(" ");
 for (int i = 0; i < 16; i++)
 {
 if (mode == 1)
 {
 strip.setPixelColor(i, strip.Color(0, 255, 0));
 strip.show();
 }
 else
 {
 strip.setPixelColor(i, strip.Color(0, 0, 255));
 strip.show();
 }
 // vai coletar múltiplas amostras de água - sensores não tão precisos
 waterTurbidity += getWaterTurbidity();
 waterPh += getWaterPh();
 if (i > 14)
 {
 // coleta amostra única para sensores de alta precisão
 waterTemperature = getWaterTemp();
 atmoTemperature = getAtmoTemp();
 atmoHumidity = getAtmoHumidity();
 }
 Serial.print(".");
 delay(500);
 }
 Serial.println("");
 Serial.println(" Success - Samples Taken");
 for (int i = 0; i <= 16; i++)
 {
 strip.setPixelColor(i, strip.Color(0, 0, 0));
 strip.show();
 delay(30);
 }
 Serial.println("________________________________________");
 Serial.println("");
 delay(500);

A seção de código acima começa esperando 6 segundos para os sensores calibrarem na água. O dispositivo então loopa 16 vezes, um novo LED acendendo no anel a cada loop.

Dados de sensores com valores flutuantes são coletados 16 vezes e então a média é calculada. Sensores de alta precisão são lidos no último loop.

Obter Hora e Data

void getCredentials()
{
 Serial.println(" [1/2] Time");
 Serial.println(" OK - Getting Time from RTC");
 currentEpoch = processTime();
 colourLED(50);
 Serial.println(" [2/2] Geolocation");
 Serial.println(" OK - Getting Geolocation from GPRS");
 while (!getLocation());
 Serial.print(" Success - Geolocation is "); Serial.print(latitude, 7); Serial.print(", "); Serial.println(longitude, 7);
 colourLED(50);
}
 
bool getLocation()
{
 if (location.available())
 {
 latitude = location.latitude();
 longitude = location.longitude();
 delay(500);
 return true;
 }
 else
 {
 delay(500);
 return false;
 }
}

O primeiro loop lida com as credenciais. A hora é extraída do RTC onboard pois foi sincronizada com a rede GSM no setup. A geolocalização é extraída do GPRS.

Processar Dados

void processData()
{
 Serial.println(" OK - Getting Mean of Water pH and Turbidity");
 waterPh = (waterPh / 16);
 waterTurbidity = (waterTurbidity / 16);
 Serial.println(" OK - Dumping Data to Serial");
 Serial.println("");
 Serial.print(" [Water] pH "); Serial.println(waterPh);
 Serial.print(" [Water] Turbidity "); Serial.println(waterTurbidity);
 Serial.print(" [Water] Temperature "); Serial.println(waterTemperature);
 Serial.print(" [Atmo] Temperature "); Serial.println(atmoTemperature);
 Serial.print(" [Atmo] Humidity "); Serial.println(atmoHumidity);
 Serial.println("");
 Serial.println(" Success - Data Processed");
 colourLED(50);
}
 
String makeLine()
{
 Serial.println(" OK - Making String");
 String dataReturned; dataReturned += "{"; dataReturned += " \n";
 dataReturned += "\"Latitude\":" + String(latitude, 7); dataReturned += ", \n";
 dataReturned += "\"Longitude\":" + String(longitude, 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(deviceName); dataReturned += String("\""); dataReturned += ", \n";
 dataReturned += "\"epoch\":" + String(currentEpoch); dataReturned += ", \n";
 dataReturned += "\"mode\":" + String(mode); dataReturned += " \n";
 dataReturned += "}";
 Serial.println(" OK - Data is below");
 Serial.println("");
 Serial.println(dataReturned);
 Serial.println("");
 Serial.println(" Success - String is Ready");
 colourLED(50);
 return dataReturned;
}

processData() obtém a média dos dados coletados dos sensores que tendem a flutuar e então imprime todos os dados no Monitor Serial.

makeLine() compila todos os dados na string JSON enviada para a Soracom. Todos os valores são parseados em um buffer JSON pronto para ser enviado ao back-end.

Enviar Dados

void parseData(String dataToSend)
{
 Serial.println(" OK - Setting Up Connection");
 if(client.connect(url, 80))
 {
 Serial.println(" OK - Connection Established, Parsing Data");
 client.println("POST / HTTP/1.1");
 client.println("Host: harvest.soracom.io");
 client.println("User-Agent: Arduino/1.0");
 client.println("Connection: close");
 client.print("Content-Length: ");
 client.println(dataToSend.length());
 client.println("");
 client.println(dataToSend);
 Serial.println(" OK - Data Parsed");
 }
 Serial.println(" OK - Getting Responce");
 Serial.println("");
 while(1)
 {
 if(client.available()) 
 {
 char c = client.read();
 Serial.print(c);
 }
 if(!client.connected()) 
 {
 break;
 }
 }
 Serial.println(" Success - Data is Parsed");
}

Finalmente, os dados são enviados para a Soracom. O dispositivo estabelece conexão com o servidor e prepara as credenciais. Os dados são então enviados ao servidor e a resposta impressa no Monitor Serial.

O dispositivo então entra em sleep até um gatilho acordá-lo, repetindo os passos novamente.

Passo 4: Configurando as Variáveis

Existem certas variáveis que devem ser editadas antes do projeto poder ser usado. Estão listadas abaixo. Instruções para configurá-las também estão abaixo.

• mode o modo do dispositivo dita se ele coleta amostras periodicamente ou se coleta amostras pela ação de um botão. Se esta variável for 1, o dispositivo precisará ser acionado por um botão. Se o modo for 2, o dispositivo coletará amostras periodicamente.
• deviceID and deviceName estas são variáveis personalizadas usadas para identificar o dispositivo se uma frota de dispositivos estiver sendo usada. Cada dispositivo deve receber um ID e Nome únicos para fácil identificação.
• sleepTime armazena o tempo que o dispositivo dorme entre leituras, definido como 5 segundos no código, apropriado para testes mas deve ser alterado para uso em campo. Uma amostra pode ser coletada em intervalos de 15 minutos.
• proDebug usado durante debug, definido como false no código mas se o monitor serial for necessário durante debug deve ser true. Note que o dispositivo ainda imprime no serial mesmo se debug off. Se debug on, o dispositivo não rodará a menos que o monitor serial esteja ligado.

Passo 5: Fazendo Upload do Código

Antes de configurar o back-end, dados devem ser enviados a ele.

Conecte seu MKR GSM ao computador e faça upload do código para o dispositivo, certificando-se que o modo do dispositivo está definido como 1 para esta configuração. Após o upload, coloque todos os sensores na água.

Agora pressione o botão no dispositivo e aguarde os dados serem coletados e enviados. Repita algumas vezes para popular o Soracom Air.

Passo 6: Configurando a Soracom

Este passo divide-se em 2 seções: a primeira cobre a criação de conta na Soracom e registro do SIM, a segunda cobre a configuração do Soracom Harvest para coletar dados do Air. Se já tem conta na Soracom, pule a primeira seção.

Seção 1: Criando uma Conta

Seção 2: Grupos e Harvest

Passo 7: Configurando o Lagoon

A última coisa a configurar na Soracom é o Lagoon, a ferramenta que usaremos para visualizar nossos dados e criar alertas por email se os dados não forem bons. Siga os passos abaixo.

Problemas de Calibração

Os sensores de turbidez e pH precisam ser calibrados para uso preciso. Você pode descobrir que ao rodar o código, a turbidez está em 105% ou o pH da água em 3. Neste caso, os sensores devem ser calibrados. Um guia rápido para calibrá-los está abaixo.

• Sensor de pH Pode ser calibrado usando os potenciômetros no módulo. Coloque a sonda em água engarrafada parada de pH 7 e aguarde 5 minutos. Desenvolva um código que imprima o pH do sensor no monitor serial. Gire o potenciômetro até o pH ser 7.
• Sensor de Turbidez Não é muito preciso, então uma porcentagem relativa comparada à água pura é usada. Para refinar o valor de água pura, se suas leituras excederem 100% de turbidez, coloque o sensor em água pura e desenvolva código que imprima a tensão no pino analógico do sensor de pH no monitor serial. Uma variável chamada calibration está em sensors.h, altere o valor dessa variável para a tensão recebida quando a sonda estava em água pura.

Bibliotecas

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

Final

Finalmente, fiz um gabinete para o projeto que podia ser facilmente portátil mas fixo para coletar amostras tanto no modo 1 quanto 2. Passos abaixo.

Finalmente, certifique-se que o modo está configurado adequadamente e comece a usar o dispositivo em campo. Confira seu rio ou lago local e veja quão limpo está. Brinque com o painel e veja quais outros widgets ele tem.

Contexto

Hoje, dados são a nova moeda e coletá-los fácil e eficientemente é chave para um ambiente melhor. Medindo a poluição de rios e lagos coletivamente, podemos aumentar a conscientização de que as águas estão ficando mais sujas e algo deve ser feito.

Estava pensando em uma ideia para o concurso da Soracom e senti que tinha que fazer algo benéfico para o meio ambiente. A ideia de pessoas e empresas trabalhando juntas em painéis coletivos para visualizar o status de rios e lagos globalmente me inspirou a assumir este projeto.

O que você fará para parar a poluição da água? Porque a ação deve ser tomada hoje, e amanhã é um dia tarde demais.

Código

Código

O repositório do projeto: https://github.com/Andrei-Florian/UnifiedWater-v1

Esquemáticos

schematics_e7TRP6KJKI.fzz