UnifiedWater v1 – Kit complet de capteur de qualité d'eau Arduino

Composants et fournitures

• Arduino MKR GSM 1400 × 1
• Anneau NeoPixel Adafruit : WS2812 5050 RGB LED × 1
• GY21 Température et Humidité × 1
• Capteur de turbidité, sortie phototransistor × 1
• Capteur de température étanche DS18B20 Adafruit × 1
• Kit pH Sensor / Meter DFRobot Gravity : Analog Spear Tip × 1
• Interrupteur poussoir 12mm SparkFun × 1
• Fils de connexion (générique) × 1
• Résistance 220 ohm × 1

Outils et machines nécessaires

• Fer à souder (générique)

Applications et services en ligne

• Arduino Web Editor
• Plateforme de connectivité IoT SORACOM Air
• SORACOM Harvest
• SORACOM Lagoon

À propos de ce projet

Vue d'ensemble

Les rivières. Essentielles à notre survie, au commerce, etc. De grands efforts ont été faits cette dernière décennie pour réduire notre pollution des plans d'eau mondiaux. Les rivières sont la source de la pollution, car les gens ne vont pas en mer pour jeter leurs déchets. Ils les jettent dans les rivières.

Ces rivières se déversent ensuite dans la mer, l'océan et ainsi la brosse à dents jetée un jour dans une rivière traverse le monde et atterrit de l'autre côté.

Dans un monde qui tente de lutter contre la pollution, les données sont cruciales. Il devrait être facile pour les entreprises de collaborer sur un projet mondial pour réduire la pollution de l'eau. C'est là qu'intervient UnifiedWater.

Un dispositif assez bon marché et évolutif qui peut facilement collecter et analyser ces données, si nécessaires pour savoir à quel point une rivière est polluée. WaterAid existe en 2 modes : un pour les entreprises et un pour les particuliers.

Plusieurs dispositifs peuvent fonctionner ensemble, placés à différents points d'un cours d'eau ou dans différents plans d'eau. Ces dispositifs collectent des données à intervalles réguliers et les envoient vers la même base de données. Cela permet à l'entreprise de vérifier l'état de la rivière ou du lac surveillé en un clic.

Une version portable du dispositif est également disponible. Dans cette version, l'individu peut emporter le dispositif et, lorsqu'il souhaite prélever un échantillon d'eau, il appuie sur un bouton du dispositif et le place dans l'eau pendant 30 secondes. Les données seront ensuite disponibles sur un tableau de bord en ligne.

En collectant la température de l'eau, le pH, l'humidité ainsi que la température et l'humidité atmosphériques, WaterAid est équipé de tous les capteurs nécessaires pour surveiller la pollution de la rivière.

Fonctionnalité

WaterAid permet à l'utilisateur, une entreprise ou un particulier de collecter des données de manière sûre et précise et de visualiser toutes ces données en un seul endroit grâce au cloud de Soracom. Le projet est composé d'un front-end et d'un back-end.

Front-End

Le front-end du projet est le dispositif physique utilisé pour collecter les données et les envoyer vers le cloud. Le dispositif peut être mis en mode 1 ou 2. En mode 1, le dispositif enregistre un ensemble de données sur pression d'un bouton, utile pour la surveillance occasionnelle d'un plan d'eau. Le mode 2 configure le dispositif pour prendre des relevés à un intervalle de temps défini et pousser ces données vers le cloud.

Un MKR GSM est utilisé pour le front-end car il est facile à utiliser et fiable. Il peut aussi accéder à Soracom via GSM. Voici les étapes suivies par le dispositif lors de la collecte de données.

Batterie

Le dispositif peut être alimenté de plusieurs façons : par une batterie LiPo via le port prévu, par une power bank, ou en connectant une batterie via le port VIN.

La durée de vie du dispositif dépend fortement de la capacité de la batterie. Le dispositif passe en mode veille entre les relevés pour économiser un maximum d'énergie.

Anneau LED

Le dispositif est également équipé d'un anneau LED qui fournit à l'utilisateur un retour visuel sur l'état actuel. Il y a 3 modes :

• Multicolore : le dispositif configure ou traite des données
• Clignotement rouge : avertissement, généralement signifie que le dispositif doit être placé dans l'eau, ou peut indiquer une erreur
• Progression bleue ou verte : le dispositif prend actuellement un échantillon et doit être placé dans l'eau

Prise d'un échantillon

Tous les capteurs du dispositif doivent être immergés lors de la prise d'un échantillon. Un délai de 6 secondes est prévu avant la prise de l'échantillon pour permettre aux capteurs de se stabiliser. Pour de meilleurs résultats, les capteurs doivent être immergés pendant la phase de stabilisation.

Traitement des données

Les données doivent être envoyées à Soracom sous forme de chaîne JSON. Cela donne une valeur à toutes les clés utilisées. Les données seront alors faciles à interpréter par le back-end. Voici un exemple de payload qui serait envoyé :

{
  "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
}

Back-End

Le back-end du projet fait référence à Soracom. Les données sont collectées et visualisées dans le back-end sur des tableaux de bord créés avec Soracom Lagoon.

Le Tableau de bord

Le tableau de bord résume toutes les données collectées par le dispositif. Il trace les lieux de collecte sur une carte, la couleur variant selon le niveau de pollution de l'eau. Les données sont ensuite graphiques en courbes et résumées dans un tableau.

L'utilisateur recevra aussi des alertes par email si la valeur du pH ou de la turbidité de l'eau est anormale.

Évolutivité

Le dispositif peut être facilement mis à l'échelle et toutes les données collectées et illustrées sur le même tableau de bord. Plusieurs dispositifs peuvent envoyer des données vers Soracom et avoir les données visualisées sur le dashboard.

Le prix du dispositif et la facilité extrême de le construire et le programmer permettent d'utiliser une flotte de dispositifs. Ceux-ci peuvent aussi être facilement enregistrés dans Soracom avec des outils comme Soracom Krypton.

Chaque entreprise ou particulier aura son tableau de bord personnalisé où les données collectées par ses dispositifs seront visualisées. Espérons que dans un futur proche, les gens pourront collaborer sur le même tableau de bord et partager leurs données.

Avantages

L'individu ou l'entreprise utilisant ce produit bénéficiera de :

• Coûts de fonctionnement réduits car le dispositif est très autonome
• Facilement évolutif, le dispositif peut fonctionner seul ou en flotte de dizaines d'autres
• Collecte de données rapide permettant d'envoyer les données vers le cloud et de les visualiser en temps réel
• Visualisation facile, les données peuvent être visualisées n'importe où et n'importe quand via le dashboard en ligne

Construction du projet

Étape 1 : Matériel requis

Ce projet nécessite de nombreux capteurs pour surveiller de nombreux paramètres liés à l'eau et à l'atmosphère. Voici la liste de tout le matériel nécessaire :

• 1 Arduino MKR GSM
• 1 Anneau LED RGB 16 LEDs
• 1 Module température/humidité GY-21
• 1 Capteur de turbidité
• 1 Capteur de température étanche
• 1 Capteur pH et module
• 1 Bouton poussoir
• 1 Résistance (220Ω)
• Fils de connexion

Étape 2 : Connexion du circuit

Les composants doivent être soudés ensemble. Pour faciliter la compréhension du schéma, une breadboard a été utilisée. Le schéma est ci-dessous.

Préparation du MKR GSM

Après avoir soudé les capteurs sur le dispositif, la carte SIM, l'antenne GSM et la batterie doivent être attachées. J'alimente la carte avec 2 piles AA via le port VIN.

Étape 3 : Comprendre le code

Il y a 4 sections principales dans le code du projet :

• Collecter les données des capteurs
• Obtenir l'heure et la date
• Traiter les données
• Envoyer les données

Collecter les données des capteurs

Serial.println("Taking Sample");
Serial.println("________________________________________");
Serial.println("Taking Sample");
Serial.println(" OK - Warming Up");
delay(6000); // délai pour calibration capteurs
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();
  }
  // plusieurs échantillons d'eau pour capteurs imprécis
  waterTurbidity += getWaterTurbidity();
  waterPh += getWaterPh();
  if (i > 14) {
    // un seul échantillon pour capteurs haute précision
    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);

Ce code attend 6 secondes pour la calibration des capteurs dans l'eau. Le dispositif boucle 16 fois, une nouvelle LED s'allumant sur l'anneau à chaque boucle. Les données des capteurs aux valeurs fluctuantes sont collectées 16 fois puis la moyenne est calculée. Les capteurs haute précision sont lus à la dernière boucle.

Obtenir l'heure et la date

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;
  }
}

La première boucle gère les identifiants. L'heure est extraite de l'horloge temps réel (RTC) embarquée car elle a été synchronisée avec le réseau GSM au setup. La géolocalisation est extraite du GPRS.

Traiter les données

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() calcule la moyenne des données collectées par les capteurs fluctuants et affiche toutes les données sur le moniteur série. makeLine() compile toutes les données dans la chaîne JSON envoyée à Soracom.

Envoyer les données

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");
}

Finalement, les données sont envoyées à Soracom. Le dispositif établit une connexion avec le serveur, prépare les identifiants, envoie les données et affiche la réponse sur le moniteur série. Le dispositif passe ensuite en veille jusqu'au prochain déclencheur.

Étape 4 : Configuration des variables

Certaines variables doivent être modifiées avant d'utiliser le projet :

• mode : mode du dispositif (1 = actionné par bouton, 2 = relevés périodiques)
• deviceID et deviceName : identifiants uniques pour chaque dispositif dans une flotte
• sleepTime : temps de veille entre relevés (5s pour test, 15min en production)
• proDebug : mode débogage (false en production, true pour débogage série)

Étape 5 : Téléversement du code

Connectez votre MKR GSM à l'ordinateur et téléversez le code, assurez-vous que le mode est à 1 pour la configuration. Après le téléversement, placez tous les capteurs dans l'eau, appuyez sur le bouton et attendez la collecte et l'envoi. Répétez plusieurs fois pour peupler Soracom Air.

Étape 6 : Configuration de Soracom

Cette étape est en deux sections : création de compte et enregistrement de la SIM, puis configuration de Soracom Harvest pour collecter les données.

Section 1 : Création de compte – Suivez les captures d'écran pour créer un compte Soracom, enregistrer la SIM, configurer le groupe, etc.

Section 2 : Groupes et Harvest – Configurez le groupe, activez Harvest, définissez le format de données, etc.

Étape 7 : Configuration de Lagoon

Dernière étape sur Soracom : configurer Lagoon pour visualiser les données et créer des alertes email si les données sont anormales. Suivez les captures d'écran détaillées.

Problèmes de calibration

Les capteurs de turbidité et de pH doivent être calibrés pour être précis.

• Capteur pH : Utilisez les potentiomètres sur le module. Placez la sonde dans de l'eau en bouteille pH 7 stable pendant 5 minutes. Développez un code qui affiche le pH sur le moniteur série. Tournez le potentiomètre jusqu'à obtenir pH 7.
• Capteur de turbidité : Pas très précis, on prend un pourcentage relatif par rapport à l'eau pure. Si vos relevés dépassent 100%, placez le capteur dans de l'eau pure et mesurez la tension sur la broche analogique. Modifiez la variable calibration dans sensors.h avec cette tension.

Bibliothèques

• ArduinoLowPower (c) 2016 Arduino LLC – LGPL
• Adafruit_Neopixel (c) Phil Burges – LGPL
• MKRGSM (c) 2016 Arduino AG – LGPL
• Wire (c) 2006 Nicholas Zambetti – LGPL
• OneWire (c) 2007 Jim Studt – GPL
• DallasTemperature – GPL
• RTCZero (c) 2015 Arduino LLC – LGPL

Finalisation

J'ai réalisé un boîtier pour le projet, facilement portable mais fixable pour collecter des échantillons en mode 1 et 2.

Enfin, assurez-vous que le mode est correctement réglé et commencez à utiliser le dispositif sur le terrain. Testez votre rivière ou lac local et voyez à quel point il est propre. Jouez avec le dashboard et découvrez ses autres widgets.

Contexte

Aujourd'hui, les données sont la nouvelle monnaie et les collecter facilement et efficacement est la clé d'un meilleur environnement. En mesurant collectivement la pollution des rivières et des lacs, nous pouvons sensibiliser au fait que les eaux se salissent et qu'il faut agir.

Je cherchais une idée pour le concours Soracom et je voulais faire quelque chose de bénéfique pour l'environnement. L'idée de personnes et d'entreprises travaillant ensemble sur des tableaux de bord collectifs pour visualiser l'état des rivières et lacs mondialement m'a inspiré ce projet.

Que ferez-vous pour arrêter la pollution de l'eau ? Car l'action doit être prise aujourd'hui, et demain sera un jour trop tard.

Code

Le dépôt du projet : GitHub UnifiedWater-v1

Schémas

schematics_e7TRP6KJKI.fzz