Usando Cartões SD com o Arduino- Parte 2

Encerrando o nosso rápido estudo, vamos ver a questão do software.

Usando um Cartão SD com o Arduino: Software

Tratar os sistema FAT de arquivos é algo bastante complexo (poderíamos dizer que corresponde ao coração das primeiras versões do MSDOS). Felizmente o pessoal da Sparkfun e da Adafruit fez uma biblioteca para isto, e esta biblioteca faz parte da instalação da IDE do Arduino.

O Arduino é bastante limitado para uma implementação muito sofisticada. Em particular temos o problema da memória. Para melhor desempenho, o MSDOS procurava manter a FAT sempre na memória (alguém se lembra do comando BUFFERS no CONFIG.SYS?). A biblioteca SD (até onde pude observar) se vira com um único buffer de 512bytes (lembrar que o ATmega328 tem apenas 2K de Ram).

Um detalhe é que a biblioteca configura o pino D10 do Arduino como saída, devido ao funcionamento do sinal SS do ATmega que comentei na parte anterior.

O código abaixo é uma variação do exemplo DataLogger da biblioteca. Ele grava em um arquivo a temperatura medida pelo LM35, de cinco em cinco segundos. A abertura e fechamento do arquivo é comandada pela serial do Arduino (lembre-se de fechar o arquivo antes de desligar o Arduino).

view plaincopy to clipboardprint?

1. /* 
2.    Registra temperatura em arquivo no cartão SD 
3.    DQ 21/09/14 
4.     
5.    Adaptação do exemplo datalogger da biblioteca SD 
6.    created  24 Nov 2010 
7.    modified 9 Apr 2012 
8.    by Tom Igoe 
9.   
10.    Montagem: 
11.    * Sensor LM35 ligado a AN0 
12.    * Cartão SD conectado ao SPI 
13.      ** MOSI - pin 11 
14.      ** MISO - pin 12 
15.      ** CLK - pin 13 
16.      ** CS - pin 4 
17.       
18.  */  
19.   
20. #include <SD.h>  
21.   
22. // Saída digital usada para o CS do cartão SD  
23. const int chipSelect = 4;  
24.   
25. // Arquivo de dados  
26. File dataFile;  
27.   
28. // Iniciação  
29. void setup()  
30. {  
31.   // Abre a porta inicial  
32.   Serial.begin(9600);  
33.   while (!Serial) {  
34.     ; // wait for serial port to connect. Needed for Leonardo only  
35.   }  
36.   
37.   // Acesso o cartão SD  
38.   Serial.print("Acessando cartao SD...");  
39.   if (!SD.begin(chipSelect)) {  
40.     Serial.println(" falha ao acessar o cartao.");  
41.     return;  
42.   }  
43.   Serial.println(" sucesso.");  
44. }  
45.   
46. // Laco de coleta  
47. void loop()  
48. {  
49.   // Trata a serial  
50.   if (Serial.available() > 0) {  
51.     // recebeu caracter pela serial, espaço abre ou fecha o arquivo  
52.     if (Serial.read() == ' ') {  
53.       if (dataFile) {  
54.         dataFile.close();  
55.         Serial.println ("Arquivo fechado");  
56.       } else {  
57.         dataFile = SD.open("datalog.txt", FILE_WRITE);  
58.         if (dataFile) {  
59.           Serial.println ("Arquivo aberto");  
60.         } else {  
61.           Serial.println("Erro ao abrir datalog.txt");  
62.         }  
63.       }  
64.     }  
65.   }  
66.     
67.   // Se arquivo aberto, le o sensor e grava a leitura  
68.   if (dataFile) {  
69.     unsigned sensor = analogRead(A0);  
70.     sensor = (sensor*500)/1024;  // converte para temperatura  
71.     dataFile.println(sensor);  
72.     Serial.println(sensor);  
73.     delay (5000);    // 5 segundos entre leituras  
74.   }  
75. }  

/*
   Registra temperatura em arquivo no cartão SD
   DQ 21/09/14
   
   Adaptação do exemplo datalogger da biblioteca SD
   created  24 Nov 2010
   modified 9 Apr 2012
   by Tom Igoe
 
   Montagem:
   * Sensor LM35 ligado a AN0
   * Cartão SD conectado ao SPI
     ** MOSI - pin 11
     ** MISO - pin 12
     ** CLK - pin 13
     ** CS - pin 4
 	 
 */

#include <SD.h>

// Saída digital usada para o CS do cartão SD
const int chipSelect = 4;

// Arquivo de dados
File dataFile;

// Iniciação
void setup()
{
  // Abre a porta inicial
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  // Acesso o cartão SD
  Serial.print("Acessando cartao SD...");
  if (!SD.begin(chipSelect)) {
    Serial.println(" falha ao acessar o cartao.");
    return;
  }
  Serial.println(" sucesso.");
}

// Laco de coleta
void loop()
{
  // Trata a serial
  if (Serial.available() > 0) {
    // recebeu caracter pela serial, espaço abre ou fecha o arquivo
    if (Serial.read() == ' ') {
      if (dataFile) {
        dataFile.close();
        Serial.println ("Arquivo fechado");
      } else {
        dataFile = SD.open("datalog.txt", FILE_WRITE);
        if (dataFile) {
          Serial.println ("Arquivo aberto");
        } else {
          Serial.println("Erro ao abrir datalog.txt");
        }
      }
    }
  }
  
  // Se arquivo aberto, le o sensor e grava a leitura
  if (dataFile) {
    unsigned sensor = analogRead(A0);
    sensor = (sensor*500)/1024;  // converte para temperatura
    dataFile.println(sensor);
    Serial.println(sensor);
    delay (5000);    // 5 segundos entre leituras
  }
}

O tamanho da bilbioteca SD é significativo: o exemplo acima ocupa cerca de 14K, o que é próximo da metade da memória do ATmega328. Destes 14K, 11K são da biblioteca SD.

Comentário Finais

O uso de cartões SD no Arduino está pouco acima do nível "urso andando de bicicleta" (ele não anda muito bem, mas é incrível conseguir andar alguma coisa). Gasta uma parcela significativa da Flash e Ram do ATmega e não é muito veloz.

Se você deseja salvar poucos dados, considere usar a EEProm do ATmega ou uma EEProm externa. Se a biblioteca SD for lenta para as suas necessidades, mas não muito, você pode deixar de lado o sistema FAT e acessar diretamente os blocos.

Se você quer fazer um uso mais sofisticado do cartão, considere usar um "mini PC" como o Raspberry Pi e a Beaglebone Black.