Regarder sur YouTube

Tutoriel ESP32 42/55 - Prendre une photo avec la caméra enregistrée sur Micro SD CAM-1 | Kit ESP32 de SunFounder

Dans ce tutoriel, nous utiliserons le microcontrôleur ESP32 ainsi que sa carte d'extension de SunFounder pour capturer des photos à l'aide d'une caméra et les enregistrer directement sur une carte micro SD. Ce projet utilise les fonctionnalités intégrées de l'ESP32, y compris le Wi-Fi et le Bluetooth, pour créer un appareil photo compact. À la fin de ce tutoriel, vous disposerez d'une configuration fonctionnelle capable de prendre et de stocker des images, qui pourront ensuite être consultées sur un ordinateur.

Pour ceux qui découvrent l'écosystème ESP32, ce kit offre une plateforme polyvalente pour divers projets, y compris celui-ci. La caméra utilisée dans ce projet est la OV2640, qui offre une résolution de 1600x1200 pixels. Bien qu'elle ne corresponde pas à la qualité des smartphones modernes, elle est suffisante pour des tâches de capture d'images de base. Pour clarifier certaines étapes, n'hésitez pas à consulter la vidéo accompagnant ce tutoriel (dans la vidéo à 00:00).

Matériel expliqué

Les composants principaux de ce projet incluent le microcontrôleur ESP32, le module caméra (OV2640) et une carte micro SD pour le stockage. L'ESP32 est un microcontrôleur puissant avec des capacités Wi-Fi et Bluetooth intégrées, ce qui le rend idéal pour les applications IoT. Le module caméra capture des images, qui sont ensuite traitées par l'ESP32.

La carte micro SD agit comme un support de stockage pour les images capturées. Dans cette configuration, l'ESP32 communique avec le module caméra en utilisant des broches GPIO spécifiques, et les images sont enregistrées au format JPEG sur la carte SD. Cela permet de récupérer et d'afficher facilement les photos plus tard.

• Assurez-vous que la caméra est correctement orientée lors de son insertion dans la carte ESP32.
• Utilisez une carte micro SD d'une capacité de 32 Go ou moins pour éviter les problèmes de compatibilité.
• Connectez GPIO 0 à GND pour le mode de programmation.
• Faites attention à l'alimentation électrique pour éviter les problèmes de baisse de tension.
• Maintenez l'appareil photo stable lors de la prise de photos pour éviter des images floues.

Instructions de câblage

Pour câbler le module caméra ESP32, commencez par vous assurer que l'ESP32 est éteint. Connectez le module de carte micro SD à l'ESP32 en utilisant les broches suivantes : connectez leCSbroche de la carte SD à l'ESP32GPIO 5,MOSIàGPIO 23,MISOàGPIO 19, etSCKàGPIO 18. Ensuite, connectez les broches du module caméra comme suit :PWDNàGPIO 32,XCLKàGPIO 0,SIODàGPIO 26, etSIOCàGPIO 27. Les broches de données de pixelsY2àY9devrait être connecté àGPIO 5à traversGPIO 39tel que défini dans votre code.

Assurez-vous de connecter correctement les broches de terre et d'alimentation. L'ESP32 peut être alimenté par la batterie incluse dans le kit. Après le câblage, vérifiez que les connexions sont sécurisées avant d'allumer l'appareil. Si vous suivez les instructions attentivement, vous devriez voir la caméra s'initialiser correctement lorsque vous téléversez le code.

Exemples de code et guide étape par étape

Dans le code, nous commençons par inclure les bibliothèques nécessaires et définir les configurations des broches de la caméra. La variablepictureNumberest initialisé pour suivre le nombre de photos prises.

int pictureNumber = 0;

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);  // Disable brownout detector
  Serial.begin(115200);
  camera_config_t config;
  // Configuration settings for the camera
  config.ledc_channel = LEDC_CHANNEL_0;
  // Additional camera settings...
}

La fonction de configuration initialise la communication série et configure les paramètres de la caméra. La configuration comprend des paramètres tels queledc_channel,pin_d0, etxclk_freq_hzpour des performances optimales.

Ensuite, nous gérons le processus de capture d'images en utilisant une boucle pour prendre plusieurs photos. Les données d'image sont enregistrées sur la carte SD avec un nom de fichier basé sur lepictureNumber.

for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = esp_camera_fb_get(); // Take Picture
    String path = "/picture" + String(pictureNumber) + ".jpg"; // File path
    File file = fs.open(path.c_str(), FILE_WRITE); // Open file to write
    // Write image data to file
    file.write(fb->buf, fb->len);
    // Update picture number in EEPROM
    EEPROM.write(0, pictureNumber);
}

Cette boucle capture jusqu'à cinq images, chaque image étant enregistrée avec un nom de fichier unique. L'utilisation de l'Eeprom permet au programme de se souvenir du dernier numéro de photo, garantissant que chaque nouvelle image a un identifiant unique.

Démonstration / À quoi s'attendre

Lorsque vous exécutez le code, l'ESP32 initialisera la caméra et la carte SD. Après avoir appuyé sur le bouton de réinitialisation de l'ESP32, il prendra une série de photos, qui seront numérotées séquentiellement de 0 à 255 en fonction de la valeur EEPROM. Après avoir capturé les images, vous pouvez retirer la carte micro SD et visualiser les photos sur votre ordinateur.

Les pièges courants incluent de s'assurer que la carte micro SD est correctement formatée et insérée, ainsi que de maintenir une position de caméra stable pour éviter les images floues. Si vous rencontrez des problèmes avec la caméra qui ne capture pas d'images, vérifiez à nouveau le câblage et les configurations définies dans le code (dans la vidéo à 06:45).

Horodatages de vidéo

• 00:00 Début
• 1:39 Introduction
• 5:19 Code de la caméra ESP32 expliqué
• 11:10 Sélection du panneau ESP32 et du port COM dans l'IDE Arduino
• 12:52 Prise de photos à l'intérieur et à l'extérieur test

Images

esp32-41-setting-3

extension_bopard_camera

20240103_163227858_iOS

esp32-41-setting-1

esp32-41-setting-2

esp32-41-setting-3

extension_bopard_camera

20240103_163227858_iOS

esp32-41-setting-1

esp32-41-setting-2

/*
 * Rui Santos
 * Détails complets du projet sur https://RandomNerdTutorials.com/esp32-cam-take-photo-save-microsd-card
 * 
 * IMPORTANT !!!
 * - Sélectionnez la carte "AI Thinker ESP32-CAM"
 * - GPIO 0 doit être connecté à GND pour télécharger un sketch
 * - Après avoir connecté GPIO 0 à GND, appuyez sur le bouton RESET intégré de l'ESP32-CAM pour mettre votre carte en mode de flash
 * 
 * La permission est par la présente accordée, gratuitement, à toute personne obtenant une copie
 * de ce logiciel et des fichiers de documentation associés.
 * L'avis de droit d'auteur ci-dessus et cet avis de permission doivent être inclus dans toutes
 * les copies ou portions substantielles du Logiciel.
 */
#include "esp_camera.h"
#include "Arduino.h"
#include "FS.h" // Carte SD ESP32
#include "SD_MMC.h" // Carte SD ESP32
#include "soc/soc.h" // Désactiver les problèmes de brownour
#include "soc/rtc_cntl_reg.h" // Désactiver les problèmes de brownour
#include "driver/rtc_io.h"
#include <EEPROM.h> // lire et écrire dans la mémoire flash

 // définir le nombre de bytes que vous souhaitez accéder
#define EEPROM_SIZE 1

 // Définition des broches pour le modèle de caméra AI_THINKER
#define PWDN_GPIO_NUM 32
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 0
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27

#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 21
#define Y4_GPIO_NUM 19
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 5
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22

int pictureNumber = 0;

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // désactiver le détecteur de baisse de tension

  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_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;

  if (psramFound()) {
    config.frame_size = FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }

 // Initier la caméra
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }

 // Serial.println("Démarrage de la carte SD");
  if (!SD_MMC.begin()) {
    Serial.println("SD Card Mount Failed");
    return;
  }

  uint8_t cardType = SD_MMC.cardType();
  if (cardType == CARD_NONE) {
    Serial.println("No SD Card attached");
    return;
  }

 // initialiser l'EEPROM avec une taille prédéfinie
  EEPROM.begin(EEPROM_SIZE);
  pictureNumber = EEPROM.read(0) + 1;

  for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = NULL;

 // Prendre une photo avec l'appareil photo
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }

 // Chemin où la nouvelle image sera enregistrée sur la carte SD
    String path = "/picture" + String(pictureNumber) + ".jpg";

    fs::FS &fs = SD_MMC;
 // Serial.printf("Nom du fichier image : %s\n", path.c_str());

    File file = fs.open(path.c_str(), FILE_WRITE);
    if (!file) {
      Serial.println("Failed to open file in writing mode");
    } else {
      file.write(fb->buf, fb->len); // Écrire les données d'image dans un fichier
      if (shoot == 4) {
        Serial.printf("Saved file to path: %s\n", path.c_str());
      }else{
        Serial.printf("Shooting... \n");
      }
      EEPROM.write(0, pictureNumber); // Mettre à jour le numéro de l'image dans l'Eeprom
      EEPROM.commit();
    }
    file.close(); // Fermez le fichier
    esp_camera_fb_return(fb); // Renvoyez la mémoire tampon d'image au pilote de la caméra.
    delay(200); // Délai court entre les tirs
  }
 // Éteint la LED blanche intégrée de l'ESP32-CAM (flash) connectée au GPIO 4
  pinMode(4, OUTPUT);
  digitalWrite(4, LOW);
  rtc_gpio_hold_en(GPIO_NUM_4);

 // Mettez l'ESP32-CAM en veille profonde.
  delay(2000);
  Serial.println("Going to sleep now");
  delay(2000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop() {
 // Boucle vide car nous mettons l'ESP32-CAM en veille profonde.
}