（3） 文件系统上传

最新推荐文章于 2024-08-08 07:03:33 发布
最新推荐文章于 2024-08-08 07:03:33 发布
阅读量823 收藏 4
点赞数 1
文章标签： json 操作系统 sketch
原文链接：http://www.cnblogs.com/kekeoutlook/p/10584003.html
版权

将文件上载到服务器

博哥零基础教你玩转ESP8266（十八） ESP8266 Filesystem

WiFi-ESP8266入门开发(七)-文件系统

使用ESP8266 SPIFFS

ESP8266 TFT(ST7735)彩屏-web刷图

 

在某些情况下，您可能希望从浏览器中将新文件上载到服务器，而无需通过USB连接到ESP8266以便刷新新的SPIFFS映像。
在本章中，我将向您展示如何使用HTML表单和POST请求将文件上载或编辑到我们的小型ESP服务器。

客户：HTML表单

上传文件的最简单方法是使用HTML表单，就像在第一个服务器示例中一样，我们使用表单打开/关闭LED，并将登录凭据发送回服务器。如果选择文件输入，则会自动获取文件选择器，浏览器将向服务器发送正确的POST请求，并附带文件。 
<form method="post" enctype="multipart/form-data">
    <input type="file" name="name">
    <input class="button" type="submit" value="Upload">
</form>

　　

服务器

在ESP代码中，我们必须向我们的服务器添加一个处理程序来处理对 / upload  URI的POST请求。当它收到POST请求时，它会将状态200（OK）发送回客户端以开始接收文件，然后将其写入SPIFFS。成功上载文件后，它会将客户端重定向到成功页面。
相关的新代码可以在  
建立
 和  
行为文件上传
 功能。 
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266mDNS.h>
#include <ESP8266WebServer.h>
#include <FS.h>   // Include the SPIFFS library

ESP8266WiFiMulti wifiMulti;     // Create an instance of the ESP8266WiFiMulti class, called 'wifiMulti'

ESP8266WebServer server(80);    // Create a webserver object that listens for HTTP request on port 80

File fsUploadFile;              // a File object to temporarily store the received file

String getContentType(String filename); // convert the file extension to the MIME type
bool handleFileRead(String path);       // send the right file to the client (if it exists)
void handleFileUpload();                // upload a new file to the SPIFFS

void setup() {
  Serial.begin(115200);         // Start the Serial communication to send messages to the computer
  delay(10);
  Serial.println('\n');

  wifiMulti.addAP("ssid_from_AP_1", "your_password_for_AP_1");   // add Wi-Fi networks you want to connect to
  wifiMulti.addAP("ssid_from_AP_2", "your_password_for_AP_2");
  wifiMulti.addAP("ssid_from_AP_3", "your_password_for_AP_3");

  Serial.println("Connecting ...");
  int i = 0;
  while (wifiMulti.run() != WL_CONNECTED) { // Wait for the Wi-Fi to connect
    delay(1000);
    Serial.print(++i); Serial.print(' ');
  }
  Serial.println('\n');
  Serial.print("Connected to ");
  Serial.println(WiFi.SSID());              // Tell us what network we're connected to
  Serial.print("IP address:\t");
  Serial.println(WiFi.localIP());           // Send the IP address of the ESP8266 to the computer

  if (!MDNS.begin("esp8266")) {             // Start the mDNS responder for esp8266.local
    Serial.println("Error setting up MDNS responder!");
  }
  Serial.println("mDNS responder started");

  SPIFFS.begin();                           // Start the SPI Flash Files System

  server.on("/upload", HTTP_GET, []() {                 // if the client requests the upload page
    if (!handleFileRead("/upload.html"))                // send it if it exists
      server.send(404, "text/plain", "404: Not Found"); // otherwise, respond with a 404 (Not Found) error
  });

  server.on("/upload", HTTP_POST,                       // if the client posts to the upload page
    [](){ server.send(200); },                          // Send status 200 (OK) to tell the client we are ready to receive
    handleFileUpload                                    // Receive and save the file
  );

  server.onNotFound([]() {                              // If the client requests any URI
    if (!handleFileRead(server.uri()))                  // send it if it exists
      server.send(404, "text/plain", "404: Not Found"); // otherwise, respond with a 404 (Not Found) error
  });

  server.begin();                           // Actually start the server
  Serial.println("HTTP server started");
}

void loop() {
  server.handleClient();
}

String getContentType(String filename) { // convert the file extension to the MIME type
  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(".ico")) return "image/x-icon";
  else if (filename.endsWith(".gz")) return "application/x-gzip";
  return "text/plain";
}

bool handleFileRead(String path) { // send the right file to the client (if it exists)
  Serial.println("handleFileRead: " + path);
  if (path.endsWith("/")) path += "index.html";          // If a folder is requested, send the index file
  String contentType = getContentType(path);             // Get the MIME type
  String pathWithGz = path + ".gz";
  if (SPIFFS.exists(pathWithGz) || SPIFFS.exists(path)) { // If the file exists, either as a compressed archive, or normal
    if (SPIFFS.exists(pathWithGz))                         // If there's a compressed version available
      path += ".gz";                                         // Use the compressed verion
    File file = SPIFFS.open(path, "r");                    // Open the file
    size_t sent = server.streamFile(file, contentType);    // Send it to the client
    file.close();                                          // Close the file again
    Serial.println(String("\tSent file: ") + path);
    return true;
  }
  Serial.println(String("\tFile Not Found: ") + path);   // If the file doesn't exist, return false
  return false;
}

void handleFileUpload(){ // upload a new file to the SPIFFS
  HTTPUpload& upload = server.upload();
  if(upload.status == UPLOAD_FILE_START){
    String filename = upload.filename;
    if(!filename.startsWith("/")) filename = "/"+filename;
    Serial.print("handleFileUpload Name: "); Serial.println(filename);
    fsUploadFile = SPIFFS.open(filename, "w");            // Open the file for writing in SPIFFS (create if it doesn't exist)
    filename = String();
  } else if(upload.status == UPLOAD_FILE_WRITE){
    if(fsUploadFile)
      fsUploadFile.write(upload.buf, upload.currentSize); // Write the received bytes to the file
  } else if(upload.status == UPLOAD_FILE_END){
    if(fsUploadFile) {                                    // If the file was successfully created
      fsUploadFile.close();                               // Close the file again
      Serial.print("handleFileUpload Size: "); Serial.println(upload.totalSize);
      server.sendHeader("Location","/success.html");      // Redirect the client to the success page
      server.send(303);
    } else {
      server.send(500, "text/plain", "500: couldn't create file");
    }
  }
}

　　

该  
行为文件上传
 函数只是将附加到POST请求的文件写入SPIFFS。
 
如果你也想使用其他文件类型，你可以将它们添加到  
的getContentType
 功能。

上传文件

要将新文件上载到ESP或更新现有文件，只需转到 http：//esp8266.local/upload ，单击“  选择文件” 按钮，选择要上载的文件，然后单击“上 载” 。您现在可以在URL栏中输入URL，然后打开新文件。

关于安全的说明

这个例子不是很安全（显然）。例如，每个可以连接到ESP的人都可以上传新文件，或者编辑现有文件并插入 XSS代码 。还有很多错误检查/处理，比如检查SPIFFS中是否有足够的空间来上传新文件等。

高级示例

这些SPIFFS服务器示例的代码（大部分来自）由Hristo Gochkov编写的示例。您可以在文件>示例> ESP8266WebServer> FSBrowser下找到它。它有一个用于在浏览器中浏览和编辑文件的Web界面，还有一些其他不错的功能。
  
/*
  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 <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <FS.h>

#define DBG_OUTPUT_PORT Serial

#ifndef STASSID
#define STASSID "your-ssid"
#define STAPSK  "your-password"
#endif

const char* ssid = STASSID;
const char* password = STAPSK;
const char* host = "esp8266fs";

ESP8266WebServer server(80);
//holds the current upload
File fsUploadFile;

//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 (SPIFFS.exists(pathWithGz) || SPIFFS.exists(path)) {
    if (SPIFFS.exists(pathWithGz)) {
      path += ".gz";
    }
    File file = SPIFFS.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 = SPIFFS.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 (!SPIFFS.exists(path)) {
    return server.send(404, "text/plain", "FileNotFound");
  }
  SPIFFS.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 (SPIFFS.exists(path)) {
    return server.send(500, "text/plain", "FILE EXISTS");
  }
  File file = SPIFFS.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 = SPIFFS.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\":\"";
    output += String(entry.name()).substring(1);
    output += "\"}";
    entry.close();
  }

  output += "]";
  server.send(200, "text/json", output);
}

void setup(void) {
  DBG_OUTPUT_PORT.begin(115200);
  DBG_OUTPUT_PORT.print("\n");
  DBG_OUTPUT_PORT.setDebugOutput(true);
  SPIFFS.begin();
  {
    Dir dir = SPIFFS.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");

}

void loop(void) {
  server.handleClient();
  MDNS.update();
}

　　实际项目

物料准备：
   ESP8266 *1
    TFT彩屏   *1 （驱动IC:ST7735S）
    杜邦线若干
导线连接：
     ESP8266--------------------TFT

  • GPIO4--------------------RST
  • GPIO5--------------------D/C
  • GPIO13(MOSI)-----------DIN(SDI,MOSI)
  • GPIO14(SCK)-------------CLK(SCK)
  • GPIO15(SS,CS)-----------CS(SS)
  • 3.3V----------------------3.3V,LED+100R电阻
  • GND---------------------GND

（括号里的为同一个io不同称呼）
工作流程：
8266连接路由器-->8266建立web服务器-->电脑访问web页面-->上传图片-->保存图片到flash-->读取图片数据-->发送个给tft显示
准备工作：
   1.安装arduino ide for esp8266（使用arduino ide开发8266）.
    2.加载附件中的库文件到ide目录中。（ST7735S库略微修改过给8266使用）

 

   3.看看示例我们知道了这个tft屏的用法。
     4.下载烧录附件中的源码。
     5.可选，安装附件中的Bonjour服务，用于mdns，可在浏览器输入域名访问8266的web，直接访问esp8266fs.local即可

下载固件完成后，打开串口监视器等待8266连接路由器，值得注意的是如果这片8266第一次使用spiffs可能需要1-2分钟的格式化时间。
开始工作：
    1.待8266正常工作完成后，打开串口监视器中查看ip地址。

  2.在浏览器打开串口监视器中获取到的ip地址访问8266，如果安装了Bonjour服务直接访问esp8266fs.local

3.选择需要显示的图片，本程序只做了显示bmp格式的图片，所以上传的文件附件必须为bmp格式并且分辨率为128*128，24位

4.点击上传，待文件上传完成就可以看到上传的图片了

工程文件

上面两个是库文件，但在该对应目录下。

 

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <FS.h>
#include <Adafruit_GFX.h>    // Core graphics library
#include <Adafruit_ST7735.h> // Hardware-specific library
#include <SPI.h>

#define TFT_CS  15  // Chip select line for TFT display
#define TFT_RST  4  // Reset line for TFT (or see below...)
#define TFT_DC   5  // Data/command line for TFT

//wifi配置
const char* ssid = "love";
const char* password = "love123456";
const char* host = "esp8266";

//
const char mainPageString[] PROGMEM = "<!DOCTYPE html>\r\n\
<html>\r\n\
<head>\r\n\
  <meta http-equiv='Content-type' content='text/html; charset=utf-8'>\r\n\
  <title>ESP Monitor</title>\r\n\
</head>\r\n\
<body>\r\n\
  <img src='/logo.bmp' width='128' height='128' />\r\n\
  <form method='POST' action='/' enctype='multipart/form-data'>\r\n\
  <input type='file' name='update' id='update'><input type='submit' value='提交'></form>\r\n\
  文件格式必须为bmp，24位深，本示例使用的屏幕为1.44寸TFT,分辨率128*128，ic:ST7735\r\n\
</body>\r\n\
</html>";

//监听80端口
ESP8266WebServer server(80);

Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
File fsUploadFile;

#define BUFFPIXEL 20
// These read 16- and 32-bit types from the SD card file.
// BMP data is stored little-endian, Arduino is little-endian too.
// May need to reverse subscript order if porting elsewhere.

uint16_t read16(File f) {
  uint16_t result;
  ((uint8_t *)&result)[0] = f.read(); // LSB
  ((uint8_t *)&result)[1] = f.read(); // MSB
  return result;
}

uint32_t read32(File f) {
  uint32_t result;
  ((uint8_t *)&result)[0] = f.read(); // LSB
  ((uint8_t *)&result)[1] = f.read();
  ((uint8_t *)&result)[2] = f.read();
  ((uint8_t *)&result)[3] = f.read(); // MSB
  return result;
}

void bmpDraw(char *filename, uint8_t x, uint8_t y) {

  File     bmpFile;
  int      bmpWidth, bmpHeight;   // W+H in pixels
  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
  uint32_t bmpImageoffset;        // Start of image data in file
  uint32_t rowSize;               // Not always = bmpWidth; may have padding
  uint8_t  sdbuffer[3*BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
  boolean  goodBmp = false;       // Set to true on valid header parse
  boolean  flip    = true;        // BMP is stored bottom-to-top
  int      w, h, row, col;
  uint8_t  r, g, b;
  uint32_t pos = 0, startTime = millis();

  if((x >= tft.width()) || (y >= tft.height())) return;

  Serial.println();
  Serial.print("Loading image '");
  Serial.print(filename);
  Serial.println('\'');
  bmpFile = SPIFFS.open(filename,"r");
  // Open requested file on SD card
  if (!bmpFile) {
    Serial.print("File not found");
    return;
  }

  // Parse BMP header
  if(read16(bmpFile) == 0x4D42) { // BMP signature
    Serial.print("File size: "); Serial.println(read32(bmpFile));
    (void)read32(bmpFile); // Read & ignore creator bytes
    bmpImageoffset = read32(bmpFile); // Start of image data
    Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
    // Read DIB header
    Serial.print("Header size: "); Serial.println(read32(bmpFile));
    bmpWidth  = read32(bmpFile);
    bmpHeight = read32(bmpFile);
    if(read16(bmpFile) == 1) { // # planes -- must be '1'
      bmpDepth = read16(bmpFile); // bits per pixel
      Serial.print("Bit Depth: "); Serial.println(bmpDepth);
      if((bmpDepth == 24) && (read32(bmpFile) == 0)) { // 0 = uncompressed

        goodBmp = true; // Supported BMP format -- proceed!
        Serial.print("Image size: ");
        Serial.print(bmpWidth);
        Serial.print('x');
        Serial.println(bmpHeight);

        // BMP rows are padded (if needed) to 4-byte boundary
        rowSize = (bmpWidth * 3 + 3) & ~3;

        // If bmpHeight is negative, image is in top-down order.
        // This is not canon but has been observed in the wild.
        if(bmpHeight < 0) {
          bmpHeight = -bmpHeight;
          flip      = false;
        }

        // Crop area to be loaded
        w = bmpWidth;
        h = bmpHeight;
        if((x+w-1) >= tft.width())  w = tft.width()  - x;
        if((y+h-1) >= tft.height()) h = tft.height() - y;

        // Set TFT address window to clipped image bounds
        tft.setAddrWindow(x, y, x+w-1, y+h-1);

        for (row=0; row<h; row++) { // For each scanline...

          // Seek to start of scan line.  It might seem labor-
          // intensive to be doing this on every line, but this
          // method covers a lot of gritty details like cropping
          // and scanline padding.  Also, the seek only takes
          // place if the file position actually needs to change
          // (avoids a lot of cluster math in SD library).
          if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
            pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
          else     // Bitmap is stored top-to-bottom
            pos = bmpImageoffset + row * rowSize;
          if(bmpFile.position() != pos) { // Need seek?
            bmpFile.seek(pos,SeekSet);
            buffidx = sizeof(sdbuffer); // Force buffer reload
          }

          for (col=0; col<w; col++) { // For each pixel...
            // Time to read more pixel data?
            if (buffidx >= sizeof(sdbuffer)) { // Indeed
              bmpFile.read(sdbuffer, sizeof(sdbuffer));
              buffidx = 0; // Set index to beginning
            }

            // Convert pixel from BMP to TFT format, push to display
            b = sdbuffer[buffidx++];
            g = sdbuffer[buffidx++];
            r = sdbuffer[buffidx++];
            tft.pushColor(tft.Color565(r,g,b));
          } // end pixel
        } // end scanline
        Serial.print("Loaded in ");
        Serial.print(millis() - startTime);
        Serial.println(" ms");
      } // end goodBmp
    }
  }

  bmpFile.close();
  if(!goodBmp) Serial.println("BMP format not recognized.");
}


//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";
}

//读取spiffs中的文件
bool handleFileRead(String path){
  Serial.println("handleFileRead: " + path);
  if(path.endsWith("/")) path += "index.htm";
  String contentType = getContentType(path);
  String pathWithGz = path + ".gz";
  if(SPIFFS.exists(pathWithGz) || SPIFFS.exists(path)){
    if(SPIFFS.exists(pathWithGz))
      path += ".gz";
    File file = SPIFFS.open(path, "r");
    size_t sent = server.streamFile(file, contentType);
    file.close();
    return true;
  }
  return false;
}

//上传文件到spiffs中
void handleFileUpload(){
  if(server.uri() != "/") return;
  HTTPUpload& upload = server.upload();
  if(upload.status == UPLOAD_FILE_START){
    String filename = upload.filename;
    if(!filename.startsWith("/")) filename = "/"+filename;
    Serial.print("handleFileUpload Name: "); Serial.println(filename);
    SPIFFS.remove("/logo.bmp");
    fsUploadFile = SPIFFS.open("/logo.bmp", "w");
    filename = String();
  } else if(upload.status == UPLOAD_FILE_WRITE){
    //Serial.print("handleFileUpload Data: "); Serial.println(upload.currentSize);
    if(fsUploadFile)
      fsUploadFile.write(upload.buf, upload.currentSize);
  } else if(upload.status == UPLOAD_FILE_END){
    if(fsUploadFile)
      fsUploadFile.close();
    Serial.print("handleFileUpload Size: "); Serial.println(upload.totalSize);
    bmpDraw("/logo.bmp", 0, 0);
  }
}

void handleRoot()
{
  server.send(200, "text/html", mainPageString);
  server.client().stop();
}




void uplaodFinish() {
  server.send(200, "text/html", mainPageString);
}

void setup(void){
  Serial.begin(115200);
  Serial.print("\n");
  Serial.setDebugOutput(true);

  SPIFFS.begin();
  {
    Dir dir = SPIFFS.openDir("/");
    while (dir.next()) {    
      String fileName = dir.fileName();
      size_t fileSize = dir.fileSize();
      Serial.printf("FS File: %s, size: %s\n", fileName.c_str(), formatBytes(fileSize).c_str());
    }
    Serial.printf("\n");
  }

  tft.initR(INITR_144GREENTAB);
  bmpDraw("/logo.bmp", 0, 0);
  delay(2000);
  //WIFI INIT
  Serial.printf("Connecting to %s\n", ssid);
  WiFi.disconnect();
  WiFi.mode(WIFI_STA);
  if (String(WiFi.SSID()) != String(ssid)) {
    WiFi.begin(ssid, password);
  }
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected! IP address: ");
  Serial.println(WiFi.localIP());

  MDNS.begin(host);
  Serial.print("Open http://");
  Serial.print(host);
  Serial.println(".local/ to see the file browser");
  
  
  //SERVER INIT
  server.on("/", HTTP_GET, handleRoot);
  //把上传的数据保存到spiffs
  server.on("/", HTTP_POST,[](){uplaodFinish();}, handleFileUpload);

  //访问的url没有在找spiffs中找到回复404
    //访问的url没有在找spiffs中找到回复404
  server.onNotFound([](){
    if(!handleFileRead(server.uri()))
      server.send(404, "text/plain", "FileNotFound");
  });
  server.begin();
  Serial.println("HTTP server started");
  
}

void loop(void){
  server.handleClient();
}

　　

转载于:https://www.cnblogs.com/kekeoutlook/p/10584003.html

a83025273
关注
文件上传
qq_44813849的博客
07-20 104
首先要搭建一个DVWA，搭建教程可以参考https://blog.csdn.net/qq_44813849/article/details/96448061 首先打开DVWA Security将此处修改为low 然后写一个一句话木马文件 在此处上传 然后打开 ...
ESP8266——入门：文件系统（三）
Ay_yzx的博客
07-22 3112
文件系统 编写的程序都是上传到板子的闪存系统中。通常ESP8266开发板的闪存大小为4Mb，其中闪存1Mb用于程序存储，剩余的3Mb用于存放系统文件和其他文件，用户可用的空间是小于3Mb的。 FS库 在使用时，执行SPIFFS.format()进行格式化文件（对于旧板子来讲） SPIFFS.begin()用于启动SPIFFS //建立文件对象 SPIFFS.open(file_name, "w"); //参数说明： //第一个参数是被操作的文件名称 //第二个参数"w" 代表写入文件信息，“r”表示读取
Arduino ESP32FS 插件使用教程
最新发布
gitblog_00358的博客
08-08 395
Arduino ESP32FS 插件使用教程 arduino-esp32fs-pluginArduino plugin for uploading files to ESP32 file system项目地址:https://gitcode.com/gh_mirrors/ar/arduino-esp32fs-plugin 项目目录结构及介绍 arduino-esp32fs-plugin/ ├──...
踩坑避雷——关于ESP32的WEB-OTA例程404/NOT FOUND报错
weixin_45436883的博客
02-23 1792
最近因为项目需要，所以在着手开发ESP32，这几天在做OTA，使用arduino中的示例OTAWebUpdater时。当我打开网页点击update后，出现了网页报错404。 然后我就愣住了，看到其他的博客写着都是可以靠这个例程升级成功的。按下F12打开开发者工具，可以看到当在添加升级文件时，网页时正常响应的 但是当我点击update跳转以后，就报错了，报错的内容也可以看到，是这个名称为serverindex的POST方法没有找到。 回到例程源码中，我们可以看到 s...
如何实现 ESP32 固件的 OTA 在线升级更新
weixin_39591047的博客
11-14 2916
请参考如下文章 https://blog.csdn.net/liwei16611/article/details/81051909 只是针对3.2、Web Browser方案固件更新 进行修改。 //const char* SSID = "HUAWEI-7MMSCQ"; //const char* PSWD = "abcdefgh"; #include <WiFi.h> ...
esp8266开发与学习之 upload 传不上去 越改越平 代码乱了 懒得去维护
梦境虽美,却不长.
04-29 349
简单运用与学习吧,后期自我拓展 本来我还想 弄个文件系统 后面发现 抄的代码都上传不了 不知道为什么.
基于Spring Boot的文件管理系统，支持文件上传，下载，删除
05-21
基于Spring Boot的文件管理系统，支持文件上传，下载，删除等操作，在线浏览文件列表及基本信息等操作。部署简单，Java课程设计必备。 依赖软件： 1、jdk1.8+ 2、maven 开发调试方法： 解压压缩包，导入IDE，...
基于Vue和Java的断点续传与大文件上传系统设计源码
04-10
本项目是一个基于Vue和Java的断点续传与大文件上传系统设计源码，共包含563个文件，其中包括258个Java文件、82个SVG文件等。系统采用了Vue-uploader和若依框架，为用户提供了一个便捷的文件上传解决方案。系统支持多...
基于Java的R-Pan文件管理系统设计源码
04-08
R-Pan文件管理系统：基于Java开发，包含385个文件，包括165个Java类文件、75个GIF图像文件、44个JavaScript文件、38个Vue组件文件、26个XML配置文件、8个PNG图像文件、5个CSS样式文件、3个BAT批处理文件、3个Shell...
阿赛文件上传系统 5.0.rar
05-23
阿赛文件上传系统，一个ASP文件，20KB左右，纯ASP无组件上传程序，支持任意扩展名文件的自定义上传，可以控制上传大小，上传至指定文件夹，是否覆盖上传，是否重命名、可使用ASPJPEG组件进行缩图、加水印等各种操作...
基于ASP.NET和C#的泽优小文件上传系统设计源码
04-05
本资源提供了一套基于ASP.NET和C#的泽优小文件上传系统设计源码，包含45个文件，其中包括13个PNG图片文件，8个JavaScript脚本文件，5个C#源代码文件，5个HTML页面文件，3个ASP.NET项目文件（.csproj），3个解决方案...
设置FileUpload上传文件大小
02-18
在配置文件里设置FileUpload上传文件大小
HttpUploadFile模拟前台POST上传图片和后台获取上传图片并上传至服务器
浮尘大侠的博客
12-26 4988
图片上传HttpUploadFile
SPIFFS Upload failed!错误
Assassin660的博客
08-22 1383
1.错误信息： Traceback (most recent call last): File "C:\Users\Administrator\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\3.0.1\tools\upload.py", line 66, in <module> esptool.main(cmdline) File "C:/Users/Administrator/AppData/Local/Ar
esp32搭建文件服务器,ESP32入门示例 - SD卡Web服务器
weixin_29615645的博客
08-12 1720
这个是来自ESP32官方示例的改版，官方的示例由于存在一些问题所以我进行了修改原本的示例有点逻辑上的问题，所以进行了一些修改主要修改有：1.新增SD卡测试部分 复制自官方SD卡示例2.新增一个根目录页，访问根目录就可以看到3.修改了目录展示页，可以通过"ip地址/list"看到，原本这个页面只会返回"BAD ARGS"4.新增Wifi设置页，可以通过Wifi设置页更改链接的Wifi(但是建议不要随...
【IoT】如何实现 ESP32 固件的 OTA 在线升级更新
热门推荐
产品线负责人
07-15 2万+
1、背景 在实际产品开发过程中，在线升级可以远程解决产品软件开发引入的问题，更好地满足用户需求。 2、OTA 简介 OTA（空中）更新是使用 Wi-Fi 连接而不是串行端口将固件加载到 ESP 模块的过程。 2.1、ESP32 的 OTA 升级有三种方式： Arduino IDE：主要用于软件开发阶段，实现不接线固件烧写 Web Browser：通过 Web 浏览器手动提供应用程序更新...
typescript初步使用
SinkDream的博客
09-15 287
创建一个目录，例如名为example 创建一个ts文件，例如名为enum.ts 在文件中写入内容： export enum TokenType { ACCESS = 'accessToken', REFRESH = 'refreshToken' } 通过命令编译文件 tsc enum.ts 在目录下生成js文件表示完成 ...
ESP8266远程OTA升级
a83025273的博客
03-28 726
https://blog.csdn.net/xh870189248/article/details/80095139 https://www.wandianshenme.com/play/arduino-ota-arduino-ide-ota-upgrade-esp8266-application/ 我这里详细地说下这里包含了啥信息！由下面可得，不同的8266模块，其外部falsh...
esp32sd卡sdio模式_ESP32入门示例 - SD卡Web服务器
weixin_42310572的博客
01-17 1066
/*SDWebServer - Example WebServer with SD Card backend for esp8266Copyright (c) 2015 Hristo Gochkov. All rights reserved.This file is part of the WebServer library for Arduino environment.This library...
FastDFS上传详解：经典分布式文件系统详解
本文将深入探讨FastDFS文件上传过程，作为一款经典的分布式文件系统，它在现代信息技术中发挥着关键作用。首先，我们将回顾分布式文件系统的基本概念和原理，解释文件系统在操作系统中的核心地位，它通过抽象和统一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值