Tento článek vysvětlí kroky pro propojení MicroSD karty s deskou ESP32 pomocí Arduino IDE.
Obsah:
2. Jak propojit ESP32 s modulem karty MicroSD
6. Provádění různých funkcí na MicroSD kartě pomocí ESP32
- 6.1. Vytváření adresářů na MicroSD kartě
- 6.2. Výpis adresářů na MicroSD kartě
- 6.3. Odebírání adresářů
- 6.4. Získejte typ karty MicroSD
- 6.5. Získejte velikost SD karty
1. Modul karty MicroSD
Modul karty MicroSD je snímač ESP32, který může připojit kartu SD k desce mikrokontroléru. Funguje přes komunikační protokol SPI. Umožňuje ESP32 nebo jakékoli jiné desce mikrokontroléru, jako je Arduino, přístup k datům uloženým na SD kartě přes protokol SPI.
Pracovní napětí pro modul SD karty je 3,3V, není tedy možné jej přímo připojit k ESP32 nebo jiné desce mikrokontroléru. K tomu musíme použít modul SD karty nebo senzor, který pracuje nad 5V.
1.1. Pinout
MicroSD karta má celkem šest pinů. Dva z nich jsou napájecí kolíky: VCC a GND. Při čtení jsou čtyři piny použity pro komunikační protokol SPI. Níže jsou uvedeny podrobnosti o všech těchto šesti pinech:
Napájecí kolíky:
- VCC: Připojuje se k 5V kolíku ESP32.
- GND: Připojuje se k zemnicímu (GND) kolíku ESP32.
Piny SPI:
- MISO: (Master In Slave Out) Připojuje se ke kolíku ESP32 MOSI (Master Out Slave In).
- KOUŘ: Připojuje se k pinu ESP32 MISO (Master In Slave Out).
- SCK: Připojuje se ke kolíku ESP32 SCK (Serial Clock).
- SS: (Slave Select) Připojuje se ke kolíku specifikovanému v kódu Arduino jako kolík SS (Slave Select).
2. Jak propojit ESP32 s modulem karty MicroSD
Chcete-li propojit ESP32 s modulem karty MicroSD, budete muset nastavit napájecí kolíky pro snímač karty SD. Dále nastavte piny SPI. Zde máte dvě možnosti, můžete buď nastavit výchozí piny SPI, nebo definovat své vlastní piny SPI.
Při použití výchozích pinů SPI přidáme SD h a SD_MMC.h knihovny. Ve výchozím nastavení tyto knihovny používají piny VSPI SPI (23, 19, 18, 5) pro komunikaci SPI. Pro SPI komunikaci však můžete nastavit i další piny.
ESP32 obsahuje dvě SPI rozhraní HSPI a VSPI s podrobnostmi o jejich pinech následovně:
| SPI | KOUŘ | MISO | CLK | CS |
| VSPI | D23 | D19 | D18 | D5 |
| HSPI | D13 | D12 | D14 | D15 |
Příbuzný: ESP32 Pinout Reference – Kompletní průvodce
2.2. Připravte si SD kartu
Dále, než budete moci pokračovat se čtením a zápisem dat na kartu MicroSD, musíte ji nejprve nastavit naformátováním všech předchozích dat na ní.
Otevřete SD kartu pomocí libovolné čtečky karet a formát to.
Vyberte FAT32 pro souborový systém vaší karty a klikněte Start .
Po naformátování karty vyberte OK .
Nyní je vaše SD karta připravena k propojení s ESP32 pomocí modulu SD karty.
2.3. Schematický diagram
Chcete-li připojit snímač MicroSD karty k ESP32, postupujte podle níže uvedené konfigurace:
Níže je uvedena tabulka pro konfiguraci pinů propojovacího vodiče:
| MicroSD karta | ESP32 |
| GND | GND |
| VCC | PŘIJÍT |
| CS | D5 |
| KOUŘ | D23 |
| SCK | D18 |
| MISO | D19 |
3. Hardware
Pro hardware potřebujete jen propojovací kabely a prkénko spolu s ESP32 a modulem SD karty.
4. Kód
Nyní napíšeme kód, který vytvoří textový soubor uvnitř MicroSD karty a poté do něj zapíše nějaký textový řetězec. Po dokončení přečteme obsah textového souboru na sériovém monitoru Arduino IDE.
Spusťte Arduino IDE a zkompilujte daný kód. Poté jej vypalte na desku ESP32:
#include#include
Soubor myFile ;
konst int CS = 5 ;
// Zapíše danou zprávu do souboru na zadané cestě
prázdnota WriteFile ( konst char * cesta , konst char * zpráva ) {
// Otevřete soubor. Podporuje otevírání jednoho souboru najednou
// před otevřením nového souboru zavřete druhý soubor
myFile = SD. OTEVŘENO ( cesta , FILE_WRITE ) ;
-li ( myFile ) {
Seriál. printf ( 'Zápis do %s' , cesta ) ;
myFile. println ( zpráva ) ;
myFile. zavřít ( ) ; // Zavřete soubor
Seriál. println ( 'dokončeno.' ) ;
} jiný {
Seriál. println ( 'chyba při otevírání souboru' ) ;
Seriál. println ( cesta ) ;
}
}
// Tisk obsahu souboru na zadané cestě
prázdnota ReadFile ( konst char * cesta ) {
// Otevřít soubor
myFile = SD. OTEVŘENO ( cesta ) ;
-li ( myFile ) {
Seriál. printf ( 'Čtení souboru z %s \n ' , cesta ) ;
// Přečíst celý soubor, dokud nedosáhnete posledního
zatímco ( myFile. dostupný ( ) ) {
Seriál. napsat ( myFile. číst ( ) ) ;
}
myFile. zavřít ( ) ; // Zavřete soubor
} jiný {
// Pokud se soubor nepodařilo otevřít, vytiskněte chybu:
Seriál. println ( 'chyba při otevírání souboru test.txt' ) ;
}
}
prázdnota založit ( ) {
Seriál. začít ( 9600 ) ;
zpoždění ( 500 ) ;
zatímco ( ! Seriál ) { ; }
Seriál. println ( 'Inicializace SD karty...' ) ;
-li ( ! SD. začít ( CS ) ) {
Seriál. println ( 'Inicializace se nezdařila!' ) ;
vrátit se ;
}
Seriál. println ( 'Inicializace dokončena.' ) ;
WriteFile ( '/test.txt' , 'Linuxhint.com' ) ;
ReadFile ( '/test.txt' ) ;
}
prázdnota smyčka ( ) {
}
4.1. Vysvětlení kódu
Pro lepší pochopení rozdělíme tento kód na podčásti.
Inicializace a nastavení: Nejprve kód začal zahrnutím některých důležitých knihoven souvisejících s modulem SD karty. Je přidána knihovna SPI.h pro komunikaci s SD kartou a SD.h pro obsluhu operací s SD kartou. Dále definuje globální proměnnou myFile typu souboru pro správu operací se soubory. Konstanta CS je nastavena na kolík 5, který bude použit jako kolík výběru čipu (CS) pro kartu SD.
Funkce Setup(): Uvnitř funkce nastavení se spustí sériová komunikace. Poté jsme inicializovali modul SD karty pomocí funkce SD.begin(CS). Dále jsme také definovali dvě různé funkce pro čtení a zápis textu do textového souboru.
Zápis na SD kartu: Funkce WriteFile() otevře soubor test.txt pro zápis pomocí SD.open(cesta, FILE_WRITE). Poté zapíše řetězec Linuxhint.com do souboru pomocí myFile.println(message).
Čtení z SD karty: Ke čtení obsahu souboru jsme použili funkci ReadFile(). V případě úspěšného načtení budou data odeslána na sériový port Arduino a zobrazena na sériovém monitoru Arduino IDE.
5. Výstup
Na výstupu můžete vidět stejný řetězec, který jsme definovali v kódu Arduino IDE, zobrazený na vašem sériovém monitoru Arduino IDE.
6. Provádění různých funkcí na MicroSD kartě pomocí ESP32
Můžeme provádět různé operace, jako je vytváření, odebírání nebo přidávání adresářů na kartách MicroSD přímo prostřednictvím kódu Arduino IDE.
6.1. Vytváření adresářů na MicroSD kartě
Níže uvedený kód vytvoří nový adresář na kartě MicroSD. Definuje funkci tzv createDir který bere jako vstup objekt systému souborů (fs::FS) a cestu. Tato funkce se pokusí vytvořit adresář se zadanou cestou a vytiskne zprávy o úspěchu nebo selhání.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
prázdnota createDir ( fs :: FS & fs , konst char * cesta ) {
Seriál. printf ( 'Vytvářím adresář: %s \n ' , cesta ) ;
-li ( fs. mkdir ( cesta ) ) {
Seriál. println ( 'Dir vytvořen' ) ;
} jiný {
Seriál. println ( 'mkdir se nezdařil' ) ;
}
}
prázdnota založit ( ) {
Seriál. začít ( 115200 ) ;
// Inicializace SD karty
-li ( ! SD. začít ( ) ) {
Seriál. println ( 'Připojení karty se nezdařilo' ) ;
vrátit se ;
}
// Vytvořte adresář s názvem 'mydir'
createDir ( SD , '/mydir' ) ;
}
prázdnota smyčka ( ) {
}
Ve výstupu můžete vidět, že je vytvořen nový adresář s /mydir název.
6.2. Výpis adresářů na MicroSD kartě
V níže uvedeném kódu uvedeme seznam všech adresářů přítomných na kartě MicroSD. The seznamDir funkce rekurzivně vypíše obsah adresáře na SD kartě. Tiskne informace jak o adresářích (s předponou „DIR“), tak o souborech (s předponou „FILE“), včetně jejich názvů a velikostí.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
prázdnota seznamDir ( fs :: FS & fs , konst char * dirname , uint8_t úrovně ) {
Seriál. printf ( 'Výpis adresáře: %s \n ' , dirname ) ;
Kořen souboru = fs. OTEVŘENO ( dirname ) ;
-li ( ! vykořenit ) {
Seriál. println ( 'Nepodařilo se otevřít adresář' ) ;
vrátit se ;
}
-li ( ! vykořenit. isDirectory ( ) ) {
Seriál. println ( 'Není adresář' ) ;
vrátit se ;
}
Soubor souboru = vykořenit. otevřít NextFile ( ) ;
zatímco ( soubor ) {
-li ( soubor. isDirectory ( ) ) {
Seriál. tisk ( ' VY : ' ) ;
Seriál. println ( soubor. název ( ) ) ;
-li ( úrovně ) {
seznamDir ( fs , soubor. název ( ) , úrovně - 1 ) ;
}
} jiný {
Seriál. tisk ( 'SOUBOR:' ) ;
Seriál. tisk ( soubor. název ( ) ) ;
Seriál. tisk ( 'VELIKOST:' ) ;
Seriál. println ( soubor. velikost ( ) ) ;
}
soubor = vykořenit. otevřít NextFile ( ) ;
}
}
prázdnota založit ( ) {
Seriál. začít ( 115200 ) ;
-li ( ! SD. začít ( ) ) {
Seriál. println ( 'Připojení karty se nezdařilo' ) ;
vrátit se ;
}
seznamDir ( SD , '/' , 0 ) ;
}
prázdnota smyčka ( ) {
}
Ve výstupu můžete vidět dva různé soubory. Jeden je textový soubor a druhý je adresář, který jsme vytvořili v předchozím kódu.
6.3. Odebírání adresářů
Nyní odstraníme dříve vytvořené adresáře a textové soubory. K tomu použijeme removeDir funkce, pokusí se odstranit adresář určený cestou. V případě úspěchu se vytiskne Dir odstraněn ; jinak se vytiskne rmdir se nezdařilo .
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
prázdnota removeDir ( fs :: FS & fs , konst char * cesta ) {
Seriál. printf ( 'Odstranění adresáře: %s \n ' , cesta ) ;
-li ( fs. je rm ( cesta ) ) {
Seriál. println ( 'Dir odstraněn' ) ;
} jiný {
Seriál. println ( 'rmdir selhal' ) ;
}
}
prázdnota založit ( ) {
Seriál. začít ( 115200 ) ;
-li ( ! SD. začít ( ) ) {
Seriál. println ( 'Připojení karty se nezdařilo' ) ;
vrátit se ;
}
}
prázdnota smyčka ( ) {
}
6.4. Získejte typ karty MicroSD
MicroSD karta popř S bezpečný D digitální karta byla původně navržena asociací SD karet a navržena pro použití v přenosných zařízeních, jako jsou chytré telefony a fotoaparáty. SD karty obsahují hlavně čtyři typy rodin:
- SDSC (SD se standardní kapacitou): Tyto karty nabízejí skromný rozsah úložné kapacity 2 GB a používají systémy souborů FAT-12 a FAT-16.
- SDHC (vysokokapacitní SD): Tyto karty mají velikost od 2 GB do 32 GB a používají souborový systém FAT-32.
- SDXC (SD s rozšířenou kapacitou): Tyto karty používají souborový systém exFAT a začínají od 32 GB až po 2 TB.
- SDIO: Karty SDIO slouží dvojímu účelu tím, že kombinují ukládání dat s funkcemi INPUT/OUTPUT.
Chcete-li zkontrolovat typ karty, spusťte níže uvedený kód:
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
prázdnota založit ( ) {
Seriál. začít ( 115200 ) ;
-li ( ! SD. začít ( ) ) {
Seriál. println ( 'Připojení karty se nezdařilo' ) ;
vrátit se ;
}
uint8_t cardType = SD. cardType ( ) ;
-li ( cardType == CARD_NONE ) {
Seriál. println ( 'Není připojena SD karta' ) ;
vrátit se ;
}
Seriál. tisk ( 'Typ karty SD:' ) ;
-li ( cardType == CARD_MMC ) {
Seriál. println ( 'MMC' ) ;
} jiný -li ( cardType == CARD_SD ) {
Seriál. println ( 'SDSC' ) ;
} jiný -li ( cardType == CARD_SDHC ) {
Seriál. println ( 'SDHC' ) ;
} jiný {
Seriál. println ( 'NEZNÁMÝ' ) ;
}
uint64_t velikost karty = SD. velikost karty ( ) / ( 1024 * 1024 ) ;
Seriál. printf ( 'Velikost karty SD: %lluMB \n ' , velikost karty ) ;
}
prázdnota smyčka ( ) {
}
Jelikož mám 32GB kartu, je vidět, že leží v rozsahu SDHC karty.
6.5. Získejte velikost karty MicroSD
Velikost SD karty můžete také získat nahráním níže uvedeného kódu na vaši desku ESP32.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
prázdnota založit ( ) {
Seriál. začít ( 115200 ) ;
-li ( ! SD. začít ( ) ) {
Seriál. println ( 'Připojení karty se nezdařilo' ) ;
vrátit se ;
}
uint8_t cardType = SD. cardType ( ) ;
-li ( cardType == CARD_NONE ) {
Seriál. println ( 'Není připojena SD karta' ) ;
vrátit se ;
}
uint64_t velikost karty = SD. velikost karty ( ) / ( 1024 * 1024 ) ;
Seriál. printf ( 'Velikost karty SD: %lluMB \n ' , velikost karty ) ;
// Zde lze volat další funkce (listDir, createDir, removeDir atd.).
}
prázdnota smyčka ( ) {
}
Z výstupu můžete vidět, že mám SD kartu přibližně 30 GB.
Závěr
Pro čtení a zápis dat z SD karty pomocí desky ESP32 se používá modul MicroSD karty. Modul karty MicroSD komunikuje s mikrokontrolérem pomocí rozhraní SPI. Můžete tedy buď použít knihovnu SPI, nebo definovat své vlastní piny SPI uvnitř kódu. Po připojení můžete číst, zapisovat textový soubor nebo vytvářet nové adresáře na SD kartě.