SmartHome par réseaux de capteurs sur Lora et station de mésure de la qualité de l’air connectée

De Ensiwiki
Aller à : navigation, rechercher


Project schedule.png
Titre du projet SmartHome par réseaux de capteurs sur Lora et station de mésure de la qualité de l’air connectée.
Cadre Projets Réseaux Mobiles et Avancés

Équipe Omar SOUFI,,Moncif TOUBOUH, Kenza HALABLY
Encadrants Franck Rousseau


Présentation du Projet

Lien vers le projet

Membres de l'équipe

  • Omar SOUFI
  • Moncif TOUBOUH
  • Kenza HALABLY

Introduction

SmartHome par réseaux de capteurs sur Lora et station de mésure de la qualité de l’air connectée. Dans le cadre du projet Réseaux Mobiles et Avancés, nous avons décidé d'utiliser à la fois des réseaux basses performances (Lora) et une plateforme IOT sur cloud (AWS IOT) afin de mettre en évidence le concept SmartHome. La taille du domaine IoT a explosé dans les dernières années, aujourd'hui il y a une infinité d'applications et différents capteurs. À ce propos,on a décidé de travailler sur une carte nucleo avec un shield LoRa expansion board connecté avec différent capteurs (température,humidité,mouvement,...) comme une simulation d'une maison intelligente.En exploitant le réseau "The things Network" considéré comme un réseau LoRaWAN collaboratif permetant à un utilisateur de profiter du réseau Lora, et de s'informer sur la situation actuelle de sa maison.

Objectifs

l’objectif est de mettre en amont le concept SmartHome à travers un réseau de capteurs, et d’essayer de se familiariser avec l'utilisation des réseaux wifi basse consommation en loccurence Lora afin de transmettre les données, mais également de le coupler avec d’autres technologies (WIFI). L'exploitation d'un réseau à faible débit nécessite un traitement sur le site de production de l'information, nous avons donc utilisé des modules appropiés. Des données issues des capteurs, une fois traitées, sont envoyées au serveur "LoRa serveur" puis récupérées et affichées sur une page web à travers The Things Network et pouvoir afficher les résultat à l'aide d'une API web adaptée à notre cas !!!.

Matériels et outils

Matériels

partie Lora

station connectée

Outils logiciels

Architecture et workflow

Le workflow global de notre application se résume dans les étapes suivantes:

  • La carte Nucleo est connectée avec un ordinateur par un câble USB,cette carte est attachée aux capteurs et au sx1272mb2das lora rf expansion board.
  • Les données des capteurs sont envoyées à l'aide du shield LoRa vers l'ensemble des Gateway LoRa disponibles.
  • Les Gateway vérifient la connexion au noeud LoRa et renvoient les données vers The Things Network (TTN).

En exploitant les intégrations de réseau TTN ,on peut visualiser les données des capteurs dans un tableau de bord (my device).

  • La carte qui matérialise la station récupere les données relatives à la qualité de l'air et à la densité des cellules via les capteurs.

on réalise un traitement sur les données afin de mésurer la qualité de l'air.

  • Le module wifi se connecte au point d'accés configuré, afin d'envoyer les données qu'on récupere sur le cloud AWS.

Les données seront stockées sur AWS afin d'effectuer des traiments statiqtiques, et en fonction des mésure observées l'utilisateur et notifié, et un système d'alerte est mis en place.

  • L'application finale reçoit les données à la fois de la station et du module Lora.

Vision globale

partie Lora

Narchi.png

Station Connectée

  • L'architecture de la station se présente comme suit:

20.png

Principes de fonctionnement

partie Lora

Capteur de température

Le capteur de température haute précision I2C (MCP9808) est un module numérique de haute précision basé sur MCP9808. Contrairement à d'autres capteurs, vous pouvez choisir la résolution de mesure de ce capteur. En plus des mesures de température de haute précision,il propose également une alerte de température programmable.

  • Caractéristiques:
  *Haute précision
    ± 0,25 (typique) de -40 ° C à + 125 ° C
    ± 0,5 ° C (maximum) de -20 ° C à 100 ° C
    ± 1 ° C (maximum) de -40 ° C à + 125 ° C
  *Résolution de mesure sélectionnable par l'utilisateur
    + 0,5 ° C, + 0,25 ° C, + 0,125 ° C, + 0,0625 ° C
  *Interface I2C

station connectée

Capteur de gaz

  • Le MQ135 est un capteur qui permet de mesurer la qualité de l’air. Le MQ135 est sensible à aux principaux polluants présents dans l’atmosphère de la maison. Ce capteur est sensible au CO2, à l’alcool, au Benzène, à l’oxyde d’azote (NOx) et à l’ammoniac (NH3).
  • Ce capteur utilise le dioxyde d’étain (SnO2) dont la conductivité électrique varie en fonction de la présence de polluant(s) . Comme tous les capteurs de la série MQ il faudra procéder à une calibration dans une atmosphère de référence pour mesurer la présence d’un polluant en particulier ref.
  • La figure suivante montre la sensibilité du capteur pour différents gaz.

1.png

  • Ce qui nous a obligé de calculer le taux Rs/R0 = 3,45 et d'avoir l'équation de calcul suivante: ppm =10e(1+(log10(RS/R0)-log10 2,539))/gas slope) ce qui coïncide au graphe suivant:

2.png

  • Pour le fonctionnement interne, il s’opère selon le schéma ci-après:

3.png

  • Ce qui nous obligé d'avoir les paramètres ci-après:
    • 3,3 V ADC
    • RL = 10 k ohm

Capteur de particules

  • Les principales caractéristiques de ce capteur sont:
    • Courant de faible consommation (MAX.20 mA)
    • Détection de poussière dans l'air
    • Distinguer la fumée de la poussière.
  • Le capteur fonctionne selon le shémas suivant:

4.png

  • La valeur de sortie spécifiée est celle qui est mesurée 0,28 ms après l'allumage de la LED.

5.png

Module WIFI

  • Le module WIFI permet d'envoyer les données vers Cloud AWS en se connectant au point d’accès déjà configuré.
  • Le module fonctionne selon la figure suivante:

8.png

IOT avec STM32L4

  • La plateforme IOT proposée par AWS se présente comme suit:

9.png

  • La connexion se fait à travers la configuration qui sera détaillée dans la partie tutorial en utilisant le module Wifi.

Amazon FreeRtos

  • Amazon FreeRTOS est un système d'exploitation temps réel qui complète le noyau FreeRTOS avec des bibliothèques pour la connectivité, la sécurité et les mises à jour OTA. Amazon FreeRTOS inclut également certaines applications de démonstration qui illustrent les fonctions Amazon FreeRTOS sur des cartes qualifiées.

14.png

Tutoriel

Le tutoriel suivant vous permettra de reproduire la pile décrite dans l'introduction de cette page et de récupérer des données em temps réels des capteurs.

Partie Lora

Pour pouvoir mettre en place cette application il faut suivre les étapes suivantes:

Installation des outils nécessaires

Note: On a utilisé Windows pour cette partie pour faciliter l'installation des outils.

  • Installer STM32CubeIDE
  • Installer PUTTY
  • Récupérer le projet "st-lrwan" donné par le professeur.
  • Choisir le projet convenable avec la carte nucleo et le shield LORA.

Préparation de la carte nucleo STM32l0rZ

  • les jumper JP1 et JP6 doivent être fermer.
  • le jumper JP5 doit être positionner sur E5V.
  • Brancher la carte au ordinateur .
  • vérifier que la carte est connecté à votre ordinateur.
  • Faire une application dans laquelle on traite les données avant de les stocker (développement d'un système distribué).

Configuration du compte The Things Network

  • Créer un compte.
  • Ajouter une application (Console -> Applications -> add application).
  • Remplir les différents champs:
 *Application ID: donner un nom à l'application. 
 *Description: Décrire votre application.
 *Application EUI: "Générer automatiquement".
 *Handler registration : ttn-handler-eu.
  • Ajouter un dispositif à votre application:
 *Device ID: ajouter un id à votre dispositif.
 *Device EUI: Générer automatiquement.
 *App Key: Générer automatiquement.
 *App EUI: Générer automatiquement.

Configuration du shield LORA

  • Chercher le fichier Commisionnig.h dans le projet "st-lrwan" et modifier les paramètres suivantes:
  #define OVER_THE_AIR_ACTIVATION                   1
  #define LORAWAN_PUBLIC_NETWORK                  true
  #define STATIC_DEVICE_EUI                         1
  #define LORAWAN_DEVICE_EUI                 // indiquer le device-EUI de votre application (big endian)
  #define LORAWAN_APPLICATION_EUI           // indiquer le application-EUI de votre application (big endian)
  #define LORAWAN_APPLICATION_KEY          // indiquer le application-key de votre application (big endian)
  #define STATIC_DEVICE_ADDRESS                     0

Débogage du projet

  • Après avoir réaliser les étapes précédentes déboguer le projet.
  • Vérifier la bonne exécution du projet en visualisant des données null dans TTN.

Ajouter les capteurs

high accuracy temperature sensor <mcp9808> v1.0

Ajouter le capteur dans la carte nucleo:

 *scl dans le pin PB_8.
 *sca dans le pin PB_9.
 *vcc dans le pin U5V. 
 *GND dans le pin GND.

Ajouter les 2 fonctions suivantes dans le fichier stm32l0xx_hal_msp.c pour activer les pin liées avec le capteur:

  • void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c)

{

 GPIO_InitTypeDef GPIO_InitStruct = {0};
 if(hi2c->Instance==I2C1)
 {
 /* USER CODE BEGIN I2C1_MspInit 0 */
 /* USER CODE END I2C1_MspInit 0 */
   __HAL_RCC_GPIOB_CLK_ENABLE();
   /**I2C1 GPIO Configuration
   PB8     ------> I2C1_SCL
   PB9     ------> I2C1_SDA
   */
   GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
   GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
   GPIO_InitStruct.Pull = GPIO_PULLUP;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
   GPIO_InitStruct.Alternate = GPIO_AF4_I2C1;
   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
   /* Peripheral clock enable */
   __HAL_RCC_I2C1_CLK_ENABLE();
 /* USER CODE BEGIN I2C1_MspInit 1 */
 /* USER CODE END I2C1_MspInit 1 */
 }

}

  • void HAL_I2C_MspDeInit(I2C_HandleTypeDef* hi2c)

{

 if(hi2c->Instance==I2C1)
 {
 /* USER CODE BEGIN I2C1_MspDeInit 0 */
 /* USER CODE END I2C1_MspDeInit 0 */
   /* Peripheral clock disable */
   __HAL_RCC_I2C1_CLK_DISABLE();
   /**I2C1 GPIO Configuration
   PB8     ------> I2C1_SCL
   PB9     ------> I2C1_SDA
   */
   HAL_GPIO_DeInit(GPIOB, GPIO_PIN_8|GPIO_PIN_9);
 /* USER CODE BEGIN I2C1_MspDeInit 1 */
 /* USER CODE END I2C1_MspDeInit 1 */
 }

}

Débogage du projet

  • Après avoir réaliser les étapes précédentes déboguer le projet.
  • Vérifier la bonne exécution du projet en visualisant la température dans TTN.

Configuration du compte TTN

  • choisir l'option cayenne LLP pour Payloads Formats.
  • Ajouter une intégration à votre application (intégrations->add integrations->mydevice) .
  • Remplir les champs:
   *process_id: ajouter un id.
   *Access key: choisir default key

Configuration du compte my device

  • créer un compte.
  • Ajouter Device/widget.
  • Sélectionner LORA puis TTN.
  • Sélectionner Cayenne LLP.
  • Remplir les champs depuis TTN.

Déboguer le projet

  • Vérifier la réception des données dans le tableau de bord de my device.

Visualisation des données

Pour la visualisation interactive de données, on a utilisé TagoIO, un outils pour gérer des appareils, stocker des données, exécuter des analyses, et intégrer des services.

Configuration TagoIO

  • Création de compte TagoIO
  • Ajouter un appareil en filtrant sur LoRaWAN TTN
  • Si l'appareil figure déjà sur la liste proposée, il faut le sélectionner. Sinon, sélectionner Custom TTN.
  • Créer une clé d'autorisation ( à retenir )
  • Ajouter un Parser Payload si nécessaire.

Configuration à ajouter sur TTN

  • Sélectionner "+add integration" dabs la section Intégrationde de l'application
  • Sélectionner TagoIO
  • Remplir le formulaire. Attention pour le champ Autorisation, il faut copier la clé d'autorisation de TagoIO
  • Pour cet appareil, on a eu besoin d'un decoder pour le format de données.

A ce stade, toutes les données envoyées par votre appareil seront transmises de TTN à votre compte TagoIO

Création de dashboard

  • Sélectionner "+" de la section Dashboads du menu
  • Remplir les informations
  • Ajouter un widget selon le besoin

Distribution du dashboard

  • Sélectionner "Distribute" sur le menu relatif à la dashboard
  • Récupérer le lien de "Public Share"

Station connectée

  • Le code global de cette partie est accessible sur Github Station connectée
  • Après avoir installés les outils logiciels nécessaires, il faut procéder comme suit :
  • Tout d'abords il faut préparer la carte en configurant l'ensemble des pins, pour cela on a utilisé STM32CubeMX.

12.png

  • On importe le projet après l'avoir télécharger de Github avec la fonctionnalité import de trueSrudio, on fait clean, ensuite debug et enfin run.
  • On vérifie l'envoie des données par minicom en configurant le port en série utilisé par la carte, sinon on peut utilisé la console de l'IDE.
  • Créer un compte AWS.
  • Ajouter un utilisateur IAM à votre compte AWS, consultez IAM Guide de l'utilisateur IAM AWS. Accorder à votre compte utilisateur IAM l'accès à AWS IoT et à Amazon FreeRTOS, attachez les stratégies IAM suivantes à votre compte utilisateur IAM :
    • AmazonFreeRTOSFullAccess
    • AWSIoTFullAccess.
  • On a a utilisé principalement les modules AWSIOT et IOT-Core de AWS.
  • Un objet AWS IoT vous permet de gérer vos appareils dans AWS IoT. Elle est stockée sur le cloudAWS.
  • Une clé privée et un certificat X.509: Le certificat et la clé privée permettent à votre appareil de s'authentifier auprès d'AWS IoT.

16.png

  • Après avoir créer l'objet on obtient l'identifiant unique de l'objet, comme le montre la figure suivante.

10.png

  • Une fois on crée l'objet il faut créer les certificats et les télécharger sur votre pc.

15.png.

  • La carte doit être enregistrée auprès d'AWS IoT pour communiquer avec le cloud AWS.

Pour enregistrer la carte auprès d'AWS IoT, vous avez besoin des éléments suivants :

    • Une stratégie AWS IoT : La stratégie AWS IoT accorde à votre appareil les autorisations d'accès aux ressources AWS IoT. Elle est stockée sur le cloud AWS.
      • iot:Connect: Accorde à votre appareil l'autorisation de se connecter à l'agent de messages AWS IoT avec�n’importe quel ID client.
      • iot:Publish: Accorde à votre appareil l'autorisation de publier un message MQTT sur n’importe quelle rubrique
      • MQTT.iot:Subscribe: Accorde à votre appareil l'autorisation de s'abonner au filtre de n’importe quelle rubrique MQTT.
      • iot:Receive: Accorde à votre appareil l'autorisation de recevoir des messages de l'agent de messages AWS.
  • Pour cette partie il faut suivre les étapes suivantes:
    • 1. Accédez à la console AWS IoT.
    • 2. Dans le volet de navigation, choisissez Gérer, puis Objets.
    • 3. Si vous n'avez pas d'objets IoT enregistrés dans votre compte, la page Vous n'avez pas encore d'objets s'affiche. Si vous voyez cette page, choisissez Enregistrer un objet. Sinon, cliquez sur Create.
    • 4. Sur la page Création d'objets AWS IoT, choisissez Créer un objet unique.
    • 5. Sur la page Ajouter l'appareil au registre d'objets, saisissez un nom pour votre objet, puis choisissez Suivant.
    • 6. Sur la page Ajouter un certificat à votre objet, sous Création de certificat en un clic, choisissez Créer un certificat.
    • 7. Téléchargez votre clé privée et votre certificat en choisissant les liens Télécharger de chacun d'eux.
    • 8. Choisissez Activer pour activer votre certificat. Les certificats doivent être activés avant utilisation.
    • 9. Choisissez Attacher une stratégie pour attacher une stratégie à votre certificat qui accorde à votre appareil l'accès aux opérations AWS IoT.
    • 10. Choisissez la stratégie que vous venez de créer, puis choisissez Enregistrer l'objet.
  • Accéder à la rubrique AWSFreeRtos.
  • Enregistrement de STM32L4 avec AWS IoT: pour cela il faut seulement chercher la carte parmi les configurations (on la déjà publier sur AWS).

17.png

  • Télécharger le projet de configuration après l'enregistrement et l'importer sur truestdudio.
  • Modifier le fichier aws_clientcredentiels.h afin de mettre vous identifiants.

19.png

  • Exécuter le projet et vérifier l’envoie des données sur AWS à travers l’outil surveille.

11.png

  • Aller dans la rubrique intégrer afin de connecter l'appareil suivre les étapes d’enregistrement de l'apareil, et télécharger le SDK AWS fournis, afin de tester la connexion à l'appareil et vérifier l’acheminement des données vers AWS(les étapes d’exécution sont fournies après téléchargement).

18.png

  • Le test de démonstration donne les résultats suivants:

13.png

Contraintes du projet

  • Conflit entre les versions soit des bibliothèques soit des matériels.
  • Difficultés de trouver les sources des problèmes.
  • Difficulté pour intégrer les projets entre eux.

Extensions possibles

  • Continuer sur l'application web d'aggrégation des données.
  • Exploiter les données afin de faire des mésures statistiques et proposer des sollutions en fonctions des données.
  • Faire une application mobile qui reçoit les notifications.
  • Mettre en place le système qui reçoit l'alerte (Déclenchement de l'extincteur automatique)

Références

  • En plus des références déja citées on ajoute:
    • st-lrwan ST Nucleo LoraWAN - STM32CubeExpansion_LRWAN V1.1.2 : Makefile + gcc support for STM32 Nucleo + LoRa shield and STM32 LoRa Discovery Kit
    • Documentation Amazon
    • généralités sur STM32 et LORA digikey .