REPUBLIQUE TUNISIENNE

RAPPORT DE STAGE
Réalisé par : Yassine Kacem

Spécialité : Electromécanique

Filière : 4éme année mécatronique

Encadré par : HALIM KACEM

Lieu de stage : 122 Avenue Fethi Zouhir, Route de, Raoued

Période de stage : 10/05/2025 au 24/08/2025

Année universitaire :2024 / 2025

Je souhaite exprimer ma sincère gratitude à toutes les personnes qui m’ont soutenu et
accompagné tout au long de mon premier stage en ingénierie.

Je tiens à remercier en particulier M. Halim Kacem, qui m’a guidé avec patience et
compétence durant cette période. Ses conseils précieux, sa disponibilité et son expertise ont
été d’une aide inestimable pour moi et ont grandement contribué à mon apprentissage.

Je remercie également l’ensemble de l’équipe du Centre Supérieur de Formation pour leur

accueil chaleureux, leur collaboration et les échanges enrichissants que nous avons pu avoir.
Leur esprit d’équipe et leur professionnalisme ont rendu mon expérience encore plus
formatrice et motivante.

Un grand merci également à tous les professeurs qui m’ont aidé à mieux apprendre et à
progresser tout au long de mon parcours.

2
Table des matières :

Table des matières

Table des matières : ................................................................................................................................. 3

Introduction générale .............................................................................................................................. 2
Chapitre 1 : Présentation du CSf.............................................................................................................. 3
1. INTRODUCTION ............................................................................................................................... 3
2. Domaine d’activité ................................................................................................................. 4
Chapitre 2 : Contexte théorique et technologique.................................................................................. 5
I. Le choix justifié de la carte ......................................................................................................... 5
1. Microcontrôleur STM32F407VG............................................................................................ 5
2. Raspberry Pi ........................................................................................................................... 6
3. Arduino UNO .......................................................................................................................... 7
4. Comparaison des solutions .................................................................................................... 8
5. Présentation de Qt ................................................................................................................. 8
5.1 Communication UART................................................................................................................ 9
6. Problématique ....................................................................................................................... 9
7. Solution adaptée ................................................................................................................... 9
II. Méthodologie de travail ................................................................................................................ 10
1. Méthodes agiles ................................................................................................................... 10
2. Méthodologie Scrum............................................................................................................ 10
3. Chronogramme de travail .................................................................................................... 11
Conclusion ............................................................................................................................................. 11
Chapitre 4 : Analyse et conception du système .................................................................................... 12
Introduction ....................................................................................................................................... 12
I. Cahier des charges.................................................................................................................... 12
II. Architecture du système........................................................................................................... 12
III. Liaison STM32 ↔ Qt................................................................................................................ 13
Conclusion ......................................................................................................................................... 14
Chapitre 4 : Analyses et spécifications des besoins............................................................................... 15
I. Introduction .............................................................................................................................. 15
II. Spécification du besoin............................................................................................................. 15

3
 III. Besoins fonctionnels................................................................................................................. 15
IV. Besoins non fonctionnels ......................................................................................................... 16
V. Identification des acteurs et des cas d’utilisation .................................................................... 16
1. Les acteurs............................................................................................................................ 17
2. Les cas d’utilisation .............................................................................................................. 17
3. Modèle général des cas d’utilisation.................................................................................... 17
VI. Raffinement des cas d’utilisation ............................................................................................. 18
VII. Gestion du projet ................................................................................................................. 19
1. Équipe et rôles ..................................................................................................................... 19
2. Product Backlog ................................................................................................................... 19
3. Planification.......................................................................................................................... 19
VIII. Conclusion ............................................................................................................................ 20
CHAPITRE 5 : Conception....................................................................................................................... 21
Introduction ....................................................................................................................................... 21
1. Choix de l’environnement de développement ..................................................................... 21
2. Architecture générale de l’application ................................................................................. 21
3. Création d’un nouveau projet Qt ......................................................................................... 22
4. Conception de l’interface graphique.................................................................................... 23
5. Étapes de développement........................................................................................................ 24
5.1 Configuration du port série ......................................................................................................... 24
Navigation entre les pages ................................................................................................................ 24
5.2 Envoi des commandes vers STM32 ............................................................................................. 25
5.3 Réception et affichage des données............................................................................................ 26
6. Communication avec STM32 .................................................................................................... 27
6.1 Initialisation du système : ........................................................................................................ 28
6.2 Configuration de l’UART :................................................................................................. 29
6.3 Boucle principale (while) : ....................................................................................................... 29
6.4 Traitement des données reçues : ............................................................................................ 29
6.5 Gestion des erreurs :........................................................................................................ 30
6.6 Fonction d’interruption UART.................................................................................................. 30
7. Communication avec l’interface Qt .................................................................................. 30
8. Résumé du fonctionnement ............................................................................................... 31
CONCLUSION ......................................................................................................................................... 32

4
Liste des figures :
Figure 1:localisation CSF ......................................................................................................................... 4
Figure 2:carte STM32F407Vg .................................................................................................................. 6
Figure 3: Raspberry PY ............................................................................................................................ 7
Figure 4: arduino UNO ............................................................................................................................ 8
Figure 5: Les différents utilisation de QT................................................................................................ 9
Figure 6: Méthode agile ........................................................................................................................ 10
Figure 7 : Méthode SCRUM .................................................................................................................. 11
Figure 8: la communication UART ........................................................................................................ 13
Figure 9: les premiers pas sur QT ......................................................................................................... 22
Figure 10:Interface principale développée sous Qt Creator ................................................................ 23
Figure 11:Fenêtre de contrôle des deux chambres.............................................................................. 24

Liste des tables

Tableau 1:Diagramme de cas d’utilisation -Gestion de la maison ...................................................... 18
Tableau 2:Diagramme de cas d’utilisation – Communication UART ................................................... 18
Tableau 3: Résumer de fonctionnement .............................................................................................. 31

5
Ce rapport présente le stage réalisé au sein du Centre Supérieur de Formation (CSF) dans le
domaine des systèmes embarqués. L’objectif principal était de mettre en pratique les
connaissances en STM32, C, C++, Linux et Qt à travers la réalisation d’un projet Smart Home.
Le système développé permet la gestion de l’éclairage de différentes chambres et l’affichage
de la température en temps réel sur une interface Qt. La communication entre la carte
STM32F407VG et le PC s’effectue via UART. Ce projet a permis de consolider mes
compétences en conception matérielle et logicielle de systèmes embarqués.

Mots-clés : STM32, Qt, C++, Systèmes embarqués, Smart Home, UART, Domotique, IoT.

1
 Introduction générale

Dans le cadre de ma formation en ingénierie, j’ai eu l’opportunité d’effectuer un premier stage au sein
du Centre Supérieur de Formation (CSF). Ce stage s’inscrit dans la continuité de mon apprentissage
théorique et vise à renforcer mes compétences techniques à travers une expérience pratique dans le

Domaine des systèmes embarqués.

Le CSF se distingue par la qualité de son encadrement et son orientation vers les technologies
avancées, notamment dans les domaines de l’électronique, de l’informatique industrielle et
du développement embarqué. Intégrer ce centre m’a permis de travailler dans un
environnement professionnel stimulant, où rigueur et innovation constituent les valeurs
fondamentales.

Au cours de ce stage, j’ai eu l’occasion d’approfondir mes connaissances dans plusieurs

technologies clés : la programmation en C et C++, le développement sous système
d’exploitation Linux, la conception et la programmation sur microcontrôleur STM32, ainsi que
la création d’interfaces graphiques à l’aide de Qt. Ces compétences sont essentielles pour la
conception et la mise en œuvre de systèmes embarqués modernes, performants et fiables.

L’objectif principal de ce stage était de concevoir et de développer une solution embarquée

fonctionnelle, tout en appliquant les méthodologies d’ingénierie étudiées durant ma
formation. Cette expérience m’a permis de relier la théorie à la pratique, d’améliorer mes
capacités d’analyse et de résolution de problèmes, et de développer un sens accru de
l’autonomie et du travail en équipe.

2
 Chapitre 1 : Présentation du Centre Supérieur de
Formation

1. INTRODUCTION

Dans ce chapitre, nous présenterons le Centre Supérieur de Formation (CSF) en mettant en avant son
rôle principal, sa localisation, ainsi que ses principaux domaines d’activité, notamment la formation
professionnelle et la réalisation de projets

LE ROLE DE CSF

CSF est un organisme de formation professionnelle multidisciplinaire, leader et connu essentiellement

grâce a son expertise en termes de développement des systèmes embarqués et domaines connexes,
ainsi que son savoir-faire pédagogique innovante dans la mise en œuvre des formations…

Depuis 2009, la date de création de leur activité en systèmes embarqués, ils ont réussi à créer un comité
solide d’experts dans ce domaine qui a assuré jusqu’à ce jour-là plus de:

20 sessions de formation pour les enseignants des grandes écoles (ENIT, INSAT, FST, ENISO...)

180 sessions pour les étudiants

320 sessions dans la reconstitution de carrière professionnelle (RCP).

3
La localisation

Figure 1:localisation CSF

Adresse : 122 Avenue Fethi Zouhir, Route de, Raoued
Horaires : Ouvert ⋅ Ferme à 12 :00 ⋅ Rouvre à 14 :00
Téléphone : +216 92.039.433
E-mail : formation@[Link]

2. Domaine d’activité
CSF, Centre Supérieur de Formation est un organisme de formation professionnelle multidisciplinaire,
leader et connu essentiellement grâce a son expertise en termes de développement des systèmes
embarqués et domaines connexes, ainsi que son savoir-faire pédagogique innovante dans la mise en
œuvre des formations. Il propose de multiples parcours en formation continue adaptées au grand
public, étudiants, salariés, demandeurs d'emploi, ainsi que ses services pour les entreprises
notamment la formation, adaptation de formation, consultation, acquisition de talents et montée en
compétences des employés. Avec 10 ans d’expérience en formation professionnelle, des milliers
d'heures de formation dispensées entre autres pour des élèves ingénieurs, des ingénieurs et des
enseignants universitaires et une notoriété chez les grandes entreprises exerçantes dans les
technologies avancés, CSF est votre partenaire idéale pour un meilleur positionnement professionnel.

4
 Chapitre 2 : Contexte théorique et technologique

I. Le choix justifié de la carte

1. Microcontrôleur STM32F407VG
Avantages :

Performance et puissance : Le STM32F407, basé sur l’architecture ARM Cortex-M4,

offre une grande puissance de traitement et une capacité de calcul élevée, ce qui le rend
idéal pour des applications nécessitant des réponses rapides et précises, comme les
tableaux de bord automobiles.

Connectivité : Grâce à ses interfaces CAN, SPI, I2C, UART et USB, il peut facilement
être intégré avec différents capteurs et systèmes de communication présents dans les
véhicules modernes.

Flexibilité : Sa configuration adaptable permet la connexion facile d’écrans LCD ou

TFT pour l’affichage de données complexes et interactives, et la gestion efficace des
entrées/sorties pour contrôler des indicateurs analogiques et numériques.

Communauté et support : Une large communauté de développeurs, une

documentation complète et un support en ligne solide facilitent le développement et la
résolution des problèmes techniques.

Inconvénients :

Complexité de développement : La programmation du STM32F407 peut s’avérer

complexe pour les débutants en raison de son architecture avancée, nécessitant la
maîtrise d’outils comme STM32CubeMX et des IDE tels que Keil ou STM32CubeIDE.

Sécurité : Comme tout système connecté, il est crucial de protéger les données et de se
prémunir contre les cybermenaces, ce qui implique l’application rigoureuse de bonnes
pratiques de sécurité.

5
 Figure 2:carte STM32F407Vg

2. Raspberry Pi
Avantages :

Puissance de calcul : Suffisante pour gérer graphiques avancés et multiples capteurs.

Connectivité et polyvalence : Wi-Fi, Bluetooth, GPIO pour intégration facile.

Facilité d’utilisation : Documentation abondante et développement accessible.

Applications étendues : Navigation GPS, streaming, gestion des capteurs.

Inconvénients :

Consommation d’énergie : Plus élevée que les microcontrôleurs.

Taille et intégration : Installation plus complexe dans un espace réduit.

Fiabilité à long terme : Gestion attentive requise pour usage automobile.

6
 Figure 3: Raspberry PY

3. Arduino UNO
Avantages :

Simplicité et accessibilité : Facile à programmer, adaptée aux projets éducatifs.

Coût abordable : Solution économique pour projets à budget limité.

Large écosystème : Bibliothèques et communauté active.

Applications variées : Contrôle de capteurs et affichage de données simples.

Inconvénients :

Limitations de puissance : Moins performant que STM32F407 pour des

fonctionnalités avancées.

Connectivité limitée : Options restreintes pour intégration complexe.

Gestion des capteurs : Nécessite une planification minutieuse pour plusieurs capteurs.

7
 Figure 4: arduino UNO

4. Comparaison des solutions

En comparant les solutions étudiées, l’utilisation de la carte STM32F407VG s’avère la plus
adaptée pour notre Smart Home, grâce à sa puissance, sa flexibilité et sa fiabilité. Le tableau
ci-dessous résume les caractéristiques principales :

Tableau 1: Comparaison entre les cartes

Solution Flexibilité Rapidité Coût Complexité Fiabilité Télémaintenance

Raspberry Élevée Moyenne Modéré Moyenne Moyenne Oui
Pi
Arduino Moyenne Moyenne Faible Faible Moyenne Non
STM32 Élevée Élevée Moyen Élevée Élevée Oui

5. Présentation de Qt
Qt est un framework multiplateforme permettant de développer des interfaces graphiques
interactives et des applications logicielles robustes. Il offre une large gamme de widgets, layouts
et outils pour concevoir des interfaces ergonomiques et intuitives. Dans ce projet, Qt est utilisé
pour :

1. Recevoir les données de température et l’état des LED depuis la STM32 via UART.
2. Afficher ces informations en temps réel sur l’interface graphique.
3. Permettre à l’utilisateur de contrôler les lumières de chaque chambre via des boutons
interactifs.
4. Assurer une communication fiable et bidirectionnelle avec le microcontrôleur.

8
 Figure 5: Les différents utilisation de QT

5.1 Communication UART

La communication UART permet l’échange de données entre la STM32 et le PC. Dans ce
projet, les informations sur la température et l’état des LED sont envoyées depuis la STM32
vers l’interface Qt, qui les affiche et permet le contrôle des équipements

6. Problématique
Le projet vise à développer un système modulaire pour la gestion et la supervision d’une maison
intelligente. L’objectif est de concevoir une solution capable d’interfacer avec une interface
utilisateur Qt, permettant de suivre en temps réel l’état des différents capteurs (température,
humidité, luminosité) et de contrôler les actionneurs (LED, ventilateurs, buzzers). Le système
doit garantir la sécurité des occupants, la régulation de la consommation énergétique et la
flexibilité pour l’ajout de nouveaux modules.

7. Solution adaptée
Nous avons proposé la mise en place d’un système embarqué basé sur STM32F407VG,
permettant l’acquisition et le traitement des données des capteurs. L’interface utilisateur Qt
permet le suivi en temps réel et le contrôle des actionneurs. Les données peuvent également
être envoyées vers un serveur cloud pour un suivi à distance et une analyse dynamique. Ce

9
système assure une surveillance rapide et précise, permettant la détection immédiate de
problèmes et la régulation des conditions ambiantes dans la maison.

II. Méthodologie de travail

1. Méthodes agiles
Les méthodes agiles permettent une gestion flexible et efficace des projets, favorisant la
satisfaction client, l’adaptabilité aux changements et la livraison rapide des fonctionnalités.
Parmi ces méthodes, la plus utilisée est la méthodologie Scrum.

Figure 6: Méthode agile

2. Méthodologie Scrum
Scrum divise le projet en itérations appelées « sprints » (2 à 4 semaines). Les tâches sont
estimées, planifiées et exécutées à l’aide d’User Stories. Les réunions quotidiennes permettent
de suivre l’avancement et résoudre les obstacles. Les rôles principaux sont :

• Product Owner : Définit les fonctionnalités et valide les livrables.

• Scrum Master : Facilite le processus et supprime les obstacles.
• Équipe de développement : Convertit les User Stories en fonctionnalités
opérationnelles.

10
 Figure 7 : Méthode SCRUM

3. Chronogramme de travail
La gestion du projet est assurée via un diagramme de Gantt, répartissant les tâches en six phases
principales : planification, conception, développement, tests, intégration et documentation
finale.

Conclusion
Ce chapitre a présenté l’analyse préliminaire du projet Smart Home, l’étude des solutions
matérielles, la problématique, la solution retenue et la méthodologie de travail. L’approche
Scrum associée à l’utilisation de STM32F407VG et Qt permet de garantir une conception
modulable, sécurisée et efficace, assurant la performance et le confort d’utilisation dans un
environnement domestique intelligent.

11
 Chapitre 3 : Analyse et conception du système

Introduction
Ce chapitre est consacré à l’analyse détaillée et à la conception du système Smart Home. Il présente le
cahier des charges, l’architecture matérielle et logicielle, ainsi que la communication entre le
microcontrôleur STM32F407VG et l’interface Qt sur PC. L’objectif est de définir clairement les besoins
fonctionnels et techniques, d’établir les protocoles de communication et de garantir une solution fiable,
extensible et ergonomique pour la supervision et le contrôle de la maison intelligente.

I. Cahier des charges

Cahier des charges détaillé

Le projet Smart Home devait répondre aux exigences suivantes :

• Gestion intelligente de l’éclairage : possibilité de contrôler individuellement chaque

chambre et de créer des scénarios automatiques en fonction de l’heure ou de la
présence.
• Surveillance de la température et de l’humidité : affichage en temps réel et alertes
en cas de dépassement des seuils prédéfinis.
• Interface utilisateur intuitive : utilisation de Qt pour créer une IHM simple,
ergonomique et réactive.
• Communication fiable et sécurisée : transmission des données entre STM32 et PC
via UART, avec protocole simple de vérification d’intégrité.
• Extensibilité : possibilité d’ajouter facilement de nouveaux capteurs ou actionneurs.

II. Architecture du système

Le système Smart Home se compose de trois parties principales :

• Module embarqué (STM32F407VG) :

Lecture des capteurs (température).

Contrôle des LED selon les commandes de l’utilisateur.

Gestion de la communication UART avec le PC.

12
 • Interface Qt sur PC :

Visualisation en temps réel des mesures.

Boutons de contrôle pour chaque chambre.

Historique des données et génération de graphiques.

• Liaison UART :

Transmission des mesures depuis STM32 vers Qt.

Réception des commandes de l’interface et exécution par la carte.

Figure 8: la communication UART

III. Liaison STM32 ↔ Qt

Les capteurs envoient les données au microcontrôleur.

• STM32 traite et formate les données.

• Transmission via UART vers le PC.
• Qt reçoit, affiche et enregistre les données.
• Le PC reçoit les données avec Qt en utilisant la classe QSerialPort.
• L’utilisateur peut envoyer des commandes pour contrôler les LED.
• STM32 reçoit ces commandes et ajuste l’éclairage en conséquence.

Protocoles et algorithmes

• Lecture des capteurs : utilisation de l’ADC interne pour capteurs

analogiques.
• Gestion des LED : PWM pour contrôle de l’intensité lumineuse.

13
 • Transmission UART : trame simple avec start/stop bits et checksum pour la
vérification des données.
• Qt : parsing des données reçues, mise à jour des widgets et génération de
notifications.

Sécurité et fiabilité

• Vérification de la cohérence des données avant affichage.

• Gestion des erreurs de communication UART.
• Limitation des commandes invalides depuis l’IHM.
• Extensibilité prévue pour intégrer des alertes par mail ou notifications push.

Tests et validation

• Vérification du fonctionnement des capteurs et des LED.

• Simulation de scénarios horaires et de détection de présence.
• Tests de transmission UART sur différentes longueurs de câble.
• Validation de l’interface Qt avec plusieurs utilisateurs.

Cette approche détaillée assure une conception robuste et fonctionnelle, prête pour la mise en
œuvre finale et l’intégration avec d’autres modules de la Smart Home.

Conclusion

Ce chapitre a permis de structurer le projet Smart Home en définissant le cahier des charges,
l’architecture du système et les protocoles de communication entre STM32 et Qt. L’analyse détaillée
a assuré que le système soit fonctionnel, sécurisé et capable de répondre aux besoins de supervision
et de contrôle en temps réel. Cette conception constitue la base solide pour le développement et
l’intégration du logiciel et du matériel dans les chapitres suivants.

14
 Chapitre 4 : Analyses et spécifications de besoins

I. Introduction

Après avoir présenté le contexte général du projet, ce chapitre sera consacré à la définition des
besoins fonctionnels et non fonctionnels de notre système Smart Home. Nous identifierons
également les acteurs impliqués dans le système ainsi que les cas d’utilisation associés. Enfin,
nous présenterons la méthodologie de gestion de projet adoptée afin de garantir une
planification rigoureuse et un développement efficace.

II. Spécification du besoin

La phase de spécification du besoin a pour objectif de définir précisément les fonctionnalités

que doit remplir notre système, ainsi que les contraintes techniques et qualitatives auxquelles il
doit répondre.

III. Besoins fonctionnels

L’analyse fonctionnelle consiste à identifier les principales fonctions que le système doit
assurer pour répondre aux attentes de l’utilisateur.
Dans le cadre de ce projet de maison intelligente, notre système se compose de deux parties
principales :

• Le module embarqué (STM32F407VG) : responsable de la lecture des capteurs et du

contrôle des actionneurs.
• Le module de supervision (interface Qt sur PC) : permettant à l’utilisateur de
visualiser et contrôler les équipements domestiques.

Les besoins fonctionnels principaux sont les suivants :

Côté STM32 (module embarqué) :

15
 • Alimenter les capteurs et les LED connectées.
• Lire les valeurs analogiques provenant du capteur de température (ex. LM35).
• Envoyer périodiquement les données mesurées via le port UART.
• Recevoir les commandes provenant du PC (allumer/éteindre les lumières).
• Gérer l’état des chambres selon les ordres reçus.

Côté PC (interface Qt) :

• Afficher en temps réel la température des différentes chambres.

• Afficher l’état (ON/OFF) des lumières.
• Permettre à l’utilisateur de commander manuellement les lumières depuis l’interface.
• Assurer une communication série fiable et bidirectionnelle avec la carte STM32.

IV. Besoins non fonctionnels

Les besoins non fonctionnels concernent la qualité de fonctionnement et les contraintes

techniques du système.
Ils incluent notamment :

• Performance : le système doit être réactif, avec une communication UART fluide et
une mise à jour rapide des informations sur l’interface Qt.
• Fiabilité : la communication entre la STM32 et le PC doit être stable et sans perte de
données.
• Simplicité : l’interface Qt doit être intuitive, claire et facile d’utilisation.
• Extensibilité : le système doit permettre l’ajout futur de nouveaux capteurs (humidité,
mouvement, etc.) ou d’autres fonctions de contrôle domotique.
• Disponibilité : le système doit pouvoir fonctionner en continu, sans redémarrage
fréquent.

V. Identification des acteurs et des cas d’utilisation

16
 1. Les acteurs
Deux acteurs principaux interagissent avec le système :

• Le microcontrôleur STM32F407VG : c’est le cœur du système embarqué. Il collecte

les informations des capteurs, traite les données et commande les actionneurs (LED).
• L’utilisateur (Administrateur) : c’est la personne qui utilise l’interface Qt pour
superviser la maison et commander les lumières.

2. Les cas d’utilisation

Un cas d’utilisation décrit les interactions entre l’acteur et le système pour accomplir une tâche
donnée.

3. Modèle général des cas d’utilisation

Le diagramme général représente les interactions entre :

• L’utilisateur via l’interface Qt,

• Et la carte STM32 qui exécute les actions matérielles.

Les principales fonctionnalités sont :

• Lecture des capteurs de température.

• Transmission des données vers le PC.
• Affichage des données sur l’interface graphique.
• Contrôle manuel des lumières par l’utilisateur.

17
VI. Raffinement des cas d’utilisation

(a) Raffinement du cas d’utilisation : Gestion de la maison

Tableau 1:Diagramme de cas d’utilisation -Gestion de la maison

Élément Description
Titre Gestion de la maison intelligente
Résumé Permet de surveiller la température et de contrôler les lumières dans
chaque chambre.
Acteur Utilisateur (via Qt)
Précondition STM32 connectée et capteurs opérationnels
Postcondition État des équipements mis à jour
Scénario - Consulter la température des chambres
principal - Allumer/éteindre les lumières
- Recevoir les alertes de température élevée

(b) Raffinement du cas d’utilisation : Communication UART

Tableau 2:Diagramme de cas d’utilisation – Communication UART

Élément Description
Titre Communication STM32 ↔ PC
Résumé Échange bidirectionnel de données entre la carte STM32 et l’interface
Qt
Acteur Utilisateur, STM32
Précondition Port série configuré (115200 bauds, 8 bits, 1 stop bit)
Postcondition Données transmises et affichées avec succès
Scénario - Envoi des mesures depuis STM32 vers PC
principal - Réception des commandes du PC
- Mise à jour en temps réel de l’interface Qt

18
VII. Gestion du projet

1. Équipe et rôles

Le projet a été réalisé selon la méthodologie Agile Scrum, favorisant une planification par
itérations.
L’équipe projet était composée comme suit :

Rôle Scrum Personne affectée

Scrum Master M. Halim Kacem
Product Owner M. Basma Yahyaoui
Équipe de réalisation Yassine Kacem et autre

2. Product Backlog

Le Product Backlog regroupe les fonctionnalités à développer sous forme de "User Stories".

Sprint User Story Feature Priorité

Sprint Configurer la carte STM32 et les Lecture et envoi des données via 1
1 capteurs UART
Sprint Créer l’interface Qt Affichage température et contrôle 2
2 LEDs
Sprint Améliorer la communication série Synchronisation temps réel et 3
3 fiabilité

3. Planification
Une seule Release a été planifiée pour la livraison finale du système complet Smart Home.
Les sprints ont permis une approche incrémentale :

1. Sprint 1 : mise en service STM32, capteur et LED.

2. Sprint 2 : développement de l’interface Qt.
3. Sprint 3 : tests de communication et intégration complète.

19
VIII. Conclusion

Ce chapitre a permis de définir les besoins fonctionnels et non fonctionnels du système Smart
Home, tout en identifiant les acteurs et les cas d’utilisation.
Nous avons également présenté la planification et la méthodologie de développement adoptées
selon l’approche Agile Scrum. Ces éléments constituent la base de la conception matérielle et
logicielle qui sera détaillée dans les chapitres suivants.

20
 CHAPITRE 5 : Conception

Introduction

Ce chapitre présente la conception et la mise en œuvre de l’application de supervision réalisée

avec Qt Creator. Cette application permet la communication bidirectionnelle entre le
microcontrôleur STM32F407 et un ordinateur via une interface UART (port série).
L’objectif est de fournir un tableau de bord intelligent, capable de recevoir, afficher et contrôler
en temps réel les informations transmises par le système embarqué.

1. Choix de l’environnement de développement

Pour la partie interface graphique et communication série, nous avons choisi Qt pour plusieurs
raisons :

• Multiplateforme : Qt permet de développer des applications compatibles Windows,

Linux ou macOS.
• Programmation orientée objet avec le langage C++, offrant puissance et modularité.
• Intégration native des signaux et slots, facilitant la gestion d’événements (clics,
lectures série, etc.).
• Modules de communication (comme QSerialPort) permettant une liaison directe avec
le microcontrôleur STM32F407.
• Concepteur d’interface graphique (Qt Designer) pour la création intuitive
d’interfaces modernes.

2. Architecture générale de l’application

L’application se compose de deux principales classes :

• MainWindow : représente la fenêtre principale et la logique d’interface (gestion des

pages, boutons, affichage LCD, etc.).
• Device : gère la communication série avec la carte STM32F407 (configuration du
port, envoi/réception des données).

La communication suit un modèle en couches :

21
1. STM32 → envoie des données capteurs sous forme de trames via UART.
2. Qt → reçoit ces trames, les décode et met à jour l’interface utilisateur.
3. Qt → peut également envoyer des commandes à STM32 pour actionner des dispositifs
(LED, relais, etc.).

3. Création d’un nouveau projet Qt

1. Lancer Qt Creator
Ouvrir Qt Creator, puis sélectionner “File → New File or Project”.
2. Choisir “Qt Widgets Application”, car notre projet nécessite une interface graphique
classique avec boutons, LCD, etc.
3. Donner un nom au projet, par exemple :
Tableau_de_bord_STM32
4. Sélectionner un dossier de destination et cliquer sur “Next”.
5. Choisir le kit de compilation (généralement Desktop Qt x.x.x MinGW ou MSVC selon
ton installation).
6. Cliquer sur Finish.

Figure 9: les premiers pas sur QT

22
 4. Conception de l’interface graphique

L’interface a été réalisée à l’aide de Qt Designer, et se compose de plusieurs pages

accessibles via un QStackedWidget :

• Page d’accueil : choix de la chambre ou du module à contrôler.

• Page 2 (Chambre 1) : affichage des données et commandes de la première chambre.
• Page 3 (Chambre 2) : affichage des données et commandes de la deuxième chambre.

Chaque page comporte :

• Des LCDNumber pour l’affichage des mesures (température, luminosité, etc.).

• Des LineEdit pour afficher l’état textuel des actionneurs.
• Des boutons pour allumer/éteindre les lumières (envoi de commande via UART).
• Des boutons de navigation pour revenir à la page d’accueil.

Figure 10:Interface principale développée sous Qt Creator

23
 Figure 11:Fenêtre de contrôle des deux chambres

5. Étapes de développement

5.1 Configuration du port série

La communication série est gérée par la classe Device, utilisant la bibliothèque QSerialPort.
Le port est configuré dès le lancement du programme grâce à la fonction Port_Config() :

Cette fonction initialise la liaison UART (vitesse, bits de stop, parité, etc.) et vérifie la
connexion avec le STM32.

Navigation entre les pages

La navigation est gérée par le QStackedWidget, qui permet d’afficher dynamiquement

différentes pages selon les boutons cliqués :

24
Cela permet une gestion claire et fluide des écrans, simulant un mini-système de menu
intégré.

5.2 Envoi des commandes vers STM32

Lorsque l’utilisateur appuie sur les boutons Allumer ou Éteindre, une commande spécifique
est envoyée au microcontrôleur :

25
Ces valeurs (“1”, “2”, “3”, “4”) sont reçues par le STM32 qui active ou désactive les
actionneurs correspondants (lampes, ventilateurs, etc.).

5.3 Réception et affichage des données

Lorsqu’une trame est reçue depuis le STM32, le signal readyRead() est émis et connecté au
slot Display_Info() :

QObject::connect([Link](), SIGNAL(readyRead()), this,

SLOT(Display_Info()));

26
Le traitement des données reçues se fait dans la fonction suivante :

Cette méthode décode la trame reçue, met à jour les LCDNumber et affiche l’état textuel des
actionneurs.

6. Communication avec STM32

La communication se fait via UART :

• Le STM32F407 envoie les mesures capteurs (température) sous forme de trames.

• L’application Qt les lit, les affiche et permet à l’utilisateur d’interagir à distance.

27
Ce mode de communication garantit une simplicité, une faible latence et une fiabilité élevée
pour un système embarqué.

Le programme est structuré selon les étapes suivantes :

6.1 Initialisation du système :

• Réinitialisation des périphériques et initialisation du HAL (Hardware
Abstraction Layer).
• Configuration de l’horloge système via la fonction
SystemClock_Config().

• Initialisation des périphériques UART et GPIO via les fonctions

MX_USART2_UART_Init() et MX_GPIO_Init().

28
 6.2 Configuration de l’UART :
L’interface UART2 est configurée à une vitesse de transmission de 115200
bauds, avec :
• 8 bits de données,
• 1 bit de stop,
• sans parité,
• mode bidirectionnel (TX/RX).

Cette configuration permet d’établir une communication stable avec le PC.

6.3 Boucle principale (while) :

• Le programme attend la réception d’un caractère via
HAL_UART_Receive_IT().

• Lorsqu’une donnée est reçue, la fonction d’interruption

HAL_UART_RxCpltCallback() est déclenchée, indiquant qu’une nouvelle
commande est disponible.

6.4 Traitement des données reçues :

• Si la donnée reçue est '1', la LED verte (pin GREEN_Pin sur GPIOD)
s’allume.
• Si la donnée reçue est '0', la LED s’éteint.

29
 • Le microcontrôleur renvoie la même donnée au PC pour confirmer la
bonne exécution de la commande.

6.5 Gestion des erreurs :

En cas d’erreur (mauvaise initialisation ou problème de communication), la
fonction Error_Handler() s’exécute :
• Les interruptions sont désactivées (__disable_irq()),
• Et la LED rouge s’allume pour indiquer un état d’erreur.

6.6 Fonction d’interruption UART

La fonction suivante est appelée automatiquement à chaque réception d’un caractère sur
l’UART :

Cette interruption met simplement un indicateur à 1 pour signaler à la boucle principale

qu’une nouvelle donnée est disponible.

7. Communication avec l’interface Qt

L’interface graphique développée sous Qt agit comme un tableau de bord de contrôle.

Lorsqu’un bouton est pressé (par exemple “Allumer la LED”), Qt envoie un caractère '1' via
le port série.
Le STM32 reçoit cette commande, active la LED correspondante, puis renvoie '1' au PC
pour confirmer.
Ce principe peut être étendu à plusieurs capteurs et actionneurs pour une maison intelligente.

30
8. Résumé du fonctionnement

Tableau 3: Résumer de fonctionnement

Action depuis PC (Qt) Donnée envoyée Réaction STM32 Réponse envoyée
Bouton “Allumer” '1' LED verte allumée '1'
Bouton “Éteindre” '0' LED verte éteinte '0'

Conclusion
Ce chapitre a détaillé le processus complet de conception de l’application Qt :
de la création de l’interface graphique à la mise en place de la communication série avec le
microcontrôleur STM32.
Grâce à la puissance du framework Qt, nous avons pu développer une interface ergonomique,
réactive et connectée, offrant une interaction fluide entre l’utilisateur et le système embarqué.

31
 Conclusion générale

Ce stage au sein du Centre Supérieur de Formation (CSF) a constitué une expérience à la

fois formatrice et enrichissante, me permettant de consolider mes connaissances théoriques
acquises durant ma formation en ingénierie mécatronique et de les appliquer dans un contexte
professionnel concret.

L’objectif principal était de concevoir et de réaliser un système embarqué intelligent pour

la gestion et la supervision d’une maison connectée, intégrant des technologies modernes telles
que le microcontrôleur STM32F407VG, le framework Qt, et une liaison UART pour la
communication série entre le microcontrôleur et le PC.

Au fil du stage, plusieurs compétences techniques ont été développées :

• La maîtrise de la programmation embarquée en C sous STM32CubeIDE ;

• La gestion des interfaces de communication UART entre carte et ordinateur ;
• La création d’interfaces graphiques dynamiques sous Qt Creator avec C++ ;
• La conception électrique et logique du système pour le contrôle des actionneurs et la
lecture des capteurs.

Le projet Smart Home a permis d’aboutir à une solution fonctionnelle capable de :

• Gérer l’allumage et l’extinction des lumières dans différentes chambres ;

• Afficher en temps réel la température ambiante ;
• Assurer une communication bidirectionnelle fiable entre le microcontrôleur et le PC ;
• Offrir une interface utilisateur intuitive et évolutive.

Sur le plan personnel, ce stage m’a permis de développer une meilleure autonomie, une
rigueur dans la gestion de projet, et une capacité d’analyse face aux problèmes techniques
rencontrés. L’encadrement de M. Halim Kacem au sein du CSF m’a également permis

32
Bibliographie :

extension://efaidnbmnnnibpcajpcglclefindmkaj/[Link]
[Link]

[Link]

extension://efaidnbmnnnibpcajpcglclefindmkaj/[Link]
[Link]

extension://efaidnbmnnnibpcajpcglclefindmkaj/[Link]
[Link]

[Link]
[Link]

[Link]

[Link]

33