Surveillance intelligente de la qualité de l'air en ville basée sur LoRa

Outils et machines nécessaires

Imprimante 3D (générique)

Applications et services en ligne

	Arduino IDE
	Grandeur
	Grandeur Canvas

À propos de ce projet

Ville intelligente et qualité de l'air

La Banque mondiale définit une ville intelligente comme une ville à forte intensité technologique. Cela signifie des services publics très efficaces.

L'une des caractéristiques fondamentales des villes intelligentes est de fournir un environnement durable. Pour un environnement durable, il est nécessaire de surveiller les conditions environnementales pour identifier les sources de pollution et les atténuer. Dans ce contexte, des milliers de capteurs de qualité de l'air sont placés pour fournir des informations en temps réel au gouvernement et aux citoyens. Ces données peuvent être transformées en informations utiles, nous permettant de prendre de meilleures décisions, qu'il s'agisse de planifier les transports ou de savoir quel est le meilleur itinéraire pour se rendre au travail à pied.

La détection de la qualité de l'air correspond bien à la vision de la ville intelligente :fournir des informations sur une ville qui n'étaient pas disponibles auparavant, permettant aux gens de prendre des décisions qui peuvent améliorer leur qualité de vie.

Problème et solution

L'augmentation du niveau de pollution de l'air dans les grandes villes est devenue une préoccupation majeure en raison du risque qu'elle représente pour la santé humaine. Dans ce contexte, la technologie est devenue un outil très utile dans la surveillance de la contamination et l'atténuation possible de son impact. En particulier, il existe différentes propositions utilisant le paradigme de l'Internet des objets (IoT) qui utilise des capteurs interconnectés afin de mesurer différents polluants. Un réseau de nœuds de capteurs de surveillance de la qualité de l'air à faible coût peut être déployé pour surveiller la qualité de l'air et les paramètres météorologiques. Ainsi, grâce à la détection des sources de pollution, la ville peut prendre des mesures correctives et améliorer sa santé environnementale. En installant des systèmes de détection des catastrophes comme des solutions de surveillance des inondations et des précipitations dans votre environnement. les citoyens peuvent être alertés à l'avance en cas d'événement catastrophique. Une vue holistique est dérivable, permettant aux autorités de prendre des décisions de planification d'infrastructure et de politique basées sur les données.

Le plan du projet

Dans ce projet, nous allons surveiller quelques paramètres environnementaux les plus importants tels que le bruit, la température, l'humidité et la qualité de l'air. Il transmet des données en temps réel via un protocole de communication sans fil à une plate-forme cloud. L'équipement fonctionne entièrement à l'énergie solaire avec une batterie de secours. Les données de l'appareil sont accessibles sur un tableau de bord qui visualise et analyse les données dans les formats souhaités.

Pour une surveillance intelligente de la qualité de l'air dans les villes, vous devez placer des nœuds de capteurs à différents endroits. En termes de consommation d'énergie et de coût, ce n'est pas une bonne idée de connecter chaque nœud de capteur individuellement au cloud. C'est plutôt une bonne idée de collecter des données à partir de tous les nœuds de capteurs d'une petite zone et de publier toutes les données dans le cloud à partir d'une seule passerelle. LoRa peut nous donner cet avantage et c'est pourquoi j'ai choisi LoRa pour mon projet.

Pour le service cloud, j'utilise Grandeur pour mon projet. Grandeur est une plate-forme IoT relativement nouvelle, conviviale pour les fabricants, où nous pouvons stocker nos données et les visualiser en créant des widgets graphiques à l'aide de la méthode du glisser-déposer. Ils fournissent également Arduino, JavaScript et Python SDK avec des exemples de code. Ainsi, on peut facilement se connecter à leur service en utilisant Arduino, NodeMCU et Raspberry Pi.

La meilleure façon d'alimenter un nœud de capteur est d'utiliser un panneau solaire. Parce que les nœuds de capteurs sont placés dans un emplacement distant différent et qu'il n'est pas toujours possible de changer fréquemment la batterie ou de fournir de l'énergie à partir d'une source d'alimentation. J'alimente mon capteur note à l'aide du panneau solaire et de la batterie Li-ion.

Création du nœud de capteur

Je veux surveiller la qualité de l'air, le niveau de bruit, la température et l'humidité. J'ai donc utilisé le capteur de qualité de l'air Grove, le capteur de bruit Grove et le capteur de température et d'humidité Grove DHT11. Une bonne chose à propos des capteurs Grove est que vous pouvez connecter tous les capteurs Grove à Arduino à l'aide du blindage de base Grove sans aucune soudure.

Pour alimenter le circuit, j'ai utilisé un panneau solaire Grove 1W et une batterie Li-ion. Pour charger la batterie à l'aide du panneau solaire, j'ai utilisé le chargeur solaire Seeed LiPo Rider Pro doté d'un convertisseur boost 5V intégré. Nous pouvons donc facilement exécuter Arduino en utilisant la sortie du LiPo Rider.

La plupart des composants utilisés ici sont disponibles sur Seeedstudio.com. L'image suivante montre une connexion de test plug-and-play pour tous les composants du nœud de capteur.

Pour transmettre les données du capteur à la passerelle IoT, j'ai utilisé l'émetteur-récepteur Reyax LoRa. L'image suivante montre le module Lora Reyax RYLR998 avec le schéma des broches.

Préparation du moteur LoRa Reyax RYLR998 pour se connecter avec le bouclier de base Arduino

Le RYLR998 a une sortie à 5 broches mâles et n'est pas compatible avec le blindage de base Grove. Pour le connecter à Grove Shield, j'ai soudé un câble Grove dans un panneau perforé avec un en-tête femelle à 5 broches. La connexion du circuit est la suivante :

Le module LoRa RYLR998 peut fonctionner en toute sécurité jusqu'à 3,6V. La broche Arduino TX produit une sortie 5V qui n'est pas sûre pour le LoRa. J'ai donc utilisé un diviseur de tension pour obtenir 3,4 V de la broche Arduino TX. De l'autre côté, la broche Arduino RX fonctionne parfaitement sur la logique 3,3V. J'ai donc connecté directement la broche TX du LoRa à la broche RX de l'Arduino. Pour un fonctionnement normal, la broche RST du LoRa doit être à l'état haut.

Maintenant, le module LoRa ci-dessus peut facilement être connecté au blindage de base à l'aide du circuit convertisseur suivant.

Mais avant de connecter le module au blindage de base, assurez-vous que le bouton d'alimentation du blindage de base est en position 3,3 V, comme sur l'image ci-dessous.

Après avoir connecté le module LoRa au blindage de base, nous pouvons tester en envoyant une commande AT au module depuis Arduino.

Communication à l'aide de l'émetteur-récepteur LoRa RYLR896

Afin d'établir la communication entre deux modules LoRa, ils doivent pouvoir se trouver par une adresse. Le schéma d'adressage de l'écosystème LoRa dépend un peu des modules et de la mise en œuvre. En termes simples, le module nous permet de définir un identifiant de réseau et une adresse. Les modules sur le même réseau (même identifiant de réseau) peuvent communiquer entre eux. Chaque module est censé avoir un identifiant (adresse) unique au sein d'un réseau. Si un module a une adresse 0, ce module est capable de recevoir des données de tous les appareils du réseau.

Chaque module est livré avec une fréquence, un identifiant de réseau et une adresse par défaut, mais vous devrez peut-être modifier la valeur par défaut. L'identifiant de réseau par défaut pour le module ci-dessus est 18 et l'adresse à 0.

Nous n'avons pas besoin de changer quoi que ce soit pour le moment pour notre projet de démonstration. Mais si vous souhaitez modifier un paramètre, veuillez consulter la fiche technique pour les détails des commandes AT.

Pour envoyer un message (HELLO RECEIVER !), il suffit d'envoyer la commande « AT+SEND=0, 15, HELLO RECEIVER ! à la connexion série du module. La première valeur de paramètre « 0 » est l'adresse du module récepteur. La valeur suivante « 15 » est le nombre de caractères/octets à envoyer. La troisième valeur du paramètre est le message à envoyer :« HELLO RECEIVER ! » (15 caractères).

Code pour le nœud de capteur

Le code suivant est développé pour le nœud de capteur afin de collecter toutes les données de capteur et de les transmettre à la passerelle IoT.

#include "AirQuality.h" //bibliothèque sur la qualité de l'air du bosquet
#include "Arduino.h"
#include "DHT.h"

# définir DHTPIN 4 // à quelle broche numérique le capteur DHT est connecté
#define DHTTYPE DHT11 // modèle du capteur DHT11 

DHT dht(DHTPIN, DHTTYPE);

AirQuality airqualitysensor;
int current_quality =-1;

const int sampleWindow =50; // Largeur de la fenêtre d'échantillonnage en mS (50 mS =20 Hz)
échantillon int non signé ;
bruit flottant ;
température flottante, humide ;
qualité int air;

 //----------------------------------------------------------- ------------------------------------------------------------
 // CONFIGURATION
 //------------------------------------------ -------------------------------------------------- -
void setup() 
{
 
 Serial.begin(115200); //Série pour lora
 airqualitysensor.init(14);
 dht.begin();

}
 
//----- -------------------------------------------------- -------------------------------------
// BOUCLE PRINCIPALE
/ /------------------------------------------------- --------------------------------------------
 
void loop() 
{
 noise =calculate_sound_in_db();
 airQuality =calculate_air_quality();
 calculate_temp_humid();

 String temperature =String (temp);
 String humid =String(humid);
 String sound =String(noise);
 String air =String(airQuality);
 
 Valeurs de string =String(temperature)+","+ String(humidité)+","+ String(son)+","+ String(air);
 String cmd ="AT+SEND=0,"+String (values.length())+","+values ; //AT+SEND=
,,
 Serial.println(cmd); //envoyé à lora
 
 delay(15000);
}

//cette fonction calcule le niveau sonore en dB
float calculate_sound_in_db(){
 long startMillis=millis(); // Début de la fenêtre d'exemple
 float peakToPeak =0; // niveau crête à crête
 
 unsigned int signalMax =0; //valeur minimale
 unsigned int signalMin =1024; //valeur maximale
 
 // collecte des données pendant 50 mS
 tandis que (millis() - startMillis  {
 sample =analogRead(A1) ; //obtenir la lecture du microphone
 if (échantillon <1024) // rejeter les lectures parasites
 {
 if (échantillon> signalMax)
 {
 signalMax =échantillon ; // ne sauvegarde que les niveaux maximum
 }
 else if (sample  {
 signalMin =sample; // enregistre uniquement les niveaux minimum
 }
 }
 }
 peakToPeak =signalMax - signalMin; // max - min =amplitude crête-crête
 //Serial.println(peakToPeak); //écrire les déciBels calibrés
 float db =map(peakToPeak,0,1000,48,120); //calibrer pour les déciBels
 //Serial.print(db); //écrire des déciBels calibrés
 //Serial.println(" dB"); //write units
 return db;
}

int calculate_air_quality(){
 current_quality=airqualitysensor.slope();
 /*
 if (current_quality>=0)// si une donnée valide est retournée.
 {
 if (current_quality==0)
 Serial.println("Force pollution ! Force signal active"); 
 else if (current_quality==1)
 Serial.println("Haute pollution !");
 else if (current_quality==2)
 Serial.println("Faible pollution !");
 else if (current_quality ==3)
 Serial.println("Air frais");
 }
 */
 return current_quality;
}

void calculate_temp_humid(){
 // La lecture de la température ou de l'humidité prend environ 250 millisecondes !
 // Les lectures du capteur peuvent également être "anciennes" jusqu'à 2 secondes ( c'est un capteur très lent)
 float h =dht.readHumidity();
 // Lire la température en Celsius (par défaut)
 float t =dht.readTemperature();
 
 // Vérifiez si des lectures ont échoué et quittez plus tôt (pour réessayer).
 if (isnan(h) || isnan(t)) {
 //Serial.println("Impossible de lire depuis le capteur DHT !");
 return;
 }

 temp =t;
 humid =h; 
 /*
 Serial.print("Humidity:");
 Serial.print(h);
 Serial.print(" %\t");
 Serial.print("Température :");
 Serial.print(t);
 Serial.print(" *C ");
 */
}
 
//programme d'entretien d'interruption pour le capteur de qualité de l'air
ISR(TIMER1_OVF_vect)
{
 if(airqualitysensor.counter==61)//définir 2 secondes comme service détecté
 {

 airqualitysensor.last_vol=airqualitysensor.first_vol;
 airqualitysensor.first_vol=analogRead(A0);
 airqualitysensor.counter=0;
 airqualitysensor.timer_index=1;
 PORTB=PORTB^0x20;
 }
 else
 {
 airqualitysensor.counter++;
 }
} 

Le code envoie les données du capteur toutes les 15 secondes. Modifiez le calendrier en fonction de vos besoins.

Télécharger et tester

Connectez maintenant tous les capteurs, téléchargez le code ci-dessus et testez dans le moniteur série. Le fichier source est joint dans la section code.

Placement des composants à l'intérieur de la boîte

Nous allons maintenant placer tous les capteurs et la batterie à l'intérieur de la boîte. Tout d'abord, imprimez en 3D les deux fichiers STL joints dans la section des pièces jointes. Les images imprimées ressemblent à l'image suivante.

La boîte complète ressemblera à ce qui suit. Vous pouvez avoir besoin d'une base d'envoi sur la qualité de votre imprimante.

Après avoir préparé la boîte, fixez d'abord le panneau solaire en haut de la boîte. Les fils de connexion à l'intérieur de la boîte à travers le trou supérieur.

Ensuite, placez d'abord l'Arduino avec le blindage de base attaché avec du ruban adhésif chaud ou du ruban adhésif double face. Placez les autres capteurs un à un et fixez-les à un endroit fixe à l'aide de colle chaude.

Placez la batterie et le lipo rider pro et ajoutez enfin le module LoRa.

Le nœud de capteur est prêt à être déployé.

Configuration de Grandeur

Grandeur fournit un service backend pour les appareils IoT où une paire appareil-utilisateur virtuel est créée. Le modèle de périphérique est décrit lors de la création comme un objet JSON contenant diverses variables (température, humidité, noise_level, air_quality dans notre cas) qui peuvent être lues et écrites. Grandeur Canvas est une application Web qui peut être utilisée pour visualiser l'état des appareils couplés à l'aide de widgets graphiques.

Pour utiliser la Grandeur, nous devons faire notre compte et faire quelques configurations importantes sur la plateforme. Consultez leur site Web https://grandeur.dev/ pour entrer dans le jeu.

1. Après vous être connecté au compte root, créez un nouveau projet :

2. Créez un nouveau compte utilisateur depuis Ajouter un compte option depuis l'onglet Accueil ou depuis l'onglet Comptes. Nous nous connecterons plus tard à notre application avec l'e-mail et le mot de passe que nous créons maintenant. Voici une autre fonctionnalité intéressante de Grandeur :plusieurs utilisateurs peuvent utiliser votre application en se connectant avec leurs e-mails et mots de passe . Chaque utilisateur peut coupler ses propres appareils et l'appareil couplé par un utilisateur devient indisponible pour les autres. L'authentification est construite au cœur de Grandeur. La création d'un utilisateur est illustrée ci-dessous :

3. Maintenant, créez un nouvel appareil via l'onglet Appareils. Cette opération génère un nouvel ID d'appareil unique que nous utiliserons lors de l'écriture du code pour notre matériel et cet ID d'appareil est requis pour se connecter à Grandure à l'aide de l'API. La création d'un appareil génère également un accessToken. N'oubliez pas de le copier et il sera utilisé dans le code matériel et ne sera plus accessible après la fermeture de la boîte de dialogue . Vous devez ajouter un modèle d'appareil avant d'ajouter un appareil à l'aide de la procédure suivante. Un modèle d'appareil est utilisé pour décrire les variables qui peuvent être communiquées par/à l'appareil.

A partir des modèles cliquez sur Ajouter et donnez un nom de modèle. Dans le schéma, mettez toutes les variables (4 dans notre cas) au format JSON. Conservez la valeur 0 pour le moment. Ces variables seront mises à jour automatiquement lorsque nous enverrons des données à partir de notre nœud d'appareil.

 {"temp":0, "humid":0, "air":0, "noise":0} 

Après avoir mis le schéma, cliquez sur Ajouter.

Après avoir ajouté le modèle d'appareil, cliquez sur l'option Ajouter à partir des appareils et sélectionnez le modèle que vous venez de créer pour lier le modèle à l'appareil.

Donnez un identifiant d'appareil et cliquez sur Enregistrer.

Copiez le jeton d'accès et il sera utilisé dans le code matériel et ne sera plus accessible après la fermeture de la boîte de dialogue.

L'appareil est créé avec succès et notez également l'ID DE L'APPAREIL. Il sera également nécessaire pour le codage.

Un utilisateur ne peut pas interagir avec un appareil à moins qu'il ne soit associé à celui-ci. Il existe deux manières de associer votre appareil :1) en utilisant le Cloud Dashboard, ou 2) via l'application Web en utilisant pairDevice() fonction de l'API de l'appareil. Cette seconde voie a une signification très forte si on la regarde du point de vue de la production. Par exemple, vous pouvez désormais expédier vos produits matériels et vos utilisateurs peuvent se connecter à votre application et déclarer la propriété d'un matériel en l'associant. Voici comment associer votre appareil à un utilisateur à l'aide de Cloud Dashboard :

Pour coupler l'appareil, cliquez sur Coupler et choisissez un compte. Vous êtes prêt à passer à l'étape suivante.

4. Nous allons maintenant créer un canevas.

Dans le menu de gauche du tableau de bord, cliquez sur canvas ou allez sur https://canvas.grandeur.tech. S'il s'agit de votre première visite sur Canvas, un Autoriser le bouton apparaîtra. L'autorisation donne à Canvas un accès aux utilisateurs et aux appareils de votre projet. En cliquant sur le bouton "Autoriser", vous serez redirigé vers le tableau de bord Grandeur où vous serez invité à choisir le projet auquel vous souhaitez que Canvas se lie.

Choisissez un widget graphique et cliquez dessus. Le menu Configurer apparaîtra, puis cliquez sur Configurer pour donner un titre au graphique et définir la variable dont vous souhaitez afficher la valeur dans ce graphique.

Cliquez pour enregistrer.

En suivant la même procédure, ajoutez 4 widgets graphiques pour les 4 variables.

Après avoir connecté Canvas à votre projet, vous pouvez voir un écran de connexion. Vous devez vous connecter ici en tant qu'utilisateur de votre projet que vous avez créé précédemment, pour lequel vous devez créer un compte utilisateur dans votre projet. Vous pouvez le faire en visitant la page des comptes du tableau de bord. Ensuite, vous pouvez vous connecter à Canvas en utilisant les informations d'identification de ce nouvel utilisateur.

Preparing IoT LoRa Gateway

In a simple way, an IoT Gateway is like home or office network router or gateway that connects sensors, IoT modules, and smart devices to the cloud. Such a gateway facilitates communication between your devices, maintains security, and provides an admin interface where you can perform basic functions.

A true IoT gateway contains communication technologies connecting end-devices (sensors, actuators, or more complex devices) and backend platforms (data, device, and subscriber management) to the gateway. It has a computing platform allowing pre-installed or user-defined applications to manage data (for routing and computing at the edge), devices, security, communication, and other aspects of the gateway.

Raspberry Pi can be a good option for a gateway with lots of flexibility but to keep it simple I am using Node MCU as a gateway for this project. Node MCU will receive the data from the LoRa module using UART. Then using Arduino SDK we will upload the data to the Grandeur cloud platform.

Firmware for the Gateway

The following code was developed for the gateway using Arduino SDK provided by Grandeur cloud. Data is received in string form from the LoRa using the UART port. Then the received data is processed to separate the individual variable from the comma-separated string value. The values are then sent to Grandeur using WiFi. The following function was used to separate the variables.

void process_received_data(){
 
 start_pos =inputString.indexOf(start_val);
 end_pos =inputString.indexOf(end_val);
 String data_string =inputString.substring(start_pos+1, end_pos-1);
 //Serial.println(data_string);
 //identifying commas inn the string
 int firstCommaIndex =data_string.indexOf(',');
 int secondCommaIndex =data_string.indexOf(',', firstCommaIndex+1);
 int thirdCommaIndex =data_string.indexOf(',', secondCommaIndex+1);
 //seperating comma seperated value from the data string 
 String temperature =data_string.substring(0, firstCommaIndex);
 String humidity =data_string.substring(firstCommaIndex+1, secondCommaIndex);
 String noise_level =data_string.substring(secondCommaIndex+1, thirdCommaIndex);
 String air_auality =data_string.substring(thirdCommaIndex+1);
 
 //Serial.println(temperature);
 //Serial.println(humidity);
 //Serial.println(noise);
 //Serial.println(air_auality);

 temp =temperature.toFloat();
 humid =humidity.toFloat();
 noise =noise_level.toFloat();
 air =air_auality.toFloat(); 

 Serial.println(temp);
 Serial.println(humid);
 Serial.println(noise);
 Serial.println(air);
 
 inputString ="";
 stringComplete =false;
 } 

The complete code is attached in the code section.

Data Visualization