LOGICIELS DE COMMUNICATION ET INTERGICIELS

(FR-SP23- MSC-ISN6120)

DEVOIR-1
MEDÈLES DE DÉVELOPPEMENT LOGICIEL

Rédigé par :
1. KOUOKAM KOUTCHOUANG Ubald
2. Bilong joseph Hermann
3. HELENE MILENE NGAH NGAH
4. MERVEILLE ILLONA SIGNE FONGANG
5. Levy Daryl MVOM MBEYO'O
6. Arnaud KAMDEM NONO

Sous la supervision du M. KENANG Gilles Landry

Mai 2023
 Devoir 1 : Modèles de développement logiciel

SOMMAIRE
I. INTRODUCTION ....................................................................................................................................................... 4
II. PRÉSENTATION DU RASPBERRY PI ........................................................................................................................... 4
A. Définition ...................................................................................................................................................... 4
B. Composants d'un Raspberry Pi ..................................................................................................................... 5
III. CONCEPTION DU SYSTÈME ........................................................................................................................................ 8
A. Architecture du système ............................................................................................................................... 8
B. Code java de fonctionnement ....................................................................................................................... 8
1. Interface de description d’un capteur : Sensor .........................................................................................................9
2. Classes pour capteurs .............................................................................................................................................10
a. PM25Sensor......................................................................................................................................................10
b. CO2Sensor ........................................................................................................................................................11
3. Classe Air Quality Monitor ......................................................................................................................................12
4. Classe Main .............................................................................................................................................................13
IV. CONCLUSION........................................................................................................................................................ 14

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
2
 Devoir 1 : Modèles de développement logiciel

LISTE DES FIGURES

Figure 1- Raspberry Pi 4 Model B ........................................................................................................................................ 6
Figure 2- Connecteur carte microSD d'un Raspberry Pi ...................................................................................................... 8
Figure 3- Architecture du système ...................................................................................................................................... 8

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
3
 Devoir 1 : Modèles de développement logiciel

I. INTRODUCTION
La pollution de l’air est un problème environnemental et sanitaire majeur qui concerne
l’ensemble de la population mondiale, notamment dans les grandes villes et les zones fortement
peuplées. Les sources peuvent être naturelles, mais sont surtout liées aux activités humaines
émettent de nombreux polluants gazeux. Une fois émis, ces derniers seront distribués dans
l’atmosphère, où ils peuvent subir des réactions physico-chimiques. Il est donc important de
suivre ces polluants, en les mesurant et à l’aide d’outils, tels que des indicateurs.
Les progrès prodigieux, de ces dernières années, dans l’électronique embarquée, ont
permis le déploiement à grande échelle des technologies touchant plusieurs domaines
d’applications dans l’environnement du réseau informatique et de l’électronique. Un système
embarqué présente une intégration entre deux parties, logicielle et matérielle, qui sont conçues
conjointement pour répondre à des fonctionnalités spécifiques.
Dans ce projet, nous nous sommes intéressés à la conception d’un système de
surveillance et de contrôle de la qualité de l’air, architecturé autour d’un Raspberry PI dont les
performances sont nombreuses.
Notre travail est organisé comme suit :
Dans la première partie, nous avons présenté le Raspberry, comment on le configure et
son utilisation. Dans la deuxième, nous avons implémenté une des utilisations du Raspberry
avec la mise en place d’un système de surveillance de la qualité de l’air.

II. PRÉSENTATION DU RASPBERRY PI

A. DÉFINITION
Le Raspberry Pi est un nano-ordinateur monocarte à processeur ARM de la taille d'une
carte de crédit conçu par des professeurs du département informatique de l'université de
Cambridge. Il s’agit d’un assemblage de différents composants informatiques, ayant la forme
d’une seule et simple carte mère.

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
4
 Devoir 1 : Modèles de développement logiciel

On y retrouve les composants de base d’un ordinateur (processeur, mémoire de travail,

etc.) ainsi que plusieurs ports (USB, HDMI, vidéo, haut-parleurs etc.). Son disque dur est une
carte microSD d'au moins 8 Go et de la classe 6 au moins. L’objectif principal du créateur du
Raspberry Pi, Eben Upton, était de créer un outil très accessible pour permettre à tous les
étudiants d’apprendre plus efficacement le développement et la programmation informatique.
En le souhaitant pratique à manipuler de par sa taille et son faible poids, peu cher et facile à
utiliser tout en préservant une très bonne performance de l’ensemble. Il est vendu de nos jours
à plus de 10 millions d'exemplaires.
B. COMPOSANTS D'UN RASPBERRY PI
▪ Alimentation USB Type-C
▪ Connecteur d'affichage DSI
▪ Sans fil / Bluetooth
▪ Micro-HDMI 0
▪ Micro-HDMI 1
▪ Système sur puce
▪ GPIO
▪ RAM
▪ Port caméra CSI
▪ Prise AV 3,5 mm
▪ PoE (Alimentation par Ethernet)
▪ USB 2.0
▪ USB 3.0
▪ Port Ethernet

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
5
 Devoir 1 : Modèles de développement logiciel

Figure 1- Raspberry Pi 4 Model B

Comme tout autre ordinateur, un Raspberry Pi est composé de différents éléments,

chacun remplissant un rôle bien défini dans le cadre de son fonctionnement.
Le premier, et sans doute le plus important, se trouve juste au-dessus du point central sur
la face supérieure de la carte (Figure 2), recouvert d'un capuchon métallique : le système sur
puce (SoC).
▪ Le terme « système sur puce » (system-on-chip en anglais) est une puce en
silicium, appelée circuit intégré, qui contient l'essentiel du système de Raspberry
Pi. Il comprend l'unité centrale de traitement (CPU), généralement considérée
comme le « cerveau » d'un ordinateur, et l'unité de traitement graphique (GPU), qui
gère l'aspect visuel.
▪ Juste à côté du SoC se trouve une autre puce, il s'agit de la mémoire vive (RAM)
de Raspberry Pi. Lorsqu’on travaille avec un Raspberry Pi, la mémoire vive
sauvegarde temporairement les informations utilisées par le processeur. Ce n'est
qu’après l'enregistrement du travail que les informations sont inscrites sur la carte
microSD. Ensemble, ces composants forment la mémoire volatile et non volatile de
Raspberry Pi : la RAM volatile se vide de son contenu chaque fois que Raspberry
Pi s'éteint, tandis que la carte microSD non volatile sauvegarde son contenu.
▪ La radio, le composant qui permet à Raspberry Pi de communiquer sans fil avec
d'autres appareils. Il remplit un double rôle : celui de radio WiFi pour la connexion
aux réseaux informatiques, et celui de Bluetooth radio pour se connecter à des
périphériques.

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
6
 Devoir 1 : Modèles de développement logiciel

▪ Une autre puce noire, visible sur le bord inférieur de la carte juste derrière les ports
USB du milieu et derrière le connecteur d'alimentation USB de type C. Il s'agit du
contrôleur USB, qui est responsable du fonctionnement des quatre ports USB.
▪ Les ports USB (Universal Serial Bus) (Figure 1-6) qui permettent de connecter
n'importe quel périphérique compatible USB à Raspberry Pi, des claviers et souris
aux appareils photo numériques et clés USB. D'un point de vue technique, il existe
deux types de ports USB : ceux qui comportent des parties noires sont des ports
USB 2.0, basés sur la deuxième version de la norme Universal Serial Bus ; ceux
qui comportent des parties bleues, les ports USB 3.0, plus rapides, basés sur la
troisième version, plus récente.
▪ À droite des ports USB se trouve un port Ethernet, utilisé pour connecter le
Raspberry Pi à un réseau informatique câblé à l'aide d'un câble muni d'un
connecteur RJ45 à son extrémité.
▪ Une prise audio-visuelle (AV) de 3,5 mm, désignée par le terme prise casque pour
y brancher un casque.
▪ Au-dessus de la prise AV 3,5 mm se trouve un connecteur d'apparence étrange
avec un rabat en plastique qui peut être tiré vers le haut ; il s'agit du connecteur de
caméra, connu sous le nom d’Interface série de la caméra (CSI).
▪ Les micro ports d'interface multimédia haute définition (micro-HDMI).
▪ Au-dessus des ports HDMI se trouve un port d'alimentation USB de type C , utilisé
pour connecter le Raspberry Pi à une source d'énergie.
▪ Un connecteur d'affichage ou Interface série d'affichage (DSI) conçu pour être
utilisé avec un écran tactile Raspberry Pi.
▪ 40 broches métalliques, réparties en deux rangées de 20 points. Il s'agit du
connecteur GPIO (general-purpose input/output), une fonctionnalité qui permet à
Raspberry Pi de communiquer avec du matériel supplémentaire, qu'il s'agisse de
LED et de boutons jusqu'aux capteurs de température, aux joysticks ou aux
moniteurs de fréquence cardiaque.
▪ Un tout dernier port, mais il n'est pas visible sur la partie supérieure : un connecteur
de carte microSD sur l'envers. Il s'agit du stockage de Raspberry Pi : la carte
microSD insérée ici contient tous les fichiers, tous les logiciels installés et le
système d'exploitation qui assure le fonctionnement du Raspberry Pi.

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
7
 Devoir 1 : Modèles de développement logiciel

Figure 2- Connecteur carte microSD d'un Raspberry Pi

III. CONCEPTION DU SYSTÈME

Pour avoir un environnement propice, nous devons nous rassurer que l’air ne dispose de
moins de dioxyde de carbone et moins de poussière. Dans cette section, nous allons décrire
l’architecture du système qui sera mis en place et de montrer l’ensemble des codes en langage
java qui ont été mis à contribution pour faire la simulation.
A. ARCHITECTURE DU SYSTÈME

Figure 3- Architecture du système

Dans le nouveau système à mettre en place, nous avons deux capteurs : un capteur de
détection de la présence de la poussière (PM25 Sensor) et un autre pour la détection du
dioxyde de carbone (CO2 Sensor). Ces deux équipements sont connectés à notre Raspberry
Pi, lequel dispose d’un écran pour la visualisation des événements.
B. CODE JAVA DE FONCTIONNEMENT
Nous avons, dans cette section, supposé que le Raspberry Pi soit opérationnel dans lequel
la version 20 du Java Development Kit (JDK) est installé. Notre code est structuré ainsi
qu’il suit :

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
8
 Devoir 1 : Modèles de développement logiciel

▪ Interface de description d’un capteur : Sensor

▪ Classes pour capteurs PM25Sensor et CO2Sensor
▪ Classe de monitoring : AirMonitoringSensor
▪ Classe principale : Main
N’ayant pas les équipements physiques à disposition, nous avons un Raspberry Pi en
virtuel et nous avons également simuler l’envoie des données avec un Timer java. En plus, les
threads ont été utilisé pour rendre la simulation plus réelle pour la lecture et l’interprétation des
données.
1. INTERFACE DE DESCRIPTION D’UN CAPTEUR : SENSOR

C’est l’interface qui permet de modéliser ou de décrire un capteur.

public interface Sensor {
public boolean isPolluted();
public void setPolluted(boolean polluted);
public void startSendingData();
public void stopSendingData();
}

Elle dispose de quatre méthodes :

▪ isPolluted : qui permet de savoir si la donnée renvoyée indique un environnement
pollué ou pas ;
▪ setPolluted : Elle permet au capteur de modifier la propriété privé qui garde les
données ;
▪ startSendingData : permet au capteur d’envoyer au Rapberry Pi. Dans notre
contexte, nous utilisons un Timer qui déclenche l’envoie d’une valeur booléenne
aléatoire
▪ stopSendingData : Elle arrête l’envoie des données par un capteur.

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
9
 Devoir 1 : Modèles de développement logiciel

2. CLASSES POUR CAPTEURS

a. PM25Sensor
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

/**
* @author Ubald KOUOKAM
* Capteur de poussière
*/
public class PM25Sensor implements Sensor {
private boolean polluted;
private final Random rand;
private final Timer timer;

public PM25Sensor() {
this.rand = new Random();
this.timer = new Timer();
}

@Override
public boolean isPolluted() {
return this.polluted;
}

@Override
public void setPolluted(boolean polluted) {
this.polluted = polluted;
}

@Override
public void startSendingData() {
this.timer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
setPolluted(rand.nextBoolean());
}
}, 1000, 1000);
}

@Override
public void stopSendingData() {
//Arrête le timer
this.timer.cancel();
this.timer.purge();
}
}

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
10
 Devoir 1 : Modèles de développement logiciel

b. CO2Sensor
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

/**
* @author Ubald KOUOKAM
* Capteur de dioxyde de carbone
*/
public class CO2Sensor implements Sensor {
private boolean polluted;
private final Random rand;
private final Timer timer;

public CO2Sensor() {
this.rand = new Random();
this.timer = new Timer();
}

@Override
public boolean isPolluted() {
return this.polluted;
}

@Override
public void setPolluted(boolean polluted) {
this.polluted = polluted;
}

@Override
public void startSendingData() {
this.timer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
setPolluted(rand.nextBoolean());
}
}, 1000, 1000);
}

@Override
public void stopSendingData() {
//Arrête le timer
this.timer.cancel();
this.timer.purge();
}
}

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
11
 Devoir 1 : Modèles de développement logiciel

3. CLASSE AIR QUALITY MONITOR

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class AirQualityMonitor {

private final List<Sensor> sensors;
private final AlertService alertService;
private boolean stopThread;

public AirQualityMonitor() {
this.sensors = new ArrayList<>();
this.alertService = new AlertService();
this.stopThread = false; //Le thread est en marche
}

public void addSensor(Sensor sensor) {

sensors.add(sensor);
}

public void removeSensor(Sensor sensor) {

sensors.remove(sensor);
}

public void startMonitoring() {

new Thread(new Runnable() {
@Override
public void run() {
while (!stopThread) {
System.out.print("\n");
for (Sensor sensor: sensors) {
if (sensor instanceof PM25Sensor) {
if (sensor.isPolluted()) {
alertService.sendAlert("Le capteur indique la présence de la poussière
dans l'air");
} else {
alertService.sendAlert("Le capteur indique que l'air ne contient pas de
la poussière");
}
}
if (sensor instanceof CO2Sensor) {
if (sensor.isPolluted()) {
alertService.sendAlert("Le capteur indique la présence du dioxyde de
carbone dans l'air");
} else {
alertService.sendAlert("Le capteur indique que l'air ne contient pas de
dioxyde de carbone");
}
}
}
//Temporisation de deux secondes
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
break;
}
}
}
}).start();
}

public List<Sensor> getSensors() {

return sensors;
}

public void setStopThread(boolean stopThread) {

this.stopThread = stopThread;
}
}

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
12
 Devoir 1 : Modèles de développement logiciel

4. CLASSE MAIN
import java.util.Scanner;

import static java.lang.System.exit;

public class Main {

private static AirQualityMonitor airQualityMonitor = null;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (true) {
showMenu();
try {
char choice = scanner.nextLine().toCharArray()[0];
switch (choice) {
case 'd' -> start();
case 'a' -> stop();
case 'q' -> {
stop();
exit(0);
}
default -> System.out.println("Choix non disponible");
}
} catch (ArrayIndexOutOfBoundsException e) {
continue;
}
}
}

public static void showMenu() {

String [] options = {
"d: Démarrer le monitoring",
"a: Arrêter le monitoring",
"q: Quitter"
};
System.out.println("********* MONITORING DE LA QUALITÉ D'AIR
*********");
for (String option : options) {
System.out.println(option);
}
System.out.print("Que voulez-vous faire : ");
}

public static void start() {

if (airQualityMonitor == null) {
airQualityMonitor = new AirQualityMonitor();
//Ajout d'un capteur de CO2
CO2Sensor co2Sensor = new CO2Sensor();
co2Sensor.startSendingData();
airQualityMonitor.addSensor(co2Sensor);
//Ajout du capteur d'air
PM25Sensor pm25Sensor = new PM25Sensor();
pm25Sensor.startSendingData();
airQualityMonitor.addSensor(pm25Sensor);
//Démarre le monitoring des capteurs
airQualityMonitor.startMonitoring();
}
}

public static void stop() {

if (airQualityMonitor != null) {
for (Sensor sensor: airQualityMonitor.getSensors()) {
sensor.stopSendingData();
airQualityMonitor.removeSensor(sensor);
}
airQualityMonitor.setStopThread(true);
airQualityMonitor = null;
}
}
}

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
13
 Devoir 1 : Modèles de développement logiciel

IV. CONCLUSION
Dans ce document, nous avons mis en place grâce à l’équipement Raspberry Pi, un
système qui permet de montrer la qualité d’air dans un environnement donné.

Rédigé par KOUOKAM K. U, BILONG J. H., NGAH NGAH, MBEYO’O MVOM, KAMDEM NONO, SIGNE FONGANG
14