Esp32-cam : Enregistrement d'images dans le stockage firebase

Rédigé par sazaki 2 commentaires
Classé dans : Non classé Mots clés : firebase

Dans ce guide, vous apprendrez à prendre et à télécharger une photo sur Firebase Storage à l'aide de l'ESP32-CAM. Vous allez créer un projet Firebase avec Storage qui vous permet de stocker vos fichiers. Ensuite, vous pouvez accéder à votre console Firebase pour visualiser les images ou créer une application Web pour les afficher (nous le ferons dans un futur tutoriel). L'ESP32-CAM sera programmé à l'aide de l'IDE Arduino.

Remarque : ce projet est compatible avec n'importe quel Carte caméra ESP32 avec la caméra OV2640 . Vous devez juste vous assurer que vous utilisez le bon brochage pour la carte que vous utilisez.

Qu'est-ce que Firebase ?

Firebase logo

Firebase est une plate-forme de développement d'applications mobiles de Google qui vous aide à créer, améliorer et développer votre application. Il dispose de nombreux services utilisés pour gérer les données de n'importe quelle application Android, IOS ou Web, comme l'authentification, la base de données en temps réel, l'hébergement, le stockage, etc.

Aperçu sur le projet

Ce guide simple montre comment prendre des photos avec l'ESP32-CAM et les envoyer vers Firebase Storage. L'ESP32-CAM prend une photo et l'envoie à Firebase à chaque réinitialisation (appuyez sur le bouton RST). L'idée est d'ajouter une sorte de déclencheur qui pourrait être utile pour vos projets, comme un capteur de mouvement PIR ou un bouton-poussoir, par exemple.

ESP32-CAM Sendo Photo to Firebase Storage Project Overview
  • Lorsque l'ESP32 s'exécute pour la première fois, il prend une nouvelle photo et l'enregistre dans le système de fichiers (SPIFFS) ;
  • L'ESP32-CAM se connecte à Firebase en tant qu'utilisateur avec e-mail et mot de passe ;< /li>
  • L'ESP32-CAM envoie l'image au stockage Firebase ;
  • Après cela, vous pouvez accéder à votre console Firebase pour afficher les images ;
  • Plus tard, vous pouvez créez une application Web à laquelle vous pouvez accéder de n'importe où pour afficher les images ESP32-CAM (nous créerons cela dans un futur tutoriel).

Contenu

Voici un résumé des étapes à suivre pour créer ce projet.

  1. Créer un projet Firebase
  2. Définir les méthodes d'authentification
  3. Créer un compartiment de stockage
  4. Obtenir la clé API du projet
  5. ESP32-CAM Envoyer des images au stockage Firebase

1) Créer un projet Firebase

1) Aller à Firebase et connectez-vous à l'aide d'un compte Google Compte.

2) Cliquez sur Commencer puis Ajouter un projet pour créer un nouveau projet.

3) Donnez un nom à votre projet, par exemple : Demo ESP Firebase.

Set Up Firebase Project for ESP32 and ESP8266 Step 1

4) Désactiver l'option Activer Google Analytics pour ce projet car il n'est pas nécessaire et cliquez sur Créer un projet.

Set Up Firebase Project for ESP32 and ESP8266 Step 2

5) La configuration de votre projet prendra quelques secondes. Ensuite, cliquez sur Continuer quand c'est prêt.

6) Vous serez redirigé vers la page de votre console Project.

2) Définir les méthodes d'authentification

Pour autoriser l'authentification avec e-mail et mot de passe, vous devez d'abord définir des méthodes d'authentification pour votre application.

"La plupart des applications doivent connaître l'identité d'un utilisateur. En d'autres termes, il s'occupe de la connexion et de l'identification des utilisateurs (dans ce cas, l'ESP32-CAM). Connaître l'identité d'un utilisateur permet à une application d'enregistrer en toute sécurité les données de l'utilisateur dans le cloud et de fournir la même expérience personnalisée sur tous les appareils de l'utilisateur. Pour en savoir plus sur les méthodes d'authentification, vous pouvez lire la documentation.

1) Dans la barre latérale gauche, cliquez sur Authentification, puis sur Commencer.

Firebase Project Authentication

2) Select the Option Email/Password.

Selecting Firebase Authentication with Email/Password

3) Activez cette méthode d'authentification et cliquez sur Enregistrer.

Enable Email/password authentication Firebase

4) L'authentification avec e-mail et mot de passe devrait maintenant être activée.

Firebase Authentication with Email/Password enabled

5) Maintenant, vous devez ajouter un utilisateur. Toujours dans l'onglet Authentification, sélectionnez l'onglet Utilisateurs en haut. Cliquez ensuite sur Ajouter un utilisateur.

Firebase Authentication Add New User

6) Ajoutez une adresse e-mail pour l'utilisateur autorisé. Il peut s'agir de l'e-mail de votre compte Google ou de tout autre e-mail. Vous pouvez également créer un e-mail pour ce projet spécifique. Ajoutez un mot de passe qui vous permettra de vous connecter à votre application et d'accéder aux fichiers de stockage. N'oubliez pas de sauvegarder le mot de passe dans un endroit sûr car vous en aurez besoin plus tard. Lorsque vous avez terminé, cliquez sur Ajouter un utilisateur.

Firebase Authentication Add User with Email and Password

7) Un nouvel utilisateur a été créé avec succès et ajouté au tableau Utilisateurs.

Firebase Users Table

Notez que Firebase crée un UID unique pour chaque utilisateur enregistré. L'UID de l'utilisateur nous permet d'identifier l'utilisateur et de garder une trace de l'utilisateur pour fournir ou refuser l'accès au projet ou à la base de données. Il y a aussi une colonne qui enregistre la date de la dernière connexion. Pour le moment, il est vide car nous ne nous sommes pas encore connectés avec cet utilisateur.

3) Créer un compartiment de stockage

1) Dans la barre latérale de gauche, cliquez sur Stockage , puis sur Commencer.

Firebase Get Started with Storage

2) Utilisez les règles de sécurité par défaut : cliquez sur Suivant.

Firebase Creating Storage Bucket Set Rules

3) Sélectionnez votre emplacement de stockage : il doit être le plus proche de votre pays.

Firebase Creating Storage Bucket Set Location

4) Attendez quelques secondes pendant qu'il crée le bucket de stockage.

Firebase Creating Storage Bucket

5) Le compartiment de stockage est maintenant configuré. Copiez l'ID du bucket de stockage, car vous en aurez besoin plus tard (copiez uniquement la section mise en évidence par un rectangle rouge, comme indiqué ci-dessous).

Firebase Storage Bucket ID

4) Obtenir la clé API du projet

Pour vous connecter à votre projet Firebase à l'aide de l'ESP32-CAM, vous devez obtenir la clé API de votre projet. Suivez les étapes suivantes pour obtenir la clé API de votre projet.

1) Dans la barre latérale de gauche, cliquez sur Paramètres du projet.

Firebase Project Settings

2) Copiez la clé API Web dans un endroit sûr, car vous en aurez besoin plus tard.

Firebase Project Settings Web API Key

5) ESP32-CAM - Envoyer des images au stockage Firebase

Avant de poursuivre le didacticiel, assurez-vous de vérifier les prérequis suivants.

Installer le module complémentaire ESP32

Nous allons programmer la carte ESP32-CAM à l'aide de l'IDE Arduino. Vous avez donc besoin de l'IDE Arduino installé ainsi que du module complémentaire ESP32. Suivez le tutoriel suivant pour l'installer, si vous ne l'avez pas déjà fait.

  • Installation de la carte ESP32 dans l'IDE Arduino (Mac instructions OS X et Linux

Installation de la bibliothèque client ESP Firebase

La bibliothèque Firebase-ESP-Client fournit plusieurs exemples pour s'interfacer avec les services Firebase. Il fournit un exemple qui montre comment envoyer des fichiers à Firebase Storage. Notre code sera basé sur cet exemple. Donc, vous devez vous assurer que cette bibliothèque est installée.

Installation – Code VS + PlatformIO

Si vous utilisez VS Code avec l'extension PlatformIO, cliquez sur l'icône PIO Home et sélectionnez l'onglet Bibliothèques. Recherchez "Firebase ESP Client". Sélectionnez la bibliothèque client Firebase Arduino pour ESP8266 et ESP32.

Install Firebase ESP Client Library VS Code

Ensuite, cliquez sur Ajouter au projet et sélectionnez le projet sur lequel vous travaillez.

Add Firebase ESP Client Library to Project VS Code

Modifiez également la vitesse du moniteur à 115200 en ajoutant la ligne suivante au fichier platformio.ini de votre projet :

monitor_speed = 115200

Installation – Arduino IDE

Si vous utilisez Arduino IDE, suivez les étapes suivantes pour installer la bibliothèque.

  1. Accédez à Croquis > ; Inclure la bibliothèque > ; Gérer les bibliothèques
  2. Recherchez Firebase ESP Client et installez Firebase Arduino Client Library for ESP8266 and ESP32 by Mobitz.< /li>
Install Firebase Arduino Client Library for ESP8266 and ESP32 by Mobitz

Maintenant, vous êtes prêt à commencer à programmer la carte ESP32-CAM pour envoyer des images à Firebase Storage.

ESP32-CAM Envoyer des images à Firebase – Code

Copiez le code suivant dans votre IDE Arduino ou dans le fichier main.cpp si vous utilisez VS Code. Il prend une photo et l'envoie à Firebase lors du premier démarrage.



#include "WiFi.h"
#include "esp_camera.h"
#include "Arduino.h"
#include "soc/soc.h"         // Désactiver les problèmes de baisse de tension
#include "soc/rtc_cntl_reg.h"  // Désactiver les problèmes de baisse de tension
#include "driver/rtc_io.h"
#include <SPIFFS.h>
#include <FS.h>
#include <Firebase_ESP_Client.h>
//Provide the token generation process info.
#include <addons/TokenHelper.h>

//Remplacer par vos identifiants réseau
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Insérer la clé API du projet Firebase
#define API_KEY "REPLACE_WITH_YOUR_FIREBASE_PROJECT_API_KEY"

// Insérer l'e-mail autorisé et le mot de passe correspondant
#define USER_EMAIL "REPLACE_WITH_THE_AUTHORIZED_USER_EMAIL"
#define USER_PASSWORD "REPLACE_WITH_THE_AUTHORIZED_USER_PASSWORD"

// Insérer l'ID de bucket de stockage Firebase, par exemple bucket-name.appspot.com
#define STORAGE_BUCKET_ID "REPLACE_WITH_YOUR_STORAGE_BUCKET_ID"

// Nom du fichier photo à enregistrer dans SPIFFS
#define FILE_PHOTO "/data/photo.jpg"

// Broches du module de caméra OV2640 (CAMERA_MODEL_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

boolean takeNewPhoto = true;

//Définir les objets de données Firebase
FirebaseData fbdo;
FirebaseAuth auth;
FirebaseConfig configF;

bool taskCompleted = false;

// Vérifie si la capture de photo a réussi
bool checkPhoto( fs::FS &fs ) {
  File f_pic = fs.open( FILE_PHOTO );
  unsigned int pic_sz = f_pic.size();
  return ( pic_sz > 100 );
}

// Capturez une photo et enregistrez-la dans SPIFFS
void capturePhotoSaveSpiffs( void ) {
  camera_fb_t * fb = NULL; // pointer
  bool ok = 0;// Booléen indiquant si la photo a été prise correctement
  do {
// Prendre une photo avec l'appareil photo
    Serial.println("Taking a photo...");

    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("La capture de l'appareil photo a échoué");
      return;
    }
    // Nom du fichier image
    Serial.printf("Nom du fichier image: %sn", FILE_PHOTO);
    File file = SPIFFS.open(FILE_PHOTO, FILE_WRITE);
 // Insertion des données dans le fichier photo
    if (!file) {
      Serial.println("Impossible d'ouvrir le fichier en mode écriture");
    }
    else {
      file.write(fb->buf, fb->len); // payload (image), payload length
      Serial.print("The picture has been saved in ");
      Serial.print(FILE_PHOTO);
      Serial.print(" - Size: ");
      Serial.print(file.size());
      Serial.println(" bytes");
    }
    // Close the file
    file.close();
    esp_camera_fb_return(fb);

// vérifie si le fichier a été correctement enregistré dans SPIFFS
    ok = checkPhoto(SPIFFS);
  } while ( !ok );
}

void initWiFi(){
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
}

void initSPIFFS(){
  if (!SPIFFS.begin(true)) {
    Serial.println("Une erreur s'est produite lors du montage de SPIFFS");
    ESP.restart();
  }
  else {
    delay(500);
    Serial.println("SPIFFS monté avec succès");
  }
}

void initCamera(){
 // OV2640 camera module
  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;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
  // Camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("L'initialisation de la caméra a échoué avec une erreur 0x%x", err);
    ESP.restart();
  } 
}

void setup() {
// Port série à des fins de débogage
  Serial.begin(115200);
  initWiFi();
  initSPIFFS();
// Éteint le 'détecteur de baisse de tension'
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
  initCamera();

  //Firebase
// Affectez la clé API
  configF.api_key = API_KEY;
 //Attribuez les identifiants de connexion de l'utilisateur
  auth.user.email = USER_EMAIL;
  auth.user.password = USER_PASSWORD;
// Attribuez la fonction de rappel pour la tâche de génération de jeton de longue durée
  configF.token_status_callback = tokenStatusCallback; //see addons/TokenHelper.h

  Firebase.begin(&configF, &auth);
  Firebase.reconnectWiFi(true);
}

void loop() {
  if (takeNewPhoto) {
    capturePhotoSaveSpiffs();
    takeNewPhoto = false;
  }
  delay(1);
  if (Firebase.ready() && !taskCompleted){
    taskCompleted = true;
    Serial.print("Uploading picture... ");

// Le type MIME doit être valide pour éviter le problème de téléchargement.
     //Les systèmes de fichiers pour flash et SD/SDMMC peuvent être modifiés dans FirebaseFS.h.
    if (Firebase.Storage.upload(&fbdo, STORAGE_BUCKET_ID /* Firebase Storage bucket id */, FILE_PHOTO /* path to local file */, mem_storage_type_flash /* memory storage type, mem_storage_type_flash and mem_storage_type_sd */, FILE_PHOTO /* path of remote file stored in the bucket */, "image/jpeg" /* mime type */)){
      Serial.printf("nDownload URL: %sn", fbdo.downloadURL().c_str());
    }
    else{
      Serial.println(fbdo.errorReason());
    }
  }
}

Vous devez insérer vos informations d'identification réseau, l'ID de compartiment de stockage et la clé API du projet pour que le projet fonctionne.

Cette esquisse était basée sur un exemple de base fourni par la bibliothèque. Vous trouverez d'autres exemples ici.

Fonctionnement du code

Continuez à lire pour savoir comment fonctionne le code .

Libraries

Tout d'abord, incluez les bibliothèques requises.

#include "WiFi.h"
#include "esp_camera.h"
#include "Arduino.h"
#include "soc/soc.h"           // Disable brownout problems
#include "soc/rtc_cntl_reg.h"  // Disable brownout problems
#include "driver/rtc_io.h"
#include <SPIFFS.h>
#include <FS.h>
#include <Firebase_ESP_Client.h>
// Fournissez les informations sur le processus de génération de jeton.
#include <addons/TokenHelper.h>

Identifiants réseau

Insérez vos informations d'identification réseau dans les variables suivantes afin que l'ESP puisse se connecter à Internet et communiquer avec Firebase.

//Remplacer par vos identifiants réseau
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Clé API du projet Firebase

Insérez la clé API de votre projet Firebase.

// Insert Firebase project API Key
#define API_KEY "REPLACE_WITH_YOUR_FIREBASE_PROJECT_API_KEY."

E-mail et mot de passe de l'utilisateur

Insérez l'adresse e-mail autorisée et le mot de passe correspondant.

#define USER_EMAIL "REPLACE_WITH_THE_AUTHORIZED_USER_EMAIL"
#define USER_PASSWORD "REPLACE_WITH_THE_AUTHORIZED_USER_PASSWORD"

ID du compartiment de stockage Firebase

Insérez l'ID du bucket de stockage Firebase, par exemple bucket-name.appspot.com. Dans mon cas, il s'agit de esp-firebase-demo.appspot.com.

define STORAGE_BUCKET_ID "REPLACE_WITH_YOUR_STORAGE_BUCKET_ID"

Chemin de l'image

La variable FILE_PHOTO définit le chemin SPIFFS où l'image sera enregistrée. Il sera enregistré avec le nom photo.jpg sous le dossier data.

#define FILE_PHOTO "/data/photo.jpg"

Définition des broches ESP32-CAM

Les lignes suivantes définissent les broches ESP32-CAM. C'est la définition du module ESP32-CAM AI-Thinker. Si vous utilisez un autre module ESP32-CAM, vous devez modifier la définition de la broche. 

// Broches du module de caméra OV2640 (CAMERA_MODEL_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

Autres variables

La variable takeNewPhoto vérifie s'il est temps de prendre une nouvelle photo. Nous allons le définir sur true, afin qu'il prenne une photo lors de la première exécution du tableau.

boolean takeNewPhoto = true;

Ensuite, nous définissons les objets de données de configuration Firebase.

//Définir les objets de données Firebase
FirebaseData fbdo;
FirebaseAuth auth;
FirebaseConfig configF;

La taskCompleted est une variable booléenne qui vérifie si nous nous sommes connectés avec succès à Firebase.

bool taskCompleted = false;

checkPhoto() Function

La fonction checkPhoto() vérifie si la photo a bien été prise et enregistrée dans SPIFFS.

// Vérifie si la capture de photo a réussi
bool checkPhoto( fs::FS &fs ) {
  File f_pic = fs.open( FILE_PHOTO );
  unsigned int pic_sz = f_pic.size();
  return ( pic_sz > 100 );
}

capturePhotoSaveSpiffs() Function

La fonction capturePhotoSaveSpiffs() prend une photo et l'enregistre dans le système de fichiers ESP32.

// Capturez une photo et enregistrez-la dans SPIFFS
void capturePhotoSaveSpiffs( void ) {
  camera_fb_t * fb = NULL; // pointer  
  bool ok = 0; // Booléen indiquant si la photo a été prise correctement
  do {
   // Prendre une photo avec l'appareil photo
    Serial.println("Taking a photo...");

    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("La capture de l'appareil photo a échoué");
      return;
    }
    // Nom du fichier image :
    Serial.printf("Nom du fichier image : %sn", FILE_PHOTO);
    File file = SPIFFS.open(FILE_PHOTO, FILE_WRITE);
  // Insertion des données dans le fichier photo
    if (!file) {
      Serial.println("Impossible d'ouvrir le fichier en mode écriture");
    }
    else {
      file.write(fb->buf, fb->len); // payload (image), payload length
      Serial.print("La photo a été enregistrée dans ");
      Serial.print(FILE_PHOTO);
      Serial.print(" - Size: ");
      Serial.print(file.size());
      Serial.println(" bytes");
    }
    // Close the file
    file.close();
    esp_camera_fb_return(fb);

// vérifie si le fichier a été correctement enregistré dans SPIFFS
    ok = checkPhoto(SPIFFS);
  } while ( !ok );
}

initWiFi() Function

The initWiFi()la fonction initialise le Wi-Fi.

void initWiFi(){
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
}

initSPIFFS() Function

The initSPIFFS() La fonction initialise le système de fichiers SPIFFS.

void initSPIFFS(){
  if (!SPIFFS.begin(true)) {
    Serial.println("Une erreur s'est produite lors du montage de SPIFFS");
    ESP.restart();
  }
  else {
    delay(500);
    Serial.println("SPIFFS monté avec succès");
  }
}

initCamera() Function

The initCamera() la fonction initialise l'ESP32-CAM.

void initCamera(){
 // OV2640 camera module
  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;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
  // Camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("L'initialisation de la caméra a échoué avec une erreur 0x%x", err);
    ESP.restart();
  } 
}

setup()

In the setup(), initialisez le moniteur série, le Wi-Fi, SPIFFS et la caméra.

// Port série à des fins de débogage
Serial.begin(115200);
initWiFi();
initSPIFFS();
// Éteint le 'détecteur de baisse de tension'
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
initCamera();

Ensuite, attribuez les paramètres suivants aux objets de configuration Firebase.

// Affecte la clé API
configF.api_key = API_KEY;
//Attribuez les identifiants de connexion de l'utilisateur
auth.user.email = USER_EMAIL;
auth.user.password = USER_PASSWORD;
// Attribuez la fonction de rappel pour la tâche de génération de jeton de longue durée
configF.token_status_callback = tokenStatusCallback; //see addons/TokenHelper.h

Enfin, initialisez Firebase.

Firebase.begin(&configF, &auth);
Firebase.reconnectWiFi(true);

loop()

Dans la boucle(), prenez une nouvelle photo et enregistrez-la dans le système de fichiers.

if (takeNewPhoto) {
  capturePhotoSaveSpiffs();
  takeNewPhoto = false;
}

Enfin, envoyez l'image à Firebase.

if (Firebase.ready() && !taskCompleted){
  taskCompleted = true;
Serial.print("Téléchargement de l'image... ");

   // Le type MIME doit être valide pour éviter le problème de téléchargement.
   //Les systèmes de fichiers pour flash et SD/SDMMC peuvent être modifiés dans FirebaseFS.h.
   if (Firebase.Storage.upload(&fbdo, STORAGE_BUCKET_ID /* Firebase Storage bucket id */, FILE_PHOTO /* path to local file */, mem_storage_type_flash /* memory storage type, mem_storage_type_flash and mem_storage_type_sd */, FILE_PHOTO /* path of remote file stored in the bucket */, "image/jpeg" /* mime type */)){
    Serial.printf("nDownload URL: %sn", fbdo.downloadURL().c_str());
  }
  else{
    Serial.println(fbdo.errorReason());
  }
}

La commande qui envoie réellement l'image est Firebase.Storage.upload():

Firebase.Storage.upload(&fbdo, STORAGE_BUCKET_ID, FILE_PHOTO, mem_storage_type_flash, FILE_PHOTO, "image/jpeg")

Cette fonction renvoie une variable booléenne indiquant le succès de l'opération.

Il accepte comme deuxième argument, l'ID de compartiment de stockage. Ensuite, le chemin où le fichier est enregistré ; le type de stockage (il peut s'agir de SPIFFS ou de carte SD*) ; le chemin où le fichier sera enregistré dans le stockage Firebase ; et enfin, le type mime.

*nous n'avons pas pu faire fonctionner cet exemple avec la carte ESP32-CAM + microSD. Si quelqu'un connaît une solution, merci de la partager.

Démonstration

Après avoir inséré les informations d'identification requises, téléchargez le code sur votre ESP32-CAM.

Après avoir téléchargé le code, ouvrez le moniteur série à un débit en bauds de 115200. Appuyez sur le bouton RST embarqué ESP32-CAM.

Il tentera de prendre une photo et l'enverra à Firebase Storage.

ESP32-CAM Picture Uploaded to Firebase Storage Demonstration Serial Monitor

Maintenant, accédez à votre console Firebase et sélectionnez l'onglet Stockage. Il devrait y avoir un dossier appelé data qui contient votre image.

Folder Created in Firebase Storage

Vous pouvez vérifier certaines métadonnées sur l'image et l'afficher en taille réelle. Vous pouvez également accéder à l'image en accédant à l'URL de téléchargement imprimée sur le moniteur série.

Picture Uploaded to Firebase Storage Metada

Résumé

Dans ce guide, vous avez appris à créer un projet Firebase avec Storage. Firebase Storage vous permet de stocker des fichiers sur le cloud. Ensuite, vous pouvez accéder à ces fichiers en accédant à la console Firebase, ou vous pouvez créer une application Web pour afficher ces fichiers (nous le ferons dans un futur tutoriel).

Nous avons montré un exemple simple sur l'envoi d'une photo prise avec l'ESP32-CAM vers le stockage Firebase. L'exemple est aussi simple que possible afin que vous puissiez comprendre les bases. L'idée est de modifier le projet pour rendre quelque chose d'utile, comme prendre une photo et la télécharger sur le stockage Firebase lorsqu'un mouvement est détecté, lorsqu'une porte s'ouvre ou lorsque vous appuyez sur un bouton.

Rendez-vous sur notre site pour des blogs aussi intéressants les uns que les autres!

2 commentaires

#1  - rami a dit :

Merci pour ce blog

Répondre
#2  - tester a dit :

test

Répondre

Écrire un commentaire

Quelle est le troisième caractère du mot h89v0qxc ?