Art Sciences 2025/2026 E5
Projet: Habiter en oiseau
Présentation du projet :
Le projet s’inspire d’une fausse théorie du complot ; Birds aren’t real. C’est l’idée que les oiseaux auraient été remplacés par des drônes par le gouvernement états-unien afin d’espionner ses citoyens.
Habiter en oiseau est une installation, un faux pigeon muni d'une caméra et d'un capteur de mouvement qui filme et enregistre chaque personne qui entre dans la pièce.
Ce projet me servira à récolter des images pour, par la suite, en faire un film. Avant de rentrer dans la salle de l’oiseau, il y aura alors une personne avec un masque de pigeon, faisant signer un document absurde de droit à l’image
Jour 1 : Mardi 27 janvier
les composants que nous avons utilisé:
tache réaliser:
Lors de cette séance, nous avons mis en place une installation de test afin de comprendre le fonctionnement du capteur PIR (Passive Infrared Sensor). Ce capteur est utilisé pour détecter la présence ou le mouvement d’un corps dans un espace, en se basant sur les variations de rayonnement infrarouge.
Le capteur PIR fonctionne de manière passive : il n’émet aucun signal, mais capte les variations de chaleur émises par les corps vivants. Lorsqu’une personne se déplace dans son champ de vision, la différence de température entre le corps et l’environnement est détectée par le capteur. Cette variation provoque l’envoi d’un signal électrique, interprété ici comme une détection de mouvement.
Nous avons donc connecté le capteur PIR à une carte ESP32 . Pour visualiser simplement son fonctionnement, nous avons ajouté une LED reliée à une sortie de la carte. L’objectif était d’avoir un retour immédiat et compréhensible :
- lorsqu’un mouvement est détecté par le capteur, la LED s’allume,
- lorsqu’il n’y a plus de mouvement, la LED s’éteint.
Cette étape nous a permis de vérifier que le capteur fonctionnait correctement et de comprendre comment lire un signal numérique provenant d’un capteur externe sur l’ESP32. Le capteur PIR est ici configuré comme une entrée, tandis que la LED est configurée comme une sortie.
Le programme fonctionne en boucle continue : l’ESP32 lit en permanence l’état du capteur PIR. Si le capteur renvoie un signal HIGH, cela signifie qu’un mouvement a été détecté et la LED s’allume. Dans le cas contraire, la LED reste éteinte. Un court délai est ajouté afin de stabiliser la lecture du signal.
Le code utilisée:
#define PIR_PIN 33
#define LED_PIN 25
void setup() {
pinMode(PIR_PIN, INPUT);
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
}
void loop() {
if (digitalRead(PIR_PIN) == HIGH) {
digitalWrite(LED_PIN, HIGH);
} else {
digitalWrite(LED_PIN, LOW);
}
delay(50);
}
Ce test est une étape essentielle du projet, car le capteur PIR permettra par la suite de déclencher la caméra dissimulée dans le pigeon lorsque quelqu’un entre dans la pièce. Il devient ainsi un élément clé du dispositif de surveillance fictif mis en place dans l’installation.
Jour 2 et 3 : Mercredi 28 et jeudi 29 janvier
Les journées du mercredi et du jeudi ont été consacrées principalement à un travail de recherche et de préparation, en attendant la réception de la caméra ESP32-CAM. Ne disposant pas encore du composant, nous n’avons pas pu effectuer de tests techniques. Nous avons donc mené un travail de recherche bibliographique afin d’anticiper son utilisation et son intégration.
Nous avons recherché et analysé différents codes, tutoriels et documentations portant sur l’ESP32-CAM. Ces recherches nous ont permis de comprendre le fonctionnement général de la caméra, notamment :
- l’initialisation de la caméra et la configuration des broches,
- les formats d’image et les résolutions possibles,
- la connexion au réseau WiFi,
- la diffusion d’un flux vidéo via une interface web intégrée.
L’objectif était de préparer en amont les futurs tests et d’identifier des solutions fiables pour associer la caméra à un capteur PIR, afin de déclencher la prise d’images lors de la détection d’un mouvement.
En parallèle de ce travail théorique, avec Anthony Moreau, nous avons procédé à la découpe du pigeon. À l’aide d’un scalpel, une ouverture a été réalisée afin de permettre l’insertion des composants électroniques (ESP32-CAM, capteur PIR, câblage, batterie).
La caméra ESP32-CAM a été reçue le jeudi soir, ce qui n’a pas permis de réaliser des tests le jour même. Ces deux journées ont donc été essentielles pour préparer le travail pratique du vendredi et assurer une mise en fonctionnement rapide dès la réception du matériel.
Vendredi nous testerons les programmes trouvés, le tutoriel que nous suivons se trouve sur ce site : https://randomnerdtutorials.com/esp32-cam-pir-motion-detector-photo-capture/
Ce tutoriel nous a servi de base de réflexion et d’aide technique. Toutefois, n’ayant pas exactement le même objectif, nous avons prévu d’en modifier le fonctionnement afin de l’adapter à notre projet.
Jour 4 : vendredi 30 janvier
Le vendredi, nous avons réalisé les premiers tests de la caméra ESP32-CAM. Cette journée a marqué une étape importante du projet, puisque nous avons pu vérifier le fonctionnement de la caméra et commencer à l’adapter à notre projet.
Dans un premier temps, nous avons rencontré plusieurs difficultés lors du téléversement du programme sur l’ESP32-CAM. Ces problèmes étaient principalement liés à des paramètres de configuration à ajuster correctement. En effet, pour que le programme fonctionne et permette l’accès au flux vidéo, il a été nécessaire de :
- renseigner le nom du réseau WiFi ainsi que le mot de passe dans le code (lignes 12 et 13),
- configurer le Serial Monitor sur “Both NL & CR” avec une vitesse de 115200 baud,
- appuyer sur le bouton reset de l’ESP32-CAM après le téléversement du programme.
Une fois ces paramètres correctement sélectionnés, la carte a pu se connecter au réseau WiFi. Le Serial Monitor affiche alors une adresse IP locale, qui permet d’accéder à une interface web depuis un navigateur. Cette page web donne accès au flux vidéo en direct ainsi qu’à différents paramètres de la caméra (résolution, qualité de l’image, luminosité, etc.).
le test a finalement été une réussite, la caméra fonctionne correctement et diffuse bien une image en direct.
Le code utilisée:
#include "esp_camera.h"
#include <WiFi.h>
// ===========================
// Select camera model in board_config.h
// ===========================
#include "board_config.h"
// ===========================
// Enter your WiFi credentials
// ===========================
const char *ssid = "testesp";
const char *password = "123456789";
void startCameraServer();
void setupLedFlash();
void setup() {
Serial.begin(115200);
Serial.setDebugOutput(true);
Serial.println();
camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;
config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sccb_sda = SIOD_GPIO_NUM;
config.pin_sccb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.frame_size = FRAMESIZE_UXGA;
config.pixel_format = PIXFORMAT_JPEG; // for streaming
//config.pixel_format = PIXFORMAT_RGB565; // for face detection/recognition
config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
config.fb_location = CAMERA_FB_IN_PSRAM;
config.jpeg_quality = 12;
config.fb_count = 1;
// if PSRAM IC present, init with UXGA resolution and higher JPEG quality
// for larger pre-allocated frame buffer.
if (config.pixel_format == PIXFORMAT_JPEG) {
if (psramFound()) {
config.jpeg_quality = 10;
config.fb_count = 2;
config.grab_mode = CAMERA_GRAB_LATEST;
} else {
// Limit the frame size when PSRAM is not available
config.frame_size = FRAMESIZE_SVGA;
config.fb_location = CAMERA_FB_IN_DRAM;
}
} else {
// Best option for face detection/recognition
config.frame_size = FRAMESIZE_240X240;
#if CONFIG_IDF_TARGET_ESP32S3
config.fb_count = 2;
#endif
}
#if defined(CAMERA_MODEL_ESP_EYE)
pinMode(13, INPUT_PULLUP);
pinMode(14, INPUT_PULLUP);
#endif
// camera init
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
return;
}
sensor_t *s = esp_camera_sensor_get();
// initial sensors are flipped vertically and colors are a bit saturated
if (s->id.PID == OV3660_PID) {
s->set_vflip(s, 1); // flip it back
s->set_brightness(s, 1); // up the brightness just a bit
s->set_saturation(s, -2); // lower the saturation
}
// drop down frame size for higher initial frame rate
if (config.pixel_format == PIXFORMAT_JPEG) {
s->set_framesize(s, FRAMESIZE_QVGA);
}
#if defined(CAMERA_MODEL_M5STACK_WIDE) || defined(CAMERA_MODEL_M5STACK_ESP32CAM)
s->set_vflip(s, 1);
s->set_hmirror(s, 1);
#endif
#if defined(CAMERA_MODEL_ESP32S3_EYE)
s->set_vflip(s, 1);
#endif
// Setup LED FLash if LED pin is defined in camera_pins.h
#if defined(LED_GPIO_NUM)
setupLedFlash();
#endif
WiFi.begin(ssid, password);
WiFi.setSleep(false);
Serial.print("WiFi connecting");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
startCameraServer();
Serial.print("Camera Ready! Use 'http://");
Serial.print(WiFi.localIP());
Serial.println("' to connect");
}
void loop() {
// Do nothing. Everything is done in another task by the web server
delay(10000);
}
Dans un second temps, une fois le fonctionnement de base de la caméra validé, nous avons commencé à modifier et compléter le programme afin de pouvoir l’adapter à notre projet. Nous avons ajouté et préparé certains éléments dans le code pour permettre l'interaction avec un capteur PIR, de manière à déclencher l’enregistrement lorsqu’un mouvement est détecté et de s'arrêter sinon.
Pour la suite du projet, il ne reste plus qu’à tester le nouveau programme après avoir connecté l’ESP32-CAM au capteur PIR. Cette étape permettra de vérifier le bon fonctionnement de l’ensemble du dispositif, en s’assurant que la caméra se déclenche correctement lors de la détection d’un mouvement.
Une fois cette connexion validée, le pigeon pourra fonctionner comme un système de surveillance automatisé, capable de détecter l’entrée d’une personne dans l’espace et d’enregistrer des images.