# ESP32 P4 micro SD nutzen

**URL:** <https://forum.arduino.cc/t/esp32-p4-micro-sd-nutzen/1442039>\
**Category:** Deutsch\
**Created:** [April 29, 2026, 5:37pm UTC](https://forum.arduino.cc/t/esp32-p4-micro-sd-nutzen/1442039 "2026-04-29T17:37:43Z")\
**Posts on this page:** 5\
**Page:** 2

<div class="post-metadata">

**Author:** ![Tommy56](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/tommy56/32/232943_2.png) [@Tommy56](https://forum.arduino.cc/u/Tommy56)\
**Post date:** [April 30, 2026, 9:35pm UTC](https://forum.arduino.cc/t/esp32-p4-micro-sd-nutzen/1442039/21 "2026-04-30T21:35:47Z")

</div>

Auch das System von Fips und OTA kannst Du in einem rein lokalen Netzwerk realisieren. Für OTA muss allerdings der Rechner mit Deiner IDE im Netzwerk sein oder Du musst da einen Downloadserver für neue Images vorhalten. Auch dafür gibt es Beispiele.

Gruß Tommy

---

<div class="post-metadata">

**Author:** ![jochen69](https://avatars.discourse-cdn.com/v4/letter/j/73ab20/32.png) [@jochen69](https://forum.arduino.cc/u/jochen69)\
**Post date:** [May 1, 2026, 2:03am UTC](https://forum.arduino.cc/t/esp32-p4-micro-sd-nutzen/1442039/22 "2026-05-01T02:03:53Z")

</div>

Vielen Dank für die Anregungen,

aber wie gesagt, es wird in dem Netzwerk keinen Rechner geben, und der einzige Server dort wird einer der ESP's sein, der mit der SD drin.

Warum Http ? Weil es dafür die meisten Beispiele gibt.  
UDP, dort müsste ich die Daten selber überprüfen, und im Fehlerfall neu anfordern.  
TCP, würde gehen, aber es gibt wenige Beispiele.  
MQTT, da bin ich schon wieder bei einem Raspberry Pi.  
SQL wäre noch eine Möglichkeit. Gibt es auch für ESP's

Natürlich könnte man den ESP auch als Updateserver nutzen, neue Firmware auf SD und Bescheid geben, ist aber alles nicht notwendig, das alles hat nur eine Funktion, und wird sich nicht ändern.

Der Server ESP muss nur auf ein Get für ein File reagieren, die Daten werden in den anderen ESP's in ein Array geschrieben, und für Ausfallsicherheit zusätzlich in einem Fram gesichert.  
Daher reicht auch eine statische Seite im Code, die auf die eine Datei mit immer gleichen Namen auf der SD zeigt

Je einfacher desto besser, meine Programierkenntnisse haben beim C64 Basic mit ein bisschen ASM angefangen und sind dann, natürlich über einen Basic Interpreter, für AVR's gegangen.  
Und jetzt halt Arduino als IDE, hätte ich da mal etwas raus gelernt, wäre es wohl VS Code.

Aber egal, das fertige Ding muss nur seine Funktion erfüllen. Und ich s verstehen.  
Das mit der Seite im Code hatte ich bei einem angepasstem Beispiel des FSBrowsers gefunden.  
War leicht von WiFi auf LAN umzustricken, noch Abspecken bis auf die benötigte Funktion und gut.

So Hoffe ich.  
Und wenn es geht, verstehe wieder etwas mehr von Objektorientierter Programmierung.

Gruß Achim

---

<div class="post-metadata">

**Author:** ![horace](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/horace/32/1014299_2.png) [@horace](https://forum.arduino.cc/u/horace)\
**Post date:** [May 1, 2026, 7:34am UTC](https://forum.arduino.cc/t/esp32-p4-micro-sd-nutzen/1442039/23 "2026-05-01T07:34:24Z")

</div>

Ich habe keinen Waveshare ESP32-P4-ETH, sondern teste einen ähnlichen Waveshare ESP32-S3 ETH Development Board SD-Reader mit

```cpp
// Waveshare ESP32-S3 ETH Development Board SD card test modified to use VSPI
// see https://forum.arduino.cc/t/esp32-initialize-VSPI-as-default-spi/1155093/12

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-microsd-card-arduino/
  
  This sketch can be found at: Examples > SD(esp32) > SD_Test
*/

// define none default VSPI pins
#define VSPI_SCK 7
#define VSPI_MISO 5
#define VSPI_MOSI 6
#define SD_CS 4

#include "FS.h"
#include "SD.h"
#include "SPI.h"

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();
  }
}

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

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

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();
}

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();
}

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();
}

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

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

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, (unsigned int) 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, (unsigned int) end);
  file.close();
}

void setup() {
  Serial.begin(115200);
  delay(2000);
  SPI.begin(VSPI_SCK, VSPI_MISO, VSPI_MOSI, SD_CS); // setup SPI pins
  if (!SD.begin(SD_CS, SPI)) { // mount card
    Serial.println("Card Mount Failed");
    return;
  }
  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");
  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() {
}

```

Du musst den SPI ändern Definitionen, die mit dem Waveshare ESP32-P4-ETH übereinstimmen

```cpp
// define none default VSPI pins
#define VSPI_SCK 7
#define VSPI_MISO 5
#define VSPI_MOSI 6
#define SD_CS 4

```

Serieller Monitorausgang

```arduino
SD Card Type: SDHC
SD Card Size: 29862MB
Listing directory: /
  DIR : System Volume Information
  FILE: ESP32-S3-ETH-Schematic.pdf SIZE: 793140
  DIR : ESP32_S3_microSD_card_VSPI_1
  FILE: test.txt SIZE: 1048576
  FILE: foo.txt SIZE: 13
Creating Dir: /mydir
Dir created
Listing directory: /
  DIR : System Volume Information
  FILE: ESP32-S3-ETH-Schematic.pdf SIZE: 793140
  DIR : ESP32_S3_microSD_card_VSPI_1
  FILE: test.txt SIZE: 1048576
  FILE: foo.txt SIZE: 13
  DIR : mydir
Removing Dir: /mydir
Dir removed
Listing directory: /
  DIR : System Volume Information
Listing directory: System Volume Information
Failed to open directory
  FILE: ESP32-S3-ETH-Schematic.pdf SIZE: 793140
  DIR : ESP32_S3_microSD_card_VSPI_1
Listing directory: ESP32_S3_microSD_card_VSPI_1
Failed to open directory
  FILE: test.txt SIZE: 1048576
  FILE: foo.txt SIZE: 13
Writing file: /hello.txt
File written
Appending to file: /hello.txt
Message appended
Reading file: /hello.txt
Read from file: Hello World!
Deleting file: /foo.txt
File deleted
Renaming file /hello.txt to /foo.txt
File renamed
Reading file: /foo.txt
Read from file: Hello World!
1048576 bytes read for 2471 ms
1048576 bytes written for 2659 ms
Total space: 29850MB
Used space: 2MB

```

---

<div class="post-metadata">

**Author:** ![jochen69](https://avatars.discourse-cdn.com/v4/letter/j/73ab20/32.png) [@jochen69](https://forum.arduino.cc/u/jochen69)\
**Post date:** [May 1, 2026, 11:35am UTC](https://forum.arduino.cc/t/esp32-p4-micro-sd-nutzen/1442039/24 "2026-05-01T11:35:38Z")

</div>

Hallo,

das hab ich auch hier rumliegen (S3), war für das Projekt nicht so gut, weil Wlan und Bluetooth on Board. Der S3 ist dafür besser unterstützt im Arduino Core.  
Und "Wireless Hardware" wird nicht so gern von der IT gesehen , besonderst wenn sie nicht unter deren Kontrolle ist.  
Das 10,1" TouchDisplay ist natürlich auch ein Grund für das P4, und wenn ich das Display doch nicht nutze, kommt es an meinen irgendwann mal fertige 3d-Drucker. ;-)

Mittlerweile geht die SD ja, lag vermuliche nur an der µSD.  
Nächste Baustelle ist der Fileserver, statische Seite (im Code), der nur die eine Datei von SD anbietet.  
Kein Upload, Rename, Dir, oder so. Einfach nach einem Http Get die Datei rüberschieben.

Also beispiele lesen lesen lesen. Mal Schauen.

Gruß Achim

---

<div class="post-metadata">

**Author:** ![jochen69](https://avatars.discourse-cdn.com/v4/letter/j/73ab20/32.png) [@jochen69](https://forum.arduino.cc/u/jochen69)\
**Post date:** [May 2, 2026, 1:35pm UTC](https://forum.arduino.cc/t/esp32-p4-micro-sd-nutzen/1442039/25 "2026-05-02T13:35:39Z")

</div>

Hallo,

und die nächste Frage zur SD Karten Nutzung.  
Muss ich Diese beim wechseln im Betrieb "auwerfen" ?

Also am einfachsten einen Taster der je nach Status die SD Einbindet, oder halt Auswirft.  
Status auf LCD anzeigen und Gut.

Und wenn ja, wie. ?  
SD.end() scheint das richtige zu sein, und macht es Sinn die VDD abzuschalten.  
Also digitalWrite(45, HIGH) bei meinem Board.  
Und einbinden wieder mit digitalWrite(45, LOW) und SPI.begin.

Zur Info,  
Da der ESP sich damit eher langweilt, versuche ich noch eine NTP-Server mit einzbauen. (über GPS)  
Ich hoffe da beisst sich nichts mit dem ESPAsyncWebServer,

Gruß Achim

Der FileServer macht was er soll, so Simple wie nötig  
`void start_server() {`  
` // Einfacher File-Explorer`  
` server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {`  
` String fileList = "<h1>Dateien:</h1><ul>";`  
` File root = SD.open("/");`  
` File file = root.openNextFile();`  
` while (file) {`  
` fileList += "<li><a href='/dl?file=" + String(file.name()) + "'>" + String(file.name()) + "</a></li>";`  
` file = root.openNextFile();`  
` }`  
` request->send(200, "text/html", fileList + "</ul>");`  
` });`  
` // Datei-Download`  
` server.on("/dl", HTTP_GET, [](AsyncWebServerRequest *request) {`  
` if (request->hasParam("file"))`  
` request->send(SD, "/" + request->getParam("file")->value(), "application/octet-stream");`  
` });`  
` server.begin();`  
` return;`  
`}`

[Previous page](https://forum.arduino.cc/t/esp32-p4-micro-sd-nutzen/1442039.md?page=1)