ESP32 Pico-Board SD-Card https://erik-bartmann.de/ ESP32 Addon SD-Card Vers. 1.1 by Erik Bartmann, November 2018
S D - C a r d I n diesem ESP32-Addon wollen wir uns dem Thema der permanenten Datenspeicherung widmen. Es gibt Möglichkeiten, Messdaten z.b. im einem EEPROM (Electrical Erasable Programmable Read Only Memory), also einem ist ein elektrisch lösch- und programmierbarer Halbleiterspeicher abzulegen. Im Mikrocontroller eines Arduino ist ein derartiger Bereich vorhanden. Der ESP32 verfügt ebenfalls über einen ähnlichen Speicher, der mithilfe der Arduino-EEPROM-Library Daten mit einem Volumen bis zu 512 Bytes in einem Flash-Speicher ablegt. Doch das ist nicht unser Thema dieses Addons. Wir wollen größere Datenmengen speichern und was bietet sich besser an, als die Flut von Daten, die manchmal anfallen, auf einer SD- Karte zu speichern. Der ESP32 kann natürlich - wie auch der Arduino - eine SD- Karte ansprechen. Das erfolgt über den SPI-Bus, der vom ESP32 unterstützt wird. Ein SD-Card- Reader ist schon für unter 4 zu bekommen und es werden Typen für SD- bzw. Mikro-SD-Karten angeboten. Die Wahl bleibt jedem selbst überlassen und spiel im Endeffekt keine Rolle. SD-Card https://erik-bartmann.de/ Seite 2
Erforderliche Libraries D a zur Ansteuerung einer SD-Karte auf dem ESP32 der SPI-Bus mit den Signalen MOSI, MISO, SCK und CS verwendet werden, ist eine zusätzliche Installation einer Library nicht erforderlich, denn sie ist standardmäßig schon in der Arduino- Entwicklungsumgebung implementiert. Die Einbindung erfolgt über #include <SPI.h> Das ist jedoch nur die halbe Miete, denn es ist noch eine weitere softwaremäßige Unterstützung von Nöten. Die Daten müssen auf der SD-Karte ja in einem bestimmten Filesystem abgelegt werden. Es werden hierbei FAT16 bzw. FAT32 für SD- bzw. SDHC- Karten unterstützt. Die Einbindung erfolgt über #include "SD.h" Der SD-Card Adapter E s gibt auf dem Markt die unterschiedlichsten SD-Card-Adapter bzw.- Module mit einer SPI-Anbindung. In meiner Kramkiste habe ich den folgenden gefunden und ich kann noch nicht einmal sagen, von welcher Firma das Teil ist. Von irgendwo aus chinesischen Gefilden vermute ich. Abbildung 1 Ein SD-Card-Adapter In meinem Fall muss der Adapter mit einer normalen SD-Karte bestückt werden. Es gibt jedoch auch sogenannte microsd-karten. Auf der folgenden Abbildung sind beide Varianten zu sehen. 3 SD-Card
Abbildung 2 micro-sd und SD-Karte Für den Fall, dass jemand ein SD-Card-Adapter besitzt, jedoch eine microsd-karte, bedeutet das nicht unbedingt ein Drama, denn es gibt entsprechende micro-adapter, die eine microsd-karte aufnehmen und es ermöglichen, einen SD-Card-Adapter damit zu füttern. Abbildung 3 Der micro-adapter Sehen wir uns kurze die Anschlüsse des SD-Card-Adapters aus der Nähe an. Auf der Abbildung kann man die einzelnen Pins aufgrund der Beschriftung eindeutig identifizieren. Die hier gezeigte Reihenfolge ist bei unterschiedlichen Adaptern nicht immer gleich und ich rate, auf jeden Fall auf die Pinbeschreibung zu achten. Abbildung 4 Der SD-Card-Adapter mit seinen Pins 4 SD-Card
Die Formatierung der SD-Karte Kommen wir zur Formatierung der SD-Karte, die in anhand des Windows-Betriebssystems zeige. Für die Formatierung einer SD-Karte ist natürlich ein SD-Card-Reader erforderlich, auf den ich nicht weiter eingehe. Nach dem Einstecken der SD-Karte in den Reader ist sie normalerweise im Windows-Explorer sichtbar. Abbildung 5 Die SD-Karte im Dateisystem Es ist an dieser Stelle sehr wichtig darauf zu achten, on auch das richtige Laufwerk ausgewählt ist. Eine unbeabsichtigte Formatierung ist schnell durchgeführt und die Restaurierung der verlorenen Daten kann einiges an Stress bedeuten und nicht immer von Erfolg gekrönt sein. Ab besten steckt man die Karte ein und zieht sie nach dem Erkennen durch das Betriebssystem wieder heraus. Durch die Beobachtung des Explorers bei diesem Vorgang kann der Laufwerksbuchstabe der SD-Karte eigentlich zweifelsfrei ermittelt werden. Gehen wir davon aus, dass der richtige Laufwerksbuchstabe identifiziert wurde und wählen dann den Menüpunkt Formatieren aus. 5 SD-Card
Es öffnet sich ein Dialogfenster, in dem im ersten Schritt das gewünschte Dateisystem - für uns FAT32 - gewählt werden kann. Die Formatierung beginnt mit dem Klick auf die Starten-Schaltfläche, wobei die Formatierungsoption Schnellformatierung angewählt bleiben kann. Nach dem Bestätigen der Abfrage, ob die Formatierung wirklich durchgeführt werden soll, endet der Vorgang mit der Meldung über die erfolgreich abgeschlossene Formatierung. Abbildung 6 Die Formatierung der SD-Karte wurde erfolgreich abgeschlossen Nun kann die SD-Karte in den SD-Card-Adapter eingeschoben werden, wobei sie mit leichtem Druck hörbar (Klick-Klick ) einrastet, was nur bei normalen SD-Karten der Fall ist. 6 SD-Card
Abbildung 7 Die eingeschobene SD-Karte Sehen wir uns den Schaltungsaufbau und den Schaltplan an. Der Schaltungsaufbau und der Schaltplan F ür einen ersten Test habe ich den SD-Card-Adapter auf dem kleinen Breadboard des ESP32-Pico-Discoveryboards [1] platziert und durch flexiblen Steckbrücken (Male-Female) mit dem ESP32 verbunden. Abbildung 8 Der SD-Card-Adapter auf dem ESP32-Pico-Discoveryboard 7 SD-Card
Da die genaue Verkabelung aus dieser Ansicht etwas schwierig ist, liefere ich den Schaltplan nach, der wie folgt ausschaut. Abbildung 9 Der Schaltplan zur Ansteuerung des SD-Card-Adapters Es ist gut zu sehen, dass die einzelnen Anschlüsse des SPI-Busses verwendet werden. Sie sind ebenfalls auf dem ESP32-Pico-Discoveryboard beschriftet, so dass eine längere Suche nach den korrekten Pins entfällt. IO19/MISO IO23/MOSI IO18/SCLK IO05/CS Abbildung 10 Die SPI-Pins auf dem ESP32-Pico-Discoveryboard Nach diesen vorbereitenden Informationen können wir uns den ESP32-Code anschauen. 8 SD-Card
Der ESP32-Code F ür einen ersten Code-Test wollen wir eine Datei auf der SD-Karte anlegen und diese mit ein paar Informationen versehen. Wichtig bei derartigen Aktionen der Speicherung von Daten sind neben den eigentlichen Daten, Zusatzinformationen wie z.b. das Datum. Darüber lassen sich dann später detaillierte Auswertungen bzw. Reporte generieren. Doch dazu in einem späteren SD-Addon mehr. Der folgende Code basiert auf den ESP32-Beispielen, die unter dem Menü Datei Beispiele SD(esp32) zu finden sind. Dem zu Grunde liegen die folgenden Methoden für den Zugriff auf die SD- Karte. listdir 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(); 9 SD-Card
createdir 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"); removedir 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"); readfile 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(); 10 SD-Card
writefile 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(); appendfile 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(); 11 SD-Card
renamefile 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"); deletefile 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"); testfileio 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 { 12 SD-Card
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(); Schauen wir uns aufgrund der hier gezeigten Methoden den Hauptsketch an, wobei die Anweisungen lediglich in der setup-funktion zu finden sind und einmalig ausgeführt werden. Der Hauptsketch Der ESP32-Code für dieses Addon [2] ist unter der folgenden Internetadresse herunterzuladen. https://github.com/erikbartmann/elektoresp32/tree/master/addons/sdcard Der Code des Hauptsketches schaut wie folgt aus. #include "FS.h" #include "SD.h" #include "SPI.h" #include "SDAccess.h" void setup() { Serial.begin(9600); if (!SD.begin()) { Serial.println("Card Mount Failed"); return; uint8_t cardtype = SD.cardType(); if (cardtype == CARD_NONE) { Serial.println("No SD card attached"); 13 SD-Card
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"); */ writefile(sd, "/data.log", "Das ist der erste Eintrag in der 1.Zeile\r\n"); appendfile(sd, "/data.log", "Das ist der nächste Eintrag in 2.Zeile\r\n"); appendfile(sd, "/data.log", "Das ist der nächste Eintrag in 3.Zeile\r\n"); void loop() { /* leer */ Über die writefile-methode wird initial die Text- bzw. Log-Datei auf der SD-Karte erzeugt. Falls sie schon unter dem Namen vorhanden sein sollte, wird sie überschrieben. Über die appendfile-methode wird der genannten Datei eine neue Zeile hinzugefügt. 14 SD-Card
Sehen wir uns zunächst die Statusmeldungen im Serial-Monitor an. Abbildung 11 Die Anzeigen im Serial-Monitor Es ist zu erkennen, dass die Log-Datei erzeugt und nachfolgend zwei Nachrichten hinzugefügt wurden. Der Inhalt der Log-Datei gestaltet sich dann wie folgt. Abbildung 12 Der Inhalt der Log-Datei Über die anderen Methoden, die im Hauptsketch auskommentiert waren, sind entsprechende Funktionen aufrufbar, wobei die Namen sprechend sind und hier nicht erläutert werden müssen. 15 SD-Card
Ein anderer SD-Karten-Adapter E s gibt auch SD-Karten Adapter, die über einen einzigen Spannungsversorgungspin lediglich mit 5V betrieben werden können. Er besitzt dann meistens die Bezeichnung Vcc. Um ganz sicher zu sein, sollte das Datenblatt des Herstellers zur Rate gezogen werden. Abbildung 13 SD-Karten-Adapter mit einem einzigen Spannungsversorgungspin für 5V Über einen auf der Platine befindlichen Spannungswandler (LDO Low-Drop-Out) wird die angelegte Spannung von 5V auf 3,3V heruntergeregelt. Es ist natürlich ebenfalls wichtig, dass z.b. die Datenleitungen MISO/MOSI ebenfalls mit 3,3V arbeiten, denn das ESP32-Board soll nicht durch eine Signalleitung, die einen Spannungspegel von 5V aufweist, beschädigt werden. 16 SD-Card
Im nächsten ESP32-SDCard-Addon werden wir uns mit der Messwertaufnahme und SD-Karten Speicherung befassen. Frohes Frickeln Web-Links [1]: https://www.erik-bartmann.de/?projekte ESP32_Discovery-Board [2]: https://github.com/erikbartmann/elektoresp32/tree/master/addons/sdcard Das ESP32-Praxisbuch https://www.elektor.de/das-esp32-praxisbuch https://www.erik-bartmann.de/ 17 SD-Card