Arduino (L12): Aumentare la memoria con scheda microSD

Di fabbrica Arduino Uno possiede una memoria di appena 32 KB. Come avviene per smartphone e tablet tale dimensione è ampliabile tramite lo slot per schede microSD.

Il modulo per aggiungere il lettore di schede microSD, e di conseguenza implementare la memoria, spesso viene incluso nell’Ethenet Shield. In questo modo in unica scheda espandibile si avrà sia la possibilità di controllare da remoto che di aumentare la memoria, fondamentale nel caso in cui si voglia creare un server web con Arduino.

Verifica di funzionamento della scheda microSD

Nell’esempio che segue se il lettore di schede microSD funziona scrive all’interno un file con il testo 

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

File myFile;

void setup() {
// Apre le comunicazioni seriali
Serial.begin(9600);
while (!Serial) {
; // attendere la porta seriale per la connessione. Necessario solo per porta USB nativa.
}
Serial.print(“Inizializzazione SD…”);

if (!SD.begin(4)) {
Serial.println(“Inizializzazione fallita!”);
return;
}
Serial.println(“Inizializzazione completata.”);

// aprire il file. Nota che solo un file può essere aperto alla volta,
// quindi bisogna chiudere questa prima di aprirne un’altra.
myFile = SD.open(“prova.txt”, FILE_WRITE);

// Se il file aperto va bene, scrivere su di esso:
if (myFile) {
Serial.print(“Sto scrivendo il testo …”);
myFile.println(“Prova 1, 2, 3.”);
// close the file:
myFile.close();
Serial.println(“fatto.”);
} else {
// Se il file non si apre, stampare un errore:
Serial.println(“errore apertura prova.txt”);
}

// riaprire il file per la lettura:
myFile = SD.open(“prova.txt”);
if (myFile) {
Serial.println(“prova.txt:”);

// leggere dal file fino a quando non c’è niente altro in esso:
while (myFile.available()) {
Serial.write(myFile.read());
}
// chiudere il file:
myFile.close();
} else {
// Se il file non si apre, stampare un errore:
Serial.println(“errore apertura prova.txt”);
}
}

void loop() {
// nulla succede dopo l’installazione
}

Avere informazioni sulla scheda microSD

/*
SD card test

This example shows how use the utility libraries on which the’
SD library is based in order to get info about your SD card.
Very useful for testing a card when you’re not sure whether its working or not.

The circuit:
* SD card attached to SPI bus as follows:
** MOSI – pin 11 on Arduino Uno/Duemilanove/Diecimila
** MISO – pin 12 on Arduino Uno/Duemilanove/Diecimila
** CLK – pin 13 on Arduino Uno/Duemilanove/Diecimila
** CS – depends on your SD card shield or module.
Pin 4 used here for consistency with other Arduino examples

created 28 Mar 2011
by Limor Fried
modified 9 Apr 2012
by Tom Igoe
*/
// include le librerie della SD:
#include <SPI.h>
#include <SD.h>

// impostare le variabili utilizzando le funzioni della libreria di utilità SD:
Sd2Card card;
SdVolume volume;
SdFile root;

// change this to match your SD shield or module;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
const int chipSelect = 4;

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

Serial.print(“\nInizializza SD …”);

// we’ll use the initialization code from the utility libraries
// since we’re just testing if the card is working!
if (!card.init(SPI_HALF_SPEED, chipSelect)) {
Serial.println(“inizializzazione fallita. Cose da controllare:”);
Serial.println(“* sd e’ inserita?”);
Serial.println(“* e’ consentita la scrittura?”);
return;
} else {
Serial.println(“Il collegamento e’ corretto e una scheda e’ presente.”);
}

// print the type of card
Serial.print(“\nTipo: “);
switch (card.type()) {
case SD_CARD_TYPE_SD1:
Serial.println(“SD”);
break;
case SD_CARD_TYPE_SD2:
Serial.println(“SDXC”);
break;
case SD_CARD_TYPE_SDHC:
Serial.println(“SDHC”);
break;
default:
Serial.println(“Sconosciuta”);
}

// Now we will try to open the ‘volume’/’partition’ – it should be FAT16 or FAT32
if (!volume.init(card)) {
Serial.println(“Non riesco a trovare FAT16/FAT32.\nAssicurati di aver formattato la scheda”);
return;
}

// print the type and size of the first FAT-type volume
uint32_t volumesize;
Serial.print(“\nIl volume e’ FAT”);
Serial.println(volume.fatType(), DEC);
Serial.println();

volumesize = volume.blocksPerCluster(); // clusters are collections of blocks
volumesize *= volume.clusterCount(); // we’ll have a lot of clusters
volumesize *= 512; // SD card blocks are always 512 bytes
Serial.print(“Dimensione volume (byte): “);
Serial.println(volumesize);
Serial.print(“Dimensione volume (Kbyte): “);
volumesize /= 1024;
Serial.println(volumesize);
Serial.print(“Dimensione volume (Mbyte): “);
volumesize /= 1024;
Serial.println(volumesize);

Serial.println(“\nI file trovati sulla scheda (nome, data e dimensione in byte): “);
root.openRoot(volume);

// list all files in the card with date and size
root.ls(LS_R | LS_DATE | LS_SIZE);
}

void loop(void) {

}

loading...

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *