Pushing value 0

[nishaz19]

I previously used FirebaseESP32.h but I'm trying to use the new FirebaseClient. I'm trying to push value into realtime data base and I want it to continuously update the value. I managed to get it working with the old library from following video tutorial but not with the new library on my own.

I'm facing the problem where its not pushing any value. Is it because of this? Originally it uses int " Database.push(aClient, "/test/int", 12345, asyncCB);" but I change it to double "Database.push(aClient, "/DHT11/Temperature", tempVal, asyncCB);" Can you help me find where is the problem? Thank you.

/**
 * SYNTAX:
 *
 * RealtimeDatabase::push<T>(<AsyncClient>, <path>, <value>, <AsyncResult>);
 * RealtimeDatabase::push<T>(<AsyncClient>, <path>, <value>, <AsyncResultCallback>, <uid>);
 *
 * T - The type of value to push.
 * <AsyncClient> - The async client.
 * <path> - The node path to push the value.
 * <value> - The value to push.
 * <AsyncResult>  - The async result (AsyncResult).
 * <AsyncResultCallback> - The async result callback (AsyncResultCallback).
 * <uid> - The user specified UID of async result (optional).
 *
 * The complete usage guidelines, please visit https://github.com/mobizt/FirebaseClient
 */

#include <Arduino.h>
#if defined(ESP32) || defined(ARDUINO_RASPBERRY_PI_PICO_W) || defined(ARDUINO_GIGA)
#include <WiFi.h>
#elif defined(ESP8266)
#include <ESP8266WiFi.h>
#elif __has_include(<WiFiNINA.h>) || defined(ARDUINO_NANO_RP2040_CONNECT)
#include <WiFiNINA.h>
#elif __has_include(<WiFi101.h>)
#include <WiFi101.h>
#elif __has_include(<WiFiS3.h>) || defined(ARDUINO_UNOWIFIR4)
#include <WiFiS3.h>
#elif __has_include(<WiFiC3.h>) || defined(ARDUINO_PORTENTA_C33)
#include <WiFiC3.h>
#elif __has_include(<WiFi.h>)
#include <WiFi.h>
#endif

#include <FirebaseClient.h>

// Infrared Temp
#include <Wire.h>
#include <Adafruit_MLX90614.h>

// DHT
#include "DHTesp.h" // Click here to get the library: http://librarymanager/All#DHTesp
#include <Ticker.h>


#define WIFI_SSID "////"
#define WIFI_PASSWORD "/////"

// The API key can be obtained from Firebase console > Project Overview > Project settings.
#define API_KEY "////"

// User Email and password that already registerd or added in your project.
#define USER_EMAIL "/////"
#define USER_PASSWORD "/////"
#define DATABASE_URL "////"

float X_out, Y_out, Z_out; // ADXL
double tempVal, humidVal; // DHT11
double tempIR; // IRTemp
// Humidity
DHTesp dht;

/** Task handle for the light value read task */
TaskHandle_t tempTaskHandle = NULL;
/** Ticker for temperature reading */
Ticker tempTicker;
/** Comfort profile */
ComfortState cf;
/** Flag if task should run */
bool tasksEnabled = false;
/** Pin number for DHT11 data pin */
int dhtPin = 27;
//ADXL
int ADXL345 = 0x53;

// Velocity Encoder
int hits = 0;
float wheel_radius = 1;
volatile unsigned int current_time;
long time_interval = 1000; //how often do you want to know velocity (milliseconds)
float velocity; //this is the velocity in length units / time_interval

// Infrared Temp
Adafruit_MLX90614 mlx = Adafruit_MLX90614();


void tempTask(void *pvParameters);
bool getTemperature();
void triggerGetTemp();

void asyncCB(AsyncResult &aResult);

DefaultNetwork network; // initilize with boolean parameter to enable/disable network reconnection

UserAuth user_auth(API_KEY, USER_EMAIL, USER_PASSWORD);

FirebaseApp app;

#if defined(ESP32) || defined(ESP8266) || defined(ARDUINO_RASPBERRY_PI_PICO_W)
#include <WiFiClientSecure.h>
WiFiClientSecure ssl_client;
#elif defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_UNOWIFIR4) || defined(ARDUINO_GIGA) || defined(ARDUINO_PORTENTA_C33) || defined(ARDUINO_NANO_RP2040_CONNECT)
#include <WiFiSSLClient.h>
WiFiSSLClient ssl_client;
#endif

// In case the keyword AsyncClient using in this example was ambigous and used by other library, you can change
// it with other name with keyword "using" or use the class name AsyncClientClass directly.

using AsyncClient = AsyncClientClass;

AsyncClient aClient(ssl_client, getNetwork(network));

RealtimeDatabase Database;


bool initTemp() {
  byte resultValue = 0;
  // Initialize temperature sensor
	dht.setup(dhtPin, DHTesp::DHT11);
	Serial.println("DHT initiated");

  // Start task to get temperature
	xTaskCreatePinnedToCore(
			tempTask,                       /* Function to implement the task */
			"tempTask ",                    /* Name of the task */
			4000,                           /* Stack size in words */
			NULL,                           /* Task input parameter */
			5,                              /* Priority of the task */
			&tempTaskHandle,                /* Task handle. */
			1);                             /* Core where the task should run */

  if (tempTaskHandle == NULL) {
    Serial.println("Failed to start task for temperature update");
    return false;
  } else {
    // Start update of environment data every 20 seconds
    tempTicker.attach(20, triggerGetTemp);
  }
  return true;
}

void triggerGetTemp() {
  if (tempTaskHandle != NULL) {
	   xTaskResumeFromISR(tempTaskHandle);
  }
}

void tempTask(void *pvParameters) {
	Serial.println("tempTask loop started");
	while (1) // tempTask loop
  {
    if (tasksEnabled) {
      // Get temperature values
			getTemperature();
		}
    // Got sleep again
		vTaskSuspend(NULL);
	}
}

bool getTemperature() {
	// Reading temperature for humidity takes about 250 milliseconds!
	// Sensor readings may also be up to 2 seconds 'old' (it's a very slow sensor)
  TempAndHumidity newValues = dht.getTempAndHumidity();
	// Check if any reads failed and exit early (to try again).
	if (dht.getStatus() != 0) {
		Serial.println("DHT11 error status: " + String(dht.getStatusString()));
		return false;
	}

	float heatIndex = dht.computeHeatIndex(newValues.temperature, newValues.humidity);
  float dewPoint = dht.computeDewPoint(newValues.temperature, newValues.humidity);
  String tempVal_String = String(newValues.temperature);
  String humidVal_String = String(newValues.humidity);
  tempVal = tempVal_String.toDouble();
  humidVal = humidVal_String.toDouble();

  //Serial.println(" T:" + tempVal_String + " H:" + humidVal_String + " I:" + String(heatIndex) + " D:" + String(dewPoint));
	return true;
}


void setup()
{

    Serial.begin(115200);
    initTemp();
    // Velocity
    attachInterrupt(16, counthits, CHANGE);
    current_time = millis();
    // Infrared Temp
    //Serial.println("Adafruit MLX90614 test");  
    mlx.begin();
    //ADXL
  Wire.begin();
  Wire.beginTransmission(ADXL345);
  Wire.write(0x2D);
  Wire.write(8);
  Wire.endTransmission();
  delay(10);
  // Off-set Calibration
  // X-axis
  Wire.beginTransmission(ADXL345);
  Wire.write(0x1E);
  Wire.write(62);
  Wire.endTransmission();
  delay(10);
  // Y-axis
  Wire.beginTransmission(ADXL345);
  Wire.write(0x1F);
  Wire.write(16445);
  Wire.endTransmission();
  delay(10);
  // Z-axis
  Wire.beginTransmission(ADXL345);
  Wire.write(0x20);
  Wire.write(-16);
  Wire.endTransmission();
  delay(10);

    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

    Serial.print("Connecting to Wi-Fi");
    unsigned long ms = millis();
    while (WiFi.status() != WL_CONNECTED)
    {
        Serial.print(".");
        delay(300);
    }
    Serial.println();
    Serial.print("Connected with IP: ");
    Serial.println(WiFi.localIP());
    Serial.println();

    Firebase.printf("Firebase Client v%s\n", FIREBASE_CLIENT_VERSION);

    Serial.println("Initializing app...");

#if defined(ESP32) || defined(ESP8266) || defined(PICO_RP2040)
    ssl_client.setInsecure();
#if defined(ESP8266)
    ssl_client.setBufferSizes(4096, 1024);
#endif
#endif

    app.setCallback(asyncCB);

    initializeApp(aClient, app, getAuth(user_auth));

    // Waits for app to be authenticated.
    // For asynchronous operation, this blocking wait can be ignored by calling app.loop() in loop().
    ms = millis();
    while (app.isInitialized() && !app.ready() && millis() - ms < 120 * 1000)
        ;

    app.getApp<RealtimeDatabase>(Database);

    Database.url(DATABASE_URL);

    Serial.println("Asynchronous Push... ");

    // Push int
    Database.push<double>(aClient, "/DHT11/Temperature", tempVal, asyncCB);

    // Push int
    Database.push<double>(aClient, "/DHT11/Humidity", humidVal, asyncCB);

    // Push int
    Database.push<double>(aClient, "/IR/TemperatureIR", tempIR, asyncCB);

    // Push int
    Database.push<float>(aClient, "/ADXL/X-axis", X_out, asyncCB);

    // Push int
    Database.push<float>(aClient, "/ADXL/Y-axis", Y_out, asyncCB);

    // Push int
    Database.push<float>(aClient, "/ADXL/Z-axis", Z_out, asyncCB);

    /*object_t obj1, obj2, obj3, obj4, obj5, obj6;
    JsonWriter writer;


    writer.create(obj1, "float/value", number_t(tempVal, 2));
    Database.push<number_t>(aClient, "/DHT11/Temperature", number_t(tempVal, 2), asyncCB);

    writer.create(obj2, "float/value", number_t(humidVal, 2));
    Database.push<number_t>(aClient, "/DHT11/Humidity", number_t(humidVal, 2), asyncCB);

    writer.create(obj3, "float/value", number_t(tempIR, 2));
    Database.push<number_t>(aClient, "/IR/TemperatureIR", number_t(tempIR, 2), asyncCB);

    writer.create(obj4, "float/value", number_t(X_out, 4));
    Database.push<number_t>(aClient, "/ADXL/X-axis", number_t(X_out, 4), asyncCB);

    writer.create(obj5, "float/value", number_t(Y_out, 4));
    Database.push<number_t>(aClient, "/ADXL/Y-axis", number_t(Y_out, 4), asyncCB);

    writer.create(obj6, "float/value", number_t(Z_out, 4));
    Database.push<number_t>(aClient, "/ADXL/Z-axis", number_t(Z_out, 4), asyncCB);
    // Push bool
    Database.push<bool>(aClient, "/test/bool", true, asyncCB);

    // Push string
    Database.push<String>(aClient, "/test/string", "hello", asyncCB);

    // Push json
    Database.push<object_t>(aClient, "/test/json", object_t("{\"data\":123}"), asyncCB);

    // Push float
    Database.push<number_t>(aClient, "/test/float", number_t(123.456, 2), asyncCB);

    // Push double
    Database.push<number_t>(aClient, "/test/double", number_t(1234.56789, 4), asyncCB);*/
    
    // Library does not provide JSON parser library, the following JSON writer class will be used with
    // object_t for simple demonstration.
    /*
    object_t json, obj1, obj2, obj3, obj4;
    JsonWriter writer;

    writer.create(obj1, "int/value", 9999);
    writer.create(obj2, "string/value", string_t("hello"));
    writer.create(obj3, "float/value", number_t(123.456, 2));
    writer.join(obj4, 3 /* no. of object_t (s) to join *//*, obj1, obj2, obj3);
    writer.create(json, "node/list", obj4);

    // To print object_t
    // Serial.println(json);

    Database.push<object_t>(aClient, "/test/json", json, asyncCB);

    object_t arr;
    arr.initArray(); // initialize to be used as array
    writer.join(arr, 4 /* no. of object_t (s) to join *//*, object_t("[12,34]"), object_t("[56,78]"), object_t(string_t("steve")), object_t(888));

    // Note that value that sets to object_t other than JSON ({}) and Array ([]) can be valid only if it
    // used as array member value as above i.e. object_t(string_t("steve")) and object_t(888).

    // Push array
    Database.push<object_t>(aClient, "/test/arr", arr, asyncCB);

    // Push float
    Database.push<number_t>(aClient, "/test/float", number_t(123.456, 2), asyncCB);

    // Push double
    Database.push<number_t>(aClient, "/test/double", number_t(1234.56789, 4), asyncCB);*/

    // To assign UID for async result
    // Database.push<number_t>(aClient, "/test/double", number_t(1234.56789, 4), asyncCB, "myUID");
}

void loop()
{
    if (!tasksEnabled) {
    // Wait 2 seconds to let system settle down
    //delay(10);
    // Enable task that will read values from the DHT sensor
    tasksEnabled = true;
    if (tempTaskHandle != NULL) {
			vTaskResume(tempTaskHandle);
		}
  }
  
  //ADXL
  Wire.beginTransmission(ADXL345);
  Wire.write(0x32);
  Wire.endTransmission(false);
  Wire.requestFrom(ADXL345, 6, true);
  X_out = (Wire.read() | Wire.read() << 8);
  X_out = X_out/256;
  Y_out = (Wire.read() | Wire.read() << 8);
  Y_out = Y_out/256;
  Z_out = (Wire.read() | Wire.read() << 8);
  Z_out = Z_out/256;

  //Velocity 
  if ( millis() >= current_time + time_interval){
  velocity = (hits*(wheel_radius * 392.7))/time_interval;//the constant is 2*pi*1000/16
  Serial.println(velocity);
  hits = 0;
  current_time = millis();
  }

  //Infrared Temp
  Serial.print("Ambient = "); Serial.print(mlx.readAmbientTempC()); 
  Serial.print("*C\tObject = "); Serial.print(mlx.readObjectTempC()); Serial.println("*C");
  Serial.print("Ambient = "); Serial.print(mlx.readAmbientTempF()); 
  Serial.print("*F\tObject = "); Serial.print(mlx.readObjectTempF()); Serial.println("*F");

  String tempIR_String = String(mlx.readObjectTempC());
  tempIR = tempIR_String.toDouble();

    // This function is required for handling async operations and maintaining the authentication tasks.
    app.loop();

    // This required when different AsyncClients than used in FirebaseApp assigned to the Realtime database functions.
    Database.loop();
}

void counthits()
{
 hits++;
}

void asyncCB(AsyncResult &aResult)
{
    if (aResult.appEvent().code() > 0)
    {
        Firebase.printf("Event task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.appEvent().message().c_str(), aResult.appEvent().code());
    }

    if (aResult.isDebug())
    {
        Firebase.printf("Debug task: %s, msg: %s\n", aResult.uid().c_str(), aResult.debug().c_str());
    }

    if (aResult.isError())
    {
        Firebase.printf("Error task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.error().message().c_str(), aResult.error().code());
    }

    if (aResult.available())
    {
        Firebase.printf("task: %s\n", aResult.uid().c_str());
        if (aResult.to<RealtimeDatabaseResult>().name().length())
            Firebase.printf("name: %s\n", aResult.uid().c_str(), aResult.to<RealtimeDatabaseResult>().name().c_str());
        Firebase.printf("payload: %s\n", aResult.c_str());
    }
}

[mobizt]

It's your device WiFi problem.

https://github.com/mobizt/FirebaseClient/blob/main/FAQ.md

I can't go in deep of your third-party lib but I'm pretty sure that it breaks the WiFi.

[mobizt]

#52 (reply in thread)

[nishaz19]

This method works for me, I had to place Database.update in the void loop() since my data have to go through void loop before it can be send to firebase as those value are from sensors where it update very frequently.

But my problem right now is it updates all those value for a few sec before stopping. I want it to update continuously.

This is the error that I get:

Thank you for your help

[mobizt]

The queue is full.

You should read the library documentation thoroughly.

[mobizt]

You are using Firebase in the wrong way that causes the quota bandwidth limit.

[mobizt]

The app.loop() and Database.loop() should run in the main loop function.