Firebase : contrôlez les GPIO ESP32 de n’importe où

Firebase : contrôlez les GPIO ESP32 de n'importe où

Dans ce guide, vous apprendrez à contrôler les GPIO ESP32 de n’importe où à l’aide de Firebase. Nous allons créer des nœuds sur la base de données en temps réel Firebase pour enregistrer les états GPIO actuels. Chaque fois qu’il y a un changement dans les nœuds de la base de données, l’ESP32 met à jour ses GPIO en conséquence. Vous pouvez modifier les états des GPIO en écrivant vous-même sur la base de données, ou vous pouvez créer une application Web pour le faire (consultez ce tutoriel).

Contrôlez les GPIO ESP32 de n'importe où à l'aide de Firebase

PARTIE 2 : Contrôler les GPIO ESP32/ESP8266 depuis n’importe où (Firebase Web App)

Nous avons un tutoriel similaire pour la carte ESP8266 : Firebase : Control ESP8266 NodeMCU GPIOs from Anywhere.

Autres tutoriels Firebase avec l’ESP32/ESP8266 qui pourraient vous intéresser :

Qu’est-ce que Firebase ?

Logo Firebase

Firebase est la plate-forme de développement d’applications mobiles de Google qui vous aide à créer, améliorer et développer votre application. Firebase fournit des services gratuits tels que l’hébergement, l’authentification et une base de données en temps réel qui vous permettent de créer une application Web complète pour contrôler et surveiller les cartes ESP32 et ESP8266 qui seraient beaucoup plus difficiles et laborieuses à construire et à configurer par vous-même.

Aperçu du projet

Le diagramme suivant montre une vue d’ensemble de haut niveau du projet que nous allons construire.

Sorties de contrôle ESP32 Firebase depuis n'importe où Présentation du projet
  1. L’ESP32 s’authentifie en tant qu’utilisateur avec e-mail et mot de passe pour pouvoir accéder à la base de données (cet utilisateur doit être ajouté sur les méthodes d’authentification Firebase) ;
  2. La base de données est protégée à l’aide de règles de base de données. Nous ajouterons la règle suivante : seuls les utilisateurs authentifiés peuvent accéder à la base de données ;
  3. La base de données comporte plusieurs nœuds qui enregistrent les états ESP32 GPIO. À titre d’exemple, nous contrôlerons trois GPIO (12, 13 et 14). Vous pouvez ajouter ou supprimer des nœuds pour contrôler plus ou moins de GPIO.
  4. L’ESP32 écoutera les modifications sur les nœuds de la base de données GPIO. Chaque fois qu’il y a un changement, il mettra à jour les états GPIO en conséquence.
  5. Vous pouvez modifier manuellement les états GPIO sur la base de données à l’aide de la console Firebase, ou vous pouvez créer une page Web (accessible de n’importe où) avec des boutons pour contrôler les GPIO et afficher les états GPIO actuels (consultez la PARTIE 2).

Voici les principales étapes pour mener à bien ce projet :

  1. Créer un projet Firebase
  2. Définir les méthodes d’authentification
  3. Obtenir la clé API du projet
  4. Configurer la base de données en temps réel
  5. Configurer les règles de sécurité de la base de données
  6. Organisation de vos nœuds de base de données
  7. ESP32 : écoute des modifications de la base de données (contrôle des GPIO)

Préparation de l’IDE Arduino

Pour ce tutoriel, nous allons programmer la carte ESP32 en utilisant le noyau Arduino. Assurez-vous donc que le module complémentaire ESP32 est installé dans votre IDE Arduino :

Si vous souhaitez programmer les cartes ESP en utilisant VS Code avec l’extension PlatformIO, suivez plutôt le tutoriel suivant :

1) Créer un projet Firebase

1) Aller à Base de feu et connectez-vous à l’aide d’un compte Google.

2) Cliquez sur Démarrer, puis sur Ajouter un projet pour créer un nouveau projet.

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

Créer le nom du projet Firebase

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

Configurer le projet Firebase pour ESP32 et ESP8266 Étape 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 ont besoin de connaître l’identité d’un utilisateur. En d’autres termes, il se charge de se connecter et d’identifier les utilisateurs (dans ce cas, l’ESP32 ou l’ESP8266). 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.

Authentification du projet Firebase

2) Sélectionnez l’option E-mail/Mot de passe.

Sélection de l'authentification Firebase avec e-mail/mot de passe

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

Activer l'authentification par e-mail/mot de passe Firebase

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

Authentification Firebase avec e-mail/mot de passe activé

5) Maintenant, vous devez ajouter un utilisateur. Dans l’onglet Authentification, sélectionnez l’onglet Utilisateurs en haut. Ensuite, cliquez sur Ajouter un utilisateur.

Authentification Firebase Ajouter un nouvel utilisateur

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 à la base de données. 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.

Authentification Firebase Ajouter un utilisateur avec e-mail et mot de passe

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

Tableau des utilisateurs Firebase

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.

Copiez l’UID de l’utilisateur, car vous en aurez besoin plus tard.

3) Obtenir la clé API du projet

Pour s’interfacer avec votre projet Firebase à l’aide des cartes ESP32 ou ESP8266, 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 gauche, cliquez sur Paramètres du projet.

Paramètres du projet Firebase

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

Clé API Web des paramètres du projet Firebase

4) Configurer la base de données en temps réel

Maintenant, créons une base de données en temps réel et configurons des règles de base de données pour notre projet.

1) Dans la barre latérale gauche, cliquez sur Base de données en temps réel, puis cliquez sur Créer une base de données.

Projet Firebase Créer une base de données en temps réel

2) Sélectionnez l’emplacement de votre base de données. Il devrait être le plus proche de votre emplacement.

Configurer la base de données en temps réel firebase ESP32 ESP8266 Sélectionner l'emplacement

3) Configurez des règles de sécurité pour votre base de données. Vous pouvez sélectionner Démarrer en mode test. Nous allons modifier les règles de la base de données dans un instant.

Configurer la base de données en temps réel firebase ESP32 ESP8266 Définir les règles de sécurité

4) Votre base de données est maintenant créée. Vous devez copier et enregistrer l’URL de la base de données, mise en évidence dans l’image suivante, car vous en aurez besoin plus tard dans votre code ESP32.

URL de la base de données du projet Firebase

5) Configurer les règles de sécurité de la base de données

Maintenant, configurons les règles de la base de données. Dans l’onglet Base de données en temps réel, sélectionnez l’onglet Règles en haut. Ensuite, cliquez sur Modifier les règles et ajoutez les règles suivantes.

{
  "rules": {
    ".read": "auth.uid === 'REPLACE_WITH_YOUR_USER_UID'",
    ".write": "auth.uid === 'REPLACE_WITH_YOUR_USER_UID'"
  }
}

Insérez l’UID de l’utilisateur que vous avez créé précédemment. Ensuite, cliquez sur Publier.

Ces règles de base de données déterminent que :

  • Seul l’utilisateur avec cet UID spécifique peut lire et écrire dans la base de données (modifier les états GPIO).

Ajouter plus d’utilisateurs

Pour ajouter plus d’utilisateurs, vous pouvez simplement aller dans l’onglet Authentification et cliquer sur Ajouter un utilisateur. Ajoutez un email et un mot de passe pour le nouvel utilisateur, et enfin cliquez sur Ajouter un utilisateur pour créer l’utilisateur.

Firebase Ajouter une nouvelle console d'adresse e-mail et de mot de passe utilisateur

Copiez l’UID de ce nouvel utilisateur et ajoutez-le aux règles de la base de données, comme suit :

{
  "rules": {
    ".read": "auth.uid === 'REPLACE_WITH_YOUR_USER_UID' || auth.uid === 'REPLACE_WITH_USER_UID2'",
    ".write": "auth.uid === 'REPLACE_WITH_YOUR_USER_UID' || auth.uid === 'REPLACE_WITH_USER_UID2'"
  }
}

Par exemple. Dans mon cas, les UID des utilisateurs sont : RjO3taAzMMXB82Xmir2LQ7XXXXXX et 9QdDc9as5mRXGAjEsQiUJkXXXXXX. Ainsi, les règles de la base de données ressembleront à ceci :

{
  "rules": {
    ".read": "auth.uid === 'RjO3taAzMMXB82Xmir2LQ7XXXXXX' || auth.uid === '9QdDc9as5mRXGAjEsQiUJkXXXXXX'",
    ".write": "auth.uid === 'RjO3taAzMMXB82Xmir2LQ7XXXXXX' || auth.uid === '9QdDc9as5mRXGAjEsQiUJkXXXXXX'"
  }
}

Enfin, publiez vos règles de base de données.

Pour en savoir plus sur les règles de base de données, vous pouvez consulter le Documentation Firebase.

6) Organisation de vos nœuds de base de données

Toutes les données stockées dans la base de données Firebase Realtime sont stockées sous forme d’objets JSON. Ainsi, vous pouvez considérer la base de données comme une arborescence JSON basée sur le cloud. Lorsque vous ajoutez des données à l’arborescence JSON, celle-ci devient un nœud avec une clé associée dans la structure JSON existante.

Vous n’êtes pas familier avec JSON ? Lisez ce guide rapide.

La meilleure façon d’organiser vos données dépendra des fonctionnalités de votre projet et de la façon dont les utilisateurs accèdent aux données.

Nous voulons contrôler les GPIO ESP32. Nous pouvons organiser les données de manière à faciliter l’ajout ultérieur de GPIO et de cartes. Ainsi, nous pouvons structurer la base de données comme suit :

Au format JSON, voici à quoi cela ressemblerait :

{
  "board1": {
    "outputs": {
      "digital": {
        "12": 0,
        "13": 0,
        "14": 0
      }
    }
  }
}

Création de nœuds de base de données

Créons maintenant les nœuds de base de données dans notre base de données. Vous pouvez créer les nœuds manuellement en écrivant les nœuds sur la console Firebase, sur l’application Web ou via l’ESP32. Nous allons les créer manuellement, il est donc plus facile de suivre le didacticiel.

1) Cliquez sur la base de données en temps réel pour que nous commencions à créer les nœuds.

Menu de la base de données en temps réel Firebase

2) Vous pouvez créer les nœuds de la base de données manuellement en utilisant les icônes (+) sur la base de données. Cependant, pour éviter les fautes de frappe, nous fournissons un fichier JSON que vous pouvez télécharger pour créer les mêmes nœuds que les nôtres. Cliquez sur le lien ci-dessous pour télécharger le fichier JSON.

Après le téléchargement, décompressez le dossier pour accéder au fichier .json.

3) Maintenant, revenez à votre base de données sur la console Firebase. Cliquez sur l’icône à trois points et sélectionnez Importer JSON.

Importation JSON de la base de données en temps réel Firebase

4) Sélectionnez le fichier JSON que vous venez de télécharger.

5) Votre base de données devrait ressembler à celle ci-dessous.

Exemple de structure de base de données en temps réel Firebase

Tous les nœuds de base de données requis pour ce projet sont créés. Vous pouvez passer à la section suivante.

7) ESP32 : écoute des modifications de la base de données (contrôle des GPIO)

Dans cette section, nous allons programmer la carte ESP32 pour effectuer les tâches suivantes :

  1. Authentifiez-vous en tant qu’utilisateur avec e-mail et mot de passe (l’utilisateur que vous avez configuré dans cette section);
  2. Écouter les modifications de la base de données sur les nœuds GPIO et modifier leurs états en conséquence.

Pièces requises

Pour ce projet, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

1681197207 199 Firebase controlez les GPIO ESP32 de nimporte ou

Diagramme schématique

Dans cet exemple, nous allons contrôler trois LED connectées aux GPIO 12, 13 et 14. Donc, câblez trois LED à l’ESP32. Vous pouvez suivre le diagramme schématique suivant.

ESP32 connecté à trois LED Schéma de principe

Vous pouvez utiliser n’importe quel autre GPIO ESP32 approprié, mais vous devez également modifier les nœuds de la base de données.

Installation de la bibliothèque cliente Firebase ESP

Le Bibliothèque cliente Firebase ESP fournit de nombreux exemples sur la façon d’interfacer l’ESP32 avec les services Firebase. Consultez la page Github de la bibliothèque ici et pensez à soutenir l’auteur si la bibliothèque est utile pour vos projets.

Installez la bibliothèque Firebase-ESP-Client (Arduino IDE)

Suivez cette section si vous utilisez Arduino IDE.

Accédez à Sketch> Inclure la bibliothèque> Gérer les bibliothèques, recherchez « Firebase ESP Client ». Sélectionnez la bibliothèque client Firebase Arduino pour ESP8266 et ESP32.

Installez la bibliothèque client Firebase Arduino pour ESP8266 et ESP32 par Mobitz

Maintenant, vous êtes prêt à commencer à programmer les cartes ESP32 pour interagir avec la base de données.

Installez la bibliothèque Firebase-ESP-Client (code VS)

Suivez les instructions suivantes si vous utilisez VS Code + 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.

Installer Firebase ESP Client Library VS Code

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

Ajouter la bibliothèque client Firebase ESP au projet VS Code

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

monitor_speed = 115200

Écoute des modifications de la base de données (états GPIO) — Code

Copiez le code suivant dans votre IDE Arduino ou dans le fichier main.cpp si vous utilisez VS Code.

Vous devez insérer les éléments suivants dans le code avant de le télécharger sur votre tableau :

  • vos identifiants réseau
  • clé API du projet
  • URL de la base de données
  • adresse e-mail et mot de passe de l’utilisateur autorisé
/*
  Rui Santos
  Complete project details at our blog.
    - ESP32: https://Raspberryme.com/firebase-control-esp32-gpios/
    - ESP8266: https://Raspberryme.com/firebase-control-esp8266-nodemcu-gpios/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  Based in the RTDB Basic Example by Firebase-ESP-Client library by mobizt
  https://github.com/mobizt/Firebase-ESP-Client/blob/main/examples/RTDB/Basic/Basic.ino
*/

#include <Arduino.h>
#if defined(ESP32)
  #include <WiFi.h>
#elif defined(ESP8266)
  #include <ESP8266WiFi.h>
#endif
#include <Firebase_ESP_Client.h>

// Provide the token generation process info.
#include "addons/TokenHelper.h"
// Provide the RTDB payload printing info and other helper functions.
#include "addons/RTDBHelper.h"

// Insert your network credentials
#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

// Insert Firebase project API Key
#define API_KEY "REPLACE_WITH_YOUR_PROJECT_API_KEY"

// Insert Authorized Username and Corresponding Password
#define USER_EMAIL "REPLACE_WITH_THE_USER_EMAIL"
#define USER_PASSWORD "REPLACE_WITH_THE_USER_PASSWORD"

// Insert RTDB URLefine the RTDB URL
#define DATABASE_URL "REPLACE_WITH_YOUR_DATABASE_URL"

// Define Firebase objects
FirebaseData stream;
FirebaseAuth auth;
FirebaseConfig config;

// Variables to save database paths
String listenerPath = "board1/outputs/digital/";

// Declare outputs
const int output1 = 12;
const int output2 = 13;
const int output3 = 14;

// Initialize WiFi
void initWiFi() {
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
  Serial.println();
}

// Callback function that runs on database changes
void streamCallback(FirebaseStream data){
  Serial.printf("stream path, %s\nevent path, %s\ndata type, %s\nevent type, %s\n\n",
                data.streamPath().c_str(),
                data.dataPath().c_str(),
                data.dataType().c_str(),
                data.eventType().c_str());
  printResult(data); //see addons/RTDBHelper.h
  Serial.println();

  // Get the path that triggered the function
  String streamPath = String(data.dataPath());

  // if the data returned is an integer, there was a change on the GPIO state on the following path /{gpio_number}
  if (data.dataTypeEnum() == fb_esp_rtdb_data_type_integer){
    String gpio = streamPath.substring(1);
    int state = data.intData();
    Serial.print("GPIO: ");
    Serial.println(gpio);
    Serial.print("STATE: ");
    Serial.println(state);
    digitalWrite(gpio.toInt(), state);
  }

  /* When it first runs, it is triggered on the root (/) path and returns a JSON with all keys
  and values of that path. So, we can get all values from the database and updated the GPIO states*/
  if (data.dataTypeEnum() == fb_esp_rtdb_data_type_json){
    FirebaseJson json = data.to<FirebaseJson>();

    // To iterate all values in Json object
    size_t count = json.iteratorBegin();
    Serial.println("\n---------");
    for (size_t i = 0; i < count; i++){
        FirebaseJson::IteratorValue value = json.valueAt(i);
        int gpio = value.key.toInt();
        int state = value.value.toInt();
        Serial.print("STATE: ");
        Serial.println(state);
        Serial.print("GPIO:");
        Serial.println(gpio);
        digitalWrite(gpio, state);
        Serial.printf("Name: %s, Value: %s, Type: %s\n", value.key.c_str(), value.value.c_str(), value.type == FirebaseJson::JSON_OBJECT ? "object" : "array");
    }
    Serial.println();
    json.iteratorEnd(); // required for free the used memory in iteration (node data collection)
  }
  
  //This is the size of stream payload received (current and max value)
  //Max payload size is the payload size under the stream path since the stream connected
  //and read once and will not update until stream reconnection takes place.
  //This max value will be zero as no payload received in case of ESP8266 which
  //BearSSL reserved Rx buffer size is less than the actual stream payload.
  Serial.printf("Received stream payload size: %d (Max. %d)\n\n", data.payloadLength(), data.maxPayloadLength());
}

void streamTimeoutCallback(bool timeout){
  if (timeout)
    Serial.println("stream timeout, resuming...\n");
  if (!stream.httpConnected())
    Serial.printf("error code: %d, reason: %s\n\n", stream.httpCode(), stream.errorReason().c_str());
}

void setup(){
  Serial.begin(115200);
  initWiFi();

  // Initialize Outputs
  pinMode(output1, OUTPUT);
  pinMode(output2, OUTPUT);
  pinMode(output3, OUTPUT);
  
  // Assign the api key (required)
  config.api_key = API_KEY;

  // Assign the user sign in credentials
  auth.user.email = USER_EMAIL;
  auth.user.password = USER_PASSWORD;

  // Assign the RTDB URL (required)
  config.database_url = DATABASE_URL;

  Firebase.reconnectWiFi(true);

  // Assign the callback function for the long running token generation task */
  config.token_status_callback = tokenStatusCallback; //see addons/TokenHelper.h

  // Assign the maximum retry of token generation
  config.max_token_generation_retry = 5;

  // Initialize the library with the Firebase authen and config
  Firebase.begin(&config, &auth);

  // Streaming (whenever data changes on a path)
  // Begin stream on a database path --> board1/outputs/digital
  if (!Firebase.RTDB.beginStream(&stream, listenerPath.c_str()))
    Serial.printf("stream begin error, %s\n\n", stream.errorReason().c_str());

  // Assign a calback function to run when it detects changes on the database
  Firebase.RTDB.setStreamCallback(&stream, streamCallback, streamTimeoutCallback);

  delay(2000);
}

void loop(){
  if (Firebase.isTokenExpired()){
    Firebase.refreshToken(&config);
    Serial.println("Refresh token");
  }
}

Afficher le code brut

Comment fonctionne le code

Continuez à lire pour savoir comment le code fonctionne ou passez à la section de démonstration.

Inclure les bibliothèques

Tout d’abord, incluez les bibliothèques requises. Ce code est également compatible avec l’ESP8266.

#include <Arduino.h>
#if defined(ESP32)
  #include <WiFi.h>
#elif defined(ESP8266)
  #include <ESP8266WiFi.h>
#endif
#include <Firebase_ESP_Client.h>

// Provide the token generation process info.
#include "addons/TokenHelper.h"
// Provide the RTDB payload printing info and other helper functions.
#include "addons/RTDBHelper.h"

Informations d’identification réseau

Incluez vos informations d’identification réseau dans les lignes suivantes afin que vos cartes puissent se connecter à Internet en utilisant votre réseau local.

// Insert your network credentials
#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

Clé API du projet Firebase, utilisateur Firebase et URL de la base de données

Insérez votre Clé API du projet Firebase– celui que vous avez dans cette section.

#define API_KEY "REPLACE_WITH_YOUR_PROJECT_API_KEY"

Insérez le email autorisé et le mot de passe correspondant—ce sont les détails de l’utilisateur que vous avez ajouté dans cette section.

// Insert Authorized Email and Corresponding Password
#define USER_EMAIL "REPLACE_WITH_THE_USER_EMAIL"
#define USER_PASSWORD "REPLACE_WITH_THE_USER_PASSWORD"

Insérez votre URL de la base de données dans la ligne suivante :

// Insert RTDB URLefine the RTDB URL
#define DATABASE_URL "REPLACE_WITH_YOUR_DATABASE_URL"

Objets Firebase et autres variables

Tout d’abord, vous devez créer un objet FirebaseData (nous l’avons appelé flux) pour gérer les données en cas de modification d’un chemin de base de données spécifique.

FirebaseData stream;

La ligne suivante définit un objet FirebaseAuth nécessaire à l’authentification.

FirebaseAuth auth;

Enfin, la ligne suivante définit un objet FirebaseConfig requis pour les données de configuration.

FirebaseConfig config;

Chemin de la base de données

Ensuite, créez une variable qui enregistre le chemin de la base de données où nous écouterons les modifications. Compte tenu de la structure de la base de données que nous avons créée précédemment, le chemin de la base de données d’écoute doit être le suivant :

String listenerPath = "board1/outputs/digital/";

Si vous souhaitez ajouter d’autres cartes, il vous suffit de modifier le chemin d’écoute en conséquence.

Créez des variables pour les sorties que vous contrôlerez. Dans notre cas, nous contrôlons les GPIO 12, 13 et 14. Vous pouvez contrôler tous les autres GPIO ESP32 (vous devrez également modifier les nœuds de la base de données) :

const int output1 = 12;
const int output2 = 13;
const int output3 = 14;

initWifi()

La fonction iniWifi() connecte l’ESP32 à votre réseau local. Nous l’appellerons plus tard dans le setup() pour initialiser le Wi-Fi.

// Initialize WiFi
void initWiFi() {
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
  Serial.println();
}

installation()

Passons maintenant à setup(). Nous verrons plus tard la fonction streamCallback().

Initialisez le moniteur série :

Serial.begin(115200);

Appelez la fonction initiWiFi() que nous avons créée précédemment, pour connecter votre carte à votre réseau local.

initWiFi();

Initialisez les GPIO en tant que sorties.

// Initialize Outputs
pinMode(output1, OUTPUT);
pinMode(output2, OUTPUT);
pinMode(output3, OUTPUT);

Attribuez la clé API à la configuration Firebase.

config.api_key = API_KEY;

Les lignes suivantes attribuent l’adresse e-mail et le mot de passe à l’objet d’authentification Firebase.

auth.user.email = USER_EMAIL;
auth.user.password = USER_PASSWORD;

Attribuez l’URL de la base de données à l’objet de configuration Firebase.

config.database_url = DATABASE_URL;

Ajoutez ce qui suit à l’objet de configuration.

// Assign the callback function for the long running token generation task
config.token_status_callback = tokenStatusCallback; //see addons/TokenHelper.h

// Assign the maximum retry of token generation
config.max_token_generation_retry = 5;

Initialisez la bibliothèque Firebase (authentification) avec les paramètres de configuration et d’authentification que nous avons définis précédemment.

// Initialize the library with the Firebase authen and config
Firebase.begin(&config, &auth);

Base de données de flux – À l’écoute des changements

L’écoute des modifications sur la base de données fonctionne avec des fonctions de rappel. Cela signifie que lorsqu’un changement est détecté sur la base de données, une fonction de rappel s’exécute.

La ligne de code suivante démarre un flux pour écouter les modifications apportées à listenerPath.

if (!Firebase.RTDB.beginStream(&stream, listenerPath.c_str()))

Ensuite, définissez une fonction de rappel à déclencher chaque fois qu’il y a un changement sur le listenerPath : la fonction streamCallback.

Firebase.RTDB.setStreamCallback(&stream, streamCallback, streamTimeoutCallback);

fonction streamCallback()

Intéressons-nous maintenant à la fonction streamCallback créée précédemment.

Lorsque la fonction streamCallback() est déclenchée, un objet appelé data de type FirebaseStream est automatiquement passé en argument à cette fonction. À partir de cet objet, nous pouvons obtenir le chemin du flux, le chemin des données (le chemin complet de la base de données où la modification s’est produite, y compris la valeur de l’enfant le plus bas), le type de données de cette valeur et le type d’événement qui a déclenché le flux.

void streamCallback(FirebaseStream data){
  Serial.printf("stream path, %s\nevent path, %s\ndata type, %s\nevent type, %s\n\n",
                data.streamPath().c_str(),
                data.dataPath().c_str(),
                data.dataType().c_str(),
                data.eventType().c_str());
  printResult(data); //see addons/RTDBHelper.h
  Serial.println();

  // Get the path that triggered the function
  String streamPath = String(data.dataPath());

Ensuite, à partir des informations obtenues, l’ESP peut exécuter certaines tâches, comme la mise à jour des états GPIO.

Lorsque vous modifiez la valeur des états GPIO sur la base de données, les données renvoyées par cet événement sont un nombre entier (dans ce cas, 0 ou 1). Donc, d’abord, nous vérifions si la réponse est un entier :

if (data.dataTypeEnum() == fb_esp_rtdb_data_type_integer){

Si c’est le cas, le chemin de l’événement correspond au chemin du nœud GPIO, par exemple /12. À partir de ce chemin, nous pouvons obtenir le numéro GPIO que nous voulons changer, nous avons juste besoin de couper le « / » de la chaîne.

String gpio = streamPath.substring(1);

Pour mieux comprendre cela, vous pouvez jeter un œil à la capture d’écran suivante. Il montre ce que vous obtenez lorsqu’il y a un changement dans les états des GPIO.

Firebase Streaming Database ESP Détection des modifications Serial Monitor

On peut obtenir la valeur de la donnée retournée comme suit (sachant au préalable qu’il s’agit d’un entier) :

int state = data.intData();

Ensuite, nous pouvons simplement appeler la fonction digitalWrite() et passer comme arguments le numéro GPIO et l’état pour maintenir les états de sortie ESP32 à jour.

digitalWrite(gpio.toInt(), state);

Lorsque l’ESP se connecte pour la première fois à la base de données, il est déclenché sur le chemin root (/) et renvoie un objet JSON avec tous les nœuds enfants. Ainsi, nous pouvons obtenir toutes les valeurs de la base de données et mettre à jour les GPIO ESP32 lors de sa première exécution. Ceci est également utile car si l’ESP32 se réinitialise, il recevra toujours cet objet JSON en premier et pourra mettre à jour tous les GPIO.

Première exécution de la base de données de streaming

Comme vous pouvez le voir sur la capture d’écran précédente, l’objet JSON qu’il reçoit se présente comme suit (il peut être différent selon les états GPIO) :

{
  "12": 0,
  "13": 0,
  "14": 0
}

Lorsque cela se produit, les données renvoyées sont de type JSON. Donc, nous pouvons l’obtenir avec l’instruction if suivante :

if (data.dataTypeEnum() == fb_esp_rtdb_data_type_json){

Nous pouvons convertir les données renvoyées en un objet FirebaseJSON :

FirebaseJson json = data.to<FirebaseJson>();

Ensuite, nous pouvons parcourir l’ensemble de l’objet JSON et obtenir les clés (GPIO) et les valeurs correspondantes (états GPIO). A chaque itération, nous sauvegardons le GPIO sur la variable gpio et son état correspondant sur la variable d’état. Ensuite, nous appelons la fonction digitalWrite() pour mettre à jour son état.

// To iterate all values in Json object
size_t count = json.iteratorBegin();
Serial.println("\n---------");
for (size_t i = 0; i < count; i++){
    FirebaseJson::IteratorValue value = json.valueAt(i);
    int gpio = value.key.toInt();
    int state = value.value.toInt();
    Serial.print("STATE: ");
    Serial.println(state);
    Serial.print("GPIO:");
    Serial.println(gpio);
    digitalWrite(gpio, state);
    Serial.printf("Name: %s, Value: %s, Type: %s\n", value.key.c_str(), value.value.c_str(), value.type == FirebaseJson::JSON_OBJECT ? "object" : "array");
}
Serial.println();
json.iteratorEnd(); // required for free the used memory in iteration (node data collection)

Cela passe par toutes les clés et valeurs nous permettant de mettre à jour tous les GPIO.

Étant donné que tout notre code fonctionne avec des fonctions de rappel, nous n’avons pas besoin de placer quoi que ce soit sur la boucle () en plus des lignes pour actualiser le jeton Firebase.

void loop(){
  if (Firebase.isTokenExpired()){
    Firebase.refreshToken(&config);
    Serial.println("Refresh token");
  }
}

Si l’ESP32 doit effectuer d’autres tâches, vous pouvez les ajouter dans la boucle(). Dans notre cas, cet exemple n’écoute que les modifications de la base de données.

Manifestation

Après avoir inséré toutes les informations d’identification requises, téléchargez le code sur votre tableau.

Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115200 et réinitialisez la carte. Vous devriez obtenir quelque chose comme indiqué ci-dessous.

Première exécution de la base de données de streaming

Comme vous pouvez le voir, lorsque l’ESP s’exécute pour la première fois, il obtient un objet JSON avec tous les états GPIO.

{
  "12": 0,
  "13": 0,
  "14": 0
}

Ensuite, accédez à la base de données Firebase Realtime sur la console Firebase. Modifiez manuellement les états GPIO (0 ou 1). Après avoir inséré une nouvelle valeur, appuyez sur Entrée.

Base de données en temps réel Firebase Enregistrement des états ESP GPIO

Juste après, vous verrez sur le moniteur série que l’ESP32 a détecté les changements.

Firebase Streaming Database ESP Détection des modifications Serial Monitor

Et il mettra à jour les états GPIO et allumera les LED presque instantanément.

Contrôlez les sorties ESP32 de n'importe où

Ensuite, si vous réinitialisez votre carte (appuyez sur le bouton RST ou coupez et rallumez l’alimentation), lorsqu’elle redémarre, elle obtiendra les derniers états GPIO de la base de données et les mettra à jour immédiatement.

Aller plus loin – Ajouter plus de tableaux

Vous pouvez aller plus loin dans ce projet et ajouter d’autres cartes. Pour ce faire, créez de nouveaux nœuds de base de données pour une deuxième carte. Vous pouvez ajouter des cartes ESP32 ou ESP8266.

Vous pouvez télécharger le fichier JSON suivant et l’importer dans votre base de données, et il créera des nœuds pour deux cartes :

Après avoir téléchargé le fichier JSON, la base de données se présentera comme suit :

La base de données en temps réel Firebase permet d'enregistrer plusieurs cartes GPIO

Maintenant, vous pouvez télécharger le même code sur la nouvelle carte (elle est compatible avec l’ESP32 et l’ESP8266). Mais n’oubliez pas de changer le chemin d’écoute. Ça devrait être:

String listenerPath = "board2/outputs/digital/";

Maintenant, vous pouvez contrôler les deux cartes en modifiant les états GPIO sur la base de données.

Contrôlez les sorties ESP32 et ESP8266 à partir de n'importe où sur plusieurs cartes

Dans la partie 2, nous allons créer une application Web Firebase afin que vous disposiez d’une interface agréable pour contrôler vos GPIO de n’importe où sans avoir à utiliser la console Firebase et à modifier la base de données manuellement :

Conclusion

Dans ce didacticiel, vous avez appris à utiliser la base de données en temps réel Firebase pour enregistrer les états ESP GPIO. Vous avez également appris à programmer l’ESP32 pour écouter les modifications de la base de données. Chaque fois qu’un changement est détecté, nous mettons à jour les états GPIO correspondants. Vous pouvez modifier le code afin que l’ESP écoute toutes les autres données enregistrées dans la base de données, pas seulement les états GPIO. Comme vous pouvez accéder à la base de données en temps réel Firebase de n’importe où, vous pouvez également contrôler vos cartes de n’importe où. C’est idéal pour les projets IoT.

Dans la partie 2, nous allons créer une application Web pour contrôler vos GPIO de n’importe où, sans avoir besoin de vous connecter manuellement sur la console Firebase :

Si vous aimez les projets Firebase, veuillez consulter notre nouvel eBook. Nous sommes sûrs que vous l’aimerez :

En savoir plus sur l’ESP32 avec nos ressources :

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :

YouTube video