Micro SD Card con Arduino

 



In questo tutorial, viene mostrato come leggere e scrivere le schede SD utilizzando il modulo “MicroSD Card Adapter” e Arduino Uno. Un grande vantaggio del modulo è che può essere utilizzato con la libreria SD fornita con l’IDE Arduino. La libreria SD semplifica l’inizializzazione, la lettura e la scrittura della scheda.

Il modulo viene fornito con un regolatore di tensione. Pertanto, i pin 5V e 3.3V dell’Arduino possono essere utilizzati per l’alimentazione. C’è anche un chip LVC125A sul modulo che converte la logica dell’interfaccia da 3.3V-5V a 3.3V. Questo si chiama spostamento del livello logico. Ciò significa che è possibile utilizzare questa scheda per interagire con microcontrollori a 3.3 e 5 V come Arduino.
Esistono in realtà due modi per interfacciarsi con le schede micro SD: la modalità SPI e la modalità SDIO. La modalità SDIO è molto più veloce e viene utilizzata nei telefoni cellulari, fotocamere digitali ecc. Ma è più complessa e richiede la firma di documenti di non divulgazione. Per questo motivo, hobbisti come noi probabilmente non incontreranno mai il codice dell’interfaccia in modalità SDIO. Al contrario, ogni modulo della scheda SD si basa sulla modalità SPI che è facile da usare per qualsiasi microcontrollore.

 

MOSI MISO SCK CS
Arduino Uno 11 12 13 10
Arduino Nano 11 12 13 10
Arduino Mega 51 50 52 53

Nel caso in cui si utilizzi una scheda Arduino diversa da quella sopra menzionata, si consiglia di controllare la documentazione ufficiale di Arduino prima di procedere.

In questo progetto utilizzeremo un Arduino UNO.

COME FARE?
– Collegare il pin 10 di Arduino al CS del modulo “MicroSD Card Adapter”.
– Collegare il pin 11 di Arduino al MOSI del modulo “MicroSD Card Adapter”.
– Collegare il pin 12 di Arduino al MISO del modulo “MicroSD Card Adapter”.
– Collegare il pin 13 di Arduino al SCK del modulo “MicroSD Card Adapter”.
– Collegare il pin 5V di Arduino al VCC del modulo “MicroSD Card Adapter”.
– Collegare il pin GND di Arduino al GND del modulo “MicroSD Card Adapter”.

Test del modulo della scheda SD con CardInfo

Comunicare con una scheda SD fortunatamente per noi, Arduino IDE contiene già una libreria molto carina chiamata SD che semplifica la lettura e la scrittura su schede SD. Quindi, selezioniamo lo sketch di esempio CardInfo dall’Arduino IDE.

Questo sketch non scriverà alcun dato sulla SD. Ti dice solo se è riuscito a riconoscere la SD e visualizza alcune informazioni al riguardo. Questo può essere molto utile quando si cerca di capire se una scheda SD è supportata. Prima di provare qualsiasi nuova SD, ti consigliamo di eseguire questo sketch una volta!

Vai all’inizio dello sketch e assicurati che la linea chipSelect sia correttamente inizializzata, nel nostro caso stiamo usando il pin digitale n. 10, quindi cambialo in 10!

OK, ora inserisci la scheda SD nel modulo e carica lo sketch.

Non appena apri il monitor seriale, probabilmente otterrai qualcosa di simile al seguente:

Potresti trovarlo incomprensibile, ma è utile vedere che il tipo di scheda è SDHC (SD High Capacity), il tipo di volume è FAT32 e la dimensione della scheda di circa 4 GB ecc.

Lettura e scrittura dei dati

Considerando che hai inizializzato correttamente la scheda SD, passeremo al nostro prossimo esempio. Il seguente sketch farà una dimostrazione di base della scrittura e della lettura dei dati da un file. Prova lo sketch, prima di iniziare la sua suddivisione dettagliata.

/*

Visita ArduinoFacile su:
https://arduinofacile.altervista.org

La Pagina Facebook di ArduinoFacile su:
https://www.facebook.com/ArduinoFacile/

Micro SD Card con Arduino
*/

#include <SPI.h>
#include <SD.h>

File myFile;

// change this to match your SD shield or module;
const int chipSelect = 10;

void setup()
{
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  Serial.print("Initializing SD card...");

  if (!SD.begin()) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");

  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  myFile = SD.open("test.txt", FILE_WRITE);

  // if the file opened okay, write to it:
  if (myFile) {
    Serial.print("Writing to test.txt...");
    myFile.println("testing 1, 2, 3.");
    // close the file:
    myFile.close();
    Serial.println("done.");
  } else {
    // if the file didn't open, print an error:
    Serial.println("error opening test.txt");
  }

  // re-open the file for reading:
  myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println("test.txt:");

    // read from the file until there's nothing else in it:
    while (myFile.available()) {
      Serial.write(myFile.read());
    }
    // close the file:
    myFile.close();
  } else {
    // if the file didn't open, print an error:
    Serial.println("error opening test.txt");
  }
}

void loop()
{
  // nothing happens after setup
}
}

Lo sketch inizia con l’inclusione della libreria SD integrata e della libreria SPI che ci consente di comunicare facilmente con la scheda SD tramite l’interfaccia SPI.

#include <SPI.h>
#include <SD.h>

Dopo che le librerie sono state incluse, la prossima cosa da fare è dichiarare il pin Arduino a cui chipSelect (CS)è collegato il pin del modulo della scheda SD. Non è necessario dichiarare altri pin SPI poiché stiamo utilizzando l’interfaccia SPI hardware e questi pin sono già dichiarati nella libreria SPI. Dopo aver dichiarato il pin, creiamo quindi un oggetto myFile , che verrà utilizzato in seguito per memorizzare i dati sulla scheda SD.

const int chipSelect = 10;
File myFile;

Successivamente, nel setup() iniziamo la comunicazione seriale per mostrare i risultati sul monitor seriale. Ora, usando SD.begin() inizializzeremo la scheda SD e se l’inizializzazione ha esito positivo l’ istruzione ” if ” diventa vera, la stringa  “initialization done. ” viene stampato sul monitor seriale, altrimenti verra stampato sul monitor seriale la seguente stringa “initialization failed!” e il programma termina.

Serial.begin(9600);
  Serial.print("Initializing SD card...");
  if (!SD.begin()) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");

Successivamente, SD.open() aprirà il file denominato ” test.txt “. Nel nostro caso, poiché tale file non è presente, verrà creato. L’altro parametro FILE_WRITE apre il file in modalità lettura-scrittura.

myFile = SD.open("test.txt", FILE_WRITE);

Una volta aperto il file, stamperemo il messaggio “Writing to test.txt…” sul monitor seriale e quindi usando myFile.println()  scriveremo il testo “testing 1, 2, 3.” nel file. Successivamente è necessario utilizzare la close() per garantire che i dati scritti nel file vengano salvati.

if (myFile) {
    Serial.print("Writing to test.txt...");
    myFile.println("testing 1, 2, 3.");
    myFile.close();
    Serial.println("done.");
  } else {
    Serial.println("error opening test.txt");
  }

Ora leggiamo lo stesso file per verificare se l’operazione di scrittura ha avuto esito positivo. A tale scopo, utilizzeremo la stessa funzione SD.open(), ma questa volta poiché il file ” test.txt ” è già stato creato, la funzione aprirà il file . Quindi utilizzando la funzione myFile.read() leggeremo dal file e lo stamperemo sul monitor seriale. La funzione read() in realtà legge solo un carattere alla volta, quindi è necessario utilizzare il ciclo “while” e la funzione myFile.available() per leggere tutti i caratteri nel file. Alla fine dobbiamo chiudere il file.

myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println("test.txt:");
    while (myFile.available()) {
      Serial.write(myFile.read());
    }
    myFile.close();
  } else {
    Serial.println("error opening test.txt");
  }

Poiché questo è solo uno sketch dimostrativo per dimostrare come leggere e scrivere i file, non ha senso eseguire il codice più volte, quindi tutto il codice è stato inserito nel setup() che viene eseguito una sola volta, invece di inserirlo in un loop() che viene eseguito all’infinito.

void loop() 
{
}

Ora dopo aver caricato il codice su Arduino, se tutto è a posto, sul monitor seriale apparirà quanto segue.