WeMos D1 Mini (ESP8266) Flash

All the ESP8266 boards I've seen come with on-board flash, which is persistant storage you can access for both reading and writing.

Although the flash-memory isn't rated for a huge number of writes it's enormously useful, especially as a way of serving content over HTTP.

Adding Content

We'll cover programatically serving content in the next section, but the most typical use-case is reading content from flash and sending it to clients over HTTP.

Install the arduino-esp8266fs-plugin, according to the instructions.

Once you've done that you'll find that you can create a data/ directory inside your sketch folder. The contents of that folder will be uploaded to your flash-storage when you choose the menu item:

• Tools | ESP8266 Sketch Data Upload

A sample tree might look like this

d1-http-server/
├── d1-http-server.ino
└── data
    ├── index.html
    └── rss.jpg

Programatic Access

Include the appropriate header in your sketch, and initialize the library in your setup method:

#include <FS.h>

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

Once you've done that you can open files as you'd expect:

File f = SPIFFS.open("/f.txt", "w");
if (f)
{
   f.println("Here is some content" );
   f.close();
}

Or for reading:

// this opens the file "test.txt" in read-mode
File f = SPIFFS.open("/test.txt", "r");

while(f.available())
{
      //Lets read line by line from the file
      String line = f.readStringUntil('\n');
      Serial.println(line);
}
f.close();

You can also read the names of files which are present:

Dir dir = SPIFFS.openDir("/data");
while (dir.next()) {
    Serial.print(dir.fileName());
    File f = dir.openFile("r");
    Serial.println(f.size());
}

Serving Flash-Content Over HTTP

Assuming you've added some content, as per the description above, you can now serve that content via a simple program such as this one:

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <FS.h>


//
// WiFi details.
//
const char* ssid = "SCOTLAND";
const char* password = "highlander1";


//
// Return the file from the Flash
//
bool loadFromSpiffs(String path)
{
    //
    // Default content-type.
    //
    String dataType = "text/plain";

    //
    // Indexes are index.htm
    //
    if (path.endsWith("/"))
        path += "index.htm";

    //
    // Guess content-type by searching for suffix.
    //
    if (path.endsWith(".htm"))
        dataType = "text/html";
    else if (path.endsWith(".css"))
        dataType = "text/css";
    else if (path.endsWith(".js"))
        dataType = "application/javascript";
    else if (path.endsWith(".png"))
        dataType = "image/png";
    else if (path.endsWith(".gif"))
        dataType = "image/gif";
    else if (path.endsWith(".jpg"))
        dataType = "image/jpeg";
    else if (path.endsWith(".ico"))
        dataType = "image/x-icon";
    else if (path.endsWith(".xml"))
        dataType = "text/xml";
    else if (path.endsWith(".pdf"))
        dataType = "application/pdf";
    else if (path.endsWith(".zip"))
        dataType = "application/zip";

    //
    // Open the file, if we can
    //
    File dataFile = SPIFFS.open(path.c_str(), "r");
    if ( ! dataFile )
        return false;

    //
    // Serve it.
    //
    server.streamFile(dataFile, dataType);
    dataFile.close();

    return true;
}

//
// Handle a request which wasn't explicitly matched.
//
//  Either
//
//   a.  Return the suitable file from the flash
// or
//   b.  Return a generic 404 page.
//
void handleNotFound()
{
    //
    // If we could serve from flash we're good.
    //
    if (loadFromSpiffs(server.uri()))
        return;

    //
    // Otherwise a generic 404.
    //
    String message = "File Not Detected\n\n";
    message += "URI: ";
    message += server.uri();
    message += "\nMethod: ";
    message += (server.method() == HTTP_GET) ? "GET" : "POST";
    message += "\nArguments: ";
    message += server.args();
    message += "\n";

    for (uint8_t i = 0; i < server.args(); i++)
    {
        message += " NAME:" + server.argName(i) + "\n VALUE:" + server.arg(i) + "\n";
    }

    server.send(404, "text/plain", message);
    Serial.println(message);
}


//
// Configure the program.
//
void setup()
{
    Serial.begin(115200);
    SPIFFS.begin();


    // Connect to WiFi network
    WiFi.mode(WIFI_STA);
    WiFi.hostname("flash-httpd");
    WiFi.begin(ssid, password);

    // Wait until we're connected.
    while (WiFi.status() != WL_CONNECTED)
    {
        delay(500);
        Serial.print(".");
    }

    Serial.println("WiFi connected");


    // Print the IP address
    Serial.print("Use this URL to connect: ");
    Serial.print("http://");
    Serial.print(WiFi.localIP());
    Serial.println("/");

    // Configure & start the server
    server.onNotFound(handleNotFound);
    server.begin();

}


//
// Handle incoming HTTP-requests.
//
void loop()
{
    server.handleClient();
}