Assistant vocal local pour contrôle
d’éclairage avec Arduino Nano
ESP32 et TensorFlow Lite
Mini-projet – Domotique et Intelligence Artificielle
Embarquée
Classe : MT3.1
Élaboré par : HAMMAMI Med Aziz
NEFZI Jedallah
YAHYAOUI Ranim
SIELEMIN Med Mokhtar
Année universitaire :
2025–2026
Sommaire
1. Introduction..........................................................................................................................................3
2. Cahier des charges................................................................................................................................3
2.1 Objectifs fonctionnels.....................................................................................................................3
2.2 Contraintes techniques....................................................................................................................3
2.3 Contraintes de réalisation...............................................................................................................3
3. Description du système.........................................................................................................................4
3.1 Architecture matérielle...................................................................................................................4
3.2 Architecture logicielle....................................................................................................................4
4. Réalisation............................................................................................................................................4
4.1 Acquisition audio............................................................................................................................4
4.2 Pré-traitement du signal..................................................................................................................5
4.3 Modèle TensorFlow Lite pour microcontrôleurs............................................................................5
4.4 Commande de la LED / relais.........................................................................................................5
5. Tests et résultats....................................................................................................................................6
5.1 Méthodologie de test......................................................................................................................6
5.2 Résultats expérimentaux (exemple)................................................................................................6
6. Limites et améliorations possibles........................................................................................................6
6.1 Limites actuelles.............................................................................................................................6
6.2 Pistes d’amélioration......................................................................................................................6
7. Conclusion............................................................................................................................................8
Liste des Figures :
Figure 1: Schéma global du système..........................................................................................3
Figure 2 : Schéma de câblage entre Arduino Nano ESP32, microphone I2S.............................5
Figure 3 : Schéma bloc de l’architecture logicielle....................................................................5
Figure 4 : Capture d’écran de l’IDE montrant l’initialisation de l’interface I2S........................6
Figure 5 : Exemple de représentation temps-fréquence (spectrogramme) d’un mot-clé............7
Figure 6 : Photo du prototype – Arduino, microphone I2S et LED allumée..............................8
Liste des Tableaux :
Tableau 1 : Résultats expérimentaux..........................................................................................9
1. Introduction
Les assistants vocaux sont de plus en plus présents dans la vie quotidienne : enceintes
connectées, Smartphones, téléviseurs intelligents, etc. La plupart de ces systèmes s’appuient
sur des serveurs distants (Cloud) pour traiter la voix et exécuter les commandes, ce qui
présente plusieurs inconvénients :
collecte de données personnelles,
dépendance à la connexion Internet,
latence parfois perceptible.
L’objectif de ce mini-projet est de concevoir un assistant vocal très simple, fonctionnant
entièrement en local sur une carte Arduino Nano ESP32. Le système permet de contrôler
l’éclairage à l’aide de commandes vocales de base, traitées grâce à un modèle de
reconnaissance de mots-clés (keyword spotting) développé avec TensorFlow Lite.
Figure 1: Schéma global du système
2. Cahier des charges
2.1 Objectifs fonctionnels
Le système doit :
Reconnaître au minimum deux commandes vocales :
o « Lumière ON » ;
o « Lumière OFF ».
Fonctionner en mode entièrement local, sans connexion à Internet.
Réagir en temps quasi réel (latence faible entre la parole et l’action).
Page 3
Commander une LED ou un module relais représentant une lampe.
2.2 Contraintes techniques
Utiliser une carte Arduino Nano ESP32 comme plateforme de calcul.
Utiliser un microphone I2S pour la capture du signal audio.
Le modèle de reconnaissance doit être suffisamment compact pour tenir dans la
mémoire du microcontrôleur.
La consommation d’énergie doit rester modérée (fonctionnement sur USB ou
alimentation externe).
2.3 Contraintes de réalisation
Durée de réalisation limitée (mini-projet).
Disponibilité de ressources logicielles (bibliothèques Arduino, exemples TensorFlow
Lite).
Nécessité de simplifier certaines étapes (prétraitement audio, entraînement du modèle)
pour rester dans un cadre pédagogique.
3. Description du système
3.1 Architecture matérielle
L’architecture matérielle est composée des éléments suivants :
Une Arduino Nano ESP32 utilisée comme unité de traitement.
Un microphone I2S permettant de numériser le signal vocal.
Une LED (ou un relais) connectée à un GPIO pour représenter l’éclairage.
Une breadboard et des fils de connexion pour le prototypage.
Le microphone est relié aux broches I2S de l’ESP32 (BCK, WS, SD), tandis que la LED est
connectée via une résistance à un GPIO. L’alimentation et la programmation se font par le
port USB.
Page 4
Figure 2 : Schéma de câblage entre Arduino Nano ESP32, microphone I2S
3.2 Architecture logicielle
L’architecture logicielle se décompose en plusieurs blocs :
1. Acquisition audio : configuration de l’interface I2S de l’ESP32 pour lire des
échantillons audio à une certaine fréquence (par exemple 16 kHz).
2. Pré-traitement du signal : transformation du signal brut en caractéristiques plus
compactes et informatives (par exemple, calcul de MFCC).
3. Inférence du modèle TensorFlow Lite : exécution d’un réseau de neurones léger
pour classer les données en différentes catégories (« silence », « ON », « OFF »).
4. Prise de décision : interprétation des probabilités de sortie du modèle et
déclenchement de l’action associée.
5. Commande de la sortie : pilotage de la LED ou du relais via une broche GPIO.
Figure 3 : Schéma bloc de l’architecture logicielle
Page 5
4. Réalisation
4.1 Acquisition audio
La première étape consiste à configurer l’interface I2S du Nano ESP32 afin de récupérer les
échantillons audio issus du microphone. Une fréquence d’échantillonnage de 16 kHz est
typiquement utilisée pour la reconnaissance vocale de mots-clés.
Le code met en place le driver I2S, définit la taille des buffers DMA et lit régulièrement des
blocs d’échantillons dans un tableau en mémoire. Ce flux audio continu fournit les données
nécessaires au traitement du signal.
Figure 4 : Capture d’écran de l’IDE montrant l’initialisation de l’interface I2S
Page 6
4.2 Pré-traitement du signal
Le signal brut est difficile à exploiter directement par un réseau de neurones. Il est donc
transformé en un ensemble de caractéristiques plus appropriées, telles que :
la puissance dans différentes bandes de fréquences,
ou idéalement, des coefficients cepstraux en fréquences de Mel (MFCC).
Dans un projet complet, le calcul des MFCC peut être réalisé sur un PC pour générer le
modèle, puis reproduit de façon optimisée sur le microcontrôleur. Dans ce mini-projet, le
prétraitement peut être simplifié tout en expliquant le principe des MFCC dans le rapport.
Figure 5 : Exemple de représentation temps-fréquence (spectrogramme) d’un mot-clé
4.3 Modèle TensorFlow Lite pour microcontrôleurs
Le modèle de reconnaissance vocale est entraîné à l’avance sur PC à partir d’un jeu de
données contenant :
des extraits audio contenant les mots « ON » et « OFF » ;
des exemples de bruit et de silence.
Après entraînement, le modèle est converti au format TensorFlow Lite, puis adapté à la
version Micro pour être utilisé directement sur la carte Arduino. Le modèle est intégré au
projet sous la forme d’un tableau C (par exemple dans un fichier model.h).
Dans l’application, la bibliothèque TensorFlow Lite for Microcontrollers :
Page 7
alloue un tensor arena en mémoire,
initialise l’interpréteur,
exécute le modèle à chaque nouvelle fenêtre de données.
La sortie du modèle est un vecteur de probabilités correspondant aux classes « silence », « ON
» et « OFF ».
4.4 Commande de la LED / relais
Une fois la commande reconnue, la carte agit sur la sortie :
Si la classe prédite est « ON » : la LED est allumée (GPIO à l’état haut).
Si la classe prédite est « OFF » : la LED est éteinte (GPIO à l’état bas).
Cette LED peut être remplacée par un relais pour commander une véritable lampe d’éclairage.
Figure 6 : Photo du prototype – Arduino, microphone I2S et LED allumée
5. Tests et résultats
5.1 Méthodologie de test
Les tests ont été effectués dans plusieurs conditions :
Environnement calme (peu de bruit de fond).
Page 8
Différentes distances entre l’utilisateur et le microphone (environ 50 cm et 1 mètre).
Plusieurs locuteurs pour tester la robustesse aux variations de voix.
Pour chaque scénario, un certain nombre de tentatives ont été réalisées pour les commandes «
ON » et « OFF », et le nombre de réussites a été comptabilisé.
5.2 Résultats expérimentaux (exemple)
Scénario Nombre d’essais Reconnaissances Taux de succès
correctes
20 18 90%
« Lumière ON » -1 m
20 17 85%
« Lumière OFF » -1m
Environnement 20 14 70%
légèrement bruyant
Tableau 1 : Résultats expérimentaux
Les résultats montrent que le système est globalement fiable dans un environnement calme.
En présence de bruit, les performances diminuent, ce qui est attendu pour un système
embarqué de capacité limitée.
6. Limites et améliorations possibles
6.1 Limites actuelles
Les principales limites du prototype sont les suivantes :
Nombre de commandes réduit (deux mots-clés seulement).
Sensibilité au bruit et aux conditions acoustiques.
Modèle de petite taille, donc moins performant qu’un modèle plus complexe dans le
Cloud.
Absence de gestion avancée du mot d’activation (Wake Word).
6.2 Pistes d’amélioration
Plusieurs améliorations sont possibles :
Ajouter de nouvelles commandes vocales (« Ventilateur ON/OFF », « Mode Nuit »,
etc.).
Améliorer le pré-traitement audio (filtrage, réduction de bruit).
Optimiser l’architecture du modèle pour obtenir un meilleur compromis entre
précision et consommation de mémoire.
Page 9
Intégrer la solution dans un système domotique plus large, avec pilotage d’autres
appareils via Wi-Fi ou Bluetooth.
7. Conclusion
Ce mini-projet démontre qu’il est possible de concevoir un assistant vocal simple,
fonctionnant entièrement en local sur une carte Arduino Nano ESP32. En combinant un
microphone I2S, un traitement du signal et un modèle TensorFlow Lite pour
microcontrôleurs, le système parvient à reconnaître quelques commandes de base pour
contrôler l’éclairage.
Même si les performances restent modestes par rapport à des solutions industrielles, le
prototype met en avant trois avantages majeurs :
Confidentialité : aucun envoi de données vocales vers le Cloud.
Faible latence : exécution locale, réponse rapide.
Coût réduit : composants peu onéreux et facilement disponibles.
Ce travail constitue une bonne introduction à l’intelligence artificielle embarquée et à la
domotique. Il peut servir de base à des projets plus ambitieux, intégrant davantage de
commandes, de capteurs et d’appareils connectés.
Page 10
Les sources :
[Link]
[Link]
[Link]
[Link]
Page 11