First init.

libraries/SD/examples/CardInfo/CardInfo.ino

@@ -0,0 +1,118 @@
+/*
+  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.
+  Pin numbers reflect the default SPI pins for Uno and Nano models.
+  The circuit:
+    SD card attached to SPI bus as follows:
+ ** SDO - pin 11 on Arduino Uno/Duemilanove/Diecimila
+ ** SDI - 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 10 used here for consistency with other Arduino examples
+
+  created  28 Mar 2011
+  by Limor Fried
+  modified 24 July 2020
+  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;
+// Default SPI on Uno and Nano: pin 10
+// Arduino Ethernet shield: pin 4
+// Adafruit SD shields and modules: pin 10
+// Sparkfun SD shield: pin 8
+// MKR Zero SD: SDCARD_SS_PIN
+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?");
+    Serial.println("Note: press reset button on the board and reopen this Serial Monitor after fixing your issue!");
+    while (1);
+  } else {
+    Serial.println("Wiring is correct and a card is present.");
+  }
+
+  // print the type of card
+  Serial.println();
+  Serial.print("Card 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");
+    while (1);
+  }
+
+  Serial.print("Clusters:          ");
+  Serial.println(volume.clusterCount());
+  Serial.print("Blocks x Cluster:  ");
+  Serial.println(volume.blocksPerCluster());
+
+  Serial.print("Total Blocks:      ");
+  Serial.println(volume.blocksPerCluster() * volume.clusterCount());
+  Serial.println();
+
+  // print the type and size of the first FAT-type volume
+  uint32_t volumesize;
+  Serial.print("Volume type is:    FAT");
+  Serial.println(volume.fatType(), DEC);
+
+  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks
+  volumesize *= volume.clusterCount();       // we'll have a lot of clusters
+  volumesize /= 2;                           // SD card blocks are always 512 bytes (2 blocks are 1 KB)
+  Serial.print("Volume size (KB):  ");
+  Serial.println(volumesize);
+  Serial.print("Volume size (MB):  ");
+  volumesize /= 1024;
+  Serial.println(volumesize);
+  Serial.print("Volume size (GB):  ");
+  Serial.println((float)volumesize / 1024.0);
+
+  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);
+  root.close();
+}
+
+void loop(void) {
+}

libraries/SD/examples/Datalogger/Datalogger.ino

@@ -0,0 +1,79 @@
+/*
+  SD card datalogger
+
+  This example shows how to log data from three analog sensors
+  to an SD card using the SD library. Pin numbers reflect the default
+  SPI pins for Uno and Nano models
+
+  The circuit:
+   analog sensors on analog pins 0, 1, and 2
+   SD card attached to SPI bus as follows:
+ ** SDO - pin 11
+ ** SDI - pin 12
+ ** CLK - pin 13
+ ** CS - depends on your SD card shield or module.
+ 		Pin 10 used here for consistency with other Arduino examples
+    (for MKR Zero SD: SDCARD_SS_PIN)
+
+  created  24 Nov 2010
+  modified  24 July 2020
+  by Tom Igoe
+
+  This example code is in the public domain.
+
+*/
+
+#include <SPI.h>
+#include <SD.h>
+
+const int chipSelect = 10;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  // wait for Serial Monitor to connect. Needed for native USB port boards only:
+  while (!Serial);
+
+  Serial.print("Initializing SD card...");
+
+  if (!SD.begin(chipSelect)) {
+    Serial.println("initialization failed. Things to check:");
+    Serial.println("1. is a card inserted?");
+    Serial.println("2. is your wiring correct?");
+    Serial.println("3. did you change the chipSelect pin to match your shield or module?");
+    Serial.println("Note: press reset button on the board and reopen this Serial Monitor after fixing your issue!");
+    while (true);
+  }
+
+  Serial.println("initialization done.");
+}
+
+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");
+  }
+}

libraries/SD/examples/DumpFile/DumpFile.ino

@@ -0,0 +1,65 @@
+/*
+  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.
+  Pin numbers reflect the default SPI pins for Uno and Nano models.
+
+  The circuit:
+   SD card attached to SPI bus as follows:
+ ** SDO - pin 11
+ ** SDI - pin 12
+ ** CLK - pin 13
+ ** CS - depends on your SD card shield or module.
+ 		Pin 10 used here for consistency with other Arduino examples
+   (for MKR Zero 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 <SD.h>
+
+const int chipSelect = 10;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  // wait for Serial Monitor to connect. Needed for native USB port boards only:
+  while (!Serial);
+
+  Serial.print("Initializing SD card...");
+
+  if (!SD.begin(chipSelect)) {
+    Serial.println("initialization failed. Things to check:");
+    Serial.println("1. is a card inserted?");
+    Serial.println("2. is your wiring correct?");
+    Serial.println("3. did you change the chipSelect pin to match your shield or module?");
+    Serial.println("Note: press reset button on the board and reopen this Serial Monitor after fixing your issue!");
+    while (true);
+  }
+
+  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.
+  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() {
+}

libraries/SD/examples/Files/Files.ino

@@ -0,0 +1,76 @@
+/*
+  SD card basic file example
+
+  This example shows how to create and destroy an SD card file.
+  The circuit. Pin numbers reflect the default
+  SPI pins for Uno and Nano models:
+   SD card attached to SPI bus as follows:
+ ** SDO - pin 11
+ ** SDI - pin 12
+ ** CLK - pin 13
+ ** CS - depends on your SD card shield or module.
+ 		Pin 10 used here for consistency with other Arduino examples
+    (for MKR Zero SD: SDCARD_SS_PIN)
+
+  created   Nov 2010
+  by David A. Mellis
+  modified 24 July 2020
+  by Tom Igoe
+
+  This example code is in the public domain.
+*/
+#include <SD.h>
+
+const int chipSelect = 10;
+File myFile;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  // wait for Serial Monitor to connect. Needed for native USB port boards only:
+while (!Serial);
+
+  Serial.print("Initializing SD card...");
+
+  if (!SD.begin(chipSelect)) {
+    Serial.println("initialization failed. Things to check:");
+    Serial.println("1. is a card inserted?");
+    Serial.println("2. is your wiring correct?");
+    Serial.println("3. did you change the chipSelect pin to match your shield or module?");
+    Serial.println("Note: press reset button on the board and reopen this serial monitor after fixing your issue!");
+    while (1);
+  }
+  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.
+}

libraries/SD/examples/NonBlockingWrite/NonBlockingWrite.ino

@@ -0,0 +1,118 @@
+/*
+  Non-blocking Write
+
+  This example demonstrates how to perform non-blocking writes
+  to a file on a SD card. The file will contain the current millis()
+  value every 10ms. If the SD card is busy, the data will be dataBuffered
+  in order to not block the sketch.
+
+  If data is successfully written, the built in LED will flash. After a few
+  seconds, check the card for a file called datalog.txt
+
+  NOTE: myFile.availableForWrite() will automatically sync the
+        file contents as needed. You may lose some unsynced data
+        still if myFile.sync() or myFile.close() is not called.
+
+  Pin numbers reflect the default SPI pins for Uno and Nano models
+  Updated for clarity and uniformity with other examples
+
+  The circuit:
+   analog sensors on analog ins 0, 1, and 2
+   SD card attached to SPI bus as follows:
+ ** SDO - pin 11
+ ** SDI - pin 12
+ ** CLK - pin 13
+ ** CS - depends on your SD card shield or module.
+    Pin 10 used here for consistency with other Arduino examples
+    (for MKR Zero SD: SDCARD_SS_PIN)
+
+    modified 24 July 2020
+    by Tom Igoe
+
+  This example code is in the public domain.
+*/
+#include <SD.h>
+
+const int chipSelect = 10;
+
+// file name to use for writing
+const char filename[] = "datalog.txt";
+
+// File object to represent file
+File myFile;
+// string to buffer output
+String dataBuffer;
+// last time data was written to card:
+unsigned long lastMillis = 0;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  // reserve 1 kB for String used as a dataBuffer
+  dataBuffer.reserve(1024);
+
+  // set LED pin to output, used to blink when writing
+  pinMode(LED_BUILTIN, OUTPUT);
+
+  // wait for Serial Monitor to connect. Needed for native USB port boards only:
+  while (!Serial);
+
+  Serial.print("Initializing SD card...");
+
+  if (!SD.begin(chipSelect)) {
+    Serial.println("initialization failed. Things to check:");
+    Serial.println("1. is a card inserted?");
+    Serial.println("2. is your wiring correct?");
+    Serial.println("3. did you change the chipSelect pin to match your shield or module?");
+    Serial.println("Note: press reset button on the board and reopen this Serial Monitor after fixing your issue!");
+    while (true);
+  }
+
+  Serial.println("initialization done.");
+
+  // If you want to start from an empty file,
+  // uncomment the next line:
+  //  SD.remove(filename);
+  // try to open the file for writing
+
+  myFile = SD.open(filename, FILE_WRITE);
+  if (!myFile) {
+    Serial.print("error opening ");
+    Serial.println(filename);
+    while (true);
+  }
+
+  // add some new lines to start
+  myFile.println();
+  myFile.println("Hello World!");
+  Serial.println("Starting to write to file...");
+}
+
+void loop() {
+  // check if it's been over 10 ms since the last line added
+  unsigned long now = millis();
+  if ((now - lastMillis) >= 10) {
+    // add a new line to the dataBuffer
+    dataBuffer += "Hello ";
+    dataBuffer += now;
+    dataBuffer += "\r\n";
+    // print the buffer length. This will change depending on when
+    // data is actually written to the SD card file:
+    Serial.print("Unsaved data buffer length (in bytes): ");
+    Serial.println(dataBuffer.length());
+    // note the time that the last line was added to the string
+    lastMillis = now;
+  }
+
+  // check if the SD card is available to write data without blocking
+  // and if the dataBuffered data is enough for the full chunk size
+  unsigned int chunkSize = myFile.availableForWrite();
+  if (chunkSize && dataBuffer.length() >= chunkSize) {
+    // write to file and blink LED
+    digitalWrite(LED_BUILTIN, HIGH);
+    myFile.write(dataBuffer.c_str(), chunkSize);
+    digitalWrite(LED_BUILTIN, LOW);
+    // remove written data from dataBuffer
+    dataBuffer.remove(0, chunkSize);
+  }
+}

libraries/SD/examples/ReadWrite/ReadWrite.ino

@@ -0,0 +1,80 @@
+/*
+  SD card read/write
+
+  This example shows how to read and write data to and from an SD card file
+  The circuit. Pin numbers reflect the default
+  SPI pins for Uno and Nano models:
+   SD card attached to SPI bus as follows:
+ ** SDO - pin 11
+ ** SDI - pin 12
+ ** CLK - pin 13
+ ** CS - pin 4 (For For Uno, Nano: pin 10. For MKR Zero SD: SDCARD_SS_PIN)
+
+  created   Nov 2010
+  by David A. Mellis
+  modified  24 July 2020
+  by Tom Igoe
+
+  This example code is in the public domain.
+
+*/
+#include <SD.h>
+
+const int chipSelect = 10;
+File myFile;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  // wait for Serial Monitor to connect. Needed for native USB port boards only:
+  while (!Serial);
+
+  Serial.print("Initializing SD card...");
+
+  if (!SD.begin(chipSelect)) {
+    Serial.println("initialization failed. Things to check:");
+    Serial.println("1. is a card inserted?");
+    Serial.println("2. is your wiring correct?");
+    Serial.println("3. did you change the chipSelect pin to match your shield or module?");
+    Serial.println("Note: press reset button on the board and reopen this Serial Monitor after fixing your issue!");
+    while (true);
+  }
+
+  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
+}

libraries/SD/examples/listfiles/listfiles.ino

@@ -0,0 +1,86 @@
+/*
+  Listfiles
+
+  This example shows how to print out the files in a
+  directory on a SD card. Pin numbers reflect the default
+  SPI pins for Uno and Nano models
+
+  The circuit:
+   SD card attached to SPI bus as follows:
+ ** SDO - pin 11
+ ** SDI - pin 12
+ ** CLK - pin 13
+ ** CS - depends on your SD card shield or module.
+ 		Pin 10 used here for consistency with other Arduino examples
+    (for MKR Zero 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
+  modified 24 July 2020
+  by Tom Igoe
+  
+  This example code is in the public domain.
+
+*/
+#include <SD.h>
+
+const int chipSelect = 10;
+File root;
+
+void setup() {
+ // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  // wait for Serial Monitor to connect. Needed for native USB port boards only:
+  while (!Serial);
+
+  Serial.print("Initializing SD card...");
+
+  if (!SD.begin(chipSelect)) {
+    Serial.println("initialization failed. Things to check:");
+    Serial.println("1. is a card inserted?");
+    Serial.println("2. is your wiring correct?");
+    Serial.println("3. did you change the chipSelect pin to match your shield or module?");
+    Serial.println("Note: press reset button on the board and reopen this Serial Monitor after fixing your issue!");
+    while (true);
+  }
+
+  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();
+  }
+}