Visita mi canal de youtube

sábado, 24 de septiembre de 2016

Modulo Micro SD Arduino

El uso de la biblioteca SD para recuperar información a través de un puerto serie

Este ejemplo muestra cómo leer la información acerca de una tarjeta SD. El ejemplo reporta tipo de volumen, espacio libre y otra información utilizando la biblioteca SD, enviarlo a través del puerto serie. Por favor, haga clic aquí para obtener más información sobre la biblioteca SD.

hardware necesario

Arduino o Genuino bordo
Escudo de Ethernet (u otro tablero con una ranura SD)
tarjeta SD formateada

Circuit



Código

El código de abajo está configurado para su uso con un escudo de Ethernet, que tiene una ranura de SD a bordo. En la configuración (), llame SD.begin (), nombrando el pin 4 como el pin CS. Este pin varía dependiendo de la marca del escudo o placa que está utilizando.

El código utiliza algunas librerías de utilidades indocumentados a reportar información sobre la tarjeta SD. Esta información incluye el formato (FAT16 o FAT32) y la estructura de archivos, así como la cantidad de espacio libre y el espacio utilizado en la tarjeta.


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) {

}


El uso de la biblioteca SD para registrar datos


Este ejemplo muestra cómo utilizar la Biblioteca de tarjetas SD para registrar los datos de tres sensores analógicos a una tarjeta SD. Por favor, haga clic aquí para obtener más información sobre la biblioteca SD.

hardware necesario

Arduino o Genuino bordo
Escudo de Ethernet (u otro tablero con una ranura SD)
3 potenciómetros 10k ohm
alambras interconexion
tablero de circuitos
tarjeta SD formateada

Circuit


La placa Arduino o Genuino tiene que ser conectado a la Ethernet Shield. Los tres potenciómetros pueden estar sustituidos con otros sensores analógicos, para ser conectados de acuerdo con sus técnicas de interfaz.


Schematics


Código

El código de abajo está configurado para su uso con un escudo de Ethernet, que tiene una ranura de SD a bordo. En la configuración (), llame SD.begin (), nombrando el pin 4 como el pin CS. Este pin varía dependiendo de la marca del escudo o placa.

En el bucle (), una cadena se crea para contener la información de tres sensores analógicos. Se repite el código a través de los sensores, la adición de sus datos a la cadena.

A continuación, el archivo en la tarjeta SD se abre llamando SD.open (). Una vez disponibles, los datos se escriben en la tarjeta cuando se utiliza dataFile.println (). El archivo debe estar cerrada con dataFile.close () para guardar la información.

/*
  SD card datalogger

 This example shows how to log data from three analog sensors
 to an SD card using the SD library.

 The circuit:
 * analog sensors on analog ins 0, 1, and 2
 * SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4

 created  24 Nov 2010
 modified 9 Apr 2012
 by Tom Igoe

 This example code is in the public domain.

 */


#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");
  }
}


DESCARGA ¡¡ GRATIS !! —–> LIBROS DE
ELECTRONICA
 –>ENTRA AQUI PARA VER


El uso de la biblioteca SD para recuperar información a través de un puerto serie


Este ejemplo muestra cómo leer un archivo de una tarjeta SD usando la biblioteca SD y enviarlos a través del puerto serie. Por favor, haga clic aquí para obtener más información sobre la biblioteca SD.

hardware necesario

Arduino o Genuino bordo
Escudo de Ethernet (u otro tablero con una ranura SD)
tarjeta SD formateada con un archivo llamado "datalog.txt" que contiene un poco de texto

Código

El código de abajo está configurado para su uso con un escudo de Ethernet, que tiene una ranura de SD a bordo. En la configuración (), llame SD.begin (), nombrando el pin 4 como el pin CS. Este pin varía dependiendo de la marca del escudo o placa que está utilizando.

En la tarjeta SD, existe un archivo con el nombre "datalog.txt". En el bucle (), el archivo es abierto al llamar SD.open (). Para enviar el archivo en serie a un ordenador, utilice Serial.print (), leer el contenido del archivo con SD.read ()

/*
  SD card file dump

 This example shows how to read a file from the SD card using the
 SD library and send it over the serial port.

 The circuit:
 * SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4

 created  22 December 2010
 by Limor Fried
 modified 9 Apr 2012
 by Tom Igoe

 This example code is in the public domain.

 */


#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.");

  // 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");

  // if the file is available, write to it:
  if (dataFile) {
    while (dataFile.available()) {
      Serial.write(dataFile.read());
    }
    dataFile.close();
  }
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");
  }
}

void loop() {
}


El uso de la biblioteca SD para crear y eliminar archivos en una tarjeta SD


Este ejemplo muestra cómo crear y destruir un archivo en una tarjeta SD. Por favor, haga clic aquí para obtener más información sobre la biblioteca SD.

hardware necesario

Arduino o Genuino bordo
Escudo de Ethernet (u otro tablero con una ranura SD)
tarjeta SD formateada

Código

El código de abajo está configurado para su uso con un escudo de Ethernet, que tiene una ranura de SD a bordo. En la configuración (), SD.begin () nombres de los pines 4 como el pasador de CS. Este pin varía dependiendo de la marca del escudo o placa que está utilizando.

En la configuración (), abra un archivo nuevo con SD.open () llamado "example.txt". FILE_WRITE permite leer y escribir el acceso al archivo, a partir de finales. En este ejemplo, sin embargo, cerrar inmediatamente el archivo llamando myFile.close ().

Después de comprobar para asegurarse de que existe el archivo con SD.exists (), elimine el archivo de la tarjeta con SD.remove.

/*
  SD card basic file example

 This example shows how to create and destroy an SD card file
 The circuit:
 * SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4

 created   Nov 2010
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe

 This example code is in the public domain.

 */

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

File myFile;

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...");

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

  if (SD.exists("example.txt")) {
    Serial.println("example.txt exists.");
  } else {
    Serial.println("example.txt doesn't exist.");
  }

  // open a new file and immediately close it:
  Serial.println("Creating example.txt...");
  myFile = SD.open("example.txt", FILE_WRITE);
  myFile.close();

  // Check to see if the file exists:
  if (SD.exists("example.txt")) {
    Serial.println("example.txt exists.");
  } else {
    Serial.println("example.txt doesn't exist.");
  }

  // delete the file:
  Serial.println("Removing example.txt...");
  SD.remove("example.txt");

  if (SD.exists("example.txt")) {
    Serial.println("example.txt exists.");
  } else {
    Serial.println("example.txt doesn't exist.");
  }
}

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


El uso de la biblioteca SD para imprimir el directorio de archivos de la tarjeta SD


Este ejemplo muestra cómo listar los archivos disponibles en el directorio de la tarjeta SD. Por favor, haga clic aquí para obtener más información sobre la biblioteca SD.

hardware necesario

Arduino o Genuino bordo
Escudo de Ethernet (u otro tablero con una ranura SD)
tarjeta SD formateada

Código

El código de abajo está configurado para su uso con un escudo de Ethernet, que tiene una ranura de SD a bordo. En la configuración (), SD.begin () nombres de los pines 4 como el pasador de CS. Este pin varía dependiendo de la marca del escudo o placa que está utilizando.

El bucle principal () no hace nada porque la función que imprime el directorio de archivos de "/" de la tarjeta SD se llama desde el setup (). Esto porque tenemos que verlo sólo una vez.

La función printDirectory explora a través de la lista de entradas y las impresiones en serie cada archivo y directorio actual. Para los archivos del tamaño se imprime también.


/*
  Listfiles

 This example shows how print out the files in a
 directory on a SD card

 The circuit:
 * SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4

 created   Nov 2010
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe
 modified 2 Feb 2014
 by Scott Fitzgerald

 This example code is in the public domain.

 */

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

File root;

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...");

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

  root = SD.open("/");

  printDirectory(root, 0);

  Serial.println("done!");
}

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

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("\t\t");
      Serial.println(entry.size(), DEC);
    }
    entry.close();
  }
}


El uso de la biblioteca SD a leer y escribir en un archivo en una tarjeta SD


Este ejemplo muestra cómo leer y escribir datos hacia y desde una tarjeta SD. Por favor, haga clic aquí para obtener más información sobre la biblioteca SD.

hardware necesario

Arduino o Genuino bordo
Escudo de Ethernet (u otro tablero con una ranura SD)
tarjeta SD formateada

La placa Arduino o Genuino tiene que ser conectado a la Ethernet Shield y también tiene un cable USB conectado a la computadora.


Código


El código de abajo está configurado para su uso con un escudo de Ethernet, que tiene una ranura de SD a bordo. En la configuración (), que llamamos SD.begin (), nombrando el pin 4 como el pin CS. Este pin varía dependiendo de la marca del escudo o placa que está utilizando.

En setup (), crear un nuevo archivo con SD.open () llamado "test.txt". FILE_WRITE permite leer y escribir el acceso al archivo, a partir de finales. Si un archivo "test.txt" ya estaba en la tarjeta, se abre ese archivo.

Nombre de la instancia del archivo abierto "myFile".

Una vez abierto, el uso myFile.println () para escribir una cadena a la tarjeta, seguido de un retorno de carro. Una vez que el contenido está escrito, cierre el archivo.

Una vez más, abra el archivo con SD.open (). Una vez abierto, pedir al Arduino para leer el contenido del archivo con SD.read () y enviarlos a través del puerto serie. Después se leen todos los contenidos del archivo, cierre el archivo con SD.close ().


/*
  SD card read/write

 This example shows how to read and write data to and from an SD card file
 The circuit:
 * SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4

 created   Nov 2010
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe

 This example code is in the public domain.

 */


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

File myFile;

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...");

  if (!SD.begin(4)) {
    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
}


DESCARGA ¡¡ GRATIS !! —–> LIBROS DE
ELECTRONICA
 –>ENTRA AQUI PARA VER


DESCARGA SOFTWARE PARA SIMULAR CIRCUITOS ELECTRONICOS HACIENDO CLICK AQUI.


0 comentarios:

Publicar un comentario