Formatting under Windows/Mac

If you bought an SD card, chances are it’s already pre-formatted with a FAT filesystem. However you may have problems with how the factory formats the card, or if it’s an old card it needs to be reformatted. The Arduino SD library we use supports both FAT16 and FAT32 filesystems. If you have a very small SD card, say 8-32 Megabytes you might find it is formatted FAT12 which isnt supported. You’ll have to reformat these card. Either way, its always good idea to format the card before using, even if its new! Note that formatting will erase the card so save anything you want first.

Get Card Info

The Arduino SD Card library has a built in example that will help you test the shield and your connections

If you have an older Datalogging shield without the SPI header connection and you are using a Leonardo, Mega or anything other than an UNO, you’ll need to install a special version of the SD library

/* Sensor test sketch
for more information see http://www.ladyada.net/make/logshield/lighttemp.html
*/

#define aref_voltage 3.3 // we tie 3.3V to ARef and measure it with a multimeter!

int photocellPin = 0; // the cell and 10K pulldown are connected to a0
int photocellReading; // the analog reading from the analog resistor divider

//TMP36 Pin Variables
int tempPin = 1; //the analog pin the TMP36’s Vout (sense) pin is connected to
//the resolution is 10 mV / degree centigrade with a
//500 mV offset to allow for negative temperatures
int tempReading; // the analog reading from the sensor

void setup(void) {
// We’ll send debugging information via the Serial monitor
Serial.begin(9600);

// If you want to set the aref to something other than 5v
analogReference(EXTERNAL);
}

void loop(void) {
photocellReading = analogRead(photocellPin);

Serial.print("Light reading = ");
Serial.print(photocellReading); // the raw analog reading

// We’ll have a few threshholds, qualitatively determined
if (photocellReading < 10) {
Serial.println(" – Dark");
} else if (photocellReading < 200) {
Serial.println(" – Dim");
} else if (photocellReading < 500) {
Serial.println(" – Light");
} else if (photocellReading < 800) {
Serial.println(" – Bright");
} else {
Serial.println(" – Very bright");
}

tempReading = analogRead(tempPin);

Serial.print("Temp reading = ");
Serial.print(tempReading); // the raw analog reading

// converting that reading to voltage, which is based off the reference voltage
float voltage = tempReading * aref_voltage / 1024;

// print out the voltage
Serial.print(" – ");
Serial.print(voltage); Serial.println(" volts");

// now print out the temperature
float temperatureC = (voltage – 0.5) * 100 ; //converting from 10 mv per degree wit 500 mV offset
//to degrees ((volatge – 500mV) times 100)
Serial.print(temperatureC); Serial.println(" degrees C");

// now convert to Fahrenheight
float temperatureF = (temperatureC * 9 / 5) + 32;
Serial.print(temperatureF); Serial.println(" degrees F");

delay(1000);
}
[/code]

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
// MKRZero SD: SDCARD_SS_PIN
// const int chipSelect = 4;
const int chipSelect = 10;

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

}
[/code]

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 (for MKRZero SD: SDCARD_SS_PIN)

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;
const int chipSelect = 10;

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");
}
}
[/code]

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 (for MKRZero SD: SDCARD_SS_PIN)

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;
const int chipSelect = 10;

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()
{
}
[/code]

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 (for MKRZero SD: SDCARD_SS_PIN)

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(10))
{
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.
}
[/code]

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 (for MKRZero SD: SDCARD_SS_PIN)

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(10))
{
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("tt");
Serial.println(entry.size(), DEC);
}
entry.close();
}
}
[/code]

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 (for MKRZero SD: SDCARD_SS_PIN)

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(10))
{
Serial.println("initialization failed!");
return;
}
Serial.println("initialization done.");

// SD.remove("test.txt");
// delay(1000);

// 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
}
[/code]

RTC_DS1307 RTC;

void setup ()
{
// Serial.begin(57600);
Serial.begin(9600);

Wire.begin();
RTC.begin();

if (! RTC.isrunning())
{
Serial.println("RTC is NOT running!");
//sets the RTC to the date & time this sketch was compiled
RTC.adjust(DateTime(__DATE__, __TIME__));
}

}

void loop ()
{
DateTime now = RTC.now();
Serial.print(now.year(), DEC);
Serial.print(‘/’);
Serial.print(now.month(), DEC);
Serial.print(‘/’);
Serial.print(now.day(), DEC);
Serial.print(‘ ‘);
Serial.print(now.hour(), DEC);
Serial.print(‘:’);
Serial.print(now.minute(), DEC);
Serial.print(‘:’);
Serial.print(now.second(), DEC);
Serial.println();
delay(1000);
}
[/code]

RTC_DS1307 RTC;
// Adafruit_MCP9808 tempsensor = Adafruit_MCP9808();
File myFile;
const int chipSelect = 10;

void setup()
{
Wire.begin();
Serial.begin(9600);
RTC.begin();
//sd setup
if (!SD.begin(chipSelect))
{
Serial.println("initialization failed!");
return;
}
Serial.println("initialization complete.");
//temp sensor setup
// if (!tempsensor.begin())
// {
// Serial.println("Couldn’t find MCP9808!");
// while (1);
// }
//RTC setup
if (! RTC.isrunning())
{
Serial.println("RTC is NOT running!");
// following line sets the RTC to the date & time this sketch was compiled
RTC.adjust(DateTime(__DATE__, __TIME__));
}
}

void loop()
{
// float c = tempsensor.readTempC();
float c = 100;

float f = c * 9.0 / 5.0 + 32;
DateTime now = RTC.now();
//create a file
File myFile = SD.open("mcp9808.txt", FILE_WRITE);
//write to file
if (myFile)
{
Serial.print("Writing to mcp9808.txt…");
//date and time section
if(now.hour() <10)
{
myFile.print("0");
}
myFile.print(now.hour());
myFile.print(":");

if(now.minute() < 10)
{
myFile.print("0");
}
myFile.print(now.minute());
myFile.print(":");

if(now.second() < 10)
{
myFile.print("0");
}
myFile.print(now.second());
myFile.print(",");
//sensor section
myFile.print(c);
myFile.print(",");
myFile.print(f);
myFile.println();
//close the file
myFile.close();
Serial.println("done.");
// tempsensor.shutdown_wake(1);
delay(2000);
// tempsensor.shutdown_wake(0);
}
else
{
Serial.println("error opening mcp9808.txt file");
}
delay(1000);
}
[/code]

// A simple data logger for the Arduino analog pins

// how many milliseconds between grabbing data and logging it. 1000 ms is once a second
#define LOG_INTERVAL 1000 // mills between entries (reduce to take more/faster data)

// how many milliseconds before writing the logged data permanently to disk
// set it to the LOG_INTERVAL to write each time (safest)
// set it to 10*LOG_INTERVAL to write all data every 10 datareads, you could lose up to
// the last 10 reads if power is lost but it uses less power and is much faster!
#define SYNC_INTERVAL 1000 // mills between calls to flush() – to write data to the card
uint32_t syncTime = 0; // time of last sync()

#define ECHO_TO_SERIAL 1 // echo data to serial port
#define WAIT_TO_START 0 // Wait for serial input in setup()

// the digital pins that connect to the LEDs
#define redLEDpin 2
#define greenLEDpin 3

// The analog pins that connect to the sensors
#define photocellPin 0 // analog 0
#define tempPin 1 // analog 1
#define BANDGAPREF 14 // special indicator that we want to measure the bandgap

#define aref_voltage 3.3 // we tie 3.3V to ARef and measure it with a multimeter!
#define bandgap_voltage 1.1 // this is not super guaranteed but its not -too- off

RTC_DS1307 RTC; // define the Real Time Clock object

// for the data logging shield, we use digital pin 10 for the SD cs line
const int chipSelect = 10;

// the logging file
File logfile;

void error(char *str)
{
Serial.print("error: ");
Serial.println(str);

// red LED indicates error
digitalWrite(redLEDpin, HIGH);

while(1);
}

void setup(void)
{
Serial.begin(9600);
Serial.println();

// use debugging LEDs
pinMode(redLEDpin, OUTPUT);
pinMode(greenLEDpin, OUTPUT);

#if WAIT_TO_START
Serial.println("Type any character to start");
while (!Serial.available());
#endif //WAIT_TO_START

// initialize the SD card
Serial.print("Initializing SD card…");
// make sure that the default chip select pin is set to
// output, even if you don’t use it:
pinMode(10, OUTPUT);

// see if the card is present and can be initialized:
if (!SD.begin(chipSelect))
{
error("Card failed, or not present");
}
Serial.println("card initialized.");

// create a new file
char filename[] = "LOGGER00.CSV";
for (uint8_t i = 0; i < 100; i++)
{
filename[6] = i/10 + ‘0’;
filename[7] = i%10 + ‘0’;
if (! SD.exists(filename))
{
// only open a new file if it doesn’t exist
logfile = SD.open(filename, FILE_WRITE);
break; // leave the loop!
}
}

if (! logfile)
{
error("couldnt create file");
}

Serial.print("Logging to: ");
Serial.println(filename);

// connect to RTC
Wire.begin();
if (!RTC.begin())
{
logfile.println("RTC failed");
#if ECHO_TO_SERIAL
Serial.println("RTC failed");
#endif //ECHO_TO_SERIAL
}

logfile.println("millis,stamp,datetime,light,temp,vcc");
#if ECHO_TO_SERIAL
Serial.println("millis,stamp,datetime,light,temp,vcc");
#endif //ECHO_TO_SERIAL

// If you want to set the aref to something other than 5v
analogReference(EXTERNAL);
}

void loop(void)
{
DateTime now;

// delay for the amount of time we want between readings
delay((LOG_INTERVAL -1) – (millis() % LOG_INTERVAL));

digitalWrite(greenLEDpin, HIGH);

// log milliseconds since starting
uint32_t m = millis();
logfile.print(m); // milliseconds since start
logfile.print(", ");
#if ECHO_TO_SERIAL
Serial.print(m); // milliseconds since start
Serial.print(", ");
#endif

// fetch the time
now = RTC.now();
// log time
logfile.print(now.unixtime()); // seconds since 1/1/1970
logfile.print(", ");
logfile.print(‘"’);
logfile.print(now.year(), DEC);
logfile.print("/");
logfile.print(now.month(), DEC);
logfile.print("/");
logfile.print(now.day(), DEC);
logfile.print(" ");
logfile.print(now.hour(), DEC);
logfile.print(":");
logfile.print(now.minute(), DEC);
logfile.print(":");
logfile.print(now.second(), DEC);
logfile.print(‘"’);
#if ECHO_TO_SERIAL
Serial.print(now.unixtime()); // seconds since 1/1/1970
Serial.print(", ");
Serial.print(‘"’);
Serial.print(now.year(), DEC);
Serial.print("/");
Serial.print(now.month(), DEC);
Serial.print("/");
Serial.print(now.day(), DEC);
Serial.print(" ");
Serial.print(now.hour(), DEC);
Serial.print(":");
Serial.print(now.minute(), DEC);
Serial.print(":");
Serial.print(now.second(), DEC);
Serial.print(‘"’);
#endif //ECHO_TO_SERIAL

analogRead(photocellPin);
delay(10);
int photocellReading = analogRead(photocellPin);

analogRead(tempPin);
delay(10);
int tempReading = analogRead(tempPin);

// converting that reading to voltage, for 3.3v arduino use 3.3, for 5.0, use 5.0
float voltage = tempReading * aref_voltage / 1024;
float temperatureC = (voltage – 0.5) * 100 ;
float temperatureF = (temperatureC * 9 / 5) + 32;

logfile.print(", ");
logfile.print(photocellReading);
logfile.print(", ");
logfile.print(temperatureF);
#if ECHO_TO_SERIAL
Serial.print(", ");
Serial.print(photocellReading);
Serial.print(", ");
Serial.print(temperatureF);
#endif //ECHO_TO_SERIAL

// Log the estimated ‘VCC’ voltage by measuring the internal 1.1v ref
analogRead(BANDGAPREF);
delay(10);
int refReading = analogRead(BANDGAPREF);
float supplyvoltage = (bandgap_voltage * 1024) / refReading;

logfile.print(", ");
logfile.print(supplyvoltage);
#if ECHO_TO_SERIAL
Serial.print(", ");
Serial.print(supplyvoltage);
#endif // ECHO_TO_SERIAL

logfile.println();
#if ECHO_TO_SERIAL
Serial.println();
#endif // ECHO_TO_SERIAL

digitalWrite(greenLEDpin, LOW);

// Now we write data to disk! Don’t sync too often – requires 2048 bytes of I/O to SD card
// which uses a bunch of power and takes time
if ((millis() – syncTime) < SYNC_INTERVAL) return;
syncTime = millis();

// blink LED to show we are syncing data to the card & updating FAT!
digitalWrite(redLEDpin, HIGH);
logfile.flush();
digitalWrite(redLEDpin, LOW);

}
[/code]