Firebase Firebase w zastosowaniach IoT - #2 - Firebase z ESP32 i ESP8266

Karrol · Marzec 1, 2021

Ten artykuł jest częścią serii "Firebase w zastosowaniach IoT"

Ostatnio dowiedzieliśmy się czym jest Firebase, jak stworzyć projekt i jak zadbać o jego bezpieczeństwo. Teraz nadszedł czas na bardziej praktyczne zastosowanie. W tej części omówimy dostęp do Firestore i RTDB z poziomu ESP8266 i ESP32.

Wykorzystywane w dalszych przykładach bazy danych uzupełnijmy tak jak na poniższych zrzutach ekranu.

^{Realtime Database}

^Firestore

DANE DOSTĘPOWE

Do połączenia się z naszym projektem będą potrzebne jego identyfikator oraz klucz API. Możemy je znaleźć wchodząc w ustawienia naszego projektu.

^{Widok ustawień projektu z zaznaczonym identyfikatorem i kluczem API.}

Będzie też potrzebny adres URL naszego projektu, który możemy znaleźć w zakładce RTDB.

^{Widok zakładki RTDB z zaznaczonym adresem URL projektu.}

PRZYGOTOWANIE

Do obsługi Firebase na płytkach ESP będziemy wykorzystywać bibliotekę Firebase_ESP_Client by mobizt. W tym celu na początku musimy ją zaimportować do naszego Arduino IDE (pobierając z Github lub wyszukując w menedżerze bibliotek Firebase Arduino Client Library for ESP8266 and ESP32). Dalsze przykłady będą bazować na przykładach dostarczonych przez twórcę tej biblioteki.

Niezależnie od tego, z których usług Firebase chcemy korzystać, na początku musimy zaimportować biblioteki, połączyć się z wifi i zainicjalizować połączenie z Firebase.

Importujemy biblioteki. Zwróćmy uwagę, że dzięki zaimportowaniu ich w taki sposób, nasz kod będzie działał na ESP8266 i na ESP32 bez konieczności modyfikowania go.

// dołączamy bibliotekę WiFi w zależności od płytki
#if defined(ESP32)
#include <WiFi.h>
#elif defined(ESP8266)
#include <ESP8266WiFi.h>
#endif

// dołączenie biblioteki do obsługi Firebase
#include <Firebase_ESP_Client.h>

Następnie definiujemy obiekty, z których będziemy później korzystać:

//Definiujemy obiekt Firebase Data
FirebaseData fbdo;

//Definiujemy FirebaseAuth, gdzie będziemy trzymać dane do uwierzytelniania
FirebaseAuth auth;

// Definiujemy FirebaseConfig, gdzie będziemy trzymać dane do konfiguracji
FirebaseConfig config;

Kolejnym krokiem jest połączenie z wifi. Robimy to wewnątrz funkcji setup():

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

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD); // ustawiamy swoje dane dostępu do wifi
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)
  {
    Serial.print(".");
    delay(300);
  }
}

Musimy jeszcze zainicjować połączenie z naszym projektem:

void setup()
{
  // łączenie z wifi...
  
  //Do ustawień konfiguracji (config) zapisujemy klucz API i adres URL naszego projektu
  config.host = FIREBASE_HOST;  //"PROJECT_ID.firebaseio.com"
  config.api_key = API_KEY;

  //Do ustawień uwierzytelniania zapisujemy dane do konta użytkownika, którego stworzyliśmy w poprzedniej części artykułu
  auth.user.email = USER_EMAIL;          // "[email protected]"
  auth.user.password = USER_PASSWORD;    // "123456"

  //Inicjalizujemy połączenie z Firebase używając ustawionych danych
  Firebase.begin(&config, &auth);

  //Opcjonalnie ustawiamy automatyczne łączenie z WiFi po zerwaniu połączenia (zalecane)
  Firebase.reconnectWiFi(true);
}

Gotowe! Nasz program łączy się już z naszym projektem i za moment będziemy mogli korzystać z dobrodziejstw oferowanych przez Firebase. Na chwilę oderwijmy się jednak od Firebase i spójrzmy na inną funkcjonalność, którą zapewnia nam ta biblioteka.

OPERACJE NA FORMACIE JSON

Twórca biblioteki dostarcza nam możliwość łatwego operowania na obiektach JSON za pomocą biblioteki FirebaseJson. Przyda nam się to podczas pracy z bazami danych, bo RTDB jest jednym wielkim drzewem JSON (omawialiśmy to w poprzedniej części artykułu).

Do dyspozycji mamy 3 typy obiektów:

FirebaseJson - struktura Json, dane przechowywane są w { }
FirebaseJsonArray - tablica, którą możemy umieścić wewnątrz FirebaseJson, dane przechowywane są w [ ]
FirebaseJsonData - typ służący do przechowywania fragmentów pobranych z FirebaseJson np. sama wartości temperatury z czujnik1.

Przyjrzyjmy się najważniejszym funkcjom oferowanym przez tę bibliotekę:

// deklaracja obiektu FirebaseJson
FirebaseJson json;

// deklaracja obiektu FirebaseJsonArray
FirebaseJsonArray arr;

// deklaracja obiektu FirebaseJsonData
FirebaseJsonData jsonData;


// dodanie nowej gałęzi z jej wartością
json.add(“ścieżka”, wartość);

// edytowanie, nadpisanie lub utworzenie nowej (jeśli nie istnieje) gałęzi
json.set(“ścieżka”, wartość);

// usuwanie gałęzi
json.remove(“scieżka”);

// zapisywanie obiektu json do postaci napisu (string)
String nazwa_zmiennej_string;
json.toString(nazwa_zmiennej_string, true);

// czyszczenie zawartości obiektu
json.clear();

// eksport zawartości gałęzi do jsonData
json.get(jsonData, "ścieżka");

// zamienianie napisu (typ string) w obiekt FirebaseJson
json.setJsonData(string);


// dodawanie zawartości do obiektu FirebaseJsonArray
arr.add(wartość);
arr.add(“ścieżka”, wartość);

// edytowanie, nadpisanie lub utworzenie nowej zawartości w obiekcie FirebaseJsonArray
arr.set(“ścieżka”, wartość);

// usuwanie zawartości komórki tablicy
arr.remove(“ścieżka”);

// zapisywanie obiektu arr do postaci napisu (string)
String nazwa_zmiennej_string;
arr.toString(nazwa_zmiennej_string, true);

// czyszczenie zawartości obiektu arr
arr.clear();

// eksport zawartości komórki tablicy do jsonData
arr.get(jsonData, "ścieżka");

// parametr określający czy do jsonData udało się zapisać dane - true lub false
jsonData.success

// parametr określający typ danych w jsonData: string, int, double, bool, object, array, null, undefined
jsonData.type

// wypisywanie zawartości jsonData dla różnych typów danych
Serial.println(jsonData.stringValue);
Serial.println(jsonData.intValue);
Serial.println(jsonData.boolValue);
Serial.println(jsonData.floatValue);
Serial.println(jsonData.doubleValue);

Przykładowe zastosowanie:

#include <Arduino.h>
#include <FirebaseJson.h>

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

    FirebaseJson json;
    FirebaseJson json1;

    json1.add("temperatura", 23.5);
    json1.add("wilgotnosc", 67);

    json.set("led/led1", false);
    json.set("led/led2", true);
    json.set("pomiary/czujnik1", json1); // dodajemy json1 jako wartość gałęzi "pomiary/czujnik1"

    String jsonStr;
    json.toString(jsonStr, true);
    Serial.println("----------------------------");
    Serial.println(jsonStr);

    /* Otrzymujemy:
    {
      "led": {
          "led1": false,
          "led2": true
      },
      "pomiary": {
          "czujnik1": {
              "temperatura": 23.5,
              "wilgotnosc": 67
          }
      }
    }
    */

    
    FirebaseJsonArray arr;

    arr.add("pomiar1");
    arr.add("pomiar2");

    arr.set("[3]/pomiar3/temperatura", "34");
    arr.set("[3]/pomiar3/wilgotnosc", "44");

    arr.set("[3]/pomiar4/temperatura", "11");
    arr.set("[3]/pomiar4/wilgotnosc", "22");

    json.clear();
    json.add("pomiary",arr); // do gałęzi "pomiary" jako wartość dodajemy tablicę arr

    json.toString(jsonStr, true);
    Serial.println("----------------------------");
    Serial.println(jsonStr);

    /* Otrzymujemy:
    {
        "pomiary": [
            "pomiar1",      //[0] - add automatycznie numeruje od zera
            "pomiar2",      //[1] - następnie dodaje element o id 1
            null,           //[2] - element o id 2 jest null, bo pomiar3 i pomiar4 zapisujemy do elementu o id 3
            {               //[3] - tutaj dodajemy pomiar 3 i 4
                "pomiar3": {
                    "temperatura": "34",
                    "wilgotnosc": "44"
                },
                "pomiar4": {
                    "temperatura": "11",
                    "wilgotnosc": "22"
                }
            }
        ]
    }
    */


    arr.clear();
    FirebaseJsonArray arr2;
    
    arr.add("banan");
    arr.add("gruszka");
    arr.add("winogrono");

    arr2.add("pomidor");
    arr2.add("ogorek");
    arr2.add("ziemniak");

    json.clear();
    json.add("owoce",arr);
    json.add("warzywa",arr2);

    json.toString(jsonStr, true);
    Serial.println("----------------------------");
    Serial.println(jsonStr);

    /* Otrzymujemy:
    {
        "owoce": [
            "banan",
            "gruszka",
            "winogrono"
        ],
        "warzywa": [
            "pomidor",
            "ogorek",
            "ziemniak"
        ]
    }
    */



    arr.clear();
    arr2.clear();
    
    arr.set("banan");
    arr.set("gruszka");
    arr.set("winogrono");

    arr2.set("pomidor");
    arr2.set("ogorek");
    arr2.set("ziemniak");

    json.clear();
    json.add("owoce",arr);
    json.add("warzywa",arr2);

    json.toString(jsonStr, true);
    Serial.println("----------------------------");
    Serial.println(jsonStr);

    /* Otrzymujemy:
    {
        "owoce": [
            "root": [
                "root": [
                    "root": []
                ]
            ]
        ],
        "warzywa": [
            "root": [
                "root": [
                    "root": []
                ]
            ]
        ]
    }

    Jest to przykład niepoprawnego użycia set(). Nie możemy set() używać zamiennie z add()!
     */
}

void loop()
{
}

Omówiliśmy tylko podstawowe funkcjonalności. Dokładne omówienie wszystkich funkcji, które oferuje ta biblioteka, możemy znaleźć w jej dokumentacji.

OBSŁUGA REALTIME DATABASE

Większość funkcji do obsługi RTDB wywołujemy w postaci Firebase.RTDB.nazwa_funkcji() .

ODCZYT DANYCH Z RTDB

Metoda, której będziemy używać zależy od tego, czy znamy typ danych w bazie. Jeśli wiemy jakiego typu są dane, które chcemy odczytać możemy użyć funkcji określonych dla konkretnych typów danych:

getInt, getBool, getFloat, getDouble, getString, getJSON

Jeśli tego nie wiemy możemy użyć funkcji get i sprawdzić typ otrzymanych danych za pomocą obiekt_FirebaseData.dataType() np. fbdo.dataType().

Ogólna postać wywołania wymienionych wyżej funkcji wygląda następująco:

Firebase.RTDB.nazwa_funkcji(obiekt, "ścieżka")  //obiekt to wskaźnik na utworzony wcześniej obiekt FirebaseData
// dla uproszczenia w dalszej części będziemy go nazywać fbdo
  
//np:
Firebase.RTDB.nazwa_funkcji(&fbdo, "/pomiary/czujnik1/temperatura")

Wywołanie tych funkcji zwraca prawdę, jeśli udało się odczytać dane, lub fałsz, jeśli wystąpił błąd.

Po wywołaniu funkcji otrzymane dane będą przechowywane w obiekcie FirebaseData (będziemy go nazywać fbdo). W zależności od ich typu możemy odczytać je za pomocą jednego z poleceń:

fbdo.intData()
fbdo.floatData()
fbdo.doubleData()
fbdo.boolData()
fbdo.stringData()
fbdo.jsonString()
fbdo.jsonObject()
fbdo.jsonObjectPtr()
fbdo.jsonArray()
fbdo.jsonArrayPtr()
fbdo.jsonData()
fbdo.blobData()

Próba pozyskania danych innego typu niż uzyskane z bazy zwróci pustkę (pustą zmienną/ pusty obiekt / pustą tablicę).

Przykład zastosowania, gdy nie znamy typu:

if(Firebase.RTDB.get(&fbdo, "/led/led1"))
{
  //Sukces
  Serial.print("Udalo sie odczytac dane! typ = ");
  Serial.println(fbdo.dataType());

  if(fbdo.dataType() == "int"){
    Serial.print("wartosc = ");
    Serial.println(fbdo.intData());
  }else if(fbdo.dataType() == "bool"){
    if(fbdo.boolData())
      Serial.println("wartosc: true");
    else
      Serial.println("wartosc: false");
  }

}else{
  //Błąd, wypisz powód

  Serial.print("Blad pobierania danych: ");
  Serial.println(fbdo.errorReason());
}

Przykład zastosowania, gdy znamy typ odczytywanych danych:

if (Firebase.RTDB.getInt(&fbdo, "/pomiary/czujnik1/wilgotnosc")) {

  if (fbdo.dataType() == "int") {
    Serial.println(fbdo.intData());
  }

} else {
  Serial.println(fbdo.errorReason());
}

ZAPIS DANYCH DO RTDB

Dane do RTDB możemy zapisać na 3 sposoby:

set - zapisuje lub zmienia dane w konkretnym miejscu (konkretna ścieżka) np. możemy zmienić temperaturę w /pomiary/czujnik1/temperatura. Metoda ta spowoduje nadpisanie danych w określonej lokalizacji, w tym wszelkich węzłów podrzędnych. Oznacza to, że zapisując tylko wartość temperatury do lokalizacji /pomiary/czujnik1 utracimy zapisaną wartość wilgotności.
update - zmienia dane w konkretnym miejscu bez nadpisywania pozostałych danych. Oznacza to, że zapisując tylko wartość temperatury do lokalizacji /pomiary/czujnik1 zapisana wartość wilgotności pozostanie bez zmian.
push - dodaje nowy węzeł do bazy nadając mu unikalne id. Ma to zastosowanie np. jeżeli chcemy gromadzić historię pomiarów (a nie tylko ostatni).

Przy zapisie za pomocą set i push, analogicznie jak podczas odczytu danych, możemy korzystać z różnych funkcji dla różnych typów danych:

set, setInt, setFloat, setDouble, setBool, setString, setJSON, setArray, setBlob, setFile,
push, pushInt, pushFloat, pushDouble, pushBool, pushString, pushJSON, pushArray, pushBlob, pushFile

Funkcje te zwracają true lub false, w zależności od tego, czy udało się zapisać dane, czy nie. Standardowo wywołanie funkcji wygląda następująco:

Firebase.RTDB.nazwa_funkcji(&fbdo, “ścieżka”, wartość);

Dodatkowo istnieją funkcje, za pomocą których możemy zapisać aktualny czas serwera.

pushTimestamp(&fbdo, “ścieżka”);
setTimestamp(&fbdo, “ścieżka”);

Chcąc skorzystać z metody update musimy nasze dane umieścić w strukturze FirebaseJson. Mamy do dyspozycji dwie funkcje:

updateNode(&fbdo, “ścieżka”, &json);  // serwer zwraca odpowiedź
updateNodeSilent(&fbdo, “ścieżka”, &json);  // serwer nie zwraca odpowiedzi

Przykład zastosowania:

// dołączamy bibliotekę WiFi w zależności od płytki
#if defined(ESP32)
#include <WiFi.h>
#elif defined(ESP8266)
#include <ESP8266WiFi.h>
#endif

// dołączenie biblioteki do obsługi Firebase
#include <Firebase_ESP_Client.h>

//Definiujemy obiekt Firebase Data
FirebaseData fbdo;

//Definiujemy FirebaseAuth, gdzie będziemy trzymać dane do uwierzytelniania
FirebaseAuth auth;

// Definiujemy FirebaseConfig, gdzie będziemy trzymać dane do konfiguracji
FirebaseConfig config;


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

  WiFi.begin("WIFI_SSID", "WIFI_HASLO");
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)
  {
    Serial.print(".");
    delay(300);
  }

  //Do ustawień uwierzytelniania zapisujemy dane do konta użytkownika 
  auth.user.email = "[email protected]";
  auth.user.password = "123456";

  //Do ustawień konfiguracji (config) zapisujemy klucz API i adres projektu
  config.host = "https://ADRES.firebaseio.com";
  config.api_key = "API_KEY";



  //Inicjalizujemy połączenie z Firebase używając ustawionych danych
  Firebase.begin(&config, &auth);
  
  //Opcjonalnie ustawiamy automatyczne łączenie z WiFi po zerwaniu połączenia
  Firebase.reconnectWiFi(true);

  //----------------- ODCZYT --------------------------------------//

  Serial.print("GETINT: wilogotnosc: ");
  if (Firebase.RTDB.getInt(&fbdo, "/pomiary/czujnik1/wilgotnosc")) {

    if (fbdo.dataType() == "int") {
      Serial.println(fbdo.intData());
    }

  } else {
    Serial.println(fbdo.errorReason());
  }


  //----------------------- UPDATE ---------------------------------//
  
  Serial.println("Robie UPDATE");
  FirebaseJson json;
  json.add("temperatura",55.8);
  
  if(Firebase.RTDB.updateNode(&fbdo, "/pomiary/czujnik1", &json))
  {
     //sukces
     Serial.println("Update - sukces");

  }else{
    //blad
    Serial.print("Blad w update: ");
    Serial.println(fbdo.errorReason());
  }
  
  delay(5000);
  
  //---------------------- PUSH --------------------------------------//
  
  Serial.println("Robie PUSH");

  json.clear().add("temperatura",34.4);
  json.add("wilgotnosc", 55);

  if(Firebase.RTDB.pushJSON(&fbdo, "/pomiary/", &json))
  {
    //sukces
     Serial.println("Push - sukces");

  }else{
    //blad
    Serial.print("Blad w push: ");
    Serial.println(fbdo.errorReason());
  }

  delay(10000);
  
  //-------------------- SET - WERSJA 1 -------------------------------//

  Serial.println("Robie SET v1");

  if(Firebase.RTDB.setFloat(&fbdo, "/pomiary/czujnik1/temperatura", 99.9))
  {
     //sukces
     Serial.println("Set v1 - sukces");

  }else{
    //blad
    Serial.print("Blad w set v1: ");
    Serial.println(fbdo.errorReason());
  }

  delay(5000);
  
  //------------------- SET - WERSJA 2 --------------------------//
  
  Serial.println("Robie SET v2");
  
  json.clear().add("temperatura",33.3);
  
  if(Firebase.RTDB.setJSON(&fbdo, "/pomiary/czujnik1", &json))
  {
    //sukces
     Serial.println("Set v2 - sukces");

  }else{
    //blad
    Serial.print("Blad w set v2: ");
    Serial.println(fbdo.errorReason());
  }

  delay(5000);

  //----------------- ZAPIS CZASU ------------------------------//

  Serial.println("Robie zapis czasu");

  if(Firebase.RTDB.pushTimestamp(&fbdo, "/czas"))
  {
    //sukces
     Serial.println("Zapis czasu - sukces");

  }else{
    //blad
    Serial.print("Blad w zapisie czasu: ");
    Serial.println(fbdo.errorReason());
  }
}

void loop() {}

Kolejne etapy wykonywania programu:

^{0. Widok przed uruchomieniem programu.}

^{1. Update na /pomiary/czujnik1 zmieniło tylko wartość temperatury (wilgotność pozostała bez zmian).}

^{2. Push stworzyło nową gałąź o unikalnym id.}

^{3. Set wykonane na /pomiary/czujnik1/temperatura zmodyfikowało tylko gałąź z temperaturą.}

^{4. set wykonane na /pomiary/czujnik1 (tak samo jak update) nadpisało całą gałąź. Zapisało nową wartość temperatury, ale w przeciwieństwie do update straciliśmy zapisaną wartość wilgotności.}

^{5. Zapis czasu.}

^{Widok monitora portu szeregowego.}

USUWANIE DANYCH Z RTDB

Możemy usunąć całą gałąź przy pomocy funkcji deleteNode(&fbdo, “ścieżka”).

NASŁUCHIWANIE ZMIAN W CZASIE RZECZYWISTYM

Czasami potrzebujemy wiedzieć, że jakieś dane w bazie uległy zmianie (np. użytkownik poprzez stronę internetową chce włączyć lampkę). Autor biblioteki udostępnił do tego celu funkcje pozwalające na śledzenie zmian w wybranej gałęzi.

Rozpoczęcie nasłuchiwania zmian:

beginStream(&fbdo, “ścieżka”);

Ustawienie jaka funkcja ma zostać wywołana po wykryciu zmian w bazie:

setStreamCallback(&fbdo, “nazwa_funkcji”, “nazwa_funkcji_wywoływanej_po_przekroczeniu_limitu_czasu”);

W praktyce możemy to przetestować na przykładowym kodzie dostarczonym przez autora biblioteki. W Arduino IDE z przykładów dla tej biblioteki wybieramy RTDB->Stream_Callback. Usuwamy całą zawartość funkcji loop() oraz zbędne zmienne i funkcję printResult(FirebaseData &data), zmieniamy String path na "/led/led1" i ustawiamy nasze dane dostępowe (wifi, dane użytkownika, dane bazy). Tak zmodyfikowany kod będzie wyświetlał informacje w monitorze portu szeregowego za każdym razem, gdy zmienimy wartość w gałęzi "/led/led1" w bazie (my na razie zrobimy to ręcznie w konsoli Firebase).

Zmodyfikowany kod:

/**
 * Created by K. Suwatchai (Mobizt)
 * 
 * Email: [email protected]
 * 
 * Github: https://github.com/mobizt
 * 
 * Copyright (c) 2021 mobizt
 *
*/

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

/* 1. Define the WiFi credentials */
#define WIFI_SSID "xxxxxxx"
#define WIFI_PASSWORD "xxxxxxx"

/* 2. Define the Firebase project host name and API Key */
#define FIREBASE_HOST "https://ADRES.firebaseio.com"
#define API_KEY "API_KEY"

/* 3. Define the user Email and password that alreadey registerd or added in your project */
#define USER_EMAIL "[email protected]"
#define USER_PASSWORD "123456"

//Define FirebaseESP8266 data object
FirebaseData fbdo1;

FirebaseAuth auth;
FirebaseConfig config;

String path = "/led/led1";

void printResult(FirebaseStream &data);

// funkcja, która zostanie wywołana po wykryciu zmiany wartości w bazie
void streamCallback(FirebaseStream data)
{
  Serial.println("Stream Data1 available...");
  Serial.println("STREAM PATH: " + data.streamPath());
  Serial.println("EVENT PATH: " + data.dataPath());
  Serial.println("DATA TYPE: " + data.dataType());
  Serial.println("EVENT TYPE: " + data.eventType());
  Serial.print("VALUE: ");
  printResult(data);
  Serial.println();
}

void streamTimeoutCallback(bool timeout)
{
  if (timeout)
  {
    Serial.println();
    Serial.println("Stream timeout, resume streaming...");
    Serial.println();
  }
}

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

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)
  {
    Serial.print(".");
    delay(300);
  }
  Serial.println();
  Serial.print("Connected with IP: ");
  Serial.println(WiFi.localIP());
  Serial.println();

  /* Assign the project host and api key (required) */
  config.host = FIREBASE_HOST;
  config.api_key = API_KEY;

  /* Assign the user sign in credentials */
  auth.user.email = "[email protected]";
  auth.user.password = "123456";

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

#if defined(ESP8266)
  //Set the size of WiFi rx/tx buffers in the case where we want to work with large data.
  fbdo1.setBSSLBufferSize(1024, 1024);
#endif

  //Set the size of HTTP response buffers in the case where we want to work with large data.
  fbdo1.setResponseSize(1024);

  if (!Firebase.RTDB.beginStream(&fbdo1, path.c_str()))
  {
    Serial.println("------------------------------------");
    Serial.println("Can't begin stream connection...");
    Serial.println("REASON: " + fbdo1.errorReason());
    Serial.println("------------------------------------");
    Serial.println();
  }

  // rozpoczynamy nasłuchiwanie zmian
  Firebase.RTDB.setStreamCallback(&fbdo1, streamCallback, streamTimeoutCallback);
}

void loop()
{
}

void printResult(FirebaseStream &data)
{
  if (data.dataType() == "int")
    Serial.println(data.intData());
  else if (data.dataType() == "float")
    Serial.println(data.floatData(), 5);
  else if (data.dataType() == "double")
    printf("%.9lf\n", data.doubleData());
  else if (data.dataType() == "boolean")
    Serial.println(data.boolData() == 1 ? "true" : "false");
  else if (data.dataType() == "string" || data.dataType() == "null")
    Serial.println(data.stringData());
  else if (data.dataType() == "json")
  {
    Serial.println();
    FirebaseJson *json = data.jsonObjectPtr();
    //Print all object data
    Serial.println("Pretty printed JSON data:");
    String jsonStr;
    json->toString(jsonStr, true);
    Serial.println(jsonStr);
    Serial.println();
    Serial.println("Iterate JSON data:");
    Serial.println();
    size_t len = json->iteratorBegin();
    String key, value = "";
    int type = 0;
    for (size_t i = 0; i < len; i++)
    {
      json->iteratorGet(i, type, key, value);
      Serial.print(i);
      Serial.print(", ");
      Serial.print("Type: ");
      Serial.print(type == FirebaseJson::JSON_OBJECT ? "object" : "array");
      if (type == FirebaseJson::JSON_OBJECT)
      {
        Serial.print(", Key: ");
        Serial.print(key);
      }
      Serial.print(", Value: ");
      Serial.println(value);
    }
    json->iteratorEnd();
  }
  else if (data.dataType() == "array")
  {
    Serial.println();
    //get array data from FirebaseData using FirebaseJsonArray object
    FirebaseJsonArray *arr = data.jsonArrayPtr();
    //Print all array values
    Serial.println("Pretty printed Array:");
    String arrStr;
    arr->toString(arrStr, true);
    Serial.println(arrStr);
    Serial.println();
    Serial.println("Iterate array values:");
    Serial.println();

    for (size_t i = 0; i < arr->size(); i++)
    {
      Serial.print(i);
      Serial.print(", Value: ");

      FirebaseJsonData *jsonData = data.jsonDataPtr();
      //Get the result data from FirebaseJsonArray object
      arr->get(*jsonData, i);
      if (jsonData->typeNum == FirebaseJson::JSON_BOOL)
        Serial.println(jsonData->boolValue ? "true" : "false");
      else if (jsonData->typeNum == FirebaseJson::JSON_INT)
        Serial.println(jsonData->intValue);
      else if (jsonData->typeNum == FirebaseJson::JSON_FLOAT)
        Serial.println(jsonData->floatValue);
      else if (jsonData->typeNum == FirebaseJson::JSON_DOUBLE)
        printf("%.9lf\n", jsonData->doubleValue);
      else if (jsonData->typeNum == FirebaseJson::JSON_STRING ||
               jsonData->typeNum == FirebaseJson::JSON_NULL ||
               jsonData->typeNum == FirebaseJson::JSON_OBJECT ||
               jsonData->typeNum == FirebaseJson::JSON_ARRAY)
        Serial.println(jsonData->stringValue);
    }
  }
  else if (data.dataType() == "blob")
  {
    Serial.println();

    for (size_t i = 0; i < data.blobData().size(); i++)
    {
      if (i > 0 && i % 16 == 0)
        Serial.println();

      if (i < 16)
        Serial.print("0");

      Serial.print(data.blobData()[i], HEX);
      Serial.print(" ");
    }
    Serial.println();
  }
  else if (data.dataType() == "file")
  {

    Serial.println();

    File file = data.fileStream();
    int i = 0;

    while (file.available())
    {
      if (i > 0 && i % 16 == 0)
        Serial.println();

      int v = file.read();

      if (v < 16)
        Serial.print("0");

      Serial.print(v, HEX);
      Serial.print(" ");
      i++;
    }
    Serial.println();
    file.close();
  }
}

Po uruchomieniu program wypisze w monitorze portu szeregowego aktualny stan gałęzi led/led1 i będzie czekać aż dokonamy zmian tej gałęzi w bazie. Za każdym razem, gdy dokonamy zmiany zostanie wypisany aktualny stan gałęzi.

^{Widok monitora portu szeregowego po uruchomieniu programu i po zmianie wartość led1 z true na false.}

OBSŁUGA FIRESTORE

Teraz zajmiemy się obsługą Firestore. Analogicznie do RTDB funkcje dotyczące Firestore wywołujemy w postaci Firebase.Firestore.nazwa_funkcji() .

ODCZYT DANYCH

W przeciwieństwie do RTDB nie mamy oddzielnej funkcji dla każdego rodzaju danych. Do pobierania danych z Firestore używamy tylko funkcji getDocument().

W ogólności funkcja ta wygląda następująco:

getDocument(FirebaseData *fbdo, “id_projektu”, “id_bazy_danych”, “ścieżka”, “maska”);

id_bazy_danych to najczęściej “” lub (default), więc my będziemy używać postaci:

getDocument(&fbdo, “id_projektu”, "", “ścieżka”, “maska”)

“maska” wskazuje, które elementy ze ścieżki mają być zwrócone. Pozwala to na pewnego rodzaju filtrowanie danych. Pominięcie tego argumentu zwróci całą zawartość ze ścieżki.

Pozyskane dane możemy odczytać przy pomocy fbdo.payload(). Funkcja ta zwraca nam tekst (string), który wyglądem przypomina drzewo JSON.

^{Przykład odczytania z bazy zawierającej w kolekcji “pomiary” dokumenty o id “czujnik2” i “czujnik3” (tak jak uzupełniliśmy na początku tej części). Ścieżka “pomiary”, brak maski.}

^{Przykład odczytu z tej samej bazy, ale ze ścieżką “pomiary/czujnik2”, brak maski.}

^{Przykład odczytu z tej samej bazy, ale ze ścieżką “pomiary” i maską “wilgotnosc”.}

Aby dostać się do konkretnej wartości możemy zamienić ten string na obiekt FirebaseJson. Służy do tego funkcja setJsonData(string).

FirebaseJson json;
json.setJsonData(fbdo.payload());

Następnie możemy pozyskać dane z gałęzi, która nas interesuje za pomocą funkcji get().

Teraz spróbujemy odczytać temperaturę odczytaną przez czujnik2 ze stworzonej przez nas bazy. Interesuje nas kolekcja pomiary i dokument czujnik2, więc jako ścieżkę ustawiamy "pomiary/czujnik2". Chcemy pobrać jedynie temperaturę (bez wilgotności), więc ustawiamy maskę “temperatura”.

Firebase.Firestore.getDocument(&fbdo, FIREBASE_PROJECT_ID, "", "pomiary/czujnik2", "temperatura")

Po wywołaniu funkcji możemy podejrzeć pobrane z bazy dane w monitorze portu szeregowego poleceniem:

Serial.println(fbdo.payload());

^{Widok monitora portu szeregowego.}

Aby uzyskać samą wartość temperatury musimy najpierw zamienić to co otrzymaliśmy na obiekt FirebaseJson.

FirebaseJson json;

json.setJsonData(fbdo.payload());

Następnie zapisujemy wartość temperatury do FirebaseJsonData za pomocą funkcji get(). Z wyświetlonego w monitorze portu szeregowego schematu naszego obiektu JSON możemy odczytać, że ścieżką do naszej wartości temperatury będzie "fields/temperatura/doubleValue".

FirebaseJsonData jsonData;

json.get(jsonData, "fields/temperatura/doubleValue");

^{Ścieżka do wartości temperatury.}

Wartość temperatury jest zapisana jako typ double, więc aby ją uzyskać odczytujemy parametr:

jsonData.doubleValue

Cały kod wygląda następująco:

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

/* 1. Define the WiFi credentials */
#define WIFI_SSID "xxxx"
#define WIFI_PASSWORD "xxxx"

/* 2. Define the Firebase project host name and API Key */
#define FIREBASE_HOST "https://ADRES.firebaseio.com"
#define API_KEY "API_KEY"
#define FIREBASE_PROJECT_ID "PROJECT_ID"


/* 3. Define the user Email and password that alreadey registerd or added in your project */
#define USER_EMAIL "[email protected]"
#define USER_PASSWORD "123456"

//Define Firebase Data object
FirebaseData fbdo;

FirebaseAuth auth;
FirebaseConfig config;

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

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)
  {
      Serial.print(".");
      delay(300);
  }
  Serial.println();

  /* Assign the project host and api key (required) */
  config.host = FIREBASE_HOST;
  config.api_key = API_KEY;

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

  Firebase.begin(&config, &auth);
  Firebase.reconnectWiFi(true);
 
  
  if (Firebase.Firestore.getDocument(&fbdo, FIREBASE_PROJECT_ID, "", "pomiary/czujnik2", "temperatura"))
  {
      Serial.println("WIDOK W POSTACI JSON");
      Serial.println("------------------------------------");
      Serial.println(fbdo.payload());
      Serial.println("------------------------------------");
      
      FirebaseJson json;
      json.setJsonData(fbdo.payload());
  
      FirebaseJsonData jsonData;
      json.get(jsonData, "fields/temperatura/doubleValue");
  
      Serial.print("Wartosc temperatury: ");
      Serial.println(jsonData.doubleValue);
  }
  else
  {
      Serial.println("FAILED");
      Serial.println("REASON: " + fbdo.errorReason());
      Serial.println("------------------------------------");
      Serial.println();
  }
}

void loop()
{
}

^{Wynik w monitorze portu szeregowego.}

ZAPIS DANYCH

Do zapisu możemy użyć funkcji createDocument() (do tworzenia) oraz patchDocument() (do edytowania). Funkcje te analogicznie do poprzednich zwracają true lub false.

createDocument(FirebaseData *fbdo, “id_projektu”, “id_bazy_danych”, “ścieżka”, “wartosc”);

patchDocument(FirebaseData *fbdo, “id_projektu”, “id_bazy_danych”, “ścieżka”, “wartosc”, “pola_do_zmodyfikowania”);

Do tych funkcji wartość musimy podać w takiej postaci, w jakiej przed chwilą odczytywaliśmy funkcją getDocument(), to znaczy napis (string) w postaci drzewa JSON.

Załóżmy, że chcemy prowadzić historię pomiarów. Dane będziemy przechowywać w kolekcji historia w oddzielnym dokumencie dla każdego pomiaru (nazwanym pomiar_nr). Do każdego dokumentu będziemy zapisywać temperaturę i wilgotność. Pomiary będziemy robić co 10 sekund.

^{Oczekiwany rezultat.}

Na początku tworzymy zawartość dokumentu i zapisujemy ją do zmiennej typu String:

String content;
FirebaseJson js;

js.set("fields/temperatura/doubleValue", String(random(10000)/100.00).c_str()); // tempertura to losowa liczba niecałkowita 0.00 - 99.99
js.set("fields/wilgotnosc/integerValue", String(random(100)).c_str()); // wilgotność to losowa liczba całkowita 0-99
js.toString(content);

Teraz tworzymy ścieżkę do dokumentu. Składa się ona z nazwy kolekcji i id dokumentu:

String documentPath = "historia/pomiar_" + String(numer);

gdzie numer to zmienna, po której iterujemy pętlę wykonującą się co 10 sekund. Oto jak będzie wyglądać nasze wysyłanie funkcji createDocument:

Firebase.Firestore.createDocument(&fbdo, FIREBASE_PROJECT_ID, "", documentPath.c_str(), content.c_str())

Cały kod wygląda następująco:

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


#define WIFI_SSID "xxxx"
#define WIFI_PASSWORD "xxxx"


#define FIREBASE_HOST "https://ADRES.firebaseio.com"
#define API_KEY "API_KEY"
#define FIREBASE_PROJECT_ID "PROJECT_ID"


#define USER_EMAIL "[email protected]"
#define USER_PASSWORD "123456"


FirebaseData fbdo;

FirebaseAuth auth;
FirebaseConfig config;

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

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)
  {
      Serial.print(".");
      delay(300);
  }
  Serial.println();

  config.host = FIREBASE_HOST;
  config.api_key = API_KEY;

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

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

unsigned long dataMillis = 0;
int numer = 0;

void loop()
{

    if (millis() - dataMillis > 10000 || dataMillis == 0)
    {
        dataMillis = millis();

        String content;
        FirebaseJson js;

        String documentPath = "historia/pomiar_" + String(numer);

        js.set("fields/temperatura/doubleValue", String(random(10000)/100.00).c_str());
        js.set("fields/wilgotnosc/integerValue", String(random(100)).c_str());
        js.toString(content);

        numer++;

        Serial.println("------------------------------------");
        Serial.println("Create a document...");

        if (Firebase.Firestore.createDocument(&fbdo, FIREBASE_PROJECT_ID, "", documentPath.c_str(), content.c_str()))
        {
            Serial.println("SUKCES");
        }
        else
        {
            Serial.println("BLAD: " + fbdo.errorReason());
        }
    }
}

Po uruchomieniu programu nasz baza Firestore zacznie się zapełniać kolejnymi pomiarami co 10 sekund: pomiar_0, pomiar_1, pomiar_2…, a w monitorze portu szeregowego zobaczymy komunikat o sukcesie.

^{Widok monitora portu szeregowego - sukces!}

Jednak jeżeli uruchomimy program ponownie to dostaniemy błąd!

^{W monitorze portu szeregowego wyskakuje błąd}

Dzieje się tak dlatego, że funkcja createDocument() służy tylko do tworzenia dokumentów, które jeszcze nie istnieją. Ponowna próba stworzenia dokumentu pomiar_0 powoduje błąd. Jeżeli chcemy edytować już istniejący dokument musimy użyć funkcji patchDocument().

W naszym kodzie musimy zmienić tylko linijkę z getDocument() na:

Firebase.Firestore.patchDocument(&fbdo, FIREBASE_PROJECT_ID, "", documentPath.c_str(), content.c_str(),"temperatura,wilgotnosc")

W miejscu “pola_do_zmodyfikownia” wpisujemy "temperatura,wilgotnosc" (bez spacji!), ponieważ chcemy zaktualizować w bazie temperaturę oraz wilgotność. Jeżeli wpisalibyśmy tylko jeden z tych parametrów (np. “temperatura”) to wartość pozostałych parametrów (wilgotność) nie uległaby zmianie.

Gdy używamy patch, a podany dokument nie istnieje to zostanie on utworzony (tak jak byśmy użyli create).

USUWANIE DOKUMENTÓW

Do usuwania dokumentów służy funkcja deleteDocument().

PODSUMOWANIE

W tej części nauczyliśmy się zapisywać i odczytywać dane z RTDB i z Firestore za pomocą ESP8266 i ESP32. Dowiedzieliśmy się także jak operować na obiektach JSON w Arduino IDE. Przedstawiona biblioteka daje jeszcze wiele możliwości, których nie omówiliśmy. Polecam zapoznać się z dokumentacją biblioteki, gdzie są one dokładnie opisane. W dokumentacji Firebase znajduje się także opis działania Firebase z innymi językami programowania oraz dostęp poprzez API.

W kolejnej części dowiemy się więcej o prezentowaniu zawartości naszej bazy użytkownikowi.

Ten artykuł jest częścią serii "Firebase w zastosowaniach IoT"

#1 - Czym jest Firebase? Jak zacząć?
#2 - Firebase z ESP32 i ESP8266 (właśnie to czytasz)

Treker · Marzec 2, 2021

@Karrol dzięki za kolejny ciekawy artykuł! Wpis został już zatwierdzony, więc od teraz jest widoczny publicznie

Mecinios · Sierpień 10, 2021

Cześć @Karrol, fajny artykuł tylko url mojej bazy danych to nie fierbaseio.com tylko firebasedatabase.app . Czy to ma jakieś znaczenie?

Edytowano Sierpień 10, 2021 przez Mecinios

Karrol · Sierpień 12, 2021

Dnia 10.08.2021 o 15:01, Mecinios napisał:

Cześć @Karrol, fajny artykuł tylko url mojej bazy danych to nie fierbaseio.com tylko firebasedatabase.app . Czy to ma jakieś znaczenie?

Cześć @Mecinios , adres bazy zależy od jej lokalizacji (zobacz tutaj). Myślę, że raczej nie powinno mieć to znaczenia. Jeśli coś nie działa to możliwe, że autor biblioteki tego nie przewidział (nie próbowałem, więc nie wiem czy tak jest) - wtedy możesz spróbować stworzyć nowy projekt z bazą w innej lokalizacji.

Firebase Firebase w zastosowaniach IoT - #2 - Firebase z ESP32 i ESP8266

Pomocna odpowiedź

Karrol

Treker (Damian Szymański)

Mecinios

Karrol

Bądź aktywny - zaloguj się lub utwórz konto!

Utwórz konto w ~20 sekund!

Zaloguj się

Quizy

Najnowsze posty w innych tematach

Przetwornica 12-230 V. Ogólne uwagi co do poprawności schematu 1 2 3 4 11

Sztuczne obciazenie DIY 1 2 3 4 6

Kurs Arduino - #8 - Sterowanie silnikami DC, pętla for 1 2 3 4 19

protokol onewire...kto slucha, kto nadaje? 1 2 3

Kurs STM32L4 – #18 – podsumowanie kursu, quiz 1 2

Inne