Cet article expliquera les étapes d'interfaçage d'une carte MicroSD avec une carte ESP32 à l'aide de l'IDE Arduino.
Table des matières:
2. Comment interfacer l'ESP32 avec le module de carte MicroSD
6. Exécution de différentes fonctions sur la carte MicroSD à l'aide de ESP32
- 6.1. Création de répertoires sur une carte MicroSD
- 6.2. Liste des répertoires sur la carte MicroSD
- 6.3. Suppression de répertoires
- 6.4. Obtenir le type de carte MicroSD
- 6.5. Obtenir la taille de la carte SD
1. Module de carte MicroSD
Le module de carte MicroSD est un capteur ESP32 qui permet de connecter la carte SD à votre carte microcontrôleur. Il fonctionne via le protocole de communication SPI. Il permet à l'ESP32 ou à toute autre carte microcontrôleur comme Arduino d'accéder aux données stockées sur la carte SD via le protocole SPI.
La tension de fonctionnement du module de carte SD est de 3,3 V, il n'est donc pas possible de le connecter directement à l'ESP32 ou à toute autre carte microcontrôleur. Pour cela, nous devons utiliser le module de carte SD ou le capteur qui fonctionne sur 5V.
1.1. Brochage
La carte MicroSD comporte un total de six broches. Deux d'entre elles sont des broches d'alimentation : VCC et GND. Pendant la lecture, quatre broches sont utilisées pour le protocole de communication SPI. Voici les détails de chacune de ces six broches :
Broches d'alimentation :
- VCC : Se connecte à la broche ESP32 5V.
- GND : Se connecte à la broche de masse (GND) de l'ESP32.
Broches SPI :
- MISO: (Master In Slave Out) Se connecte à la broche ESP32 MOSI (Master Out Slave In).
- FUMÉE: Se connecte à la broche ESP32 MISO (Master In Slave Out).
- SCK : Se connecte à la broche ESP32 SCK (Serial Clock).
- SS : (Slave Select) Se connecte à la broche spécifiée dans le code Arduino comme broche SS (Slave Select).
2. Comment interfacer l'ESP32 avec le module de carte MicroSD
Pour interfacer l'ESP32 avec le module de carte MicroSD, vous devrez configurer les broches d'alimentation du capteur de votre carte SD. Ensuite, configurez les broches SPI. Ici, vous avez deux choix : vous pouvez soit définir les broches SPI par défaut, soit définir vos propres broches SPI personnalisées.
Lors de l'utilisation des broches SPI par défaut, nous allons ajouter le SD.h. et SD_MMC.h bibliothèques. Par défaut, ces bibliothèques prennent les broches VSPI SPI (23, 19, 18, 5) pour la communication SPI. Cependant, vous pouvez également définir d'autres broches pour la communication SPI.
L'ESP32 contient deux interfaces SPI HSPI et VSPI avec leurs broches détaillées comme suit :
| IPS | FUMÉE | MISO | CLK | CS |
| VSPI | D23 | J19 | J18 | D5 |
| HSPI | J13 | J12 | J14 | J15 |
En rapport: Référence de brochage ESP32 – Un guide complet
2.2. Préparez la carte SD
Ensuite, avant de pouvoir procéder à la lecture et à l'écriture de données sur une carte MicroSD, vous devez d'abord la configurer en formatant toutes les données précédentes qu'elle contient.
Ouvrez votre carte SD à l'aide de n'importe quel lecteur de carte et format il.
Sélectionnez le FAT32 pour le système de fichiers de votre carte et cliquez sur Commencer .
Après avoir formaté la carte, sélectionnez D'ACCORD .
Votre carte SD est maintenant prête à être interfacée avec l'ESP32 à l'aide du module carte SD.
2.3. Diagramme schématique
Pour connecter le capteur de la carte MicroSD à l'ESP32, suivez la configuration ci-dessous :
Voici le tableau de configuration des broches du fil de connexion :
| Carte Micro SD | ESP32 |
| GND | GND |
| VCC | VIENS |
| CS | D5 |
| FUMÉE | D23 |
| SCK | J18 |
| MISO | J19 |
3. Matériel
Pour le matériel, vous avez juste besoin de quelques câbles de liaison, d'une planche à pain ainsi que d'un ESP32 et d'un module de carte SD.
4. Coder
Nous allons maintenant écrire un code qui créera un fichier texte à l'intérieur de la carte MicroSD et après cela, il y écrira une chaîne de texte. Une fois cela fait, nous lirons le contenu du fichier texte sur le moniteur série Arduino IDE.
Démarrez Arduino IDE et compilez le code donné. Après cela, gravez-le sur votre carte ESP32 :
#include#include
Fichier monFichier ;
const int CS = 5 ;
// Écrit le message donné dans un fichier au chemin spécifié
vide Écrire un fichier ( const carboniser * chemin , const carboniser * message ) {
// Ouvre le fichier. Il prend en charge un fichier à ouvrir à la fois
// ferme l'autre fichier avant d'ouvrir un nouveau fichier
mon fichier = DAKOTA DU SUD. ouvrir ( chemin , FILE_WRITE ) ;
si ( mon fichier ) {
En série. imprimer ( 'Écrire à %s ' , chemin ) ;
mon fichier. imprimer ( message ) ;
mon fichier. fermer ( ) ; // Ferme le fichier
En série. imprimer ( 'complété.' ) ;
} autre {
En série. imprimer ( 'Erreur à l'ouverture du fichier' ) ;
En série. imprimer ( chemin ) ;
}
}
// Imprimer le contenu du fichier au chemin spécifié
vide Lire le fichier ( const carboniser * chemin ) {
// Fichier ouvert
mon fichier = DAKOTA DU SUD. ouvrir ( chemin ) ;
si ( mon fichier ) {
En série. imprimer ( 'Lecture du fichier à partir de %s \n ' , chemin ) ;
// Lit le fichier complet jusqu'à atteindre le dernier
alors que ( mon fichier. disponible ( ) ) {
En série. écrire ( mon fichier. lire ( ) ) ;
}
mon fichier. fermer ( ) ; // Ferme le fichier
} autre {
// Si le fichier ne parvient pas à s'ouvrir, affiche une erreur :
En série. imprimer ( 'erreur d'ouverture de test.txt' ) ;
}
}
vide installation ( ) {
En série. commencer ( 9600 ) ;
retard ( 500 ) ;
alors que ( ! En série ) { ; }
En série. imprimer ( 'Initialisation de la carte SD...' ) ;
si ( ! DAKOTA DU SUD. commencer ( CS ) ) {
En série. imprimer ( 'Initialisation échouée!' ) ;
retour ;
}
En série. imprimer ( 'Initialisation terminée.' ) ;
Écrire un fichier ( '/test.txt' , 'Linuxhint.com' ) ;
Lire le fichier ( '/test.txt' ) ;
}
vide boucle ( ) {
}
4.1. Explication du code
Pour une meilleure compréhension, nous diviserons ce code en sous-parties.
Initialisation et configuration : Tout d’abord, le code a commencé par inclure quelques bibliothèques importantes liées au module de carte SD. La bibliothèque SPI.h est ajoutée pour la communication avec la carte SD et SD.h pour gérer les opérations de la carte SD. Ensuite, il définit une variable globale mon fichier de type fichier pour gérer les opérations sur les fichiers. La constante CS est définie sur la broche 5, qui sera utilisée comme broche Chip Select (CS) pour la carte SD.
Fonction Configuration() : Dans la fonction de configuration, la communication série est démarrée. Après cela, nous avons initialisé le module de carte SD à l'aide de la fonction SD.begin(CS). De plus, nous avons également défini deux fonctions différentes pour lire et écrire du texte dans un fichier texte.
Écrire sur la carte SD : La fonction WriteFile() ouvre le fichier test.txt pour l'écriture à l'aide de SD.open(path, FILE_WRITE). Après cela, il écrit la chaîne Linuxhint.com dans le fichier en utilisant myFile.println(message).
Lecture depuis la carte SD : Pour lire le contenu du fichier, nous avons utilisé la fonction ReadFile(). En cas de lecture réussie, les données seront envoyées au port série Arduino et affichées sur le moniteur série Arduino IDE.
5. Sortie
Dans la sortie, vous pouvez voir la même chaîne que celle que nous avons définie dans le code Arduino IDE s'affiche sur votre moniteur série Arduino IDE.
6. Exécution de différentes fonctions sur la carte MicroSD à l'aide de ESP32
Nous pouvons effectuer diverses opérations telles que la création, la suppression ou l'ajout de répertoires sur les cartes MicroSD directement via le code Arduino IDE.
6.1. Création de répertoires sur une carte MicroSD
Le code ci-dessous créera un nouveau répertoire à l'intérieur de la carte MicroSD. Il définit une fonction appelée createDir qui prend un objet système de fichiers (fs::FS) et un chemin en entrée. Cette fonction tente de créer un répertoire avec le chemin spécifié et imprime des messages indiquant le succès ou l'échec.
#include 'FS.h'#inclure 'SD.h'
#include 'SPI.h'
vide createDir ( fs :: FS & fs , const carboniser * chemin ) {
En série. imprimer ( 'Création du répertoire : %s \n ' , chemin ) ;
si ( fs. mkdir ( chemin ) ) {
En série. imprimer ( 'Dir créé' ) ;
} autre {
En série. imprimer ( 'mkdir a échoué' ) ;
}
}
vide installation ( ) {
En série. commencer ( 115200 ) ;
// Initialise la carte SD
si ( ! DAKOTA DU SUD. commencer ( ) ) {
En série. imprimer ( 'Échec du montage de la carte' ) ;
retour ;
}
// Crée un répertoire nommé 'monrép'
createDir ( Dakota du Sud , '/monrépertoire' ) ;
}
vide boucle ( ) {
}
Dans la sortie, vous pouvez voir qu'un nouveau répertoire est créé avec /monrép nom.
6.2. Liste des répertoires sur la carte MicroSD
Dans le code ci-dessous, nous allons lister tous les répertoires présents à l'intérieur de la carte MicroSD. Le listDir La fonction répertorie de manière récursive le contenu d’un répertoire sur une carte SD. Il imprime des informations sur les répertoires (préfixés par « DIR ») et les fichiers (préfixés par « FILE »), y compris leurs noms et tailles.
#include 'FS.h'#inclure 'SD.h'
#include 'SPI.h'
vide listDir ( fs :: FS & fs , const carboniser * nom de répertoire , uint8_t les niveaux ) {
En série. imprimer ( 'Répertoire de liste : %s \n ' , nom de répertoire ) ;
Racine du fichier = fs. ouvrir ( nom de répertoire ) ;
si ( ! racine ) {
En série. imprimer ( 'Échec de l'ouverture du répertoire' ) ;
retour ;
}
si ( ! racine. estRépertoire ( ) ) {
En série. imprimer ( 'Pas un répertoire' ) ;
retour ;
}
Fichier fichier = racine. ouvrir le fichier suivant ( ) ;
alors que ( déposer ) {
si ( déposer. estRépertoire ( ) ) {
En série. imprimer ( ' TOI : ' ) ;
En série. imprimer ( déposer. nom ( ) ) ;
si ( les niveaux ) {
listDir ( fs , déposer. nom ( ) , les niveaux - 1 ) ;
}
} autre {
En série. imprimer ( ' DÉPOSER: ' ) ;
En série. imprimer ( déposer. nom ( ) ) ;
En série. imprimer ( ' TAILLE: ' ) ;
En série. imprimer ( déposer. taille ( ) ) ;
}
déposer = racine. ouvrir le fichier suivant ( ) ;
}
}
vide installation ( ) {
En série. commencer ( 115200 ) ;
si ( ! DAKOTA DU SUD. commencer ( ) ) {
En série. imprimer ( 'Échec du montage de la carte' ) ;
retour ;
}
listDir ( Dakota du Sud , '/' , 0 ) ;
}
vide boucle ( ) {
}
En sortie, vous pouvez voir deux fichiers différents. L’un est un fichier texte et l’autre est un répertoire que nous avons créé dans le code précédent.
6.3. Suppression de répertoires
Nous allons maintenant supprimer les répertoires et fichiers texte précédemment créés. Pour cela nous allons utiliser le supprimerRep fonction, il tentera de supprimer un répertoire spécifié par le chemin. En cas de succès, il imprime Répertoire supprimé ; sinon, il s'imprime échec du répertoire rm .
#include 'FS.h'#inclure 'SD.h'
#include 'SPI.h'
vide supprimerRep ( fs :: FS & fs , const carboniser * chemin ) {
En série. imprimer ( 'Suppression du répertoire : %s \n ' , chemin ) ;
si ( fs. est rm ( chemin ) ) {
En série. imprimer ( 'Répertoire supprimé' ) ;
} autre {
En série. imprimer ( 'échec du rmdir' ) ;
}
}
vide installation ( ) {
En série. commencer ( 115200 ) ;
si ( ! DAKOTA DU SUD. commencer ( ) ) {
En série. imprimer ( 'Échec du montage de la carte' ) ;
retour ;
}
}
vide boucle ( ) {
}
6.4. Obtenir le type de carte MicroSD
Carte MicroSD ou S sécurisé D La carte numérique a été conçue à l'origine par l'association des cartes SD et conçue pour être utilisée dans des appareils portables tels que les smartphones et les appareils photo. Les cartes SD contiennent principalement quatre types de familles :
- SDSC (SD de capacité standard) : Ces cartes offrent une gamme modeste de capacité de stockage de 2 Go et utilisent les systèmes de fichiers FAT-12 et FAT-16.
- SDHC (SD haute capacité) : Ces cartes vont de 2 Go à 32 Go et utilisent le système de fichiers FAT-32.
- SDXC (SD à capacité étendue) : Ces cartes utilisent le système de fichiers exFAT et vont de 32 Go à 2 To.
- SDIO : Les cartes SDIO remplissent un double objectif en combinant le stockage de données avec les fonctions INPUT/OUTPUT.
Pour vérifier le type de votre carte, exécutez le code ci-dessous :
#include 'FS.h'#inclure 'SD.h'
#include 'SPI.h'
vide installation ( ) {
En série. commencer ( 115200 ) ;
si ( ! DAKOTA DU SUD. commencer ( ) ) {
En série. imprimer ( 'Échec du montage de la carte' ) ;
retour ;
}
uint8_t type de carte = DAKOTA DU SUD. type de carte ( ) ;
si ( type de carte == CARD_NONE ) {
En série. imprimer ( 'Aucune carte SD connectée' ) ;
retour ;
}
En série. imprimer ( 'Type de carte SD : ' ) ;
si ( type de carte == CARD_MMC ) {
En série. imprimer ( 'MMC' ) ;
} autre si ( type de carte == CARD_SD ) {
En série. imprimer ( 'SDSC' ) ;
} autre si ( type de carte == CARD_SDHC ) {
En série. imprimer ( 'SDHC' ) ;
} autre {
En série. imprimer ( 'INCONNU' ) ;
}
uint64_t Taille de la carte = DAKOTA DU SUD. Taille de la carte ( ) / ( 1024 * 1024 ) ;
En série. imprimer ( 'Taille de la carte SD : %lluMB \n ' , Taille de la carte ) ;
}
vide boucle ( ) {
}
Comme j'ai une carte de 32 Go, vous voyez qu'elle se situe dans la gamme des SDHC cartes.
6.5. Obtenir la taille de la carte MicroSD
Vous pouvez également obtenir la taille de la carte SD en téléchargeant le code ci-dessous sur votre carte ESP32.
#include 'FS.h'#inclure 'SD.h'
#include 'SPI.h'
vide installation ( ) {
En série. commencer ( 115200 ) ;
si ( ! DAKOTA DU SUD. commencer ( ) ) {
En série. imprimer ( 'Échec du montage de la carte' ) ;
retour ;
}
uint8_t type de carte = DAKOTA DU SUD. type de carte ( ) ;
si ( type de carte == CARD_NONE ) {
En série. imprimer ( 'Aucune carte SD connectée' ) ;
retour ;
}
uint64_t Taille de la carte = DAKOTA DU SUD. Taille de la carte ( ) / ( 1024 * 1024 ) ;
En série. imprimer ( 'Taille de la carte SD : %lluMB \n ' , Taille de la carte ) ;
// D'autres fonctions (listDir, createDir, RemoveDir, etc.) peuvent être appelées ici
}
vide boucle ( ) {
}
D'après la sortie, vous pouvez voir que j'ai une carte SD d'environ 30 Go.
Conclusion
Un module de carte MicroSD est utilisé pour lire et écrire les données de la carte SD à l'aide de la carte ESP32. Le module de carte MicroSD communique avec le microcontrôleur en utilisant l'interface SPI. Vous pouvez donc soit utiliser la bibliothèque SPI, soit définir vos propres broches SPI dans le code. Une fois connecté, vous pouvez lire, écrire un fichier texte, ou créer de nouveaux répertoires sur votre carte SD.