ENIB 2026 : James Box 007

Titre de la fiche expérience :

description (résumé)

Voici une photo de notre groupe avec Wilhem, Elouan et Thibault

Première conceptualisation de notre projet :

Introduction

James Bond veut dérober nos recherches. Pour protéger notre travail, nous devons concevoir une alarme qui nous avertira de sa venue. Nous avons décidé de la fabriquer nous-mêmes en utilisant un détecteur de présence couplé à une alarme sonore, ce qui nous permettra à coup sûr de le coincer.

outil et matériel

Trois Led de signalement :

Un bouton poussoir :

Un sonar/détecteur de mouvement :

Deux cartes ESP32 :

Un haut parleur :

fichiers à joindre

Fichier:James Box 007.pdf

Mettre du code Arduino

Code Émetteur (Boite avec Bouton et LED) :

  1  
  2  
  3 #include <esp_now.h>
  4 #include <WiFi.h>
  5 
  6 #define pinDeSortieArduino 32 
  7 #define frequenceDeDebut 700 // Fréquence "basse" de la sirène
  8 #define frequenceDeFin 2700 // Fréquence "haute" de la sirène
  9 
 10 // REMPLACEZ PAR L'ADRESSE MAC DU RECEPTEUR
 11 uint8_t adresseRecepteur[] = {0xB0, 0xCB, 0xD8, 0xD5, 0xFE, 0xB4};
 12 
 13 const int PIN_BOUTON = 4;
 14 const int PIN_LED_JAUNE = 15;
 15 const int PIN_LED_VERTE = 14;
 16 const int PIN_LED_ROUGE = 12;
 17 
 18 typedef struct {
 19   bool modeDetection;
 20 } MessageEmetteur;
 21 
 22 typedef struct {
 23   bool mouvementDetecte;
 24 } MessageRecepteur;
 25 
 26 MessageEmetteur msgEnvoye;
 27 MessageRecepteur msgRecu;
 28 
 29 enum Etat { ATTENTE, DETECTION, ALERTE };
 30 Etat etatActuel = ATTENTE;
 31 
 32 void onSent(const wifi_tx_info_t *info, esp_now_send_status_t status) {
 33   Serial.print("Envoi message : ");
 34   Serial.println(status == ESP_NOW_SEND_SUCCESS ? "OK" : "ECHEC");
 35 }
 36 
 37 void onReceive(const esp_now_recv_info *info, const uint8_t *data, int len) {
 38   memcpy(&msgRecu, data, sizeof(msgRecu));
 39   
 40   Serial.println(">>> MESSAGE REÇU DU RECEPTEUR <<<");
 41   Serial.print("Mouvement détecté : ");
 42   Serial.println(msgRecu.mouvementDetecte ? "OUI" : "NON");
 43   
 44   if (msgRecu.mouvementDetecte) {
 45     Serial.println("!!! ALERTE MOUVEMENT !!!");
 46     etatActuel = ALERTE;
 47     digitalWrite(PIN_LED_VERTE, LOW);
 48     digitalWrite(PIN_LED_ROUGE, HIGH);
 49 
 50     while (digitalRead(PIN_BOUTON) != LOW){
 51       // Phase de "montée" sirène
 52       for (int i = frequenceDeDebut; i < frequenceDeFin; i=i+3) {
 53         tone(pinDeSortieArduino, i); 
 54         delay(1); 
 55         if (digitalRead(PIN_BOUTON) == LOW){
 56           break;
 57         }
 58       }
 59 
 60       // Phase de "descente" sirène
 61       for (int i = frequenceDeFin; i > frequenceDeDebut; i=i-3) {
 62         tone(pinDeSortieArduino, i); 
 63         delay(1); 
 64         if (digitalRead(PIN_BOUTON) == LOW){
 65           break;
 66         }
 67       }
 68     }
 69     noTone(pinDeSortieArduino);
 70   }
 71 }
 72 
 73 void setup() {
 74   Serial.begin(115200);
 75   delay(1000);
 76   
 77   pinMode(PIN_LED_JAUNE, OUTPUT);
 78   pinMode(PIN_LED_VERTE, OUTPUT);
 79   pinMode(PIN_LED_ROUGE, OUTPUT);
 80   pinMode(PIN_BOUTON, INPUT_PULLUP);
 81   pinMode(pinDeSortieArduino, OUTPUT);
 82 
 83   digitalWrite(PIN_LED_JAUNE, HIGH);
 84   digitalWrite(PIN_LED_VERTE, LOW);
 85   digitalWrite(PIN_LED_ROUGE, LOW);
 86   
 87   WiFi.mode(WIFI_STA);
 88   Serial.println("\n=== EMETTEUR DEMARRE ===");
 89   Serial.print("MAC : ");
 90   Serial.println(WiFi.macAddress());
 91   
 92   if (esp_now_init() != ESP_OK) {
 93     Serial.println("ERREUR init ESP-NOW");
 94     return;
 95   }
 96   
 97   esp_now_register_send_cb(onSent);
 98   esp_now_register_recv_cb(onReceive);
 99   
100   esp_now_peer_info_t peerInfo = {};
101   memcpy(peerInfo.peer_addr, adresseRecepteur, 6);
102   peerInfo.channel = 0;  
103   peerInfo.encrypt = false;
104   
105   if (esp_now_add_peer(&peerInfo) == ESP_OK) {
106     Serial.println("Peer ajoute avec succes");
107   } else {
108     Serial.println("ERREUR ajout peer");
109   }
110   
111   Serial.println("Mode ATTENTE - Appuyez sur le bouton\n");
112 }
113 
114 void loop() {
115   static bool dernierEtatBouton = HIGH;
116   bool etatBouton = digitalRead(PIN_BOUTON);
117   
118   if (dernierEtatBouton == HIGH && etatBouton == LOW) {
119     delay(50);
120     
121     if (etatActuel == ATTENTE) {
122       Serial.println("\n>>> BOUTON APPUYE - Mode DETECTION");
123       etatActuel = DETECTION;
124       
125       digitalWrite(PIN_LED_JAUNE, LOW);
126       digitalWrite(PIN_LED_VERTE, HIGH);
127       tone(pinDeSortieArduino, 0);
128       
129       msgEnvoye.modeDetection = true;
130       esp_err_t result = esp_now_send(adresseRecepteur, (uint8_t *)&msgEnvoye, sizeof(msgEnvoye));
131       Serial.print("Envoi commande detection : ");
132       Serial.println(result == ESP_OK ? "OK" : "ECHEC");
133       
134     } else if (etatActuel == ALERTE) {
135       Serial.println("\n>>> BOUTON APPUYE - Retour mode ATTENTE");
136       etatActuel = ATTENTE;
137       
138       digitalWrite(PIN_LED_ROUGE, LOW);
139       digitalWrite(PIN_LED_JAUNE, HIGH);
140 
141     }else if (etatActuel == DETECTION){
142       tone(pinDeSortieArduino, 0);
143     }
144   }
145   
146   dernierEtatBouton = etatBouton;
147   delay(10);
148 }

Code Récepteur (Boite avec Capteur) :

  1 #include <esp_now.h>
  2 #include <WiFi.h>
  3 
  4 // REMPLACEZ PAR L'ADRESSE MAC DE L'EMETTEUR
  5 uint8_t adresseEmetteur[] = {0xA4, 0xF0, 0x0F, 0x5E, 0x64, 0xA4};
  6 
  7 const int PIN_TRIG = 5;
  8 const int PIN_ECHO = 18;
  9 
 10 #define SOUND_SPEED 0.034
 11 #define SEUIL_DETECTION 0.90
 12 
 13 typedef struct {
 14   bool modeDetection;
 15 } MessageEmetteur;
 16 
 17 typedef struct {
 18   bool mouvementDetecte;
 19 } MessageRecepteur;
 20 
 21 MessageEmetteur msgRecu;
 22 MessageRecepteur msgEnvoye;
 23 
 24 float distanceFixe = 0.0;
 25 bool enModeDetection = false;
 26 
 27 float mesurerDistance() {
 28   digitalWrite(PIN_TRIG, LOW);
 29   delayMicroseconds(2);
 30   digitalWrite(PIN_TRIG, HIGH);
 31   delayMicroseconds(10);
 32   digitalWrite(PIN_TRIG, LOW);
 33   
 34   long duration = pulseIn(PIN_ECHO, HIGH, 30000);
 35   if (duration == 0) return -1;
 36   
 37   return duration * SOUND_SPEED / 2;
 38 }
 39 
 40 void onReceive(const esp_now_recv_info *info, const uint8_t *data, int len) {
 41   memcpy(&msgRecu, data, sizeof(msgRecu));
 42   
 43   Serial.println("\n>>> MESSAGE RECU DE L'EMETTEUR <<<");
 44   
 45   if (msgRecu.modeDetection) {
 46     Serial.println("Commande : Passage en mode DETECTION");
 47     Serial.println("Mesure de la distance de reference...");
 48     
 49     float somme = 0;
 50     int mesuresValides = 0;
 51     
 52     for (int i = 0; i < 5; i++) {
 53       float dist = mesurerDistance();
 54       Serial.print("  Mesure ");
 55       Serial.print(i + 1);
 56       Serial.print(" : ");
 57       Serial.print(dist);
 58       Serial.println(" cm");
 59       
 60       if (dist > 0 && dist < 400) {
 61         somme += dist;
 62         mesuresValides++;
 63       }
 64       delay(100);
 65     }
 66     
 67     if (mesuresValides >= 3) {
 68       distanceFixe = somme / mesuresValides;
 69       enModeDetection = true;
 70       
 71       Serial.print("\n>>> Distance reference : ");
 72       Serial.print(distanceFixe);
 73       Serial.println(" cm");
 74       Serial.print(">>> Seuil alerte : ");
 75       Serial.print(distanceFixe * SEUIL_DETECTION);
 76       Serial.println(" cm");
 77       Serial.println(">>> SURVEILLANCE ACTIVE\n");
 78     } else {
 79       Serial.println("\n!!! ERREUR : Pas assez de mesures valides");
 80       Serial.println(">>> Retour en attente - Reappuyez sur le bouton\n");
 81       enModeDetection = false;
 82       distanceFixe = 0.0;
 83     }
 84   }
 85 }
 86 
 87 void setup() {
 88   Serial.begin(115200);
 89   delay(1000);
 90   
 91   pinMode(PIN_TRIG, OUTPUT);
 92   pinMode(PIN_ECHO, INPUT);
 93     
 94   WiFi.mode(WIFI_STA);
 95   Serial.println("\n=== RECEPTEUR DEMARRE ===");
 96   
 97   uint8_t mac[6];
 98   WiFi.macAddress(mac);
 99   Serial.print("MAC : {0x");
100   for(int i = 0; i < 6; i++) {
101     if(mac[i] < 16) Serial.print("0");
102     Serial.print(mac[i], HEX);
103     if(i < 5) Serial.print(", 0x");
104   }
105   Serial.println("}");
106   
107   if (esp_now_init() != ESP_OK) {
108     Serial.println("ERREUR init ESP-NOW");
109     return;
110   }
111   
112   esp_now_register_recv_cb(onReceive);
113   
114   esp_now_peer_info_t peerInfo = {};
115   memcpy(peerInfo.peer_addr, adresseEmetteur, 6);
116   peerInfo.channel = 0;
117   peerInfo.encrypt = false;
118   
119   if (esp_now_add_peer(&peerInfo) == ESP_OK) {
120     Serial.println("Peer ajoute avec succes");
121   } else {
122     Serial.println("ERREUR ajout peer");
123   }
124   
125   Serial.println("En attente du signal...\n");
126 }
127 
128 void loop() {
129   if (enModeDetection) {
130     float distanceActuelle = mesurerDistance();
131     
132     if (distanceActuelle > 0 && distanceActuelle < 400) {
133       Serial.print("Distance : ");
134       Serial.print(distanceActuelle);
135       Serial.print(" cm | Ref : ");
136       Serial.print(distanceFixe);
137       Serial.print(" cm | Seuil : ");
138       Serial.print(distanceFixe * SEUIL_DETECTION);
139       Serial.println(" cm");
140       
141       if (distanceActuelle < distanceFixe * SEUIL_DETECTION) {
142         Serial.println("\n!!! MOUVEMENT DETECTE !!!");
143         Serial.println("Envoi alerte a l'emetteur...");
144         
145         msgEnvoye.mouvementDetecte = true;
146         esp_err_t result = esp_now_send(adresseEmetteur, (uint8_t *)&msgEnvoye, sizeof(msgEnvoye));
147         
148         Serial.print("Resultat envoi : ");
149         Serial.println(result == ESP_OK ? "OK" : "ECHEC");
150         
151         enModeDetection = false;
152         distanceFixe = 0.0;
153         
154         Serial.println(">>> Retour en attente\n");
155         delay(2000);
156       }
157     }
158   }
159   
160   delay(200);
161 }

étapes de fabrication

étape 1

Réflexion et conceptualisation du projet. Après une phase de réflexion, nous avons finalisé le schéma du boîtier. Celui-ci intègre le détecteur d'une part, et les interfaces de sortie (LEDs et haut-parleur) d'autre part. Ce dispositif nous permettra d'être alertés à distance de l'intrusion de James Bond dans la pièce.

étape 2

Phase de test du matériel et des interactions. Pour commencer, nous avons récupéré des codes de base sur Internet afin de valider le fonctionnement individuel de chaque composant. Nous les avons ensuite adaptés pour qu'ils correspondent à nos besoins spécifiques. Cette approche nous fournit une base solide pour chaque module, ce qui facilitera grandement l'écriture du programme final.

étape 3

Documentation continue sur le Wiki. Nous rédigeons le wiki au fur et à mesure de l'avancement du projet. Nous prenons soin de photographier chaque étape afin d'illustrer nos propos et d'en faciliter la compréhension. Cette rédaction en temps réel nous assure de ne rien omettre, notamment concernant les difficultés rencontrées.

étape 4

Câblage et construction de la box. Nous avons procédé à la découpe et au dimensionnement du boîtier pour disposer d'un support de test. Actuellement, seule la partie dédiée au détecteur est assemblée. Nous fixerons les éléments restants (LEDs et haut-parleur) uniquement lorsque le programme sera totalement validé.

étape 5

Intégration et programmation finale. Nous programmons l'ensemble des composants pour assurer la communication à distance entre le détecteur et le boîtier de réception. En parallèle, nous ajustons l'agencement des éléments à l'intérieur du boîtier afin de respecter les contraintes dimensionnelles définies précédemment.

Troubleshouting

Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

Nous avons rencontré deux problèmes majeurs qui nous ont demandé beaucoup de temps.

Le premier concernait le haut-parleur. Impossible de le faire fonctionner, malgré le remplacement du matériel et la modification du code. Nous avons finalement identifié l'origine du problème : une soudure défectueuse. Une fois celle-ci refaite, le système a fonctionné immédiatement.

Le second obstacle concernait la connexion Wi-Fi entre les deux cartes, qui s'est révélée plus complexe que prévu. Nous avons eu des difficultés à appréhender le code nécessaire et, lors de nos essais, nous avons malheureusement endommagé quelques composants. De plus, il a fallu réaliser un programme spécifique pour récupérer l'adresse de chaque carte, étape indispensable pour établir la connexion.

Sources et documentation complémentaire

• Rédаctiоn et illustratiоn :
  

Les photos ont été réalisé pas notre secrétaire Thibault donc elles sont libre de droit.

• Transpаrence et dосumеntatiоn :
  

Nous avons consulté plusieurs ressources en ligne pour maîtriser les schémas de câblage. Cette démarche nous a permis d'obtenir des exemples de code pour valider le fonctionnement de chaque composant et d'en comprendre la logique de programmation.

Pour le sonar : https://randomnerdtutorials.com/esp32-hc-sr04-ultrasonic-arduino/

Pour le moteur : https://www.upesy.fr/blogs/tutorials/esp32-servo-motor-with-arduino-code-sg90?srsltid=AfmBOopU3CgdZ1zXnTinbgdxA_x03GatGw9WdU6eaWhY8GE8jk9kVVXG#

• Traçabilité :
  

Nous avons entièrement écrit le programme de la box finale ainsi que ceux destinés aux tests du haut-parleur et des LEDs. Toutefois, concernant le capteur à ultrasons (sonar) et le moteur, nous nous sommes appuyés sur les codes sources disponibles sur les sites mentionnés précédemment.

Elément de présentation

Fichier:JamesBox Prés.pdf