Art Sciences 2025/2026 E5

Projet: Habiter en oiseau

l'ékip de choc (Anthony, Maya, Jules et Nithesh)

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é:

PIR Sensor

Carte ESP32

Breadboard

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.

installation pour tester le sensor PIR avec Nithesh le meilleur binome polytech

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.

ouverture en dessous du pigeon avec Anthony

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.

ESP 32 cam

La cam marche!!! youpi

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.