Showing posts with label SD. Show all posts
Showing posts with label SD. Show all posts

Sunday, August 07, 2016

Using the SD library to read and write to a file on a SD card

This example shows how to read and write data to and from an SD card. Please click here for more information on the SD library.


Step 1: What You Need?

1 x Arduino Board ( Arduino UNO used in this tutorial) 
1 x Arduino Ethernet Shield (or other board with an SD slot)
1 x Formatted SD card

Don't have components? Don't worry. Just click the component's name. 


Step 2: Build Your Circuit.



The Arduino board has to be connected to the Ethernet Shield and also has a USB cable connected to the computer.


Step 3: Upload The Code.

1. Select the Arduino board type: Select Tools >> Board >> Select your correct Arduino board used.


2. Find the port number by accessing device manager on Windows. See the section Port (COM&LPT) and look for an open port named "Arduino Uno (COMxx)". If you are using a different board, you will find a name accordingly. What matters is the xx in COMxx part. In my case, it's COM3. So my port number is 3.


Select the right port: Tools >> Port >> Select the port number.


3. You can find this code in the example of Arduino IDE.
Select File >> Examples >> SD >> ReadWrite

Click press the "upload" button (see the button with right arrow mark).

/*
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
}

The code below is configured for use with an Ethernet shield, which has an onboard SD slot. In the setup(), we call SD.begin(), naming pin 4 as the CS pin. This pin varies depending on the make of shield or board you are using.

In setup(), create a new file with SD.open() named "test.txt". FILE_WRITE enables read and write access to the file, starting at the end. If a file "test.txt" was already on the card, that file would be opened.

Name the instance of the opened file "myFile".

Once opened, use myFile.println() to write a string to the card, followed by a carriage return. Once the content is written, close the file.

Again, open the file with SD.open(). Once opened, ask the Arduino to read the contents of the file with SD.read() and send them over the serial port. After all the contents of the file are read, close the file with SD.close().


library ReadWrite SD

Using the SD library to print the directory of files on SD card

This example shows how to list the files available in the directory of the SD card. Please click here for more information on the SD library.


Step 1: What You Need?

1 x Arduino Board ( Arduino UNO used in this tutorial) 
1 x Arduino Ethernet Shield (or other board with an SD slot)
1 x Formatted SD card

Don't have components? Don't worry. Just click the component's name. 


Step 2: Build Your Circuit.




The Arduino board has to be connected to the Ethernet Shield and also has a USB cable connected to the computer.


Step 3: Upload The Code.

1. Select the Arduino board type: Select Tools >> Board >> Select your correct Arduino board used.


2. Find the port number by accessing device manager on Windows. See the section Port (COM&LPT) and look for an open port named "Arduino Uno (COMxx)". If you are using a different board, you will find a name accordingly. What matters is the xx in COMxx part. In my case, it's COM3. So my port number is 3.


Select the right port: Tools >> Port >> Select the port number.


3. You can find this code in the example of Arduino IDE.
Select File >> Examples >> SD >> listfiles

Click press the "upload" button (see the button with right arrow mark).

/*
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();
}
}

The code above is configured for use with an Ethernet shield, which has an onboard SD slot. In the setup(), SD.begin() names pin 4 as the CS pin. This pin varies depending on the make of shield or board you are using.

The main loop() does nothing because the function that prints out the file directory of "/" of the SD card is called from the setup(). This because we need to see it just once.

The printDirectory function scans through the list of entries and prints on serial every file and directory present. For files the size is printed as well.



library listfiles SD

Using the SD library to create and remove files on a SD card

This example shows how to create and destroy a file on a SD card. Please click here for more information on the SD library.


Step 1: What You Need?

1 x Arduino Board ( Arduino UNO used in this tutorial) 
1 x Arduino Ethernet Shield (or other board with an SD slot)
1 x Formatted SD card

Don't have components? Don't worry. Just click the component's name. 


Step 2: Build Your Circuit.




The Arduino board has to be connected to the Ethernet Shield and also has a USB cable connected to the computer.


Step 3: Upload The Code.

1. Select the Arduino board type: Select Tools >> Board >> Select your correct Arduino board used.


2. Find the port number by accessing device manager on Windows. See the section Port (COM&LPT) and look for an open port named "Arduino Uno (COMxx)". If you are using a different board, you will find a name accordingly. What matters is the xx in COMxx part. In my case, it's COM3. So my port number is 3.


Select the right port: Tools >> Port >> Select the port number.


3. You can find this code in the example of Arduino IDE.
Select File >> Examples >> SD >> Files

Click press the "upload" button (see the button with right arrow mark).

/*
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.
}


The code above is configured for use with an Ethernet shield, which has an onboard SD slot. In the setup(), SD.begin() names pin 4 as the CS pin. This pin varies depending on the make of shield or board you are using.

In the setup(), open a new file with SD.open() named "example.txt". FILE_WRITE enables read and write access to the file, starting at the end. In this example though, immediately close the file by calling myFile.close().

After checking to make sure the file exists with SD.exists(), delete the file from the card with SD.remove.


Files library SD

Using the SD library to retrieve information over a serial port

This example shows how to read a file from a SD card using the SD library and send it over the serial port. Please click here for more information on the SD library.


Step 1: What You Need?

1 x Arduino Board ( Arduino UNO used in this tutorial) 
1 x Arduino Ethernet Shield (or other board with an SD slot)
1 x Formatted SD card with a file named "datalog.txt" containing some text

Don't have components? Don't worry. Just click the component's name. 


Step 2: Build Your Circuit.



The Arduino board has to be connected to the Ethernet Shield and also has a USB cable connected to the computer.


Step 3: Upload The Code.

1. Select the Arduino board type: Select Tools >> Board >> Select your correct Arduino board used.

2. Find the port number by accessing device manager on Windows. See the section Port (COM&LPT) and look for an open port named "Arduino Uno (COMxx)". If you are using a different board, you will find a name accordingly. What matters is the xx in COMxx part. In my case, it's COM3. So my port number is 3.


Select the right port: Tools >> Port >> Select the port number.



3. You can find this code in the example of Arduino IDE.
Select File >> Examples >> SD >> DumpFile

Click press the "upload" button (see the button with right arrow mark).

/*
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() {
}

The code above is configured for use with an Ethernet shield, which has an onboard SD slot. In the setup(), call SD.begin(), naming pin 4 as the CS pin. This pin varies depending on the make of shield or board you are using.

On the SD card, there is a file named "datalog.txt". In the loop(), the file is opened when calling SD.open(). To send the file serially to a computer, use Serial.print(), reading the contents of the file with SD.read().



DumpFile library SD

Saturday, August 06, 2016

Using the SD library to log data

This example shows how to use the SD card Library to log data from three analog sensors to a SD card. Please click here for more information on the SD library.


Step 1: What You Need?

1 x Formatted SD card
Male-to-Male Jumper Wires 


Don't have components? Don't worry. Just click the component's name. 


Step 2: Build Your Circuit.


The Arduino board has to be connected to the Ethernet Shield. The three potentiometers may be substituted with other analog sensors, to be wired according to their interfacing techniques.


Step 3: Upload The Code.

1. Select the Arduino board type: Select Tools >> Board >> Select your correct Arduino board used.


2. Find the port number by accessing device manager on Windows. See the section Port (COM&LPT) and look for an open port named "Arduino Uno (COMxx)". If you are using a different board, you will find a name accordingly. What matters is the xx in COMxx part. In my case, it's COM3. So my port number is 3.


Select the right port: Tools >> Port >> Select the port number.


3. You can find this code in the example of Arduino IDE.
Select File >> Examples >> SD >> Datalogger

Click press the "upload" button (see the button with right arrow mark).

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

The code above is configured for use with an Ethernet shield, which has an onboard SD slot. In the setup(), call SD.begin(), naming pin 4 as the CS pin. This pin varies depending on the make of shield or board.

In the loop(), a String is created to hold the information from three analog sensors. The code iterates through the sensors, adding their data to the string.

Next, the file on the SD card is opened by calling SD.open(). Once available, the data is written to the card when dataFile.println() is used. The file must be closed with dataFile.close() to save the information.




Datalogger library SD

Using the SD library to retrieve information over a serial port

This example shows how to read information about a SD card. The example reports volume type, free space and other information using the SD library, sending it over the serial port. Please click here for more information on the SD library.


Step 1: What You Need?

1 x Arduino Board ( Arduino UNO used in this tutorial) 
1 x Arduino Ethernet Shield (or other board with an SD slot)
1 x Formatted SD card

Don't have components? Don't worry. Just click the component's name. 


Step 2: Build Your Circuit.




The Arduino board has to be connected to the Ethernet Shield and also has a USB cable connected to the computer.


Step 3: Upload The Code.

1. Select the Arduino board type: Select Tools >> Board >> Select your correct Arduino board used.


2. Find the port number by accessing device manager on Windows. See the section Port (COM&LPT) and look for an open port named "Arduino Uno (COMxx)". If you are using a different board, you will find a name accordingly. What matters is the xx in COMxx part. In my case, it's COM3. So my port number is 3.


Select the right port: Tools >> Port >> Select the port number.



3. You can find this code in the example of Arduino IDE.
Select File >> Examples >> SD >> CardInfo

Click press the "upload" button (see the button with right arrow mark).


The code below is configured for use with an Ethernet shield, which has an onboard SD slot. In the setup(), call SD.begin(), naming pin 4 as the CS pin. This pin varies depending on the make of shield or board you are using.

The code uses some undocumented utility libraries to report information about the SD card. This information includes formatting (FAT16 or FAT32) and file structure, as well as the amount of free space and space used on the card.






/*
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 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) { }

Download:



Sources:https://www.arduino.cc/en/Tutorial/CardInfo   
CardInfo library SD

 

  • Copyright © Arduino Tutorial ™ is a registered trademark.
    Designed by Templateism. Hosted on Blogger Templates.