Como usar o Cartão SD com Arduino

09 SET
2015

Autor: Leonardo Dalla Porta

Descubra como usar o módulo de cartão SD com Arduino. Este módulo Micro SD é um dispositivo perfeito para criar dataloggers e salvar alguns tipos de arquivo utilizando o arduino. Para facilitar o uso o site oficial Arduino fornece uma biblioteca para este fim, assim vamos descrever como é utilizado essa biblioteca e explicaremos o que cada função executa.

Conexão com Arduino

A biblioteca usa a interface padrão para comunicação SPI, MISO, MOSI, SCK (CLK) e um pino de chip sinal de selecção, CS.

 

2.2

 MOSI – pino 11
 MISO – pino 12
 SCK (CLK) – pino 13
 CS – pino 4

Bibliotecas

A biblioteca Arduino padrão para cartão SD é enorme! Com o exemplo esboço de leitura / gravação, quando compilado é 13690 Bytes, que é metade do espaço disponível do flash em um mini-Arduino pro!

Então, se você estiver com pouco espaço, é uma boa idéia para encontrar uma biblioteca menor. Depende dos cartões SD e você tem o formato que você deseja usar, você tem estas opções.

FAT32 Format (maiores que 2 GB)

FAT16 Format (menor que 2 GB)

Nós não testamos todas estas bibliotecas, para fazer sua pesquisa e testá-los antes de usá-lo. Aqui vou mostrar-lhe como usar a biblioteca Arduino SD.

 

Como usar a biblioteca Arduino SD

A biblioteca SD vem com o Arduino IDE, portanto, você não precisa fazer o download. Ele precisa ser incluir no início do esboço.

1
#include

Incluindo `SD.h` automaticamente cria um” SD “objeto global que pode ser interagido dentro de uma semelhante
maneira a outros objetos globais padrão como” Serial “.

 

As funções do módulo Disponível SD Card

Leitura a partir do cartão SD

Primeiro você precisa abrir o arquivo:

 

1
File dataFile = SD.open("datalog.txt");

Ele irá retornar falso se não conseguir abrir o arquivo, de modo a verificar arquivo de dados antes de o utilizar. A “leitura” função lê o arquivo linha por linha, então você terá que usar um loop while, até que não conseguem chegar ao final do arquivo. Agora você pode gravar o arquivo usando este.

 

1
2
3
4
5
6
7
if (dataFile) {
  while (dataFile.available()) {
    Serial.write(dataFile.read());
  }
  dataFile.close();
} 
else {  // Se existir um erro, para por aqui }

Note que você precisa fechar o arquivo depois de terminar de lê-lo. Além disso, você só pode abrir um arquivo ao mesmo tempo, se você quiser ler o próximo arquivo, você precisa fechar o arquivo atual primeiro.

 

Escreva no cartão SD

Primeiro você precisa abrir o arquivo que você deseja gravar com o parâmetro “file_write”.

 

1
File dataFile  = SD.open("test.txt", FILE_WRITE);

A função “aberta” tem dois parâmetros, localização e modo de arquivo (somente necessário para “Write”, se ausente por padrão, ele abre o arquivo no modo somente leitura). Ele irá retornar falso se não conseguir abrir o arquivo, de modo a verificar arquivo de dados antes de o utilizar. Agora você pode gravar o arquivo usando este.

1
2
3
4
5
6
if (dataFile) {
  dataFile.println("writing data to test file");
  dataFile.close();
} 
else {
  //Se existir um erro, para por aqui
1
}

Note que você precisa para fechar o arquivo depois de escrever para ele. Além disso, você só pode abrir um arquivo ao mesmo tempo, se você deseja abrir o próximo arquivo, você precisa fechar o arquivo atual primeiro.

 

Verifique se existe um arquivo

1
2
3
4
5
// Check to see if the file exists: 
 if (SD.exists("example.txt")) {
    // example.txt exists
 }
 else {
1
  //Se existir um erro, para por aqui
1
}

Criar um arquivo de texto no cartão SD

Não há uma função para este fim, mas você pode abrir um arquivo com o modo “file_write” para criar um arquivo, se esse arquivo não existe.

// To create a text file, we can open a new file and immediately close it:
 dataFile = SD.open("example.txt", FILE_WRITE);
 dataFile.close();

Apagar um arquivo no cartão SD

SD.remove("example.txt");

Listar todos os arquivos no cartão SD

Não há uma função para este na biblioteca, mas podemos criar uma função personalizada para alcançar este objectivo. Esta função é a partir do exemplo de esboço na Biblioteca. Ela imprime o diretório do arquivo no monitor serial.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void printDirectory(File dir, int numTabs) {
   while(true) {
 
     File entry =  dir.openNextFile();
     if (! entry) {
       // no more files
       break;
     }
     for (uint8_t i=0; i<numTabs; i++) {
       Serial.print('t');
     }
     Serial.print(entry.name());
     if (entry.isDirectory()) {
       Serial.println("/");
       printDirectory(entry, numTabs+1);
     } else {
       // files have sizes, directories do not
       Serial.print("tt");
       Serial.println(entry.size(), DEC);
     }
     entry.close();
   }
}

Testando cartão SD ou obter informações sobre o cartão SD

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
Sd2Card card;
SdVolume volume;
SdFile root;
 
const int chipSelect = 4;   // 4 for Arduino boards, might be different in other non-Arduino boards.
 
// 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("initialization failed. Things to check:");
	Serial.println("* is a card is inserted?");
	Serial.println("* Is your wiring correct?");
	Serial.println("* did you change the chipSelect pin to match your shield or module?");
	return;
} 
else {
	Serial.println("Wiring is correct and a card is present."); 
}
 
// print the type of card
Serial.print("nCard type: ");
switch(card.type()) {
	case SD_CARD_TYPE_SD1:
		Serial.println("SD1");
		break;
	case SD_CARD_TYPE_SD2:
		Serial.println("SD2");
		break;
	case SD_CARD_TYPE_SDHC:
		Serial.println("SDHC");
		break;
	default:
		Serial.println("Unknown");
}
 
// Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
if (!volume.init(card)) {
	Serial.println("Could not find FAT16/FAT32 partition.nMake sure you've formatted the card");
	return;
}
 
// print the type and size of the first FAT-type volume
uint32_t volumesize;
Serial.print("nVolume type is 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("Volume size (bytes): ");
Serial.println(volumesize);
Serial.print("Volume size (Kbytes): ");
volumesize /= 1024;
Serial.println(volumesize);
Serial.print("Volume size (Mbytes): ");
volumesize /= 1024;
Serial.println(volumesize);
 
Serial.println("nFiles found on the card (name, date and size in bytes): ");
root.openRoot(volume);
 
// list all files in the card with date and size
root.ls(LS_R | LS_DATE | LS_SIZE);

Qualquer duvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Deixe um comentário

WordPress Blog

*

 
Free WordPress Themes
WordPress Themes