No artigo de hoje você vai aprender a utilizar um cartão de memória microSD para armazenar dados  obtidos com um microcontrolador Arduino UNO, para posterior análise e utilização.
   Cartão de memória SD é um dispositivo de armazenamento de informação em estado sólido (sem partes móveis) que foi desenvolvido pela associação SD com o objetivo de aumentar a capacidade de armazenamento de dispositivos portáteis. SD significa “Secure digital” e é o sucessor dos cartões MMC (MultiMediaCard), com adição de segurança e criptografia.
   Os cartões SD tem algumas particularidades que precisam ser observadas para sua utilização, porém o Arduino tem uma biblioteca (chamada SD) específica para lidar com arquivos em cartões de memória, tornando sua utilização muito prática e rápida. Existem inclusive vários exemplos prontos, acessíveis na IDE do Arduino em “Arquivo > Exemplos > SD”.
   A pinagem (conexão) de todos e qualquer SD card é padrão, como por exemplo em um microSD na imagem abaixo. Existem muitos shields de cartão SD para Arduino, porém todos vão funcionar da mesma forma e com a mesma pinagem (veja alguns exemplos aqui).
   Na postagem de hoje vamos utilizar um módulo microSD da Catalex que pode ser encontrado em nosso parceiro da China  (ICStation, clique aqui) ou também no Aliexpress e eBay. A conexão física do módulo com um Arduino UNO é mostrada abaixo (esta conexão segue a recomendação do sketch “CardInfo.ino”, disponível na IDE do Arduino).
A pinagem (forma de conexão) entre o módulo microSD e o Arduino é a seguinte:
– GND do microSD para o GND do Arduino
– VCC do microSD para o +5V do Arduino
– MISO do microSD para o 12 do Arduino
– MOSI do microSD para o 11 do Arduino
– SCK do microSD para o 13 do Arduino
– CS do microSD para o 4 do  Arduino
  Após feita a conexão do SD com o Arduino, abra a IDE do Arduino e o exemplo “CardInfo” (ou copie da caixa de código abaixo); faça o upload deste código para a placa e abra o monitor serial da IDE.
 // include the SD library:  
 #include <SPI.h>  
 #include <SD.h>  
   
 // set up variables using the SD utility library functions:  
 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("nInitializing SD card...");  
   
  // 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 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);  
 }  
   
   
 void loop(void) {  
   
 }  
   Se tudo estiver correto, você deve ver uma tela (monitor serial) parecida com esta abaixo. Caso apareça uma mensagem começando com  “initialization failed. Things to check: …..” você pode ter invertido alguma conexão ou então esquecido de inserir o SD card no soquete; revise as conexões e tente novamente.
   A imagem  acima traz informações importantes sobre o cartão de memória lido pelo Arduino:
– Cartão tipo SDHC: SD de alta capacidade
– Formato de arquivos FAT32 (formato criado pela microsoft )
– Tamanho do volume (Mb): 3773 (quase 4Gb) **
Arquivos encontrados no SDcard
** Informação importante: o tamanho máximo de cartão de memória lido pelo Arduino é 4Gb, devido á limitações na biblioteca SD. Mesmo que você insira um cartão  de 8Gb, 16Gb (ou maior) ele será reconhecido como 4Gb.
   O próximo exemplo será dedicado a mostrar como armazenar dados de entradas analógicas em um arquivo texto (.txt) para visualização no computador. Mantendo a mesma conexão física mostrada acima, agora você deve abrir (na IDE do Arduino) um exemplo chamado  “Datalogger.ino” em “Arquivo > Exemplos > SD > Datalogger” (ou copiar da caixa de código abaixo).
 #include <SPI.h>  
 #include <SD.h>  
   
 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("Initializing SD card...");  
   
  // see if the card is present and can be initialized:  
  if (!SD.begin(chipSelect)) {  
   Serial.println("Card failed, or not present");  
   // don't do anything more:  
   return;  
  }  
  Serial.println("card initialized.");  
 }  
   
 void loop() {  
  // make a string for assembling the data to log:  
  String dataString = "";  
   
  // read three sensors and append to the string:  
  for (int analogPin = 0; analogPin < 3; analogPin++) {  
   int sensor = analogRead(analogPin);  
   dataString += String(sensor);  
   if (analogPin < 2) {  
    dataString += ",";  
   }  
  }  
   
  // open the file. note that only one file can be open at a time,  
  // so you have to close this one before opening another.  
  File dataFile = SD.open("datalog.txt", FILE_WRITE);  
   
  // if the file is available, write to it:  
  if (dataFile) {  
   dataFile.println(dataString);  
   dataFile.close();  
   // print to the serial port too:  
   Serial.println(dataString);  
  }  
  // if the file isn't open, pop up an error:  
  else {  
   Serial.println("error opening datalog.txt");  
  }  
  delay(1000);  
 }  
   Após fazer o upload do código para o Arduino UNO,  abra o monitor serial e  observe três números serem impressos á cada linha, separados por vírgulas. Estes mesmos valores (desta mesma forma) estão sendo salvos dentro do microSD, em um arquivo chamado  “datalog.txt”. Desligue seu Arduino UNO, remova o cartão  de memória  do  shield e conecte-o ao seu computador.
   O arquivo  “datalog.txt” pode ser aberto em qualquer editor de texto (qualquer mesmo) ou até mesmo no microsoft Excel, onde você pode organizar os dados em diferentes células.
   Existem ainda diversos outros exemplos de utilização do SD card que vem na IDE do Arduino: leitura de arquivos, descobrir quais pastas estão no SD card, entre outros. Existe muito mais informação na página oficial do Arduino-SD card (disponível aqui, em Inglês).
– Para comprar um Shield microSD card em nosso Parceiro ICStation (da China), clique no texto: Micro SD Storage Board TF Card Memory Shield Module SPI For Ardu
– Para comprar o Arduino UNO em nosso Parceiro ICStation (da China), clique no texto: ICStation ATMEGA328 UNO V3.0 R3 Board Compatible Arduino UNO R3
– Para comprar os cabinhos coloridos (jumpers) em nosso Parceiro ICStation (da China), clique no texto: 1pcs Dupont Wire 10CM 2.54MM Female to Male 1P-1P Jumper Cable For Arduino
Utilizando um cartao de memória (SD) com Arduino
Classificado como:                                        

Uma ideia sobre “Utilizando um cartao de memória (SD) com Arduino

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Solve : *
20 + 7 =