Created
January 24, 2020 00:07
-
-
Save maditnerd/c08c50c8eb2bb841bfd993f4f2beee7b to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
FSWebServer - Example WebServer with SPIFFS backend for esp8266 | |
Copyright (c) 2015 Hristo Gochkov. All rights reserved. | |
This file is part of the ESP8266WebServer library for Arduino environment. | |
This library is free software; you can redistribute it and/or | |
modify it under the terms of the GNU Lesser General Public | |
License as published by the Free Software Foundation; either | |
version 2.1 of the License, or (at your option) any later version. | |
This library is distributed in the hope that it will be useful, | |
but WITHOUT ANY WARRANTY; without even the implied warranty of | |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
Lesser General Public License for more details. | |
You should have received a copy of the GNU Lesser General Public | |
License along with this library; if not, write to the Free Software | |
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
upload the contents of the data folder with MkSPIFFS Tool ("ESP8266 Sketch Data Upload" in Tools menu in Arduino IDE) | |
or you can upload the contents of a folder if you CD in that folder and run the following command: | |
for file in `\ls -A1`; do curl -F "file=@$PWD/$file" esp8266fs.local/edit; done | |
access the sample web page at http://esp8266fs.local | |
edit the page by going to http://esp8266fs.local/edit | |
*/ | |
#include <Scheduler.h> | |
#include <ESP8266WiFi.h> | |
#include <WiFiClient.h> | |
#include <ESP8266WebServer.h> | |
#include <ESP8266mDNS.h> | |
#include <FS.h> | |
#include <LittleFS.h> | |
//#include "jpgmanager.h" | |
#include <TJpg_Decoder.h> | |
#include "SPI.h" | |
#include <TFT_eSPI.h> | |
TFT_eSPI tft = TFT_eSPI(); | |
FS* filesystem = &SPIFFS; | |
//FS* filesystem = &LittleFS; | |
bool tft_output(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t* bitmap) | |
{ | |
if ( y >= tft.height() ) return 0; | |
tft.pushImage(x, y, w, h, bitmap); | |
return 1; | |
} | |
void loadJPG(String filename) { | |
tft.fillScreen(TFT_BLACK); | |
uint16_t w = 0, h = 0; | |
TJpgDec.getFsJpgSize(&w, &h, filename); // Note name preceded with "/" | |
TJpgDec.drawFsJpg(0, 0, filename); | |
} | |
#define DBG_OUTPUT_PORT Serial | |
#ifndef STASSID | |
#define STASSID "" | |
#define STAPSK "" | |
#endif | |
const char* ssid = STASSID; | |
const char* password = STAPSK; | |
const char* host = "images"; | |
String previous_image = ""; | |
ESP8266WebServer server(80); | |
//holds the current upload | |
File fsUploadFile; | |
String getValue(String data, char separator, int index) | |
{ | |
int found = 0; | |
int strIndex[] = {0, -1}; | |
int maxIndex = data.length() - 1; | |
for (int i = 0; i <= maxIndex && found <= index; i++) { | |
if (data.charAt(i) == separator || i == maxIndex) { | |
found++; | |
strIndex[0] = strIndex[1] + 1; | |
strIndex[1] = (i == maxIndex) ? i + 1 : i; | |
} | |
} | |
return found > index ? data.substring(strIndex[0], strIndex[1]) : ""; | |
} | |
class DisplayImages : public Task { | |
protected: | |
void loop() { | |
String path = "/"; | |
Dir dir = filesystem->openDir(path); | |
path = String(); | |
String output = "["; | |
while (dir.next()) { | |
File entry = dir.openFile("r"); | |
String extension = getValue(String(entry.name()), '.', 1); | |
if (extension == "jpg") { | |
Serial.print("Loading: "); | |
String filename = String(entry.name()); | |
Serial.println(filename); | |
loadJPG(filename); | |
delay(5000); | |
} | |
entry.close(); | |
} | |
} | |
} display_images; | |
class WebServer : public Task { | |
protected: | |
void loop() { | |
server.handleClient(); | |
MDNS.update(); | |
} | |
} webserver; | |
//format bytes | |
String formatBytes(size_t bytes) { | |
if (bytes < 1024) { | |
return String(bytes) + "B"; | |
} else if (bytes < (1024 * 1024)) { | |
return String(bytes / 1024.0) + "KB"; | |
} else if (bytes < (1024 * 1024 * 1024)) { | |
return String(bytes / 1024.0 / 1024.0) + "MB"; | |
} else { | |
return String(bytes / 1024.0 / 1024.0 / 1024.0) + "GB"; | |
} | |
} | |
String getContentType(String filename) { | |
if (server.hasArg("download")) { | |
return "application/octet-stream"; | |
} else if (filename.endsWith(".htm")) { | |
return "text/html"; | |
} else if (filename.endsWith(".html")) { | |
return "text/html"; | |
} else if (filename.endsWith(".css")) { | |
return "text/css"; | |
} else if (filename.endsWith(".js")) { | |
return "application/javascript"; | |
} else if (filename.endsWith(".png")) { | |
return "image/png"; | |
} else if (filename.endsWith(".gif")) { | |
return "image/gif"; | |
} else if (filename.endsWith(".jpg")) { | |
return "image/jpeg"; | |
} else if (filename.endsWith(".ico")) { | |
return "image/x-icon"; | |
} else if (filename.endsWith(".xml")) { | |
return "text/xml"; | |
} else if (filename.endsWith(".pdf")) { | |
return "application/x-pdf"; | |
} else if (filename.endsWith(".zip")) { | |
return "application/x-zip"; | |
} else if (filename.endsWith(".gz")) { | |
return "application/x-gzip"; | |
} | |
return "text/plain"; | |
} | |
bool handleFileRead(String path) { | |
DBG_OUTPUT_PORT.println("handleFileRead: " + path); | |
if (path.endsWith("/")) { | |
path += "index.htm"; | |
} | |
String contentType = getContentType(path); | |
String pathWithGz = path + ".gz"; | |
if (filesystem->exists(pathWithGz) || filesystem->exists(path)) { | |
if (filesystem->exists(pathWithGz)) { | |
path += ".gz"; | |
} | |
File file = filesystem->open(path, "r"); | |
server.streamFile(file, contentType); | |
file.close(); | |
return true; | |
} | |
return false; | |
} | |
void handleFileUpload() { | |
if (server.uri() != "/edit") { | |
return; | |
} | |
HTTPUpload& upload = server.upload(); | |
if (upload.status == UPLOAD_FILE_START) { | |
String filename = upload.filename; | |
if (!filename.startsWith("/")) { | |
filename = "/" + filename; | |
} | |
DBG_OUTPUT_PORT.print("handleFileUpload Name: "); DBG_OUTPUT_PORT.println(filename); | |
fsUploadFile = filesystem->open(filename, "w"); | |
filename = String(); | |
} else if (upload.status == UPLOAD_FILE_WRITE) { | |
//DBG_OUTPUT_PORT.print("handleFileUpload Data: "); DBG_OUTPUT_PORT.println(upload.currentSize); | |
if (fsUploadFile) { | |
fsUploadFile.write(upload.buf, upload.currentSize); | |
} | |
} else if (upload.status == UPLOAD_FILE_END) { | |
if (fsUploadFile) { | |
fsUploadFile.close(); | |
} | |
DBG_OUTPUT_PORT.print("handleFileUpload Size: "); DBG_OUTPUT_PORT.println(upload.totalSize); | |
} | |
} | |
void handleFileDelete() { | |
if (server.args() == 0) { | |
return server.send(500, "text/plain", "BAD ARGS"); | |
} | |
String path = server.arg(0); | |
DBG_OUTPUT_PORT.println("handleFileDelete: " + path); | |
if (path == "/") { | |
return server.send(500, "text/plain", "BAD PATH"); | |
} | |
if (!filesystem->exists(path)) { | |
return server.send(404, "text/plain", "FileNotFound"); | |
} | |
filesystem->remove(path); | |
server.send(200, "text/plain", ""); | |
path = String(); | |
} | |
void handleFileCreate() { | |
if (server.args() == 0) { | |
return server.send(500, "text/plain", "BAD ARGS"); | |
} | |
String path = server.arg(0); | |
DBG_OUTPUT_PORT.println("handleFileCreate: " + path); | |
if (path == "/") { | |
return server.send(500, "text/plain", "BAD PATH"); | |
} | |
if (filesystem->exists(path)) { | |
return server.send(500, "text/plain", "FILE EXISTS"); | |
} | |
File file = filesystem->open(path, "w"); | |
if (file) { | |
file.close(); | |
} else { | |
return server.send(500, "text/plain", "CREATE FAILED"); | |
} | |
server.send(200, "text/plain", ""); | |
path = String(); | |
} | |
void handleFileList() { | |
if (!server.hasArg("dir")) { | |
server.send(500, "text/plain", "BAD ARGS"); | |
return; | |
} | |
String path = server.arg("dir"); | |
DBG_OUTPUT_PORT.println("handleFileList: " + path); | |
Dir dir = filesystem->openDir(path); | |
path = String(); | |
String output = "["; | |
while (dir.next()) { | |
File entry = dir.openFile("r"); | |
if (output != "[") { | |
output += ','; | |
} | |
bool isDir = false; | |
output += "{\"type\":\""; | |
output += (isDir) ? "dir" : "file"; | |
output += "\",\"name\":\""; | |
if (entry.name()[0] == '/') { | |
output += &(entry.name()[1]); | |
} else { | |
output += entry.name(); | |
} | |
output += "\"}"; | |
entry.close(); | |
} | |
output += "]"; | |
server.send(200, "text/json", output); | |
} | |
void setup(void) { | |
tft.begin(); | |
tft.setTextColor(0xFFFF, 0x0000); | |
tft.fillScreen(TFT_WHITE); | |
delay(2000); | |
tft.setSwapBytes(true); | |
TJpgDec.setJpgScale(1); | |
TJpgDec.setCallback(tft_output); | |
//loadJPG("/loading.jpg"); | |
//delay(2000); | |
DBG_OUTPUT_PORT.begin(115200); | |
DBG_OUTPUT_PORT.print("\n"); | |
DBG_OUTPUT_PORT.setDebugOutput(true); | |
filesystem->begin(); | |
{ | |
Dir dir = filesystem->openDir("/"); | |
while (dir.next()) { | |
String fileName = dir.fileName(); | |
size_t fileSize = dir.fileSize(); | |
DBG_OUTPUT_PORT.printf("FS File: %s, size: %s\n", fileName.c_str(), formatBytes(fileSize).c_str()); | |
} | |
DBG_OUTPUT_PORT.printf("\n"); | |
} | |
//WIFI INIT | |
DBG_OUTPUT_PORT.printf("Connecting to %s\n", ssid); | |
if (String(WiFi.SSID()) != String(ssid)) { | |
WiFi.mode(WIFI_STA); | |
WiFi.begin(ssid, password); | |
} | |
while (WiFi.status() != WL_CONNECTED) { | |
delay(500); | |
DBG_OUTPUT_PORT.print("."); | |
} | |
DBG_OUTPUT_PORT.println(""); | |
DBG_OUTPUT_PORT.print("Connected! IP address: "); | |
DBG_OUTPUT_PORT.println(WiFi.localIP()); | |
MDNS.begin(host); | |
DBG_OUTPUT_PORT.print("Open http://"); | |
DBG_OUTPUT_PORT.print(host); | |
DBG_OUTPUT_PORT.println(".local/edit to see the file browser"); | |
//SERVER INIT | |
//list directory | |
server.on("/list", HTTP_GET, handleFileList); | |
//load editor | |
server.on("/edit", HTTP_GET, []() { | |
if (!handleFileRead("/edit.htm")) { | |
server.send(404, "text/plain", "FileNotFound"); | |
} | |
}); | |
//create file | |
server.on("/edit", HTTP_PUT, handleFileCreate); | |
//delete file | |
server.on("/edit", HTTP_DELETE, handleFileDelete); | |
//first callback is called after the request has ended with all parsed arguments | |
//second callback handles file uploads at that location | |
server.on("/edit", HTTP_POST, []() { | |
server.send(200, "text/plain", ""); | |
}, handleFileUpload); | |
//called when the url is not defined here | |
//use it to load content from SPIFFS | |
server.onNotFound([]() { | |
if (!handleFileRead(server.uri())) { | |
server.send(404, "text/plain", "FileNotFound"); | |
} | |
}); | |
//get heap status, analog input value and all GPIO statuses in one json call | |
server.on("/all", HTTP_GET, []() { | |
String json = "{"; | |
json += "\"heap\":" + String(ESP.getFreeHeap()); | |
json += ", \"analog\":" + String(analogRead(A0)); | |
json += ", \"gpio\":" + String((uint32_t)(((GPI | GPO) & 0xFFFF) | ((GP16I & 0x01) << 16))); | |
json += "}"; | |
server.send(200, "text/json", json); | |
json = String(); | |
}); | |
server.begin(); | |
DBG_OUTPUT_PORT.println("HTTP server started"); | |
Scheduler.start(&display_images); | |
Scheduler.start(&webserver); | |
Scheduler.begin(); | |
} | |
void loop(void) { | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment