Questo articolo spiegherà i passaggi per interfacciare una scheda MicroSD con una scheda ESP32 utilizzando l'IDE Arduino.
Sommario:
2. Come interfacciare ESP32 con il modulo scheda MicroSD
6. Esecuzione di diverse funzioni sulla scheda MicroSD utilizzando ESP32
- 6.1. Creazione di directory nella scheda MicroSD
- 6.2. Elenco delle directory nella scheda MicroSD
- 6.3. Rimozione di directory
- 6.4. Ottieni il tipo di scheda MicroSD
- 6.5. Ottieni la dimensione della scheda SD
1. Modulo scheda MicroSD
Il modulo della scheda MicroSD è un sensore ESP32 che può collegare la scheda SD alla scheda del microcontrollore. Funziona tramite il protocollo di comunicazione SPI. Consente all'ESP32 o a qualsiasi altra scheda microcontrollore come Arduino di accedere ai dati memorizzati sulla scheda SD tramite il protocollo SPI.
La tensione di lavoro per il modulo della scheda SD è 3,3 V, quindi non è possibile collegarlo direttamente all'ESP32 o a qualsiasi altra scheda microcontrollore. Per questo, dobbiamo utilizzare il modulo della scheda SD o il sensore che funziona a 5 V.
1.1. Piedinatura
La scheda MicroSD dispone di un totale di sei pin. Due di questi sono pin di alimentazione: VCC e GND. Mentre i quattro pin di lettura vengono utilizzati per il protocollo di comunicazione SPI. Di seguito sono riportati i dettagli per tutti questi sei pin:
Pin di alimentazione:
- CCV: Si collega al pin ESP32 5V.
- TERRA: Si collega al pin di terra (GND) dell'ESP32.
Pin SPI:
- MISO: (Master In Slave Out) Si collega al pin ESP32 MOSI (Master Out Slave In).
- FUMO: Si collega al pin ESP32 MISO (Master In Slave Out).
- SCK: Si collega al pin ESP32 SCK (orologio seriale).
- SS: (Slave Select) Si collega al pin specificato nel codice Arduino come pin SS (Slave Select).
2. Come interfacciare ESP32 con il modulo scheda MicroSD
Per interfacciare ESP32 con il modulo della scheda MicroSD, dovrai configurare i pin di alimentazione per il sensore della scheda SD. Quindi imposta i pin SPI. Qui hai due scelte: puoi impostare i pin SPI predefiniti o definire i tuoi pin SPI personalizzati.
Quando si utilizzano pin SPI predefiniti, aggiungeremo il file SD h E SD_MMC.h biblioteche. Per impostazione predefinita, queste librerie accettano i pin VSPI SPI (23, 19, 18, 5) per la comunicazione SPI. Tuttavia è possibile impostare anche altri pin per la comunicazione SPI.
L'ESP32 contiene due interfacce SPI HSPI e VSPI con i dettagli dei pin come segue:
| SPI | FUMO | MISO | CLK | CS |
| VSPI | D23 | D19 | D18 | D5 |
| HSPI | D13 | D12 | D14 | D15 |
Imparentato: Riferimento alla piedinatura ESP32: una guida completa
2.2. Prepara la scheda SD
Successivamente, prima di poter procedere con la lettura e la scrittura dei dati su una scheda MicroSD, devi prima configurarla formattando tutti i dati precedenti in essa contenuti.
Apri la tua scheda SD utilizzando qualsiasi lettore di schede e formato Esso.
Seleziona FAT32 per il file system della tua scheda e fai clic su Inizio .
Dopo aver formattato la scheda, seleziona OK .
Ora la tua scheda SD è pronta per essere interfacciata con ESP32 utilizzando il modulo della scheda SD.
2.3. Diagramma schematico
Per collegare il sensore della scheda MicroSD con ESP32, seguire la configurazione indicata di seguito:
Di seguito la tabella per la configurazione dei pin del filo di collegamento:
| Scheda MicroSD | ESP32 |
| GND | GND |
| VCC | VENIRE |
| CS | D5 |
| FUMO | D23 |
| SCK | D18 |
| MISO | D19 |
3. Ferramenta
Per l'hardware, sono necessari solo alcuni ponticelli su una breadboard insieme a ESP32 e al modulo della scheda SD.
4. Codice
Ora scriveremo un codice che creerà un file di testo all'interno della scheda MicroSD e successivamente scriverà una stringa di testo su di esso. Una volta terminato, leggeremo il contenuto del file di testo sul monitor seriale dell'IDE Arduino.
Avvia l'IDE Arduino e compila il codice fornito. Dopodiché masterizzalo sulla tua scheda ESP32:
#include#include
File mioFile ;
cost int CS = 5 ;
// Scrive il messaggio specificato in un file nel percorso specificato
vuoto WriteFile ( cost car * sentiero , cost car * Messaggio ) {
// Apre il file. Supporta l'apertura di un file alla volta
// chiude l'altro file prima di aprirne uno nuovo
il mio file = SD. aprire ( sentiero , FILE_SCRITTURA ) ;
Se ( il mio file ) {
Seriale. printf ( 'Scrivo su %s' , sentiero ) ;
il mio file. println ( Messaggio ) ;
il mio file. vicino ( ) ; // Chiude il file
Seriale. println ( 'completato.' ) ;
} altro {
Seriale. println ( 'errore nell'apertura del file' ) ;
Seriale. println ( sentiero ) ;
}
}
// Stampa il contenuto del file nel percorso specificato
vuoto LeggiFile ( cost car * sentiero ) {
// Apri il file
il mio file = SD. aprire ( sentiero ) ;
Se ( il mio file ) {
Seriale. printf ( 'Lettura del file da %s \N ' , sentiero ) ;
// Leggi il file completo fino a raggiungere l'ultimo
Mentre ( il mio file. disponibile ( ) ) {
Seriale. scrivere ( il mio file. Leggere ( ) ) ;
}
il mio file. vicino ( ) ; // Chiude il file
} altro {
// Se il file non si apre, stampa un errore:
Seriale. println ( 'errore durante l'apertura del file test.txt' ) ;
}
}
vuoto impostare ( ) {
Seriale. inizio ( 9600 ) ;
ritardo ( 500 ) ;
Mentre ( ! Seriale ) { ; }
Seriale. println ( 'Inizializzazione della scheda SD...' ) ;
Se ( ! SD. inizio ( CS ) ) {
Seriale. println ( 'Inizializzazione fallita!' ) ;
ritorno ;
}
Seriale. println ( 'Inizializzazione completata.' ) ;
WriteFile ( '/prova.txt' , 'Linuxhint.com' ) ;
LeggiFile ( '/prova.txt' ) ;
}
vuoto ciclo continuo ( ) {
}
4.1. Spiegazione del codice
Per una migliore comprensione divideremo questo codice in sottoparti.
Inizializzazione e configurazione: Innanzitutto, il codice ha iniziato includendo alcune importanti librerie relative al modulo della scheda SD. Viene aggiunta la libreria SPI.h per la comunicazione con la scheda SD e SD.h per la gestione delle operazioni della scheda SD. Successivamente, definisce una variabile globale il mio file di tipo file per gestire le operazioni sui file. La costante CS è impostata sul pin 5, che verrà utilizzato come pin Chip Select (CS) per la scheda SD.
Funzione Imposta(): All'interno della funzione di configurazione viene avviata la comunicazione seriale. Successivamente, abbiamo inizializzato il modulo della scheda SD utilizzando la funzione SD.begin(CS). Inoltre, abbiamo anche definito due diverse funzioni per leggere e scrivere testo in un file di testo.
Scrittura sulla scheda SD: La funzione WriteFile() apre il file test.txt per la scrittura utilizzando SD.open(percorso, FILE_WRITE). Successivamente, scrive la stringa Linuxhint.com nel file utilizzando myFile.println(message).
Lettura dalla scheda SD: Per leggere il contenuto del file, abbiamo utilizzato la funzione ReadFile(). Se letti con successo, i dati verranno inviati alla porta seriale di Arduino e visualizzati sul monitor seriale dell'IDE di Arduino.
5. Uscita
Nell'output, puoi vedere la stessa stringa che abbiamo definito all'interno del codice IDE di Arduino visualizzata sul tuo monitor seriale IDE di Arduino.
6. Esecuzione di diverse funzioni sulla scheda MicroSD utilizzando ESP32
Possiamo eseguire varie operazioni come creare, rimuovere o aggiungere directory nelle schede MicroSD direttamente tramite il codice IDE di Arduino.
6.1. Creazione di directory nella scheda MicroSD
Il codice seguente creerà una nuova directory all'interno della scheda MicroSD. Definisce una funzione chiamata creaDir che accetta un oggetto file system (fs::FS) e un percorso come input. Questa funzione tenta di creare una directory con il percorso specificato e stampa messaggi che indicano il successo o il fallimento.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
vuoto creaDir ( fs :: FS & fs , cost car * sentiero ) {
Seriale. printf ( 'Creazione directory: %s \N ' , sentiero ) ;
Se ( fs. mkdir ( sentiero ) ) {
Seriale. println ( 'Dir creata' ) ;
} altro {
Seriale. println ( 'mkdir non riuscito' ) ;
}
}
vuoto impostare ( ) {
Seriale. inizio ( 115200 ) ;
// Inizializza la scheda SD
Se ( ! SD. inizio ( ) ) {
Seriale. println ( 'Montaggio scheda non riuscito' ) ;
ritorno ;
}
// Crea una directory chiamata 'mydir'
creaDir ( SD , '/miadir' ) ;
}
vuoto ciclo continuo ( ) {
}
Nell'output, puoi vedere che viene creata una nuova directory con /miadir nome.
6.2. Elenco delle directory nella scheda MicroSD
Nel codice seguente elencheremo tutte le directory presenti all'interno della scheda MicroSD. IL elencoDir La funzione elenca ricorsivamente il contenuto di una directory su una scheda SD. Stampa informazioni su entrambe le directory (con prefisso 'DIR') e file (con prefisso 'FILE'), inclusi i loro nomi e dimensioni.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
vuoto elencoDir ( fs :: FS & fs , cost car * nome , uint8_t livelli ) {
Seriale. printf ( 'Directory di elenco: %s \N ' , nome ) ;
Radice del file = fs. aprire ( nome ) ;
Se ( ! radice ) {
Seriale. println ( 'Impossibile aprire la directory' ) ;
ritorno ;
}
Se ( ! radice. isDirectory ( ) ) {
Seriale. println ( 'Non una directory' ) ;
ritorno ;
}
File di archivio = radice. openNextFile ( ) ;
Mentre ( file ) {
Se ( file. isDirectory ( ) ) {
Seriale. stampa ( ' VOI : ' ) ;
Seriale. println ( file. nome ( ) ) ;
Se ( livelli ) {
elencoDir ( fs , file. nome ( ) , livelli - 1 ) ;
}
} altro {
Seriale. stampa ( ' FILE: ' ) ;
Seriale. stampa ( file. nome ( ) ) ;
Seriale. stampa ( ' MISURARE: ' ) ;
Seriale. println ( file. misurare ( ) ) ;
}
file = radice. openNextFile ( ) ;
}
}
vuoto impostare ( ) {
Seriale. inizio ( 115200 ) ;
Se ( ! SD. inizio ( ) ) {
Seriale. println ( 'Montaggio scheda non riuscito' ) ;
ritorno ;
}
elencoDir ( SD , '/' , 0 ) ;
}
vuoto ciclo continuo ( ) {
}
In output, puoi vedere due file diversi. Uno è un file di testo e l'altro è una directory che abbiamo creato all'interno del codice precedente.
6.3. Rimozione di directory
Ora rimuoveremo le directory e i file di testo creati in precedenza. Per questo utilizzeremo il file rimuoviDir funzione, tenterà di rimuovere una directory specificata dal percorso. In caso di successo, viene stampato Dir rimossa ; in caso contrario, viene stampato rmdir non è riuscito .
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
vuoto rimuoviDir ( fs :: FS & fs , cost car * sentiero ) {
Seriale. printf ( 'Rimozione directory: %s \N ' , sentiero ) ;
Se ( fs. è rm ( sentiero ) ) {
Seriale. println ( 'Dir rimossa' ) ;
} altro {
Seriale. println ( 'rmdir non riuscito' ) ;
}
}
vuoto impostare ( ) {
Seriale. inizio ( 115200 ) ;
Se ( ! SD. inizio ( ) ) {
Seriale. println ( 'Montaggio scheda non riuscito' ) ;
ritorno ;
}
}
vuoto ciclo continuo ( ) {
}
6.4. Ottieni il tipo di scheda MicroSD
Scheda MicroSD o S sicuro D La scheda digitale è stata progettata originariamente dall'associazione delle schede SD e progettata per l'uso in dispositivi portatili come smartphone e fotocamere. Le schede SD contengono principalmente quattro tipi di famiglie:
- SDSC (SD di capacità standard): Queste schede offrono una modesta capacità di archiviazione di 2 GB e utilizzano i file system FAT-12 e FAT-16.
- SDHC (SD ad alta capacità): Queste schede vanno da 2 GB a 32 GB e utilizzano il file system FAT-32.
- SDXC (SD a capacità estesa): Queste schede utilizzano il file system exFAT e partono da 32 GB fino a 2 TB.
- SDIO: Le schede SDIO hanno un duplice scopo combinando l'archiviazione dei dati con le funzioni INPUT/OUTPUT.
Per verificare il tipo di carta, esegui il codice seguente:
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
vuoto impostare ( ) {
Seriale. inizio ( 115200 ) ;
Se ( ! SD. inizio ( ) ) {
Seriale. println ( 'Montaggio scheda non riuscito' ) ;
ritorno ;
}
uint8_t tipo di carta = SD. tipo di carta ( ) ;
Se ( tipo di carta == CARTA_NESSUNA ) {
Seriale. println ( 'Nessuna scheda SD collegata' ) ;
ritorno ;
}
Seriale. stampa ( 'Tipo scheda SD: ' ) ;
Se ( tipo di carta == CARTA_MMC ) {
Seriale. println ( 'MMC' ) ;
} altro Se ( tipo di carta == CARTA_SD ) {
Seriale. println ( 'SDSC' ) ;
} altro Se ( tipo di carta == CARTA_SDHC ) {
Seriale. println ( 'SDHC' ) ;
} altro {
Seriale. println ( 'SCONOSCIUTO' ) ;
}
uint64_t cardSize = SD. cardSize ( ) / ( 1024 * 1024 ) ;
Seriale. printf ( 'Dimensioni scheda SD: %lluMB \N ' , cardSize ) ;
}
vuoto ciclo continuo ( ) {
}
Dato che ho una scheda da 32 GB, puoi vedere che rientra nella gamma di SDHC carte.
6.5. Ottieni la dimensione della scheda MicroSD
Puoi anche ottenere la dimensione della scheda SD caricando il codice seguente sulla tua scheda ESP32.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
vuoto impostare ( ) {
Seriale. inizio ( 115200 ) ;
Se ( ! SD. inizio ( ) ) {
Seriale. println ( 'Montaggio scheda non riuscito' ) ;
ritorno ;
}
uint8_t tipo di carta = SD. tipo di carta ( ) ;
Se ( tipo di carta == CARTA_NESSUNA ) {
Seriale. println ( 'Nessuna scheda SD collegata' ) ;
ritorno ;
}
uint64_t cardSize = SD. cardSize ( ) / ( 1024 * 1024 ) ;
Seriale. printf ( 'Dimensioni scheda SD: %lluMB \N ' , cardSize ) ;
// Qui è possibile richiamare altre funzioni (listDir, createDir,removeDir, ecc.).
}
vuoto ciclo continuo ( ) {
}
Dall'output, puoi vedere che ho una scheda SD di circa 30 GB.
Conclusione
Un modulo della scheda MicroSD viene utilizzato per leggere e scrivere i dati dalla scheda SD utilizzando la scheda ESP32. Il modulo della scheda MicroSD comunica con il microcontrollore utilizzando l'interfaccia SPI. Quindi puoi utilizzare la libreria SPI o definire i tuoi pin SPI all'interno del codice. Una volta connesso, puoi leggere, scrivere un file di testo o creare nuove directory nella scheda SD.