Cergy Paris Université

RAPPORT

pour le projet Introduction à l’IoT

Licence d’Informatique troisième année

sur le sujet

Parking Connecté
rédigé par

Maxime ANDRO
Christian BERANGER
Alice MABILLE
Benjamin PAUMARD
Margaux PEGUY
Mathieu VAYSSE
Alex VOLQUARDSEN

4 avril 2023
Table des matières
1 Introduction 3
1.1 Contexte du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Objectif du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Organisation du rapport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Spécification du projet 4
2.1 Cahier des charges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.1 Qu’est ce qu’un parking connecté ? . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.2 Différentes fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.3 Mise en place du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Conception et réalisation du projet 6

3.1 Architecture globale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 Conception des bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3 Serveur Chirpstack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.4 Réalisation des cartes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.5 Visualisation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

4 Déroulement du projet 11
4.1 Réalisation du projet par étapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.1.1 Prise en main de LoRa et configuration de serveur . . . . . . . . . . . . . . . . 11
4.1.2 Configuration de serveur et création des bases de données . . . . . . . . . . . . 11
4.1.3 Configuration de serveur et programmation des cartes STM32 . . . . . . . . . . 12
4.1.4 Intégration des cartes au réseau et ajout des capteurs . . . . . . . . . . . . . . . 13
4.1.5 Visualisation de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

5 Conclusion et perspectives 17
5.1 Résumé du travail réalisé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.2 Améliorations possibles du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

Table des figures

1 Emetteur infrarouge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Recepteur infrarouge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3 Stm32 LoRaWan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4 Architecture du parking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
5 Stockage des données par le serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
6 Application web de gestion du serveur Chirpstack . . . . . . . . . . . . . . . . . . . . . 8
7 Configuration des capteurs lorsque la place est libre . . . . . . . . . . . . . . . . . . . . 8
8 Configuration des capteurs lorsque la place est occupée . . . . . . . . . . . . . . . . . . 8
9 Architecture de la carte avec les capteurs infrarouges . . . . . . . . . . . . . . . . . . . 9
10 Interface de Grafana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
11 Connexion du récepteur infrarouge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
12 Connexion des émetteurs infrarouge . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
13 Montage final des connexions des capteurs infrarouge aux cartes STM32 . . . . . . . . 15

Liste des tableaux

1
Remerciements
Les auteurs du projet voudraient remercier vivement Iryna Andriyanova, Mohamed Ali et Hamza
Bouallagui pour leurs aides lors des travaux pour réaliser ce projet.

2
1 Introduction
Ce rapport explique l’intérêt du projet, sa conception et sa réalisation de A à Z.

1.1 Contexte du projet

L’IoT (Internet of Things) ou "internet des objets" est le "réseau des objets connectés qui ont des
interfaces intelligentes inter-connectés dans le cadre d’une application particulière (environnementale,
sociétale, etc...)".

Mais en fait... Qu’est-ce qu’un objet connecté ? C’est n’importe quel appareil capable de communi-
quer par un protocole filaire ou sans fil.

Les capteurs sont toujours présents sur les objets connectés. La notion de l’internet des objets est
apparue grâce à l’existence des capteurs.

Le but du cours d’introduction à l’IoT est de comprendre les enjeux et les défis de l’embarqué et
d’apprendre la communication sans fil.

1.2 Objectif du projet

L’objectif de ce projet est de découvrir l’IoT en concevant un parking connecté, installation urbaine
de plus en plus répandue. L’intérêt d’un tel parking est de trouver une place plus vite en affichant le
nombre de places libres restantes dans chaque allée ainsi que dans l’ensemble du parking.

1.3 Organisation du rapport

Nous verrons dans un premier temps les spécifications du projet : les notions de base, les contraintes,
et les fonctionnalités attendues.

Par la suite, nous détaillerons le déroulement du projet, c’est-à-dire la réalisation par étapes et la
répartition des tâches.

3
2 Spécification du projet
Nous allons parler dans cette partie des attentes du projet, notamment du cahier des charges et du
matériel utilisé.

2.1 Cahier des charges

Lors de la première séance nous avons du mettre en place un cahier des charges pouvant répondre
au besoin d’un parking connecté. Pour se faire, nous avons déjà dû définir à quoi correspondait un
parking connecté.

2.1.1 Qu’est ce qu’un parking connecté ?

Nous partirons d’une base de parking standard comme tout le monde connaît, un bâtiment fermé
permettant de stationner plusieurs véhicules de tous types. Cependant, notre parking sera bien plus
avancé que cela. En effet, chaque place de notre parking sera équipée d’un capteur afin de comptabiliser
en temps réel le nombre de places ainsi que les emplacements des places disponibles. Ce parking sera
capable de communiquer et faire communiquer une multitude de capteurs.

2.1.2 Différentes fonctionnalités

Notre parking devra répondre à plusieurs besoin et devra donc faire montre de différentes fonction-
nalités :
— posséder une batterie de capteur pour chaque place de parking.
— permettre une indication visuelle de la disponibilité d’une place, notamment à l’aide d’une led.
— Permettre de communiquer entre les capteurs et un relais via le protocole LoRaWan.
— Permettre une visualisation globale des places disponibles sur un terminal lier aux relais LoRa-
Wan.

2.1.3 Mise en place du projet

Pour mettre en place ce projet, nous allons créer une simulation à échelle réduite de ce parking avec
un capteur infrarouge ainsi qu’un récepteur chacun relier à deux cartes STM32 différentes qui pourrons
par la suite communiquer via le protocole LoRaWan.

Différents modules et carte : Pour la réalisation de la maquette de ce projet, nous allons utiliser
différent modules que nous listerons brièvement montré ci-dessous.

Emetteur infrarouge : Ce module comme son nom l’indique va émettre une lumière infrarouge,
réglé de façon à émettre cette lumière de façon continue. Nous pouvons voir à quoi il ressemble dans
la figure 1.

Recepteur infrarouge : Ce module va marcher de pair avec l’émetteur précédemment vu, il a pour
but de renvoyer un signal lorsqu’il capte une lumière infrarouge. Il est possible de le voir dans la figure
2.

Carte Stm32 : Il ne s’agit pas cette fois d’un module mais d’une carte sur laquelle s’exécutera le
code permettant la manipulation des différents capteurs ainsi que la communication via le protocole
LoRaWan via une antenne. Nous utiliserons dans ce projet deux cartes de ce genre représenté par la
figure 3.

4
Figure 1 – Emetteur infrarouge

Figure 2 – Recepteur infrarouge

Figure 3 – Stm32 LoRaWan

5
3 Conception et réalisation du projet
Dans cette section, nous allons détailler le fonctionnement du parking et la manière dont interagissent
les divers éléments qui composent l’architecture du parking.

3.1 Architecture globale

La conception du parking passe par un élément centrale, un serveur, vital pour gérer les places
disponibles. Ce dernier est connecté à une base de donnée dont nous allons détailler le fonctionnement
dans cette section. Ce serveur gère les connections avec différentes cartes, ces dernières communiquent
les données fournies par le capteur infrarouge indiquant si une voiture est présente ou non sur la place
de parking. La communication entre les cartes et le serveur se fait en utilisant la technologie sans fil
LoRa.

Figure 4 – Architecture du parking

3.2 Conception des bases de données

Les bases de données utilisées par le serveurs utilisent PostgreSQL, une technologie prouvée et fiable.
Le serveur utilise également Redis, c’est un outil qui permet de stocker des données en mémoire vive,
ce qui permet un accès très rapide à ces dernières. Il est utilisé ici comme un cache pour améliorer
les performances du serveur en stockant des données souvent utilisées en mémoire vive. En effet,
cela permet d’accéder plus rapidement aux informations en temps réel. Ainsi on peut maximiser les
performances du serveur en utilisant la base de données PostgreSQL pour les informations qui ne
requièrent pas d’être accessible en temps réel, et Redis pour les données en temps réel. On distingue
trois bases de données.

La base de données chirpstack_ns est utilisée pour stocker des informations relatives aux nœuds
et aux appareils de la plateforme. Elle contient des informations sur les identifiants des appareils, les
adresses MAC, les clés de session, les profils de dispositifs, les modèles de données et les méta-données
liées aux appareils. la seconde, nommé chirpstack_as est utilisée pour stocker des informations liées
aux applications de la plateforme. Elle contient des informations sur les identifiants des applications, les
identifiants des appareils liés aux applications, les adresses IP des applications et les configurations de la

6
passerelle. Enfin, nous avons la troisième et dernière base de donnéee chirpstack_as_events, elle est uti-
lisée pour stocker des événements de la plateforme, tels que les événements de connexion/déconnexion
des nœuds, les événements de données reçus ou encore les événements de changement de configuration.
Cette base de données permet aux utilisateurs de suivre l’historique des événements de la plateforme
et de déboguer les problèmes de manière efficace.

Figure 5 – Stockage des données par le serveur

3.3 Serveur Chirpstack

Le coeur même du parking est un serveur centralisant les données. Ce dernier utilise pour ça le logiciel
Chirpstack. C’est un logiciel open-source dédié à la gestion d’appareils dans le cadre de l’internet des
objets. Ce logiciel se divise en deux serveurs, le premier, le ChirpStack Network Server (NS) ,
permet la communication entre les cartes nucleo et l’application. Il est responsable de la gestion des
sessions de connexion, de la sécurité et du routage des messages entre les appareils et l’application. Le
second serveur ChirpStack Application Server (AS) permet la gestion et le traitement des données
reçues par les cartes, c’est à dire qu’il fournit un ensemble de services pour stocker et interroger les
données des appareils, ainsi que pour créer des règles de traitement pour les données reçues.

Une fois mis en place, la gestion des serveurs peut-être réalisé via une application web (utilisant
le framework web React). De cette application, nous pouvons réaliser toutes sortes d’opérations tel
qu’ajouter une carte au réseau ou encore visualiser les paramètres du serveur.

7
 Figure 6 – Application web de gestion du serveur Chirpstack

3.4 Réalisation des cartes

Afin de détecter la présence d’une voiture et pouvoir transmettre l’information au serveur, nous
utilisons une carte NUCLEO STM32 LRWAN. Sur cette carte, nous branchons un émetteur et un
récepteur infrarouge. Le principe est simple, un émetteur envoie une onde lumineuse dans le spectre
de l’infrarouge, cette dernière est capté par le récepteur. L’émetteur et le récepteur étant placés au sol,
le faisceau est alors retourné au récepteur en présence d’une voiture sur la place de parking. Dans ce
cas, on informe le serveur au travers de la connexion sans-fil LoRa que la place de parking n’est plus
disponible. On agit de la même manière lorsque le véhicule quitte son stationnement.

Figure 7 – Configuration des capteurs lorsque la place est libre

Figure 8 – Configuration des capteurs lorsque la place est occupée

8
 Concrètement, On commence par activer les pins que l’on va utiliser, puis sur la carte on initialise
les différents capteurs en fonction des pins sur lesquels ces derniers sont branchés. On active alors
l’émission de l’infrarouge, puis on entre ensuite dans une boucle qui va lire la valeur reçue par le
récepteur infrarouge, cette valeur peut avoir deux états selon si le capteur reçoit le faisceau ou non.
On envoie alors le statut de la place de parking (Si oui ou non, la place est occupée). Par la suite, afin
d’économiser de l’énergie, on enverra une information au serveur LoRa uniquement si le statut de la
place change.

Figure 9 – Architecture de la carte avec les capteurs infrarouges

3.5 Visualisation des données

Afin de visualiser les données, nous avons besoin de mettre en place de nouveau outils, premièrement,
InfluxDB, c’est une base de données dédié au stockage de données chronologiques, dans notre cas,
l’état des places de parking au cours du temps. Cette base de données est également utile pour le
stockage d’information en temps réel. Contrairement aux bases de données relationnelles, InfluxDB est
spécialement conçue pour stocker des données chronologiques, avec une prise en charge native de la
gestion de la chronologie, des requêtes basées sur le temps et des agrégations de données. InfluxDB
utilise une architecture de stockage en mémoire vive pour permettre de lire et écrire rapidement dans
la base de donnée.

Pour se faire, il est nécessaire d’utiliser Docker. C’est un système permettant d’exécuter un pro-
gramme dans une sorte de boite indépendamment de la configuration de la machine et des logiciels
installés. Dans notre cas, nous nous avons besoin de l’image InfluxDB. Attention cependant, la base
de données tournant dans un container Docker, il faut penser à rediriger le flux pour avoir accès à
l’interface d’InfluxDB sur notre navigateur web.

Enfin, l’outil que nous devons utiliser pour visualiser ces données est dénommé Grafana. Cet outil
permet de visualiser en temps réel des paramètres donnés. Grafana permet de créer des graphiques, des
tableaux de bord et des alertes pour visualiser et analyser des données provenant de diverses sources
telle que notre base de données InfluxDB. En effet, Grafana possède une large série de connecteurs,
dont un dédié à l’usage d’InfluxDB.

9
 Figure 10 – Interface de Grafana

Après avoir mis en place tous ces éléments, nous obtenons notre parking connecté est enfin prêt.
Nous pouvons visualiser l’état de notre parking et le monitorer en temps réel.

10
4 Déroulement du projet
Dans cette section, nous décrirons comment le projet a été réalisé en équipe : la répartition des tâches,
la synchronisation du travail entre les membres de l’équipe, etc.

4.1 Réalisation du projet par étapes

Ici, nous expliquerons le déroulement des différentes étapes du projet.

4.1.1 Prise en main de LoRa et configuration de serveur

Dans un premier temps, nous avons effectué la prise en main de Raspberry Pi, de l’OS Chirpstack
et la configuration d’une passerelle.

La carte Raspberry Pi possèdent plusieurs avantages :

— Son prix, en effet pour environ 32 € on peut avoir un système embarqué complet ;
— Sa taille, elle est avantageuse : c’est la taille d’une carte de crédit ;
— Sa puissance, en effet elle est comparable à des smartphones (anciens modèles) ;
— Son processeur 4 cœurs avec un Gigaoctet de RAM et qui est doté du système d’exploitation
Raspbian (contraction de Raspberry et Debian), conçu spécialement pour elle ;
— Son nombre de ressources utilisables, en effet il existe une communauté très active avec de
nombreuses librairies utilisables ;
— Ses 40 pins GPIO, qui lui permettent d’être connecté à de nombreux capteurs et composants
électroniques ;
— Sa possibilité d’utiliser une liaison serial, i2c, ou encore spi, qui est donc compatible avec beau-
coup de composants électroniques.

L’intérêt de l’OS Chirpstack est d’abord pour l’utilisation du réseau LoRa, en effet cet OS est spécia-
lement conçu pour mettre en place des serveurs en LoRa simplement. De plus, cet OS est spécialement
conçu pour de l’embarqué et est complètement open source.

Une passerelle est un dispositif permettant de faire le lien entre deux réseaux de types différents.
La passerelle va permettre le routage de paquets entre ces deux réseaux mais peut aussi effectuer des
actions plus techniques, par exemple servir de pare-feux ou de proxy.

Pour se faire, nous avons commencé par télécharger la version au format 3.x.x et de type "os-base"
de l’image système Raspberry Pi 1.

Nous avons ensuite charger l’image système sur la Raspberry Pi à l’aide de Balena Etcher, et ensuite
nous avons alimenté la LiteGateway.

Pour accéder à la console du Raspberry Pi, il faut d’abord identifier l’adresse IP de la Litegateway,
et l’entrer au lancement de PuTTY. Ensuite il faut se connecter avec les identifiants et mot de passe
’admin’, ’admin’.

Enfin, nous avons lancer la configuration de la passerelle à l’aide de la commande sudo gateway-
config. Nous avons d’abord paramétré l’antenne LoRa de la passerelle, puis indiqué à celle-ci où se
trouve le Network Server.

4.1.2 Configuration de serveur et création des bases de données

Secondement, nous avons créé les bases de données et installé le Network Server.

11
 Concernant les bases de données, nous en avons créé 3 :
— chirpstack ns : pour stocker la configuration et l’activité du Network Server ;
— chirpstack as : pour stocker les différents éléments configurés par l’utilisateur dans l’interface
de l’Application Server ;
— chirpstack as events : une base de données en extension pour enregistrer l’activité des nœuds
du réseau LoRa.

Après avoir installé et démarré PostgreSQL nous avons créé les différents profils et les différentes
bases de données associées à ces profils, puis activé les extensions nécessaires à chacune de celles-ci.

Ensuite, nous avons installé le Network Server de Chirpstack qui servira de lien entre la passerelle et
l’Apllication Server. Pour cela, nous avons récupéré le fichier de configuration fournit en annexe puis
éditer celui-ci afin de renseigner les identifiants des bases de données créées précédemment. Enfin après
chaque modification du fichier de configuration, nous avons redémarré le Network Server et afficher le
journal afin d’observer les éventuelles erreurs.

Les bases de données et le Network Server sont désormais configurés.

4.1.3 Configuration de serveur et programmation des cartes STM32

Ensuite, nous avons installé l’Application Server, paramétré le réseau via l’interface Chirpstack et
programmé des cartes STM32.

Nous avons commencé par installer l’Application Server depuis le package Ubuntu fournit. Ensuite,
nous avons dû générer une clé unique pour notre App Server puis commencé à éditer le fichier de
configuration fournit en annexe.

Les modifications a apporter au fichier sont :

— compléter les identifiants de la base de données précédement créée,
— compléter les identifiants de la base données pour les évènements sur le réseau ;
— renseigner la clé de sécurité générée juste avant.

De même que pour le Network Server, après chaque modification du fichier de configuration, nous
devons redémarrer l’Application Server et afficher le journal afin d’observer les éventuelles erreurs.

L’application Server est désormais configurée.

Après cela, nous avons paramétré le réseau via l’interface Chirpstack.

Pour se faire, nous avons commencé par entrer l’adresse "http ://localhost :8080" dans un navigateur
afin d’accéder à l’interface de Chirpstack et nous nous sommes connecté avec les identifiants par défaut.

Nous avons ensuite :

— Indiqué à Chirpstack le lien avec le Network Server ;
— Créé un groupe pour y affecter notre passerelle ;
— Enregistré sur le Network Server le groupe que nous venons de créer. Puisque le groupe possède
des passerelles, cette étape consiste à définir les droits des passerelles de ce groupe sur le Network
Server ;
— Ajouté des passerelles à notre réseau privé LoRa (Les passerelles définies ici sont celles qui sont
autorisées à rejoindre notre réseau privé) ;
— Préparé l’accueil des noeuds LoRa, qui sont les cartes STM32. (Le but est de définir avec quelles
propriétés les cartes et le serveur vont communiquer sur le réseau.) ;
— Créé une "Application" pour ajouter nos cartes STM32 au réseau LoRa.

12
 Nous pouvons ajouter nos cartes STM32 à notre Application.

Enfin, nous avons réalisé la prise en main du projet LoRaWAN pour STM32.

Pour cela, nous avons commencé par installer STM32 CubeIDE et l’extension I-CUBE-LRWAN. Il
faut ensuite importer l’extension et ajouter les dépendances du projet au PATH.

A présent, la préparation de l’environnement pour le développement des cartes STM32 est terminé.

4.1.4 Intégration des cartes au réseau et ajout des capteurs

Enfin, nous avons intégré nos cartes au réseau LoRa, ajouté les capteurs infrarouge aux cartes et
commencé la construction et l’envoi des paquets données sur le réseau LoRa.

Tout d’abord, pour intégrer notre carte au réseau LoRa, nous avons dû lui fournir les informations
de connexion nécessaires et récupérer son identifiant unique pour que le serveur puisse la reconnaître.

Nous avons commencé par connecter une carte STM32 en USB à l’ordinateur.
— Ensuite la première étape était de définir les constantes d’identité de la carte, ce qui permet à
la carte de générer un Device EUI unique.
— La deuxième étape était d’ouvrir PuTTY pour connaître le Device EUI généré par la carte
précédemment.
— Une fois le Device EUI de la carte récupérée la troisième étape était de retourner sur l’interface
de Chirpstack pour créer la carte dans notre application.
— Pour terminer la configuration de la carte il faut retourner sur STM32 CubeIDE et y rensei-
gner "l’Application Key" que l’on vient de générer lors de la création de la carte dans notre
application.
— Enfin, pour vérifier que l’installation fonctionne, on a regardé l’état de la carte sur Chirpstack
et observer sur PuTTY que la carte parvient bel et bien à rejoindre le réseau LoRa.

La configuration de la carte à été réalisée en parallèle sur deux ordinateurs pour les deux cartes
STM32.

Les deux cartes STM32 sont désormais configurées.

Ensuite nous avons réalisé l’ajout des émetteurs et récepteurs infrarouges aux cartes.

L’objectif est de récupérer la valeur du récepteur infrarouge qui indique si une voiture est présente
sur la place de parking. Lorsqu’un objet se place au-dessus du capteur, les ondes infrarouges émises par
l’émetteur rebondissent sur celui-ci et sont réceptionnées par le récepteur, qui indique un changement
d’état dans le système.

Nous avons ensuite connecté les capteurs aux ports GPIO de la carte STM32. Pour faire ce montage,
nous avons utilisé une planche pour prototypage sur laquelle nous avons branché les capteurs directe-
ment, puis nous avons utilisé des câbles mâles vers femelle sur la planche de prototypage pour relier
chaque broche du capteur au bon port de la carte.

Connexion du récepteur infrarouge

13
 Le déroulé de la connexion du récepteur infrarouge est le suivant :
— Port "+" du capteur vers "5V" de la carte ;
— Port du milieu du capteur vers "GND" de la carte ;
— Port "S" du capteur vers "PA4", qui est un port de données entrées/sorties de la carte.

Figure 11 – Connexion du récepteur infrarouge

Connexion des émetteurs infrarouge

Le déroulé de la connexion des émetteurs infrarouge est le suivant :

— Port "S" du capteur vers "PB12", qui est un port de données entrées/sorties de la carte qui sert
également à l’alimentation de la LED. C’est pourquoi il faut utiliser une résistance 220 Ohms
pour protéger la LED ;
— Le port du milieu n’est pas utilisé sur l’émetteur ;
— Port du bas du capteur vers "GND" de la carte.

Figure 12 – Connexion des émetteurs infrarouge

Le montage final est donc le suivant :

14
 Figure 13 – Montage final des connexions des capteurs infrarouge aux cartes STM32

Enfin, nous avons commencé la construction et l’envoi des paquets données sur le réseau LoRa.

Nous avons entammé la programmation des paquets LoRa à faire transiter sur le réseau. Nous avons
procéder en 3 étapes : l’initialisation des ports GPIO sur lesquels nous avons branché nos capteurs, la
gestion de l’état du capteur dans le système, et l’envoi des paquets LoRa sur le réseau.

Pour réaliser l’initialisation des ports GPIO nous avons configuré la broche PB12 en mode "sortie"
et initialisé une LED verte de la carte (LD1) en mode "sortie" pour pouvoir en prendre le contrôle et
ainsi afficher le status de la carte via cette LED.

Pour la gestion de l’état du capteur, nous devions modifier la fonction sendTxData, mais malheureu-
sement en raison du manque de matériel nous n’avons pas pu continuer cette partie puisqu’il y avait
seulement un récepteur fonctionnel pour les 3 groupes de TP.

En raison des mêmes problèmes matériel, nous n’avons pas pu réaliser l’envoi des paquets LoRa sur
le réseau et la vérification de la circulation des données sur le réseau.

4.1.5 Visualisation de données

Pour finir, nous devions réaliser la visualisation des données.

Pour ce faire, nous devions installer InfluxDB et Grafana avant de commencer la visualisation.

Pour activer InfluxDB dans Chirpstack, plusieurs étapes étaient nécessaires. Tout d’abord l’installa-
tion de InfluxDB, suivi de la création d’un bucket et d’un token API grâce à l’interface web de InfluxDB
et pour finir la configuration de l’intégration d’InfluxDB dans Chirpstack.

Nous devions ensuite réaliser l’installation de Grafana et la configuration de l’affichage des données
à représenter.

C’est après ces étapes que la visualisation de données commence.

15
 Pour les mêmes raisons que celles énoncées précédemment, nous n’avons pas pu effectuer la partie
visualisation de données de ce projet.

16
5 Conclusion et perspectives
Dans cette section, nous résumons la réalisation du projet et nous présentons également les extensions
et améliorations possibles du projet.

5.1 Résumé du travail réalisé

Nous avons dans ce projet réalisé un parking connecté, bien que nous aillons rencontrés des diffi-
cultés liées au matériel, nous avons découvert la programmation d’un raspberry Pi. Nous avons pu
mettre en place des bases de données PostgreSQL, un serveur Chirpstack ainsi que la configuration et
programmation de carte STM32 LoRaWAN. Nous avons compris comment utiliser Docker et comment
mettre en place un outil de visualisation Grafana.

Ce projet nous a également permis d’avoir une première approche de ce que représente l’internet
des objets connectés. C’est un domaine très intéressant et qui regroupe l’utilisation de très nombreuses
technologies.

5.2 Améliorations possibles du projet

Dans ce projet, plusieurs choses auraient pu être améliorées. Premièrement, la répartition des tâches,
nous avons quelque peu peiné à trouver une organisation permettant de diviser les tâches de manière
équitables. Secondement, la résolution des différents problèmes que nous avons rencontrés n’a pas
toujours été la plus efficace possible, principalement en raison de notre répartition des tâches.

17