Enregistrement de données ESP8266 dans la base de données en temps réel Firebase

Dans ce guide, vous apprendrez à enregistrer des données avec le NodeMCU ESP8266 dans la base de données en temps réel Firebase avec des horodatages (enregistrement des données) afin d’avoir un enregistrement de l’historique de vos données. Par exemple, nous enregistrerons la température, l’humidité et la pression d’un capteur BME280 et nous obtiendrons les horodatages d’un serveur NTP. Ensuite, vous pouvez accéder aux données à l’aide de la console Firebase ou créer une application Web pour afficher les résultats (consultez ce didacticiel).

Journalisation des données ESP8266 NodeMCU dans la base de données en temps réel Firebase

Partie 2 : ESP32/ESP8266 : application Web d’enregistrement de données Firebase (jauges, graphiques et tableau)

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

Qu’est-ce que 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. 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, etc.

Aperçu du projet

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

Enregistrement de données ESP8266 Firebase BME280

L’ESP8266 s’authentifie en tant qu’utilisateur avec e-mail et mot de passe (cet utilisateur doit être défini sur les méthodes d’authentification Firebase) ;
Après l’authentification, l’ESP obtient l’UID de l’utilisateur ;
La base de données est protégée par des règles de sécurité. L’utilisateur ne peut accéder qu’aux nœuds de la base de données sous le nœud avec son UID d’utilisateur. Après avoir obtenu l’UID de l’utilisateur, l’ESP peut publier des données dans la base de données ;
L’ESP8266 obtient la température, l’humidité et la pression du capteur BME280.
Il obtient l’heure juste après avoir obtenu les lectures (horodatage).
L’ESP8266 envoie la température, l’humidité, la pression et l’horodatage à la base de données.
De nouvelles lectures sont ajoutées périodiquement à la base de données. Vous aurez un enregistrement de toutes les lectures sur la base de données en temps réel Firebase.

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

Créer un projet Firebase
Définir les méthodes d’authentification
Obtenir la clé API du projet
Configurer la base de données en temps réel
Configurer les règles de sécurité de la base de données
Enregistrement de données ESP8266 (base de données en temps réel Firebase)

Vous pouvez continuer avec le projet Firebase de ce didacticiel précédent ou créer un nouveau projet. Si vous utilisez le projet Firebase de ce tutoriel précédent, vous pouvez passer à la section 4) Configurer la base de données en temps réel car les méthodes d’authentification sont déjà configurées.

Préparation de l’IDE Arduino

Pour ce tutoriel, nous allons programmer la carte ESP8266 en utilisant le noyau Arduino. Assurez-vous donc que le module complémentaire ESP8266 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.

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 s’occupe de la connexion et de l’identification des utilisateurs (dans ce cas, 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.

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.

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) Obtenir la clé API du projet

Pour s’interfacer avec votre projet Firebase à l’aide de la carte 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.

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 ESP8266.

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, copiez les règles suivantes, puis cliquez sur Publier.

// These rules grant access to a node matching the authenticated
// user's ID from the Firebase auth token
{
  "rules": {
    "UsersData": {
      "$uid": {
        ".read": "$uid === auth.uid",
        ".write": "$uid === auth.uid"
      }
    }
  }
}

Base de données en temps réel créant des règles

Ces règles accordent l’accès à un nœud correspondant à l’UID de l’utilisateur authentifié. Cela garantit que chaque utilisateur authentifié ne peut accéder qu’à ses propres données. Cela signifie que l’utilisateur ne peut accéder qu’aux nœuds qui se trouvent sous un nœud avec son UID utilisateur correspondant. S’il existe d’autres données publiées sur la base de données, pas sous un nœud avec l’UID des utilisateurs, cet utilisateur ne peut pas accéder à ces données.

Par exemple, imaginez que notre UID utilisateur soit RjO3taAzMMXBB2Xmir2LQ. Avec nos règles de sécurité, il peut lire et écrire des données dans la base de données sous le nœud UsersData/RjO3taAzMMXBB2Xmir2LQ.

Vous comprendrez mieux comment cela fonctionne lorsque vous commencerez à travailler avec l’ESP8266.

6) Enregistrement de données ESP8266 (base de données en temps réel Firebase)

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

Authentifiez-vous en tant qu’utilisateur avec e-mail et mot de passe (l’utilisateur que vous avez configuré dans cette section);
Obtenez des lectures BME280 : température, humidité et pression ;
Obtenez l’heure d’époque (horodatage) d’un serveur NTP ;
Envoyez les relevés des capteurs et l’horodatage à la base de données en temps réel en tant qu’utilisateur autorisé.

Pièces requises

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

* vous pouvez également tester le projet avec des valeurs aléatoires au lieu des lectures de capteur, ou vous pouvez utiliser n’importe quel autre capteur que vous connaissez.

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 !

Diagramme schématique

Dans ce didacticiel, nous allons envoyer les lectures du capteur BME280 à la base de données en temps réel Firebase. Vous devez donc câbler le capteur BME280 à votre carte.

Nous allons utiliser la communication I2C avec le module de capteur BME280. Pour cela, câblez le capteur aux broches ESP8266 SCL (GPIO 5 (D1)) et SDA (GPIO 4 (D2)) par défaut, comme indiqué dans le schéma suivant.

ESP8266 NodeMCU BME280 Capteur Température Humidité Pression Schéma de câblage Circuit

Vous ne connaissez pas le BME280 avec l’ESP8266 ? Lisez ce tutoriel : ESP8266 avec capteur BME280 utilisant Arduino IDE (pression, température, humidité).

Installation des bibliothèques

Pour ce projet, vous devez installer les bibliothèques suivantes :

Installation de bibliothèques – VS Code

Suivez les instructions suivantes si vous utilisez VS Code avec l’extension PlatformIO.

Installer la bibliothèque client Firebase-ESP

Il existe une librairie avec plein d’exemples pour utiliser Firebase avec l’ESP8266 : le Bibliothèque Firebase-ESP-Client. Cette bibliothèque est compatible avec les cartes ESP32 et ESP8266.

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

Installer la bibliothèque BME280

Dans l’onglet Bibliothèques, recherchez BME280. Sélectionnez la bibliothèque Adafruit BME280.

Recherche de code PlatformIO VS pour la bibliothèque BME280

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

PlatformIO avec VS Code Ajouter une bibliothèque au projet

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

monitor_speed = 115200

Installation – Arduino IDE

Suivez cette section si vous utilisez Arduino IDE.

Vous devez installer les bibliothèques suivantes :

Accédez à Sketch > Inclure la bibliothèque > Gérer les bibliothèques, recherchez les noms des bibliothèques et installez les bibliothèques.

Pour la bibliothèque client Firebase, 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 la carte ESP8266 pour interagir avec la base de données.

Enregistrement de données : code de base de données en temps réel Firebase

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

Vous devez insérer vos informations d’identification réseau, la clé API du projet, l’URL de la base de données, ainsi que l’adresse e-mail et le mot de passe de l’utilisateur autorisé.

/*
  Rui Santos
  Complete project details at our blog: https://Raspberryme.com/esp8266-data-logging-firebase-realtime-database/
  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.
*/

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <Firebase_ESP_Client.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include <NTPClient.h>
#include <WiFiUdp.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 Email 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 fbdo;
FirebaseAuth auth;
FirebaseConfig config;

// Variable to save USER UID
String uid;

// Database main path (to be updated in setup with the user UID)
String databasePath;
// Database child nodes
String tempPath = "/temperature";
String humPath = "/humidity";
String presPath = "/pressure";
String timePath = "/timestamp";

// Parent Node (to be updated in every loop)
String parentPath;

FirebaseJson json;

// Define NTP Client to get time
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org");

// Variable to save current epoch time
int timestamp;

// BME280 sensor
Adafruit_BME280 bme; // I2C
float temperature;
float humidity;
float pressure;

// Timer variables (send new readings every three minutes)
unsigned long sendDataPrevMillis = 0;
unsigned long timerDelay = 180000;

// Initialize BME280
void initBME(){
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
}

// 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();
}

// Function that gets current epoch time
unsigned long getTime() {
  timeClient.update();
  unsigned long now = timeClient.getEpochTime();
  return now;
}

void setup(){
  Serial.begin(115200);

  // Initialize BME280 sensor
  initBME();
  initWiFi();
  timeClient.begin();

  // 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);
  fbdo.setResponseSize(4096);

  // 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);

  // Getting the user UID might take a few seconds
  Serial.println("Getting User UID");
  while ((auth.token.uid) == "") {
    Serial.print('.');
    delay(1000);
  }
  // Print user UID
  uid = auth.token.uid.c_str();
  Serial.print("User UID: ");
  Serial.println(uid);

  // Update database path
  databasePath = "/UsersData/" + uid + "/readings";
}

void loop(){

  // Send new readings to database
  if (Firebase.ready() && (millis() - sendDataPrevMillis > timerDelay || sendDataPrevMillis == 0)){
    sendDataPrevMillis = millis();

    //Get current timestamp
    timestamp = getTime();
    Serial.print ("time: ");
    Serial.println (timestamp);

    parentPath= databasePath + "/" + String(timestamp);

    json.set(tempPath.c_str(), String(bme.readTemperature()));
    json.set(humPath.c_str(), String(bme.readHumidity()));
    json.set(presPath.c_str(), String(bme.readPressure()/100.0F));
    json.set(timePath, String(timestamp));
    Serial.printf("Set json... %s\n", Firebase.RTDB.setJSON(&fbdo, parentPath.c_str(), &json) ? "ok" : fbdo.errorReason().c_str());
  }
}

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. La bibliothèque ESP8266WiFi.h pour connecter l’ESP8266 à Internet, la bibliothèque Firebase_ESP_Client.h pour interfacer la carte avec Firebase, le Wire, Adafruit_Sensor et Adafruit_BME280 pour s’interfacer avec le capteur BME280, et les bibliothèques NTPClient et WiFiUdp pour obtenir l’heure.

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <Firebase_ESP_Client.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include <NTPClient.h>
#include <WiFiUdp.h>

Vous devez également inclure les éléments suivants pour que la bibliothèque Firebase fonctionne.

// 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

La ligne suivante définit un objet FirebaseData.

FirebaseData fbdo;

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;

La variable uid sera utilisée pour enregistrer l’UID de l’utilisateur. Nous pouvons obtenir l’UID de l’utilisateur après l’authentification.

String uid;

La variable databasePath enregistre le chemin principal de la base de données, qui sera mis à jour ultérieurement avec l’UID de l’utilisateur.

String databasePath;

Les variables suivantes enregistrent les nœuds enfants de la base de données pour la température, l’humidité, la pression et l’horodatage.

String tempPath = "/temperature";
String humPath = "/humidity";
String presPath = "/pressure";
String timePath = "/timestamp";

Le parentPath est le nœud parent qui sera mis à jour dans chaque boucle avec l’horodatage actuel.

// Parent Node (to be updated in every loop)
String parentPath;

Pour mieux comprendre comment nous allons organiser nos données, voici un schéma.

Base de données d'enregistrement de données Firebase BME280

Il peut sembler redondant de sauvegarder l’horodatage deux fois (dans le nœud parent et dans le nœud enfant), cependant, avoir toutes les données au même niveau de la hiérarchie simplifiera les choses à l’avenir, si nous voulons créer une application Web pour afficher les données.

Définissez le client NTP pour obtenir l’heure :

// Define NTP Client to get time
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org");

La variable d’horodatage sera utilisée pour gagner du temps (format d’heure d’époque).

int timestamp;

Pour en savoir plus sur l’obtention de l’heure d’époque avec la carte ESP8266, vous pouvez consulter le tutoriel suivant :

Nous enverrons toutes les lectures et l’horodatage correspondant à la base de données en temps réel en même temps en créant un objet JSON qui contient les valeurs de ces variables. La bibliothèque ESP Firebase Client possède ses propres méthodes JSON. Nous les utiliserons pour envoyer des données au format JSON à la base de données. Nous commençons par créer une variable de type FirebaseJson appelée json.

FirebaseJson json;

La bibliothèque ESP_Firebase_Client fournit quelques exemples montrant comment utiliser FirebaseJson et comment envoyer des données au format JSON à la base de données : Exemples FirebaseJson de la bibliothèque ESP_Firebase_Client.

Ensuite, créez un objet Adafruit_BME280 appelé bme. Cela crée automatiquement un objet capteur sur les broches I2C par défaut de l’ESP8266.

Adafruit_BME280 bme; // I2C

Les variables suivantes contiendront les relevés de température, d’humidité et de pression du capteur.

float temperature;
float humidity;
float pressure;

Temporisation

Les variables sendDataPrevMillis et timerDelay permettent de vérifier le délai entre chaque envoi. Dans cet exemple, nous fixons le temps de retard à 3 minutes (18 000 millisecondes). Une fois que vous avez testé ce projet et vérifié que tout fonctionne comme prévu, nous vous recommandons d’augmenter le délai.

// Timer variables (send new readings every three minutes)
unsigned long sendDataPrevMillis = 0;
unsigned long timerDelay = 180000;

initBME()

La fonction initBME() initialise la bibliothèque BME280 à l’aide de l’objet bme créé précédemment. Ensuite, vous devez appeler cette bibliothèque dans le setup().

void initBME(){
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
}

initWiFi()

La fonction initWiFi() connecte votre ESP à Internet en utilisant les informations d’identification réseau fournies. Vous devez appeler cette fonction plus tard dans le setup() pour initialiser le WiFi.

// 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();
}

obtenir du temps()

La fonction getTime() renvoie l’heure actuelle de l’époque.

// Function that gets current epoch time
unsigned long getTime() {
  timeClient.update();
  unsigned long now = timeClient.getEpochTime();
  return now;
}

installation()

Dans setup(), initialisez le moniteur série à des fins de débogage à un débit en bauds de 115200.

Serial.begin(115200);

Appelez la fonction initBME() pour initialiser le capteur BME280.

initBME();

Appelez la fonction initWiFi() pour initialiser le WiFi.

initWiFi();

Initialisez le client temporel :

timeClient.begin();

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);

Après avoir initialisé la bibliothèque, nous pouvons obtenir l’UID de l’utilisateur en appelant auth.token.uid. Obtenir l’UID de l’utilisateur peut prendre un certain temps, nous ajoutons donc une boucle while qui attend jusqu’à ce que nous l’obtenions.

// Getting the user UID might take a few seconds
Serial.println("Getting User UID");
while ((auth.token.uid) == "") {
  Serial.print('.');
  delay(1000);
}

Enfin, nous sauvegardons l’UID de l’utilisateur dans la variable uid et l’imprimons dans le Serial Monitor.

uid = auth.token.uid.c_str();
Serial.print("User UID: ");
Serial.print(uid);

Après avoir obtenu l’UID de l’utilisateur, nous pouvons mettre à jour le chemin de la base de données pour inclure l’UID de l’utilisateur.

// Update database path
databasePath = "/UsersData/" + uid + "/readings";

boucle()

Dans la boucle(), vérifiez s’il est temps d’envoyer de nouvelles lectures :

if (Firebase.ready() && (millis() - sendDataPrevMillis > timerDelay || sendDataPrevMillis == 0)){
  sendDataPrevMillis = millis();

Si c’est le cas, récupérez l’heure actuelle et enregistrez-la dans la variable d’horodatage.

//Get current timestamp
timestamp = getTime();
Serial.print ("time: ");
Serial.println (timestamp);

Mettez à jour la variable parentPath pour inclure l’horodatage.

parentPath= databasePath + "/" + String(timestamp);

Ensuite, ajoutez des données à l’objet json en utilisant la méthode set() et en passant comme premier argument la destination du nœud enfant (clé) et comme deuxième argument la valeur :

json.set(tempPath.c_str(), String(bme.readTemperature()));
json.set(humPath.c_str(), String(bme.readHumidity()));
json.set(presPath.c_str(), String(bme.readPressure()/100.0F));
json.set(timePath, String(timestamp));

Enfin, appelez Firebase.RTDB.setJSON(&fbdo, parentPath.c_str(), &json) pour ajouter les données au chemin parent. Nous pouvons appeler cette instruction dans une commande Serial.printf() pour imprimer les résultats dans le moniteur série en même temps que la commande s’exécute.

Serial.printf("Set json... %s\n", Firebase.RTDB.setJSON(&fbdo, parentPath.c_str(), &json) ? "ok" : fbdo.errorReason().c_str());

Manifestation

Téléchargez le code précédent sur votre carte ESP8266 NodeMCU. N’oubliez pas d’insérer vos informations d’identification réseau, la clé API du projet, l’URL de la base de données, l’adresse e-mail de l’utilisateur et le mot de passe correspondant.

Après avoir téléchargé le code, appuyez sur le bouton RST de la carte pour qu’elle commence à exécuter le code. Il doit s’authentifier auprès de Firebase, obtenir l’UID de l’utilisateur et envoyer immédiatement de nouvelles lectures à la base de données.

Ouvrez le moniteur série à un débit en bauds de 115200 et vérifiez que tout fonctionne comme prévu.

ESP8266 Envoyer le moniteur série JSON Firebase

De plus, accédez à la base de données en temps réel sur l’interface de votre projet Firebase et vérifiez que les nouvelles lectures sont enregistrées. Notez qu’il enregistre les données sous un nœud avec le propre UID d’utilisateur – c’est un moyen de restreindre l’accès à la base de données.

Enregistrement des données de la base de données en temps réel Firebase

Attendez un peu jusqu’à ce que vous obteniez des lectures sur la base de données. Développez les nœuds pour vérifier les données.

Conclusion

Dans ce didacticiel, vous avez appris à enregistrer les lectures de vos capteurs avec des horodatages dans la base de données en temps réel Firebase à l’aide de l’ESP8266. Ce n’était qu’un exemple simple pour que vous compreniez comment cela fonctionne.

Vous pouvez utiliser d’autres méthodes fournies par la bibliothèque ESP_Firebase_Client pour enregistrer vos données, et vous pouvez organiser votre base de données de différentes manières. Nous avons organisé la base de données d’une manière pratique pour un autre projet que nous publierons bientôt.

Dans la PARTIE 2, nous allons créer une application Web Firebase pour afficher toutes les données enregistrées dans un tableau et les dernières lectures sur les graphiques :

Nous espérons que vous avez trouvé ce tutoriel utile.

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

En savoir plus sur l’ESP8266 avec nos ressources :

Merci d’avoir lu.

Apprenez l’histoire de Raspberry Pi à travers cette vidéo :