ESP32 SD card uploading file to Firebase Storage.

[Toby-Cheung]

`#include <SPI.h>
#include <SD.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>

// Define Wi-Fi credentials
#define WIFI_SSID ""
#define WIFI_PASSWORD ""

// Firebase credentials
#define API_KEY ""
#define USER_EMAIL ""
#define USER_PASSWORD ""
#define STORAGE_BUCKET_ID ""

// Firebase configuration
UserAuth user_auth(API_KEY, USER_EMAIL, USER_PASSWORD, 3000);
FirebaseApp app;
WiFiClientSecure ssl_client;
DefaultNetwork network;
using AsyncClient = AsyncClientClass;
AsyncClient aClient(ssl_client, getNetwork(network));
Storage storage;
AsyncResult aResult_no_callback;
bool taskCompleted = false;

File myFile;

// Function declarations
void printResult(AsyncResult &aResult);
void printError(int code, const String &msg);
void fileCallback(File &file, const char *filename, file_operating_mode mode);

// File configuration
#define FILE_NAME ""
FileConfig upload_file(FILE_NAME, fileCallback);

void setup()
{
// Start the serial communication
Serial.begin(115200);

// Initialize the SD card
SPIClass *spi = new SPIClass(HSPI);
spi->begin(5, 4, 6, 7);
while (!SD.begin(7, *spi))
{
    Serial.println("Card Mount Failed");
    delay(1000);
}

uint8_t cardType = SD.cardType();

if (cardType == CARD_NONE)
{
    Serial.println("No SD card attached");
    return;
}

uint64_t cardSize = SD.cardSize() / (1024 * 1024);
Serial.printf("SD Card Size: %lluMB\n", cardSize);

// Connect to Wi-Fi
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();

// Initialize Firebase
Firebase.printf("Firebase Client v%s\n", FIREBASE_CLIENT_VERSION);
Serial.println("Initializing app...");

ssl_client.setInsecure();
initializeApp(aClient, app, getAuth(user_auth), aResult_no_callback);

app.getApp<Storage>(storage);

// aClient.setAsyncResult(aResult_no_callback);

}

void loop()
{
app.loop();
storage.loop();

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

    Serial.println("Upload file...");

    // File file = SD.open(FILE_NAME, FILE_READ);

    bool result = storage.upload(aClient, FirebaseStorage::Parent(STORAGE_BUCKET_ID, "test"), getFile(upload_file), "text/plain");

    if (result)
        Serial.println("File uploaded.");
    else
        printError(aClient.lastError().code(), aClient.lastError().message());
}

}

void printResult(AsyncResult &aResult)
{
if (aResult.isEvent())
{
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.downloadProgress())
{
    Firebase.printf("Download task: %s, downloaded %d%s (%d of %d)\n", aResult.uid().c_str(), aResult.downloadInfo().progress, "%", aResult.downloadInfo().downloaded, aResult.downloadInfo().total);
    if (aResult.downloadInfo().total == aResult.downloadInfo().downloaded)
    {
        Firebase.printf("Download task: %s, completed!\n", aResult.uid().c_str());
    }
}

if (aResult.uploadProgress())
{
    Firebase.printf("Upload task: %s, uploaded %d%s (%d of %d)\n", aResult.uid().c_str(), aResult.uploadInfo().progress, "%", aResult.uploadInfo().uploaded, aResult.uploadInfo().total);
    if (aResult.uploadInfo().total == aResult.uploadInfo().uploaded)
    {
        Firebase.printf("Upload task: %s, completed!\n", aResult.uid().c_str());
        Serial.print("Download URL: ");
        Serial.println(aResult.uploadInfo().downloadUrl);
    }
}

}

void printError(int code, const String &msg)
{
Firebase.printf("Error, msg: %s, code: %d\n", msg.c_str(), code);
}

void fileCallback(File &file, const char *filename, file_operating_mode mode)
{
switch (mode)
{
case file_mode_open_read:
myFile = SD.open(filename, FILE_READ);
if (!myFile)
{
Serial.println("Failed to open file for reading");
}
else
{
Serial.println("File opened for reading");
}
break;
case file_mode_open_write:
myFile = SD.open(filename, FILE_WRITE);
if (!myFile)
{
Serial.println("Failed to open file for writing");
}
else
{
Serial.println("File opened for writing");
}
break;
case file_mode_open_append:
myFile = SD.open(filename, FILE_APPEND);
if (!myFile)
{
Serial.println("Failed to open file for appending");
}
else
{
Serial.println("File opened for appending");
}
break;
case file_mode_remove:
if (SD.remove(filename))
{
Serial.println("File removed");
}
else
{
Serial.println("Failed to remove file");
}
break;
default:
break;
}
file = myFile;
}
`
I have faced a bug that when I comment the line "File file = SD.open(FILE_NAME, FILE_READ);" under the void loop(), error of (-104) occur but when I added the line back, the upload can be successfully done. Anyone knows why?

[mobizt]

There is no bug but your logic problem.

You do not open or touch the file that used by the FileConfig.
// File file = SD.open(FILE_NAME, FILE_READ);

If you do that, you should close that file prior to upload and download.

[mobizt]

Library does not handle your file directly but though the File class object you have set in fileCalllback.

You are corresponding to open and remove file in fileCalllback.

[Toby-Cheung]

The version I gave above didn't work for me. If I add back the commented line, the program will work.

[mobizt]

Please read and learn to understand what I wrote again.

You are correspondent on open and remove file in the fileCallback function which is code on your side.

Opening file outside that function is your own risk.

Library is working with filesystem through the user global defined File class object (myFile) which you later initiate the library internal defined File class object (file) with this myFile inside the fileCallback.

void fileCallback(File &file, const char *filename, file_operating_mode mode)
{
 
    // Set the internal File object with global File object.
    file = myFile;
}

You have to update ESP32 Core SDK to latest version.

Any upload error is because your code and your SD not a library.