Arduino ESP32 Web服务器SD卡文件管理

最新推荐文章于 2024-08-27 13:25:27 发布
最新推荐文章于 2024-08-27 13:25:27 发布
阅读量2.5k 收藏 31
点赞数 6
分类专栏： Arduino ESP32 入门实例教程 文章标签： Arduino SD卡
本文为Perseverance52博主原创文章，未经博主允许，不得转载！
本文链接：https://blog.csdn.net/weixin_42880082/article/details/121579181
版权

Arduino ESP32 Web服务器SD卡文件管理

本示例来自官方示例，如果直接使用，会有问题，找不到SD卡，这一点坑了好久，排查的时候排查接线排查卡，更换程序又可以找到，确定是程序代码问题。

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

程序代码

/*
  SDWebServer - Example WebServer with SD Card backend for esp8266

  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
  This file is part of the WebServer 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

  Have a FAT Formatted SD Card connected to the SPI port of the ESP8266
  The web root is the SD Card root folder
  File extensions with more than 3 charecters are not supported by the SD Library
  File Names longer than 8 charecters will be truncated by the SD library, so keep filenames shorter
  index.htm is the default index (works on subfolders as well)

  upload the contents of SdRoot to the root of the SDcard and access the editor by going to http://esp8266sd.local/edit

*/
#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <ESPmDNS.h>
#include <SPI.h>
#include <SD.h>
#include "FS.h"
#define Serial Serial

const char* ssid = "MERCURY_D268G";
const char* password = "pba5ayzk";
const char* host = "esp32sd";

WebServer server(80);

static bool hasSD = false;
File uploadFile;


#define DBG_OUTPUT_PORT Serial
 
String wifissid = "";
String wifipwd = "";  


/******容量转换*******/ 
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";
  }
}
  /******查看SD卡文件列表*******/  
void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
    Serial.printf("Listing directory: %s\n", dirname);
  
    File root = fs.open(dirname);
    if(!root){
        Serial.println("Failed to open directory");
        return;
    }
    if(!root.isDirectory()){
        Serial.println("Not a directory");
        return;
    }
  
    File file = root.openNextFile();
    while(file){
        if(file.isDirectory()){
            Serial.print("  DIR : ");
            Serial.println(file.name());
            if(levels){
                listDir(fs, file.name(), levels -1);
            }
        } else {
            Serial.print("  FILE: ");
            Serial.print(file.name());
            Serial.print("  SIZE: ");
            Serial.println(file.size());
        }
        file = root.openNextFile();
    }
}
/******SD卡创建文件夹*******/  
void createDir(fs::FS &fs, const char * path){
    Serial.printf("Creating Dir: %s\n", path);
    if(fs.mkdir(path)){
        Serial.println("Dir created");
    } else {
        Serial.println("mkdir failed");
    }
}
  /******删除SD卡中的文件夹*******/ 
void removeDir(fs::FS &fs, const char * path){
    Serial.printf("Removing Dir: %s\n", path);
    if(fs.rmdir(path)){
        Serial.println("Dir removed");
    } else {
        Serial.println("rmdir failed");
    }
}
  /******读取SD卡中的文件*******/ 
void readFile(fs::FS &fs, const char * path){
    Serial.printf("Reading file: %s\n", path);
  
    File file = fs.open(path);
    if(!file){
        Serial.println("Failed to open file for reading");
        return;
    }
  
    Serial.print("Read from file: ");
    while(file.available()){
        Serial.write(file.read());
    }
    file.close();
}
    /******向SD卡中的文件写数据*******/ 
void writeFile(fs::FS &fs, const char * path, const char * message){
    Serial.printf("Writing file: %s\n", path);
  
    File file = fs.open(path, FILE_WRITE);
    if(!file){
        Serial.println("Failed to open file for writing");
        return;
    }
    if(file.print(message)){
        Serial.println("File written");
    } else {
        Serial.println("Write failed");
    }
    file.close();
}
/******向SD卡中的文件中添加数据*******/  
void appendFile(fs::FS &fs, const char * path, const char * message){
    Serial.printf("Appending to file: %s\n", path);
  
    File file = fs.open(path, FILE_APPEND);
    if(!file){
        Serial.println("Failed to open file for appending");
        return;
    }
    if(file.print(message)){
        Serial.println("Message appended");
    } else {
        Serial.println("Append failed");
    }
    file.close();
}
      /******给SD卡中的文件重命名*******/ 
void renameFile(fs::FS &fs, const char * path1, const char * path2){
    Serial.printf("Renaming file %s to %s\n", path1, path2);
    if (fs.rename(path1, path2)) {
        Serial.println("File renamed");
    } else {
        Serial.println("Rename failed");
    }
}
     /******删除SD卡中的文件*******/  
void deleteFile(fs::FS &fs, const char * path){
    Serial.printf("Deleting file: %s\n", path);
    if(fs.remove(path)){
        Serial.println("File deleted");
    } else {
        Serial.println("Delete failed");
    }
}
      /******测试SD卡读写*******/ 
void testFileIO(fs::FS &fs, const char * path){
    File file = fs.open(path);
    static uint8_t buf[512];
    size_t len = 0;
    uint32_t start = millis();
    uint32_t end = start;
    if(file){
        len = file.size();
        size_t flen = len;
        start = millis();
        while(len){
            size_t toRead = len;
            if(toRead > 512){
                toRead = 512;
            }
            file.read(buf, toRead);
            len -= toRead;
        }
        end = millis() - start;
        Serial.printf("%u bytes read for %u ms\n", flen, end);
        file.close();
    } else {
        Serial.println("Failed to open file for reading");
    }
   
    file = fs.open(path, FILE_WRITE);
    if(!file){
        Serial.println("Failed to open file for writing");
        return;
    }
  
    size_t i;
    start = millis();
    for(i=0; i<2048; i++){
        file.write(buf, 512);
    }
    end = millis() - start;
    Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
    file.close();
}
  
/******客户端网页回调函数*******/ 
void returnOK() {
  server.send(200, "text/plain", "");
}
  
void returnOK(String msg) {
  server.send(200, "text/plain", msg+"\r\n");
}
  
void returnFail(String msg) {
  server.send(500, "text/plain", msg + "\r\n");
}
  
bool loadFromSdCard(String path) {
  String dataType = "text/plain";
  if (path.endsWith("/")) {
    path += "index.htm";
  }
  
  if (path.endsWith(".src")) {
    path = path.substring(0, path.lastIndexOf("."));
  } else 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";
  }
  
  File dataFile = SD.open(path.c_str());
  if (dataFile.isDirectory()) {
    path += "/index.htm";
    dataType = "text/html";
    dataFile = SD.open(path.c_str());
  }
  
  if (!dataFile) {
    return false;
  }
  
  if (server.hasArg("download")) {
    dataType = "application/octet-stream";
  }
  
  if (server.streamFile(dataFile, dataType) != dataFile.size()) {
    DBG_OUTPUT_PORT.println("Sent less data than expected!");
  }
  
  dataFile.close();
  return true;
}
    /******客户端获取wifi信息回调函数*******/ 
void handleWifiPage()
{
  String content = "<html><body>Congratulations! You Now Connect to The Wifi!<br>";
    content += "You Connect Wifi Name is:"+String(ssid)+"<br>";
    content += "Wifi Password is:"+String(password)+"<br>";
    content += "You input ssid is:" + wifissid + "<br>";
    content += "You input password is:"+wifipwd+"<br>";
    content += "</body></html>";
    server.send(200, "text/html", content);
}
    /******客户端设置wifi信息*******/ 
void handleSetWifi()
{
  String msg;
  if (server.hasArg("DISCONNECT")){
    Serial.println("Disconnection");
    String header = "HTTP/1.1 301 OK\r\nSet-Cookie: ESPSESSIONID=0\r\nLocation: /wifiinfo\r\nCache-Control: no-cache\r\n\r\n";
    server.sendContent(header);
    return;
  }
  if (server.hasArg("WIFINAME") && server.hasArg("WIFIPWD")){
      wifissid=server.arg("WIFINAME");
      wifipwd=server.arg("WIFIPWD");
      String header = "HTTP/1.1 301 OK\r\nSet-Cookie: ESPSESSIONID=1\r\nLocation: /wifiinfo\r\nCache-Control: no-cache\r\n\r\n";
      server.sendContent(header);
      Serial.println("WIFI INFO:");
      Serial.println("Wifi Name:"+wifissid);
      Serial.println("Wifi Password:"+wifipwd);
      if(WiFi.isConnected())
      {
        WiFi.disconnect();
      }
      WiFi.begin(wifissid.c_str(),wifipwd.c_str());
      int i=0;
      while (WiFi.status() != WL_CONNECTED && i++ < 50) {//wait 25 seconds
         Serial.print(".");
        delay(500);
      }
    if (i == 51) {
        DBG_OUTPUT_PORT.print("Could not connect to");
        DBG_OUTPUT_PORT.println(wifissid);
        while (1) {
        delay(500);
      }
    }
      DBG_OUTPUT_PORT.print("Connected! IP address: ");
       DBG_OUTPUT_PORT.println(WiFi.localIP());
      return;
    }
    String content = "<html><body><form method='POST'>This is a Wifi Setting Page<br>";
    content += "Wifi SSID:<input type='text' name='WIFINAME' placeholder='wifi ssid'><br>";
    content += "Wifi Password:<input type='password' name='WIFIPWD' placeholder='wifi password''><br>";
    content += "<input type='submit' name='SUBMIT' value='Submit'></form>" + msg + "<br>";
    content += "We Can Scan The Wifi List is:<br>";
    int n = WiFi.scanNetworks();
    if(n==0)
      content += "There is no wifi can use!<br>";
    else
    {
      content += "<ol>";
      for(int i=0; i<n;i++){
        content += (String("<li>")+String(" Wifi SSID:")+String(WiFi.SSID(i))+String(" Wifi RSSI:")+String(WiFi.RSSI(i))+String((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?String(" "):String("*"))+String("</li>"));
      }
      content += "</ol>";
    }
    content += "</body></html>";
    server.send(200, "text/html", content);
}
  
void handleRoot(){
  Serial.println("Enter handleRoot");
  String header;
  String content = "<html><body><H1>Hello, ESP32 Web Server!</H1><br>";
  if (server.hasHeader("User-Agent")){
    content += "the user agent used is : " + server.header("User-Agent") + "<br><br>";
  }
  content += "You can choose this page to visit:<br>";
  content +="<a href='/wifiset' class='button'>Wifi Setup</a><br />";
  content +="<a href='/wifiinfo' class='button'>Wifi Infomation</a><br />";
  content +="<a href='/list' class='button'>File List</a><br />";
  content +="<a href='/upload' class='button'>Upload File</a><br />";
  content +="Good Luck Everyone!";
  content += "</body></html>";
  server.send(200, "text/html", content);
}
  
void handleUploadWeb()
{
  File html=SD.open("/upload/upload.html");
  String dataType = "text/html";
  server.streamFile(html,dataType);
  Serial.println("Open Upload File");
}
void handleFileUpload() {
  bool updone=false;
  if (server.uri() != "/edit") {
    return;
  }
  String fileName = "";
  HTTPUpload& upload = server.upload();
  if (upload.status == UPLOAD_FILE_START) {
    if (SD.exists((char *)upload.filename.c_str())) {
      SD.remove((char *)upload.filename.c_str());
    }
    fileName = "/upload/"+upload.filename.substring(upload.filename.lastIndexOf('\\')+1);
    Serial.println(fileName);
    uploadFile = SD.open(fileName, FILE_WRITE);
    if(uploadFile!=NULL)
      Serial.println("File exsist!");
    DBG_OUTPUT_PORT.print("Upload: START, filename: "); DBG_OUTPUT_PORT.println(upload.filename);
  } else if (upload.status == UPLOAD_FILE_WRITE) {
    if (uploadFile) {
      if(uploadFile.write(upload.buf, upload.currentSize))
        Serial.println("write Done");
    }
    DBG_OUTPUT_PORT.print("Upload: WRITE, Bytes: "); DBG_OUTPUT_PORT.println(upload.currentSize);
  } else if (upload.status == UPLOAD_FILE_END) {
      uploadFile.close();
    DBG_OUTPUT_PORT.print("Upload: END, Size: "); DBG_OUTPUT_PORT.println(upload.totalSize);
      String message = "Upload Done!\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(200, "text/plain", message);
    updone=true;
  }
  if(updone)
    if(fileName!="")
      readFile(SD,fileName.c_str());
    }
  
void deleteRecursive(String path) {
  File file = SD.open((char *)path.c_str());
  if (!file.isDirectory()) {
    file.close();
    SD.remove((char *)path.c_str());
    return;
  }
  
  file.rewindDirectory();
  while (true) {
    File entry = file.openNextFile();
    if (!entry) {
      break;
    }
    String entryPath = path + "/" + entry.name();
    if (entry.isDirectory()) {
      entry.close();
      deleteRecursive(entryPath);
    } else {
      entry.close();
      SD.remove((char *)entryPath.c_str());
    }
    yield();
  }
  
  SD.rmdir((char *)path.c_str());
  file.close();
}
  
void handleDelete() {
  if (server.args() == 0) {
    return returnFail("BAD ARGS");
  }
  String path = server.arg(0);
  if (path == "/" || !SD.exists((char *)path.c_str())) {
    returnFail("BAD PATH");
    return;
  }
  deleteRecursive(path);
  returnOK();
}
  
void handleCreate() {
  if (server.args() == 0) {
    return returnFail("BAD ARGS");
  }
  String path = server.arg(0);
  if (path == "/" || SD.exists((char *)path.c_str())) {
    returnFail("BAD PATH");
    return;
  }
  
  if (path.indexOf('.') > 0) {
    File file = SD.open((char *)path.c_str(), FILE_WRITE);
    if (file) {
      file.write(0);
      file.close();
    }
  } else {
    SD.mkdir((char *)path.c_str());
  }
  returnOK();
}
      /******客户端网页列出SD目录下的文件*******/ 
String listDir2Web(fs::FS &fs, const char * dirname, uint8_t levels)
{
  String message="";
  File root = fs.open(dirname);
    if(!root){
        message += "Failed to open directory <br />";
        return message;
    }
    if(!root.isDirectory()){
        message += "Not a directory <br />";
        return message;
    }
    File file = root.openNextFile();
    while(file){
        if(file.isDirectory()){
           message +="  DIR : ";
           message += String(file.name())+String("<br />");
            if(levels){
                message += listDir2Web(fs, file.name(), levels -1);
            }
        } else {
            message += String("  FILE: ");
            message += String(file.name())+String("<br />");
            message += String("  SIZE: ");
            message += formatBytes(file.size())+String("<br />");
        }
        file = root.openNextFile();
    }
    return message;
}
/******SD卡信息列表*******/ 
void printDirectory() {
    String header = "<html><body>";
    String message= header + "<h2>List the file in the SD Card:</h2>";
    message += listDir2Web(SD,"/",5);
    server.send(200,"text/html",message);
}
  
void handleNotFound() {
  if (hasSD && loadFromSdCard(server.uri())) {
    return;
  }
  String message = "SDCARD 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);
  DBG_OUTPUT_PORT.print(message);
}
  
void setup(void) {
  DBG_OUTPUT_PORT.begin(115200);
  DBG_OUTPUT_PORT.setDebugOutput(true);
  DBG_OUTPUT_PORT.print("\n");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  DBG_OUTPUT_PORT.print("Connecting to ");
  DBG_OUTPUT_PORT.println(ssid);
  
  // Wait for connection
  uint8_t i = 0;
  while (WiFi.status() != WL_CONNECTED && i++ < 50) {//wait 25 seconds
    Serial.print(".");
    delay(500);
  }
  if (i == 51) {
    DBG_OUTPUT_PORT.print("Could not connect to");
    DBG_OUTPUT_PORT.println(ssid);
    while (1) {
      delay(500);
    }
  }
  DBG_OUTPUT_PORT.print("Connected! IP address: ");
  DBG_OUTPUT_PORT.println(WiFi.localIP());
  //Setting sub network
  
  if (MDNS.begin(host)) {
    MDNS.addService("http", "tcp", 80);
    DBG_OUTPUT_PORT.println("MDNS responder started");
    DBG_OUTPUT_PORT.print("You can now connect to http://");
    DBG_OUTPUT_PORT.print(host);
    DBG_OUTPUT_PORT.println(".local");
  }
  
  
  server.on("/",handleRoot);
  server.on("/list", HTTP_GET, printDirectory);
  server.on("/edit", HTTP_DELETE, handleDelete);
  server.on("/edit", HTTP_PUT, handleCreate);
  server.on("/upload",HTTP_GET,handleUploadWeb);
  server.on("/wifiinfo",HTTP_GET,handleWifiPage);
  server.on("/wifiset",HTTP_GET,handleSetWifi);
  server.on("/wifiset",HTTP_POST,handleSetWifi);
  server.on("/edit", HTTP_POST, []() {
    returnOK();
  }, handleFileUpload);
  server.onNotFound(handleNotFound);
  
  server.begin();
  DBG_OUTPUT_PORT.println("HTTP server started");
  
  /*if (SD.begin(SS)) {
    DBG_OUTPUT_PORT.println("SD Card initialized.");
    hasSD = true;
  }**/
 if(!SD.begin()){
        Serial.println("Card Mount Failed");
        return;
    }
    else
    {
      Serial.println("SD Card Ready!");
      hasSD=true;
    }
    uint8_t cardType = SD.cardType();
  
    if(cardType == CARD_NONE){
        Serial.println("No SD card attached");
        return;
    }
  
    Serial.print("SD Card Type: ");
    if(cardType == CARD_MMC){
        Serial.println("MMC");
    } else if(cardType == CARD_SD){
        Serial.println("SDSC");
    } else if(cardType == CARD_SDHC){
        Serial.println("SDHC");
    } else {
        Serial.println("UNKNOWN");
    }
  
    uint64_t cardSize = SD.cardSize() / (1024 * 1024);
    Serial.printf("SD Card Size: %lluMB\n", cardSize);
  
    listDir(SD, "/", 0);
    createDir(SD, "/mydir");
    createDir(SD, "/upload");
    listDir(SD, "/", 0);
    removeDir(SD, "/mydir");
    listDir(SD, "/", 2);
    writeFile(SD, "/hello.txt", "Hello ");
    appendFile(SD, "/hello.txt", "World!\n");
    readFile(SD, "/hello.txt");
    deleteFile(SD, "/foo.txt");
    renameFile(SD, "/hello.txt", "/foo.txt");
    readFile(SD, "/foo.txt");
    testFileIO(SD, "/test.txt");
    Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
    Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
}
  
void loop(void) {
  server.handleClient();
}
  • 编译信息
使用 1.0  版本的库 WiFi 在文件夹： C:\Users\Administrator\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\libraries\WiFi 
使用 1.0  版本的库 WebServer 在文件夹： C:\Users\Administrator\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\libraries\WebServer 
使用 1.0  版本的库 ESPmDNS 在文件夹： C:\Users\Administrator\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\libraries\ESPmDNS 
使用 1.0  版本的库 SPI 在文件夹： C:\Users\Administrator\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\libraries\SPI 
使用 1.0.5  版本的库 SD 在文件夹： C:\Users\Administrator\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\libraries\SD 
使用 1.0  版本的库 FS 在文件夹： C:\Users\Administrator\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\libraries\FS 
"C:\\Users\\Administrator\\AppData\\Local\\Arduino15\\packages\\esp32\\tools\\xtensa-esp32-elf-gcc\\1.22.0-97-gc752ad5-5.2.0/bin/xtensa-esp32-elf-size" -A "d:\\arduino\\MyHexDir/SDWebServer2.ino.elf"
项目使用了 811734 字节，占用了 (17%) 程序存储空间。最大为 4685824 字节。
全局变量使用了41272字节，(12%)的动态内存，余留286408字节局部变量。最大为327680字节。
perseverance52
关注
专栏目录
Arduino ESP32 基于Web服务端SD文件管理系统完善
perseverance51博客
12-01 817
Arduino ESP32 基于Web服务端SD文件管理系统功能完善 在上一版的基础上添加了，查看SD卡容量的功能。 主程序代码 /* * * ESP32 example of downloading and uploading a file from or to the ESP device's Filing System */ #ifdef ESP8266 #include <ESP8266WiFi.h> // Built-in #include &
Arduino ESP32 基于Web服务端对SD卡网页式文件管理
perseverance51博客
11-28 1580
Arduino ESP32 基于Web服务端对SD卡网页式文件管理 上一版本：《Arduino ESP32/8266 HttpWebServe服务端对SD卡进行文件上传和下载》 主要是针对上一版本的功能进一步添加和完善，没添加一个功能都不容易，只能一步一步进行，版本迭代。在之前的版本里面没有删除SD里面的文件的功能，这次加上了该功能，更改完ESP32的有要去升级升级ESP8266的相对应的功能，真的不容易，本来是想着能兼容一套程序实现对两款型号的支持，事与愿违，由于一些库函数的不兼容，放弃了这想法，只
少走弯路，ESP32 使用Micro SD(TF)的经验说明
Sean.Pu的专栏
08-27 1689
最初看网上的资料说D0,D1,D2,D3,CMD 这些都需要接上拉10K的电阻， CLK不需要接。从arduino换成了idf，从arduino ide换成platformio，还是无果。后来做其他尝试，换成了 39，40，47 ，居然可以1线SDMMC访问了。网上有些说法是有些电阻可以不要，于是重新贴片，某些电阻不贴，还是不行。不过，SPI方式倒是验证通过了，sdmmc方式始终不行。怀疑卡座问题，飞线把引脚接地，最初是没有接GND的。出于保险，CLK设计了电阻位，最初没有放上电阻。
Esp32_FileMgr文件管理器，Smartconfig配网，file web server网页管理SD卡文件
03-12
Esp32_FileMgr文件管理器， Smartconfig配网， SD卡file web server 网页管理SD卡文件，可下载，删除，编辑，重命名文件 Esp32cam直接使用。 支持MMC类型SD卡。
Arduino ESP32HttpWebServe服务端对SD卡进行文件上传和下载
perseverance51博客
11-25 3210
Arduino ESP32/8266 HttpWebServe服务端对SD卡进行文件上传和下载 实现的功能是，通过网页端，访问ESP32/8266,对挂载在ESP32/8266上的SD卡进行文件下载或者上传，相当于一个微型版的NVS，当然你也可以利用这个功能扩展更多丰富的其他功能。 主程序代码 /* * * ESP32/ESP8266 example of downloading and uploading a file from or to the ESP device's Fili
Arduino-ESP32 http客户端获取远程服务器文件并存SD卡
star_melon的博客
08-07 1941
实现 #include <HTTPClient.h> #include <WiFi.h> void getFile(String file_name) { HTTPClient http; Serial.print("[HTTP] begin...\n"); String storage_path = "/image/" + file_name; http.begin("http://host:port/file/" + file_name); Serial.prin
使用Arduino开发ESP32（14）：基于SD卡的Web服务器搭建
Naisu的各种笔记
06-21 6224
文章目录目的总结 目的 总结
Arduino ESP32 WebServe服务端对SD卡文件管理系统
perseverance51博客
11-26 1446
Arduino ESP8266 WebServe服务端对SD卡文件管理系统 实现的功能是，通过网页端，访问ESP8266,对挂载在ESP8266上的SD卡进行文件下载或者上传，相当于一个微型版的NAS（网络附属存储），当然你也可以利用这个功能扩展更多丰富的其他功能。 本次实验的对象是下面的这种下卡Micro SD卡（TF卡） 接线说明 SD card attached to SPI bus as follows: ** MOSI - D7 ---GPIO 13 ** MISO - D6
Arduino ESP32 Web服务器从microSD卡读取
perseverance51博客
11-26 1146
Arduino ESP32 Web服务器从microSD卡读取 将网页内容放到SD卡中，当有客户端数据请求时，从SD卡读取信息进行发送，比起SPIFFS文件系统，更节约板上的硬件资源。 SD卡接线说明 ESP32----- SD D5(GPIO 5)-----CS D18(GPIO 18)-----SCK D19(GPIO 19)-----MISO D23()GPIO 23-----MOSI 文件放置 需要把文件放置到SD卡的根目录下。注意SD卡的格式FAT32格式。 实例代码 /*
Arduino ESP8266 Web服务端SD卡文件管理系统V1.1
perseverance51博客
11-28 1084
Arduino ESP8266 Web服务端SD卡文件管理系统 上一版本《Arduino ESP8266 WebServe服务端对SD卡文件管理系统》 主要是针对上一版本的功能进一步添加和完善，每添加一个功能都不容易，只能一步一步进行，版本迭代。在之前的版本里面没有删除SD里面的文件的功能，这次加上了该功能，ESP32和ESP8266都需维护，真的不容易，本来是想着能兼容一套程序实现对两款型号的支持，事与愿违，由于一些库函数的不兼容，放弃了这想法，只能将程序分开。目前的程序，整体功能已经初步完成。后续
ESP8266 or ESP32开启WebServe服务实现文件上传和下载功能
perseverance51博客
08-19 1709
ESP8266 or ESP32开启WebServe服务实现文件上传和下载功能测试实例代码 本实例需要外接TF卡模块 Micro SD卡和MIni SD卡版本参数 需要的库 #ifdef ESP8266 #include <ESP8266WiFi.h> // Built-in #include <ESP8266WiFiMulti.h> // Built-in #include <ESP8266WebServer.h> // B
ESP32_bin文件
05-05
ESP32通过乐鑫官方FLASH下载工具烧录代码，其中所需要的四个bin文件
基于FreeRTOS的ESP32环境监测系统：利用Arduino框架实现SD卡数据记录与FTP服务器集成(二）---记录文件管理
Firmin123456的博客
04-28 934
在我的上篇文章中我把所有的温湿度数据都写到一份CSV文件中，这种会造成该文件越来越大，给系统读写带来压力，还会有一次读写错误后，整份纪录丢失的风险。因此，我将记录文件根据尺寸大小进行拆分。
【esp32-s3】6.2 文件系统——文件夹列表
qq_38091632的博客
05-01 2200
esp32s3 列出文件夹下的文件名称
Arduino ESP32当作FTP服务器 访问SD卡文件
perseverance51博客
11-30 4256
ESP32当作FTP服务器 访问SD卡文件 该项目原创来源于一位日本的开发者，今天来学习一下，但是也有国内开发者，在此基础上做了一版改进，我将会在下文当中，介绍苏荷搭建和使用。 开源项目原地址(采用的是镜像地址，国内访问无障碍)：https://hub.fastgit.org/robo8080/ESP32_FTPServer_SD 国内开发者在此基础上改的一版的地址：https://github.com/MollySophia/ESP32_FTPServer_SD 访问方式： 程序烧录完成后，串
esp32搭建文件服务器,ESP32入门示例 - SD卡Web服务器
weixin_29615645的博客
08-12 1747
这个是来自ESP32官方示例的改版，官方的示例由于存在一些问题所以我进行了修改原本的示例有点逻辑上的问题，所以进行了一些修改主要修改有：1.新增SD卡测试部分 复制自官方SD卡示例2.新增一个根目录页，访问根目录就可以看到3.修改了目录展示页，可以通过"ip地址/list"看到，原本这个页面只会返回"BAD ARGS"4.新增Wifi设置页，可以通过Wifi设置页更改链接的Wifi(但是建议不要随...
Arduino ESP32利用SDServer文件管理系统在线调取DHT历史数据
perseverance51博客
11-30 468
Arduino ESP32利用SDServer文件管理系统在线调取DHT历史数据 实验的目的：通过DHT温湿度传感器采集数据，并且将数据存储到SD内，通过浏览器网页访问挂载在ESP8266的上的SD卡，调取相关的文件数据，下载下来查看历史记录。类似于网络NVR的微型数据采集设备。 实验效果演示 接线说明 DHT11 DATA数据引脚接：D4 SD卡（2GB的TF卡配合卡槽使用） ESP32 ESP32 -----tf卡 VIN-----VCC GND----GND D5----CS
ESP32网络开发实例-从SD卡加载Web页面文件
视觉与物联智能
10-14 660
在文中，将展示如何构建一个 Web 服务器，为存储在SD卡中的 HTML 和 CSS 文件提供服务。 我们不必将 HTML 和 CSS 文本硬编码入代码中，而是创建单独的 HTML 和 CSS 文件。
Arduino ESP32 第三方库读取SD卡信息（三）
perseverance51博客
11-30 1557
Arduino ESP32 第三方库读取SD卡信息（三） 相关篇《Arduino ESP32 第三方库读取SD卡信息（一）》 《Arduino ESP32 第三方库读取SD卡信息（二）》 所需库github地址：https://github.com/nhatuan84/esp32-micro-sdcard 如果网页无法加载，将域名改为镜像地址的例如：https://hub.fastgit.org/nhatuan84/esp32-micro-sdcard 接线说明 [ESP32 IO26
ARDUINO ESP32从服务器下载文件到SD卡中
最新发布
09-11
Arduino ESP32可以通过网络连接到服务器，并从服务器下载文件保存到SD卡中。以下是实现这一功能的基本步骤： 1. 准备工作： - 确保你有一个可用的ESP32开发板。 - 准备一张SD卡，并将其插入ESP32的SD卡槽中。 - 确保ESP32已经安装了SD卡库（如SD库）和网络库（如WiFi库）。 2. 连接到网络： - 使用ESP32的WiFi库连接到你的网络。你需要提供SSID（网络名称）和密码。 3. 从服务器获取文件： - 使用ESP32的网络功能，建立与服务器的连接。通常使用HTTP协议来下载文件。 - 发送HTTP GET请求到服务器上的文件URL。 - 接收来自服务器的数据流，并将其写入SD卡。这通常涉及到打开一个文件流到SD卡，并将HTTP响应数据写入该文件流。 4. 关闭连接： - 下载完成后，关闭与服务器的连接和SD卡文件流，完成数据保存。 这里是一个简化的代码示例，展示如何实现这个过程（注意：这是一个概念示例，实际编程时需要根据实际情况调整错误处理和数据处理的细节）： ```cpp #include <WiFi.h> #include <HTTPClient.h> #include <SPI.h> #include <SD.h> // 替换以下宏定义为你的网络和文件信息 #define WIFI_SSID "yourSSID" #define WIFI_PASSWORD "yourPassword" #define SERVER_URL "http://example.com/file.txt" #define SD_CARDCHIP SELECTOR void setup() { Serial.begin(115200); // 连接WiFi WiFi.begin(WIFI_SSID, WIFI_PASSWORD); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.println("Connecting to WiFi..."); } Serial.println("Connected to WiFi"); // 初始化SD卡 if (!SD.begin(SD_CARDCHIP)) { Serial.println("SD卡初始化失败"); return; } } void loop() { // 检查SD卡是否准备好 if (!SD.begin(SD_CARDCHIP)) { Serial.println("Card Mount Failed"); return; } WiFiClient client; HTTPClient http; // 初始化HTTP客户端 http.begin(client, SERVER_URL); int httpCode = http.GET(); if (httpCode > 0) { // 请求成功 File file = SD.open("/file.txt", FILE_WRITE); if (file) { // 写入文件 file.print(http.getString()); file.close(); } else { Serial.println("Failed to open file in writing mode"); } } else { Serial.println("Error on HTTP request"); } http.end(); delay(10000); // 10秒后再次尝试下载 } ```
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值