Firebase Authentication Failure When Using Bluetooth Initialization.

[avinashboy]

I'm working on a project that uses two packages: firebaseClient and bluetooth. The issue is that after initializing both packages, the Firebase authentication fails repeatedly. However, if I comment out the initialization of the Bluetooth serial setup, Firebase works fine. How can I resolve this issue?

[avinashboy]

#include <WiFi.h>
#include <Preferences.h>
#include <FirebaseClient.h>
#include <WiFiClientSecure.h>
#include "BluetoothSerial.h"

String device_name = "ESP32-BT-Slave";

// Pin Definitions
#define RELAY_PIN 22

// Firebase Realtime Database Variables
Preferences preferences;
DefaultNetwork network;
FirebaseApp app;
WiFiClientSecure ssl_client1, ssl_client2;
RealtimeDatabase Database;

using AsyncClient = AsyncClientClass;
AsyncClient aClient(ssl_client1, getNetwork(network)), aClient2(ssl_client2, getNetwork(network));

String wifiSSID, wifiPassword, webKey, userEmail, userPassword, databaseURL;

bool isRelayOn = false;
bool taskComplete = false;
bool initialStreamEventIgnored = false;
char lastHash[32] = { 0 };

BluetoothSerial SerialBT;

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, HIGH);
  SerialBT.begin(device_name); //comment out this
  preferences.begin("user_prefs", false);
  loadPreferences();
}

// Load Configuration from Preferences
void loadPreferences() {
  if (preferences.isKey("wifiSSID")) {
    wifiSSID = preferences.getString("wifiSSID");
    wifiPassword = preferences.getString("wifiPassword");
    webKey = preferences.getString("webKey");
    userEmail = preferences.getString("userEmail");
    userPassword = preferences.getString("userPassword");
    databaseURL = preferences.getString("databaseURL");
    Serial.println("loaded preferences data.");
  } else {
    // Set default values if preferences are not set
    // wifiSSID = "YourWiFiSSID";
    // wifiPassword = "YourWiFiPassword";
    // webKey = "YourFirebaseWebKey";
    // userEmail = "YourEmail@example.com";
    // userPassword = "YourPassword";
    // databaseURL = "YourFirebaseDatabaseURL";

    // Save them for future use
    // preferences.putString("wifiSSID", wifiSSID);
    // preferences.putString("wifiPassword", wifiPassword);
    // preferences.putString("webKey", webKey);
    // preferences.putString("userEmail", userEmail);
    // preferences.putString("userPassword", userPassword);
    // preferences.putString("databaseURL", databaseURL);

    Serial.println("Default preferences saved.");
  }

  connectWiFi();
}

void connectWiFi() {
  Serial.println("Connecting to Wi-Fi...");
  WiFi.begin(wifiSSID.c_str(), wifiPassword.c_str());

  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(300);
  }

  Serial.println("\nConnected to Wi-Fi");
  Serial.print("IP Address: ");
  Serial.println(WiFi.localIP());

  connectFirebase();
}

void connectFirebase() {
  UserAuth user_auth(webKey, userEmail, userPassword);
  Firebase.printf("Firebase Client v%s\n", FIREBASE_CLIENT_VERSION);

  ssl_client1.setInsecure();
  ssl_client2.setInsecure();

  initializeApp(aClient2, app, getAuth(user_auth), asyncCB, "authTask");
  app.getApp<RealtimeDatabase>(Database);
  Database.url(databaseURL);
  Database.setSSEFilters("get,put,patch,keep-alive,cancel,auth_revoked");
}

void loop() {
  app.loop();
  app.ttl();
  Database.loop();
  ensureRelayOff();

  if (app.ready() && !taskComplete) {
    taskComplete = true;

    String userUID = app.getUid();
    if (!userUID.isEmpty()) {
      Serial.printf("User authenticated with UID: %s\n", userUID.c_str());
      startListeningToAlert(userUID);
    } else {
      Serial.println("Failed to retrieve UID. Ensure authentication is successful.");
    }
  }

  // if (Serial.available()) {
  //   SerialBT.write(Serial.read());
  // }
  // if (SerialBT.available()) {
  //   Serial.write(SerialBT.read());
  // }
}

void startListeningToAlert(String uid) {
  String alertPath = "internalsosalert/" + uid + "/alert";
  Serial.printf("Listening for alerts at path: %s\n", alertPath.c_str());

  Database.get(aClient, alertPath, asyncCB, true, "streamTask");
}

void asyncCB(AsyncResult &aResult) {
  printResult(aResult);
}

void printResult(AsyncResult &aResult) {
  if (aResult.isEvent()) {
    Serial.printf("Event: %s, Msg: %s, Code: %d\n", aResult.uid().c_str(), aResult.appEvent().message().c_str(), aResult.appEvent().code());
  } else if (aResult.isError()) {
    Serial.printf("Error: %s, Msg: %s, Code: %d\n", aResult.uid().c_str(), aResult.error().message().c_str(), aResult.error().code());
  } else if (aResult.available()) {
    RealtimeDatabaseResult &RTDB = aResult.to<RealtimeDatabaseResult>();
    if (RTDB.isStream()) {
      String currentData = String(RTDB.to<const char *>());
      char currentHash[32];
      calculateSimpleHash(currentData.c_str(), currentHash);

      if (strcmp(lastHash, currentHash) != 0) {
        strncpy(lastHash, currentHash, sizeof(lastHash));
        if (!initialStreamEventIgnored) {
          triggerRelay(2000);
          initialStreamEventIgnored = true;
        } else {
          triggerRelay(10000);
        }
      }
    }
  }
}

void triggerRelay(int duration) {
  Serial.printf("Relay triggered for %d ms\n", duration);
  digitalWrite(RELAY_PIN, LOW);
  delay(duration);
  digitalWrite(RELAY_PIN, HIGH);
}

void ensureRelayOff() {
  if (isRelayOn) {
    digitalWrite(RELAY_PIN, HIGH);
    isRelayOn = false;
    Serial.println("Relay was forcefully turned off.");
  }
}

void calculateSimpleHash(const char *data, char *hash) {
  uint8_t xorSum = 0;
  while (*data) {
    xorSum ^= *data++;
  }
  snprintf(hash, 32, "%02X", xorSum);
}

[avinashboy]

USING ESP32 board

BEFORE comment out

18:37:10.792 -> Connected to Wi-Fi
18:37:10.792 -> IP Address: 192.168.1.106
18:37:10.792 -> Firebase Client v1.4.10
18:37:10.792 -> Event: authTask, Msg: authenticating, Code: 7
18:37:10.792 -> Event: authTask, Msg: auth request sent, Code: 8
18:37:12.045 -> Event: authTask, Msg: auth response received, Code: 9
18:37:12.045 -> Event: authTask, Msg: ready, Code: 10
18:37:12.045 -> User authenticated with UID: 44A0kS18L2eyDWnPuG9hmq4tHSW2
18:37:12.045 -> Listening for alerts at path: internalsosalert/44A0kS18L2eyDWnPuG9hmq4tHSW2/alert
18:37:17.663 -> Relay triggered for 2000 ms

AFTER comment out

18:29:30.397 -> Connected to Wi-Fi
18:29:30.397 -> IP Address: 192.168.1.106
18:29:30.435 -> Firebase Client v1.4.10
18:29:30.435 -> Event: authTask, Msg: authenticating, Code: 7
18:29:30.435 -> Event: authTask, Msg: auth request sent, Code: 8
18:30:00.026 -> Event: authTask, Msg: error, Code: -1
18:30:04.992 -> Event: authTask, Msg: authenticating, Code: 7
18:30:04.992 -> Event: authTask, Msg: auth request sent, Code: 8
18:30:34.955 -> Event: authTask, Msg: error, Code: -1
18:30:40.012 -> Event: authTask, Msg: authenticating, Code: 7
18:30:40.012 -> Event: authTask, Msg: auth request sent, Code: 8
18:31:10.033 -> Event: authTask, Msg: error, Code: -1
18:31:14.951 -> Event: authTask, Msg: authenticating, Code: 7
18:31:14.987 -> Event: authTask, Msg: auth request sent, Code: 8
18:31:44.947 -> Event: authTask, Msg: error, Code: -1
18:31:50.013 -> Event: authTask, Msg: authenticating, Code: 7
18:31:50.013 -> Event: authTask, Msg: auth request sent, Code: 8
18:32:20.012 -> Event: authTask, Msg: error, Code: -1

[mobizt]

You should debug the WiFiClientSecure which defined on your side why it fails.

FYI.
You cannot use WiFi while using Bluetooth and vice versa because they share the same radio antenna.

[avinashboy]

Thank you for the information. Could you provide more details on debugging WIFIClientSecure? Also, is there a recommended approach to handle both WiFi and Bluetooth without conflicts?

[mobizt]

https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/coexist.html

You cannot use both WiFi and Bluetooth simultaneously in Arduino IDE based on ESP32 Arduino Core, but it is possible in ESP-IDF platform.

For debug the WIFIClientSecure and other ESP32 Arduino Core libraries, you can set the Core Debug Level in Arduino IDE's Tools menu.

As I told you that the WiFi will not work and WIFIClientSecure will not work too.

[avinashboy]

Thank you so much