Firebase_ESP_Client firebase upload error

[chamikasahan]

Hi, im using below code to upload my recorded raw file to firebase storage. but it show

this error. Im using Firebase_ESP_Client library.
Recording complete. File saved: /guardianRecord1.raw, Size: 655360 bytes Recording complete File size to upload: 655360 bytes Uploading file: /guardianRecord1.raw to Firebase path: /audio/guardianRecord1.raw Failed to upload file, HTTP code: -1000 Error reason: [218363][D][NetworkManager.cpp:123] hostByName(): DNS found IPv4 35.201.97.85 [218370][V][WiFiClientImpl.h:317] tcpConnect(): Starting socket [223087][D][NetworkManager.cpp:123] hostByName(): DNS found IPv4 35.201.97.85 [223094][V][WiFiClientImpl.h:317] tcpConnect(): Starting socket [347846][D][NetworkManager.cpp:123] hostByName(): DNS found IPv4 35.201.97.85 [347853][V][WiFiClientImpl.h:317] tcpConnect(): Starting socket

this is the code i used. please help me.

`#include <driver/i2s.h>
#include <WiFi.h>
#include <Firebase_ESP_Client.h>
#include <WiFiClientSecure.h>
#include <LittleFS.h>
#include <Preferences.h>
#include <Arduino.h>
#include <TinyGPS++.h>

// Firebase configuration
#include "addons/TokenHelper.h"
#include "addons/RTDBHelper.h"

// I2S configuration for recording
#define I2S_WS 25
#define I2S_SD 33
#define I2S_SCK 32
#define I2S_PORT I2S_NUM_0
#define I2S_SAMPLE_RATE (16000)
#define I2S_SAMPLE_BITS (16)
#define I2S_READ_LEN (16 * 1024) // Reduced buffer size for stability
#define RECORD_TIME (20) // Seconds
#define I2S_CHANNEL_NUM (1)
#define FLASH_RECORD_SIZE (I2S_CHANNEL_NUM * I2S_SAMPLE_RATE * I2S_SAMPLE_BITS / 8 * RECORD_TIME)

// Wi-Fi and Firebase configurations
#define WIFI_SSID "Chamika"
#define WIFI_PASSWORD "24682468"
#define API_KEY ""
#define USER_EMAIL ""
#define USER_PASSWORD ""
#define STORAGE_BUCKET_ID ""
#define DATABASE_URL "*****"

// Define the push button pin
#define BUTTON_PIN 23

File file;
char filename[50]; // To store dynamically generated filename

// Create object for HardwareSerial and GPS
HardwareSerial GPS_Serial(2);
TinyGPSPlus gps;

// Firebase objects
FirebaseData fbdo;
FirebaseAuth auth;
FirebaseConfig config;

Preferences preferences; // Create Preferences object

// File counter
int fileCounter;
bool recordingComplete = false;
bool taskCompleted = false;
bool recordingInProgress = false;
unsigned long sendDataPrevMillis = 0;
bool signupOK = false;
int buttonState = 0;

// Function prototypes
void LittleFSInit();
void i2sInit();
void i2s_adc(void* arg);
void uploadToFirebase();
bool fileExists(const char* path);
void generateNewFileName();
void clearLittleFS();

void setup() {
Serial.begin(115200);
Serial.printf("Available space: %u bytes\n", LittleFS.totalBytes() - LittleFS.usedBytes());

GPS_Serial.begin(9600, SERIAL_8N1, 16, 17); // Use pins 16 and 17 for RX and TX
pinMode(BUTTON_PIN, INPUT_PULLUP);

preferences.begin("counter", false); // Open preferences with the namespace "counter"
fileCounter = preferences.getInt("fileCounter", 1);
Serial.printf("Starting with fileCounter: %d\n", fileCounter);

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

LittleFSInit();

config.api_key = API_KEY;
config.database_url = DATABASE_URL;
auth.user.email = USER_EMAIL;
auth.user.password = USER_PASSWORD;

if (Firebase.signUp(&config, &auth, "", "")) {
Serial.println("Firebase signup successful");
signupOK = true;
} else {
Serial.printf("Firebase signup failed: %s\n", config.signer.signupError.message.c_str());
}

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

void loop() {
if (!recordingInProgress) {
smartDelay(1000);

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

  if (gps.location.isValid()) {
    double latitude = gps.location.lat();
    double longitude = gps.location.lng();
    double altitude = gps.altitude.meters();

    Firebase.RTDB.setFloat(&fbdo, "/gps/latitude", latitude);
    Firebase.RTDB.setFloat(&fbdo, "/gps/longitude", longitude);
    Firebase.RTDB.setFloat(&fbdo, "/gps/altitude", altitude);
  } else {
    Serial.println("Invalid GPS data");
  }
}

}

if (Firebase.ready() && signupOK) {
buttonState = digitalRead(BUTTON_PIN);

if (buttonState == LOW) {
  if (Firebase.RTDB.setInt(&fbdo, "/alertStatus", 1)) {
    Serial.println("Button pressed! Alert sent to Firebase.");
    recordingInProgress = true;

    i2sInit();
    xTaskCreate(i2s_adc, "i2s_adc", 1024 * 4, NULL, 1, NULL);
  }
} else {
  Firebase.RTDB.setInt(&fbdo, "/alertStatus", 0);
}

delay(500);

}
}

static void smartDelay(unsigned long ms) {
unsigned long start = millis();
do {
while (GPS_Serial.available()) {
gps.encode(GPS_Serial.read());
}
} while (millis() - start < ms);
}

void LittleFSInit() {
if (!LittleFS.begin()) {
Serial.println("LittleFS initialization failed, formatting...");
if (LittleFS.format() && LittleFS.begin()) {
Serial.println("LittleFS formatted and mounted successfully.");
} else {
Serial.println("LittleFS failed to format or mount.");
while (1) yield();
}
} else {
Serial.println("LittleFS mounted successfully.");
}

generateNewFileName();
}

void generateNewFileName() {
int fileNumber = 1;

if (LittleFS.exists("/fileCounter.txt")) {
File counterFile = LittleFS.open("/fileCounter.txt", FILE_READ);
fileNumber = counterFile.parseInt();
counterFile.close();
}

sprintf(filename, "/guardianRecord%d.raw", fileNumber);

File counterFile = LittleFS.open("/fileCounter.txt", FILE_WRITE);
counterFile.printf("%d", fileNumber + 1);
counterFile.close();

Serial.printf("New file name generated: %s\n", filename);
}

void i2sInit() {
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = I2S_SAMPLE_RATE,
.bits_per_sample = i2s_bits_per_sample_t(I2S_SAMPLE_BITS),
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = 0,
.dma_buf_count = 16,
.dma_buf_len = 1024,
.use_apll = 1
};
i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);

const i2s_pin_config_t pin_config = {
.bck_io_num = I2S_SCK,
.ws_io_num = I2S_WS,
.data_out_num = -1,
.data_in_num = I2S_SD
};
i2s_set_pin(I2S_PORT, &pin_config);
}

void i2s_adc(void* arg) {
int i2s_read_len = I2S_READ_LEN;
int flash_wr_size = 0;
size_t bytes_read;

char* i2s_read_buff = (char*)malloc(i2s_read_len);
if (!i2s_read_buff) {
Serial.println("Memory allocation failed!");
vTaskDelete(NULL);
}

// Open the file for writing
file = LittleFS.open(filename, FILE_WRITE);
if (!file) {
Serial.println("Failed to open file for writing!");
free(i2s_read_buff);
vTaskDelete(NULL);
}

Serial.println(" *** Recording Start *** ");
while (flash_wr_size < FLASH_RECORD_SIZE) {
i2s_read(I2S_PORT, (void*)i2s_read_buff, i2s_read_len, &bytes_read, portMAX_DELAY);
if (bytes_read > 0) {
file.write((const uint8_t*)i2s_read_buff, bytes_read);
flash_wr_size += bytes_read;
Serial.printf("Sound recording %u%%\n", flash_wr_size * 100 / FLASH_RECORD_SIZE);
Serial.printf("Free Heap: %u bytes\n", ESP.getFreeHeap());

  // Flush data to ensure it's written to LittleFS
  file.flush();
}

// Yield periodically to avoid watchdog reset
vTaskDelay(1);

}

// Final flush and close file
file.flush();
file.close();
free(i2s_read_buff);

if (LittleFS.exists(filename)) {
File savedFile = LittleFS.open(filename, FILE_READ);
if (savedFile) {
Serial.printf("Recording complete. File saved: %s, Size: %u bytes\n", filename, savedFile.size());
savedFile.close();
} else {
Serial.println("Recording complete but failed to open the saved file!");
}
} else {
Serial.println("Recording complete but file not found!");
}

Serial.println("Recording complete");
recordingComplete = true;

// After recording, upload to Firebase
uploadToFirebase();

// Resume GPS updates after upload
recordingInProgress = false;

i2s_driver_uninstall(I2S_PORT);
vTaskDelete(NULL);
}
void uploadToFirebase() {
// Ensure LittleFS is mounted and file exists
if (!LittleFS.exists(filename)) {
Serial.println("File does not exist, cannot upload.");
return;
}

// Debug info for file size
File tempFile = LittleFS.open(filename, FILE_READ);
if (tempFile) {
Serial.printf("File size to upload: %u bytes\n", tempFile.size());
tempFile.close();
} else {
Serial.println("Failed to open the file before upload.");
return;
}

// Specify the upload path
String uploadPath = "/audio/guardianRecord" + String(fileCounter) + ".raw";
Serial.printf("Uploading file: %s to Firebase path: %s\n", filename, uploadPath.c_str());

// Attempt the upload
if (Firebase.Storage.upload(&fbdo, STORAGE_BUCKET_ID, filename, mem_storage_type_flash, uploadPath.c_str(), "audio/raw")) {
Serial.println("Upload successful!");
fileCounter++;
preferences.putInt("fileCounter", fileCounter);
clearLittleFS();
} else {
// Print more detailed error information
Serial.printf("Failed to upload file, HTTP code: %d\n", fbdo.httpCode());
Serial.printf("Error reason: %s\n", fbdo.errorReason().c_str());
}
}

void clearLittleFS() {
LittleFS.remove(filename);
}
`

[mobizt]

You are using deprecated library which no further supports and posting in the wrong repo.

[chamikasahan]

okayy.. i will check it.. thank you for the information !!

[chamikasahan]

if its possible, can yu help me to convert my old firebase librarycode to new library code.

if i provide my full code !

[mobizt]

I wrote clearly that you should read the library documentation before use.

This is the library repository not a community website or forum to ask the coding question.

Something is not working because you don't learn it and follow the example guidelines.

[mobizt]

Don't be urgently to use this library, you have to spend the time to read the library documentation, playing with all examples then you will get the idea how library works and how to adapt it.

If you use this library in async mode, you have to know that all delay (s) in your code will interrupt the library to work properly.

You can use this library in sync mode as usual too, but you have to follow the examples.