Arduino Mega - Carte Micro SD

Matériel requis

Ou vous pouvez acheter les kits suivants:

À propos du module carte Micro SD

Le module carte Micro SD est une carte de dérivation qui fournit une interface pratique entre votre Arduino Mega et les cartes micro SD standard. Ce module gère toutes les exigences électriques complexes, la conversion des niveaux de tension, et les connexions de socket de carte physique, rendant simple l'ajout d'une capacité de stockage massive à vos projets.

Caractéristiques principales :

• Communication SPI : Utilise le bus SPI (Serial Peripheral Interface) pour un transfert de données rapide
• Régulation de tension : Régulateur de tension intégré et convertisseurs de niveaux protègent la carte SD 3.3V des signaux 5V de l'Arduino
• Support de capacité : Fonctionne avec des cartes micro SD de 128MB jusqu'à 32GB (SDHC)
• Système de fichiers : Supporte les systèmes de fichiers FAT16 et FAT32 pour une compatibilité facile avec les ordinateurs
• Hot-swappable : Les cartes peuvent être retirées et lues sur les ordinateurs en utilisant des lecteurs de carte SD standard
• Transfert rapide : La communication SPI permet des vitesses de transfert de données suffisantes pour la plupart des applications d'enregistrement de données

Comment ça fonctionne :

Le module agit comme un adaptateur intermédiaire entre la logique 5V de l'Arduino Mega et les exigences 3.3V de la carte SD. Il inclut des régulateurs de tension embarqués et des convertisseurs de niveaux pour assurer une communication sûre. Le module communique en utilisant le protocole SPI, qui utilise 4 broches principales (MOSI, MISO, SCK, SS) pour transférer des données en série à des vitesses jusqu'à 4Mbps sur Arduino.

Compatibilité du système de fichiers :

Les cartes SD doivent être formatées avec des systèmes de fichiers FAT16 (pour les cartes ≤2GB) ou FAT32 (pour les cartes >2GB jusqu'à 32GB). Ce sont des formats standard que l'Arduino et les ordinateurs peuvent lire, rendant facile le transfert de données entre appareils. La bibliothèque SD Arduino fournit des fonctions de haut niveau qui cachent la complexité des opérations du système de fichiers FAT.

Brochage

Le module carte Micro SD présente six broches qui se connectent au bus SPI de l'Arduino Mega. Comprendre chaque broche est essentiel pour un fonctionnement correct :

Broches d'alimentation :

• Broche VCC : Entrée d'alimentation. Connectez à la broche 5V de l'Arduino Mega. Le régulateur embarqué convertit ceci en 3.3V pour la carte SD.
• Broche GND : Référence de masse. Connectez à la broche GND de l'Arduino Mega pour compléter le circuit.

Broches de communication SPI :

• Broche MISO (Master In Slave Out) : Ligne de données de la carte SD vers l'Arduino. Connectez à la broche MISO de l'Arduino Mega (broche numérique 50). Cette ligne transporte les données lues depuis la carte SD.
• Broche MOSI (Master Out Slave In) : Ligne de données de l'Arduino vers la carte SD. Connectez à la broche MOSI de l'Arduino Mega (broche numérique 51). Cette ligne transporte les données écrites vers la carte SD.
• Broche SCK (Serial Clock) : Signal d'horloge généré par l'Arduino. Connectez à la broche SCK de l'Arduino Mega (broche numérique 52). Cette ligne synchronise le transfert de données entre les appareils.
• Broche CS (Chip Select) / Broche SS (Slave Select) : Active la carte SD pour la communication. Connectez à n'importe quelle broche numérique de l'Arduino Mega (communément la broche 53, mais configurable dans le code). Quand LOW, la carte SD écoute ; quand HIGH, elle est ignorée.

Emplacements des broches SPI de l'Arduino Mega :

L'Arduino Mega a des broches SPI matérielles dédiées qui fournissent la communication la plus rapide et la plus fiable :

• Broche 50 : MISO (Master In Slave Out)
• Broche 51 : MOSI (Master Out Slave In)
• Broche 52 : SCK (Serial Clock)
• Broche 53 : SS (Slave Select) - Par défaut, mais n'importe quelle broche numérique peut être utilisée

Notes importantes :

• Utilisez toujours les broches SPI matérielles (50, 51, 52) pour MISO, MOSI, et SCK sur l'Arduino Mega
• La broche CS/SS est configurable - vous la spécifiez dans la fonction SD.begin()
• Différentes cartes Arduino utilisent différents numéros de broches SPI (l'Uno utilise les broches 10-13)
• Ne connectez jamais la carte SD directement à l'Arduino sans le module - la différence de tension endommagera la carte !

Préparation

Avant d'utiliser votre carte micro SD avec l'Arduino, vous devez la formater correctement. Ceci assure la compatibilité avec la bibliothèque SD Arduino et permet des opérations de fichiers fiables.

Étape 1 : Insérer la carte dans l'ordinateur

Branchez la carte micro SD dans votre ordinateur en utilisant un lecteur de carte SD USB 3.0 (ou le slot de carte SD intégré de votre ordinateur avec un adaptateur micro SD).

Étape 2 : Vérifier et formater la carte

La carte SD DOIT être formatée en FAT16 ou FAT32 :

• FAT16 : Pour les cartes SD de 2GB ou moins
• FAT32 : Pour les cartes SD plus grandes que 2GB jusqu'à 32GB
• exFAT : NON supporté par la bibliothèque SD Arduino (n'utilisez pas ce format)

Formatage Windows :

1. Ouvrez l'Explorateur de fichiers et localisez le lecteur de carte SD
2. Clic droit sur le lecteur et sélectionnez "Formater"
3. Choisissez "FAT32" pour le système de fichiers (ou "FAT" pour les cartes ≤2GB)
4. Cliquez "Démarrer" pour formater

Formatage Mac :

1. Ouvrez Utilitaire de disque (Applications → Utilitaires → Utilitaire de disque)
2. Sélectionnez la carte SD dans la barre latérale gauche
3. Cliquez "Effacer"
4. Choisissez "MS-DOS (FAT)" pour le format
5. Cliquez "Effacer" pour formater

Vérifier le format :

Après formatage, la carte devrait être vide et prête pour l'utilisation Arduino. L'Arduino créera les fichiers automatiquement pendant le fonctionnement.

Spécifications de carte recommandées :

• Capacité : 2GB à 16GB est idéal (32GB maximum)
• Classe de vitesse : Classe 4 ou plus pour un enregistrement de données fiable
• Marque : Utilisez des marques de qualité (SanDisk, Samsung, Kingston) pour la fiabilité

Schéma de câblage

Examinons les connexions de câblage entre votre Arduino Mega et le module carte Micro SD. Le module utilise le bus SPI (Serial Peripheral Interface), qui nécessite 4 lignes de données plus les connexions d'alimentation.

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Résumé des connexions :

*La broche 53 est la broche SS par défaut, mais vous pouvez utiliser n'importe quelle broche numérique en la spécifiant dans SD.begin(numéro_broche)

Meilleures pratiques de câblage :

• Câbles courts : Utilisez des câbles de liaison plus courts que 20cm pour une communication SPI fiable à hautes vitesses
• Évitez la diaphonie : Gardez les câbles séparés et évitez de les faire courir parallèlement les uns aux autres
• Connexions sécurisées : Assurez-vous que toutes les connexions sont fermement installées - les câbles desserrés causent des pannes intermittentes
• Qualité d'alimentation : La carte SD peut consommer 100-200mA pendant les opérations d'écriture, assurez-vous que votre alimentation peut gérer ceci
• Insertion de carte : Insérez toujours la carte micro SD dans le module AVANT d'alimenter l'Arduino

Partage du bus SPI :

Plusieurs appareils SPI (cartes SD, écrans, capteurs) peuvent partager les mêmes lignes MISO, MOSI, et SCK. Chaque appareil a besoin de sa propre broche CS (Chip Select) unique. Seul l'appareil avec CS tiré à LOW communiquera, tandis que les autres restent inactifs.

Arduino Mega - Comment ouvrir un fichier sur carte Micro SD et le créer s'il n'existe pas

Une des opérations de carte SD les plus fondamentales est l'ouverture de fichiers. La bibliothèque SD Arduino rend ceci simple avec la fonction SD.open(), qui peut à la fois ouvrir les fichiers existants et en créer de nouveaux automatiquement.

Comment fonctionne l'ouverture de fichier :

Quand vous appelez SD.open() avec un nom de fichier et le mode FILE_WRITE, la bibliothèque :

1. Vérifie si le fichier existe sur la carte SD
2. S'il existe, l'ouvre pour ajout (ajouter des données à la fin)
3. S'il n'existe pas, crée un nouveau fichier vide avec ce nom
4. Retourne un objet File que vous utilisez pour les opérations de lecture/écriture

Règles de nommage de fichier :

• Longueur maximum de nom de fichier : 8 caractères + extension de 3 caractères (format 8.3)
• Utilisez seulement des lettres, chiffres, et underscores (évitez les espaces et caractères spéciaux)
• Les extensions sont optionnelles mais recommandées (.txt, .csv, .log, .dat)
• Exemples : "data.txt", "sensor.log", "config.dat"

Fermez toujours les fichiers :

Après avoir ouvert et utilisé un fichier, appelez toujours file.close(). Ceci assure :

• Les données sont correctement écrites sur la carte SD (vidées des buffers)
• L'intégrité du système de fichiers est maintenue
• Le fichier est disponible pour d'autres opérations
• Prévient la corruption de données si l'alimentation est perdue

Code Arduino Mega

Étapes rapides

Suivez ces instructions détaillées étape par étape pour tester la création et l'ouverture de fichier sur votre carte SD :

• Mettez la carte micro SD dans le module carte micro SD.
• Utilisez le schéma de câblage pour connecter le module carte micro SD à l'Arduino Mega.
• Connectez l'Arduino Mega à votre ordinateur avec un câble USB.
• Ouvrez l'IDE Arduino sur votre ordinateur.
• Choisissez la carte Arduino Mega et le port COM correct.
• Ouvrez le moniteur série dans l'IDE Arduino.
• Copiez le code montré et collez-le dans l'IDE Arduino.

9. Téléverser le code : Cliquez le bouton Téléverser (icône flèche droite) dans la barre d'outils de l'IDE Arduino pour compiler et téléverser le code vers l'Arduino Mega. Attendez le message "Téléversement terminé".

10. Voir les résultats : Regardez la fenêtre du moniteur série. Après le premier téléversement avec une carte SD fraîche, vous devriez voir :

Ce qui se passe :

• Ligne 1 : Confirme que la carte SD s'est initialisée avec succès
• Ligne 2 : Le fichier n'existe pas encore, donc il est en cours de création
• Ligne 3 : Le fichier existe maintenant et est confirmé sur la carte

11. Tester à nouveau : Appuyez sur le bouton reset de votre Arduino Mega ou re-téléversez le code. Le moniteur série devrait maintenant afficher :

Notez que le fichier existe déjà, donc le message "Creating" est sauté.

12. Vérifier sur ordinateur :

• Retirez la carte micro SD du module (éteignez d'abord l'Arduino)
• Insérez la carte micro SD dans un lecteur de carte USB
• Connectez le lecteur de carte USB à votre ordinateur
• Ouvrez le lecteur dans l'Explorateur de fichiers (Windows) ou Finder (Mac)
• Confirmez que le fichier "arduino.txt" existe sur la carte
• Vous pouvez ouvrir le fichier pour voir son contenu (devrait être vide à ce point)

Arduino Mega - Comment écrire/lire des données vers/depuis un fichier sur carte Micro SD

Maintenant explorons la lecture et l'écriture de données réelles vers les fichiers de carte SD. C'est la fonctionnalité principale pour l'enregistrement de données, le stockage de configuration, et les applications de données persistantes.

Écrire des données dans les fichiers :

La bibliothèque SD fournit plusieurs méthodes pour écrire des données :

• file.print() : Écrit du texte sans retour à la ligne (comme Serial.print())
• file.println() : Écrit du texte avec un retour à la ligne à la fin (comme Serial.println())
• file.write() : Écrit des octets bruts pour des données binaires

Toutes les données sont ajoutées à la fin du fichier à moins que vous supprimiez explicitement et recréiez le fichier.

Lire des données depuis les fichiers :

La lecture peut être faite de plusieurs façons :

• file.read() : Lit un caractère à la fois, retourne -1 quand la fin de fichier est atteinte
• file.available() : Retourne le nombre d'octets disponibles à lire (0 quand à la fin du fichier)
• Caractère par caractère : Bon pour parser et traiter chaque caractère
• Ligne par ligne : Plus efficace pour des données texte structurées (couvert dans la section suivante)

Position de fichier et EOF :

Chaque fichier a un pointeur de position interne qui suit où vous êtes actuellement en train de lire ou écrire. Lors de la lecture, le pointeur avance avec chaque caractère. Quand il atteint la fin du fichier, file.available() retourne 0.

Exemple d'utilisation :

Cet exemple démontre un cycle complet écriture-puis-lecture :

1. Ouvre un fichier pour écriture
2. Écrit deux lignes de texte dans le fichier
3. Ferme le fichier (important !)
4. Rouvre le fichier pour lecture
5. Lit et affiche chaque caractère jusqu'à la fin du fichier
6. Ferme le fichier à nouveau

• Le moniteur série a montré ce qui était dans le fichier.

Comportement important - Ajout de données : Le mode FILE_WRITE ajoute toujours de nouvelles données à la fin des fichiers existants plutôt que de les écraser. C'est intentionnel et parfait pour l'enregistrement de données ! Cependant, si vous réinitialisez l'Arduino Mega ou re-téléversez ce code, le même texte sera écrit à nouveau dans le fichier, résultant en un contenu dupliqué.

Après une seconde réinitialisation, le moniteur série affichera :

Pour éviter cette duplication :

• Supprimez le fichier avant d'écrire (montré dans la section "écraser" ci-dessous)
• Écrivez des données seulement quand des conditions spécifiques sont remplies (ex : pression de bouton, nouvelle lecture de capteur)
• Utilisez un flag dans l'EEPROM pour suivre si les données initiales ont été écrites

Vérifier sur ordinateur :

Vous pouvez aussi retirer la carte micro SD du module et l'insérer dans un lecteur de carte SD USB pour voir les fichiers sur votre ordinateur. Ouvrez "arduino.txt" dans n'importe quel éditeur de texte (Bloc-notes, TextEdit) pour voir le contenu exact écrit par l'Arduino. C'est extrêmement utile pour déboguer et vérifier les opérations d'enregistrement de données !

Arduino Mega - Comment lire un fichier sur carte Micro SD ligne par ligne

Lire des fichiers ligne par ligne est beaucoup plus efficace que la lecture caractère par caractère quand on travaille avec des données texte structurées comme des fichiers CSV, des logs avec horodatages, ou des fichiers de configuration. Cette approche rend l'analyse et le traitement des données significativement plus faciles.

Comment fonctionne la lecture ligne par ligne :

Au lieu de traiter chaque caractère individuellement, la lecture ligne par ligne :

1. Lit des caractères jusqu'à ce qu'elle rencontre un caractère de retour à la ligne ('\n')
2. Stocke tous les caractères de cette ligne dans une variable String
3. Retourne la ligne complète pour traitement
4. Répète jusqu'à ce que la fin du fichier soit atteinte

Avantages de la lecture ligne par ligne :

• Parsing plus facile : Chaque ligne est une unité complète de données
• Support CSV : Parfait pour les fichiers de valeurs séparées par des virgules (CSV)
• Logs structurés : Excellent pour les entrées de log avec horodatage
• Code moins complexe : Logique plus simple que le parsing caractère par caractère
• Meilleure performance : Moins d'appels de fonctions et d'opérations

Cas d'utilisation :

• Lire des logs de capteurs avec horodatages
• Traiter des fichiers de données CSV (capteur1,capteur2,capteur3)
• Charger des paramètres de configuration (format clé=valeur)
• Parser des phrases NMEA GPS
• Lire des fichiers texte multi-lignes

Implémentation :

L'exemple ci-dessous utilise la fonction readStringUntil(), qui lit des caractères jusqu'à ce qu'elle rencontre un délimiteur spécifié (dans ce cas, '\n' pour retour à la ligne). Ceci rend facile le traitement de chaque ligne comme une chaîne complète.

Sortie attendue sur le moniteur série :

Comprendre la sortie :

• Chaque ligne du fichier est affichée avec un préfixe de numéro de ligne
• Les lignes vides (s'il y en a) s'afficheront comme blanches entre les numéros de ligne
• Le compte de lignes reflète précisément le nombre de lignes dans le fichier

Arduino Mega - Comment écraser un fichier sur carte Micro SD

Par défaut, le mode FILE_WRITE ajoute des données à la fin des fichiers existants. Bien que ce soit parfait pour l'enregistrement continu de données, parfois vous devez complètement remplacer le contenu d'un fichier avec de nouvelles données. Ceci s'appelle "écraser" le fichier.

Pourquoi écraser les fichiers ?

Écraser est utile pour :

• Fichiers de configuration : Mettre à jour les paramètres sans garder les anciennes valeurs
• Fichiers de statut : Remplacer le statut actuel avec un nouveau statut
• Logs quotidiens : Commencer frais chaque jour avec de nouvelles données
• Données temporaires : Effacer les anciens calculs et stocker de nouveaux
• Fichiers de résumé : Remplacer les anciens résumés avec des informations mises à jour

Comment écraser :

La bibliothèque SD Arduino n'a pas de mode "écraser" directement. Au lieu de cela, vous utilisez un processus en deux étapes :

1. Supprimer l'ancien fichier : Utilisez SD.remove(filename) pour supprimer le fichier existant
2. Créer un nouveau fichier : Ouvrez le fichier avec SD.open(filename, FILE_WRITE) qui crée un fichier vide frais

Cette approche assure que vous commencez avec un fichier complètement propre, éliminant toutes les anciennes données.

Considérations importantes :

• Perte de données : Supprimer enlève toutes les données précédentes de façon permanente - assurez-vous que c'est intentionnel
• Opérations atomiques : Il y a un bref moment entre supprimer et créer où le fichier n'existe pas
• Gestion d'erreurs : Vérifiez toujours si la suppression a réussi avant d'écrire de nouvelles données
• Stratégie de sauvegarde : Pour des données critiques, considérez écrire vers un nouveau nom de fichier d'abord, puis supprimer l'ancien fichier

Processus d'exemple :

Cet exemple démontre l'écrasement de fichier en :

1. Supprimant tout fichier existant avec le même nom
2. Créant un fichier nouveau frais
3. Écrivant de nouvelles données dans le fichier propre
4. Relisant les données pour vérifier que seul le nouveau contenu existe

Sortie attendue du moniteur série :

Après avoir téléversé ce code, le moniteur série affichera :

Ce qui se passe :

1. La carte SD est initialisée avec succès
2. L'ancien fichier est supprimé (s'il existait)
3. Un nouveau fichier est créé et deux lignes de texte sont écrites
4. Le fichier est fermé pour assurer que les données sont sauvées
5. Le fichier est rouvert pour lecture
6. Le contenu est lu caractère par caractère et affiché

Tester la fonctionnalité d'écrasement :

Test 1 - Exécution initiale : Téléversez le code et observez la sortie ci-dessus.

Test 2 - Vérifier l'écrasement : Appuyez sur le bouton reset de votre Arduino Mega (ou re-téléversez le code). Le moniteur série devrait montrer EXACTEMENT la même sortie - pas doublée ! Ceci confirme que le fichier a été écrasé, pas ajouté.

Test 3 - Vérification ordinateur :

• Éteignez l'Arduino
• Retirez la carte micro SD du module
• Insérez-la dans un lecteur de carte SD USB
• Connectez à votre ordinateur
• Ouvrez "arduino.txt" dans un éditeur de texte
• Vérifiez qu'il contient seulement les deux lignes, indépendamment du nombre de fois que vous avez réinitialisé l'Arduino

Comparaison avec le mode ajout :

Si vous aviez utilisé FILE_WRITE sans SD.remove(), chaque réinitialisation aurait ajouté des lignes dupliquées. Avec la méthode d'écrasement, le fichier contient toujours exactement ce qui a été écrit dans la dernière exécution - parfait pour les fichiers de configuration et les mises à jour de statut

Tutoriels connexes