Comment utiliser Module Micro SD Card avec Arduino

Introduction

Stocker et récupérer des données de configuration à partir d’un module Micro SD Card avec un Arduino UNO est un aspect crucial de nombreux projets qui impliquent la collecte et l’analyse de données. Un module Micro SD Card permet le stockage facile et efficace de grandes quantités de données, en en faisant une solution idéale pour les applications nécessitant un enregistrement de données. L’Arduino UNO, une carte microcontrôleur populaire, offre une plateforme conviviale pour développer et mettre en œuvre divers projets. En utilisant un module Micro SD Card avec un Arduino UNO, les développeurs peuvent concevoir des solutions faciles à déployer et à adapter pour répondre à leurs besoins spécifiques.

Lecture à partir d’une carte SD avec Arduino

Composants matériels

Avant de commencer, on va supposer que vous avez Carte Micro SD, et donc voici les composants matériels nécessaires pour utiliser le module Micro SD Card avec Arduino pour la lecture de cette Carte Micro SD :

• Arduino UNO
• Carte Micro SD
• Module Micro SD Card
• Fils de connexion (Jumper Wires)

Câblage et Connexions

Le câblage des connexions est le suivant :

Installation de l’IDE Arduino et des Bibliothèques

Avant de téléverser le code, vous devez installer le logiciel Arduino IDE à partir du site officiel d’Arduino. Ensuite, téléchargez et décompressez les bibliothèques nécessaires pour le module Micro SD Card, et placez-les dans le dossier des bibliothèques Arduino.

Code

Voici le code complet qui lit les valeurs du fichier de configuration à partir de la carte Micro SD et les affiche dans le moniteur série :

#include <SD.h>

#define PIN_SPI_CS 4

#define FILE_NAME "config.txt"

#define KEY_MAX_LENGTH    30 // change it if key is longer
#define VALUE_MAX_LENGTH  30 // change it if value is longer


// variables
int myInt_1;
int myInt_2;
float myFloat_1;
float myFloat_2;
String myString_1;
String myString_2;

void setup() {
  Serial.begin(9600);

  if (!SD.begin(PIN_SPI_CS)) {
    Serial.println(F("SD Card failed, or not present"));
    while (1); // don't do anything more:
  }

  Serial.println(F("SD Card initialized."));

  myInt_1    = SD_findInt(F("myInt_1"));
  myInt_2    = SD_findInt(F("myInt_2"));
  myFloat_1  = SD_findFloat(F("myFloat_1"));
  myFloat_2  = SD_findFloat(F("myFloat_2"));
  myString_1 = SD_findString(F("myString_1"));
  myString_2 = SD_findString(F("myString_2"));

  Serial.print(F("myInt_1 = "));
  Serial.println(myInt_1);

  Serial.print(F("myInt_2 = "));
  Serial.println(myInt_2);

  Serial.print(F("myFloat_1 = "));
  Serial.println(myFloat_1);

  Serial.print(F("myFloat_2 = "));
  Serial.println(myFloat_2);

  Serial.print(F("myString_1 = "));
  Serial.println(myString_1);

  Serial.print(F("myString_2 = "));
  Serial.println(myString_2);
}

void loop() {

}


bool SD_available(const __FlashStringHelper * key) {
  char value_string[VALUE_MAX_LENGTH];
  int value_length = SD_findKey(key, value_string);
  return value_length > 0;
}

int SD_findInt(const __FlashStringHelper * key) {
  char value_string[VALUE_MAX_LENGTH];
  int value_length = SD_findKey(key, value_string);
  return HELPER_ascii2Int(value_string, value_length);
}

float SD_findFloat(const __FlashStringHelper * key) {
  char value_string[VALUE_MAX_LENGTH];
  int value_length = SD_findKey(key, value_string);
  return HELPER_ascii2Float(value_string, value_length);
}

String SD_findString(const __FlashStringHelper * key) {
  char value_string[VALUE_MAX_LENGTH];
  int value_length = SD_findKey(key, value_string);
  return HELPER_ascii2String(value_string, value_length);
}

int SD_findKey(const __FlashStringHelper * key, char * value) {
  File configFile = SD.open(FILE_NAME);

  if (!configFile) {
    Serial.print(F("SD Card: error on opening file "));
    Serial.println(FILE_NAME);
    return;
  }

  char key_string[KEY_MAX_LENGTH];
  char SD_buffer[KEY_MAX_LENGTH + VALUE_MAX_LENGTH + 1]; // 1 is = character
  int key_length = 0;
  int value_length = 0;

  // Flash string to string
  PGM_P keyPoiter;
  keyPoiter = reinterpret_cast<PGM_P>(key);
  byte ch;
  do {
    ch = pgm_read_byte(keyPoiter++);
    if (ch != 0)
      key_string[key_length++] = ch;
  } while (ch != 0);

  // check line by line
  while (configFile.available()) {
    int buffer_length = configFile.readBytesUntil('\n', SD_buffer, 100);
    if (SD_buffer[buffer_length - 1] == '\r')
      buffer_length--; // trim the \r

    if (buffer_length > (key_length + 1)) { // 1 is = character
      if (memcmp(SD_buffer, key_string, key_length) == 0) { // equal
        if (SD_buffer[key_length] == '=') {
          value_length = buffer_length - key_length - 1;
          memcpy(value, SD_buffer + key_length + 1, value_length);
          break;
        }
      }
    }
  }

  configFile.close();  // close the file
  return value_length;
}

int HELPER_ascii2Int(char *ascii, int length) {
  int sign = 1;
  int number = 0;

  for (int i = 0; i < length; i++) {
    char c = *(ascii + i);
    if (i == 0 && c == '-')
      sign = -1;
    else {
      if (c >= '0' && c <= '9')
        number = number * 10 + (c - '0');
    }
  }

  return number * sign;
}

float HELPER_ascii2Float(char *ascii, int length) {
  int sign = 1;
  int decimalPlace = 0;
  float number  = 0;
  float decimal = 0;

  for (int i = 0; i < length; i++) {
    char c = *(ascii + i);
    if (i == 0 && c == '-')
      sign = -1;
    else {
      if (c == '.')
        decimalPlace = 1;
      else if (c >= '0' && c <= '9') {
        if (!decimalPlace)
          number = number * 10 + (c - '0');
        else {
          decimal += ((float)(c - '0') / pow(10.0, decimalPlace));
          decimalPlace++;
        }
      }
    }
  }

  return (number + decimal) * sign;
}

String HELPER_ascii2String(char *ascii, int length) {
  String str;
  str.reserve(length);
  str = "";

  for (int i = 0; i < length; i++) {
    char c = *(ascii + i);
    str += String(c);
  }

  return str;
}

Explication du Fonctionnement

Le code débute par l’initialisation de la communication série et la vérification de la présence et de l’accès à la carte Micro SD. Ensuite, il lit les valeurs du fichier de configuration à l’aide des fonctions auxiliaires SD_findInt(), SD_findFloat(), et SD_findString(). Les valeurs récupérées sont ensuite affichées dans le moniteur série.

Les fonctions auxiliaires, telles que SD_available(), SD_findKey(), HELPER_ascii2Int(), et HELPER_ascii2Float(), aident à lire et à convertir les valeurs dans le fichier de configuration.

Applications d’utiliser module Micro SD Card avec Arduino

L’utilisation d’un module Micro SD Card avec Arduino offre de nombreuses possibilités d’application :

• Enregistrement de données
• Calibration des capteurs
• Configuration et paramétrage du système
• Mise à jour du micrologiciel
• Personnalisation de l’interface utilisateur
• Contrôle et surveillance à distance

Conclusion

En utilisant un module Micro SD Card avec Arduino, il devient plus facile de stocker et de récupérer des données de configuration pour divers projets. Grâce à ce tutoriel, vous avez appris comment lire les valeurs à partir d’un fichier de configuration stocké sur une carte Micro SD et les afficher dans le moniteur série. Vous pouvez maintenant explorer de nombreuses applications pratiques de cette fonctionnalité dans vos projets Arduino. N’hésitez pas à expérimenter et à adapter ces techniques pour répondre à vos besoins spécifiques. Amusez-vous bien en développant vos projets créatifs avec Arduino et le module Micro SD Card !

Lien outilles

1. Téléchargement de l’Arduino IDE : https://www.arduino.cc/en/software
2. Pour plus d’articles : https://www.moussasoft.com/tutoriels-electroniques
3. Twitter: Moussa Lhoussaine (@Moussasoft_com) / Twitter

Arduino – Home