[chronojump/michrolab: 47/57] Included the library for SD
- From: Xavier Padullés <xpadulles src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [chronojump/michrolab: 47/57] Included the library for SD
- Date: Tue, 24 May 2022 15:20:52 +0000 (UTC)
commit 614a1d58b9388692f06bd7012dc2527daea6c0e0
Author: Xavier Padullés <testing chronojump org>
Date: Sat May 21 12:07:11 2022 +0200
Included the library for SD
arduino/ForceSensorTFT/libraries/SD/README.adoc | 26 +
.../libraries/SD/examples/CardInfo/CardInfo.ino | 116 ++
.../SD/examples/Datalogger/Datalogger.ino | 84 ++
.../libraries/SD/examples/DumpFile/DumpFile.ino | 65 +
.../libraries/SD/examples/Files/Files.ino | 75 +
.../examples/NonBlockingWrite/NonBlockingWrite.ino | 91 ++
.../libraries/SD/examples/ReadWrite/ReadWrite.ino | 79 +
.../libraries/SD/examples/listfiles/listfiles.ino | 80 +
.../SD/extras/codespell-ignore-words-list.txt | 0
arduino/ForceSensorTFT/libraries/SD/keywords.txt | 31 +
.../ForceSensorTFT/libraries/SD/library.properties | 9 +
arduino/ForceSensorTFT/libraries/SD/src/File.cpp | 168 +++
arduino/ForceSensorTFT/libraries/SD/src/README.txt | 13 +
arduino/ForceSensorTFT/libraries/SD/src/SD.cpp | 637 ++++++++
arduino/ForceSensorTFT/libraries/SD/src/SD.h | 138 ++
.../libraries/SD/src/utility/FatStructs.h | 418 ++++++
.../libraries/SD/src/utility/Sd2Card.cpp | 777 ++++++++++
.../libraries/SD/src/utility/Sd2Card.h | 273 ++++
.../libraries/SD/src/utility/Sd2PinMap.h | 525 +++++++
.../libraries/SD/src/utility/SdFat.h | 641 ++++++++
.../libraries/SD/src/utility/SdFatUtil.h | 77 +
.../libraries/SD/src/utility/SdFatmainpage.h | 202 +++
.../libraries/SD/src/utility/SdFile.cpp | 1527 ++++++++++++++++++++
.../libraries/SD/src/utility/SdInfo.h | 232 +++
.../libraries/SD/src/utility/SdVolume.cpp | 351 +++++
25 files changed, 6635 insertions(+)
---
diff --git a/arduino/ForceSensorTFT/libraries/SD/README.adoc b/arduino/ForceSensorTFT/libraries/SD/README.adoc
new file mode 100644
index 000000000..fb3ed030c
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/README.adoc
@@ -0,0 +1,26 @@
+= SD Library for Arduino =
+
+image:https://travis-ci.org/arduino-libraries/SD.svg?branch=master[Build Status,
link=https://travis-ci.org/arduino-libraries/SD]
+
+The SD library allows for reading from and writing to SD cards.
+
+For more information about this library please visit us at
+http://www.arduino.cc/en/Reference/SD
+
+== License ==
+
+ Copyright (C) 2009 by William Greiman
+Copyright (c) 2010 SparkFun Electronics
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
diff --git a/arduino/ForceSensorTFT/libraries/SD/examples/CardInfo/CardInfo.ino
b/arduino/ForceSensorTFT/libraries/SD/examples/CardInfo/CardInfo.ino
new file mode 100644
index 000000000..97913efde
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/examples/CardInfo/CardInfo.ino
@@ -0,0 +1,116 @@
+/*
+ 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;
+
+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?");
+ 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 1KB)
+ 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);
+}
+
+void loop(void) {
+}
diff --git a/arduino/ForceSensorTFT/libraries/SD/examples/Datalogger/Datalogger.ino
b/arduino/ForceSensorTFT/libraries/SD/examples/Datalogger/Datalogger.ino
new file mode 100644
index 000000000..c2631c0a4
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/examples/Datalogger/Datalogger.ino
@@ -0,0 +1,84 @@
+/*
+ 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 (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;
+
+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:
+ while (1);
+ }
+ 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");
+ }
+}
+
+
+
+
+
+
+
+
+
diff --git a/arduino/ForceSensorTFT/libraries/SD/examples/DumpFile/DumpFile.ino
b/arduino/ForceSensorTFT/libraries/SD/examples/DumpFile/DumpFile.ino
new file mode 100644
index 000000000..74919991c
--- /dev/null
+++ b/arduino/ForceSensorTFT/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.
+
+ 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;
+
+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:
+ while (1);
+ }
+ 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() {
+}
+
diff --git a/arduino/ForceSensorTFT/libraries/SD/examples/Files/Files.ino
b/arduino/ForceSensorTFT/libraries/SD/examples/Files/Files.ino
new file mode 100644
index 000000000..cabebba51
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/examples/Files/Files.ino
@@ -0,0 +1,75 @@
+/*
+ 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 (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(4)) {
+ Serial.println("initialization failed!");
+ 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.
+}
+
+
+
diff --git a/arduino/ForceSensorTFT/libraries/SD/examples/NonBlockingWrite/NonBlockingWrite.ino
b/arduino/ForceSensorTFT/libraries/SD/examples/NonBlockingWrite/NonBlockingWrite.ino
new file mode 100644
index 000000000..29d8ec66d
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/examples/NonBlockingWrite/NonBlockingWrite.ino
@@ -0,0 +1,91 @@
+/*
+ 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 buffered
+ in order to not block the sketch.
+
+ 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.
+
+ The circuit:
+ - Arduino MKR Zero board
+ - micro SD card attached
+
+ This example code is in the public domain.
+*/
+
+#include <SD.h>
+
+// file name to use for writing
+const char filename[] = "demo.txt";
+
+// File object to represent file
+File txtFile;
+
+// string to buffer output
+String buffer;
+
+unsigned long lastMillis = 0;
+
+void setup() {
+ Serial.begin(9600);
+ while (!Serial);
+
+ // reserve 1kB for String used as a buffer
+ buffer.reserve(1024);
+
+ // set LED pin to output, used to blink when writing
+ pinMode(LED_BUILTIN, OUTPUT);
+
+ // init the SD card
+ if (!SD.begin()) {
+ Serial.println("Card failed, or not present");
+ // don't do anything more:
+ while (1);
+ }
+
+ // If you want to start from an empty file,
+ // uncomment the next line:
+ // SD.remove(filename);
+
+ // try to open the file for writing
+ txtFile = SD.open(filename, FILE_WRITE);
+ if (!txtFile) {
+ Serial.print("error opening ");
+ Serial.println(filename);
+ while (1);
+ }
+
+ // add some new lines to start
+ txtFile.println();
+ txtFile.println("Hello World!");
+}
+
+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 buffer
+ buffer += "Hello ";
+ buffer += now;
+ buffer += "\r\n";
+
+ lastMillis = now;
+ }
+
+ // check if the SD card is available to write data without blocking
+ // and if the buffered data is enough for the full chunk size
+ unsigned int chunkSize = txtFile.availableForWrite();
+ if (chunkSize && buffer.length() >= chunkSize) {
+ // write to file and blink LED
+ digitalWrite(LED_BUILTIN, HIGH);
+ txtFile.write(buffer.c_str(), chunkSize);
+ digitalWrite(LED_BUILTIN, LOW);
+
+ // remove written data from buffer
+ buffer.remove(0, chunkSize);
+ }
+}
diff --git a/arduino/ForceSensorTFT/libraries/SD/examples/ReadWrite/ReadWrite.ino
b/arduino/ForceSensorTFT/libraries/SD/examples/ReadWrite/ReadWrite.ino
new file mode 100644
index 000000000..d964668c4
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/examples/ReadWrite/ReadWrite.ino
@@ -0,0 +1,79 @@
+/*
+ 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 (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(4)) {
+ Serial.println("initialization failed!");
+ while (1);
+ }
+ 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
+}
+
+
diff --git a/arduino/ForceSensorTFT/libraries/SD/examples/listfiles/listfiles.ino
b/arduino/ForceSensorTFT/libraries/SD/examples/listfiles/listfiles.ino
new file mode 100644
index 000000000..48f84fb99
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/examples/listfiles/listfiles.ino
@@ -0,0 +1,80 @@
+/*
+ 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 (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(4)) {
+ Serial.println("initialization failed!");
+ while (1);
+ }
+ 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();
+ }
+}
+
+
+
diff --git a/arduino/ForceSensorTFT/libraries/SD/extras/codespell-ignore-words-list.txt
b/arduino/ForceSensorTFT/libraries/SD/extras/codespell-ignore-words-list.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/arduino/ForceSensorTFT/libraries/SD/keywords.txt
b/arduino/ForceSensorTFT/libraries/SD/keywords.txt
new file mode 100644
index 000000000..91e74b830
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/keywords.txt
@@ -0,0 +1,31 @@
+#######################################
+# Syntax Coloring Map SD
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+SD KEYWORD1 SD
+File KEYWORD1 SD
+SDFile KEYWORD1 SD
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+begin KEYWORD2
+exists KEYWORD2
+mkdir KEYWORD2
+remove KEYWORD2
+rmdir KEYWORD2
+open KEYWORD2
+close KEYWORD2
+seek KEYWORD2
+position KEYWORD2
+size KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+FILE_READ LITERAL1
+FILE_WRITE LITERAL1
diff --git a/arduino/ForceSensorTFT/libraries/SD/library.properties
b/arduino/ForceSensorTFT/libraries/SD/library.properties
new file mode 100644
index 000000000..60e885928
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/library.properties
@@ -0,0 +1,9 @@
+name=SD
+version=1.2.4
+author=Arduino, SparkFun
+maintainer=Arduino <info arduino cc>
+sentence=Enables reading and writing on SD cards.
+paragraph=Once an SD memory card is connected to the SPI interface of the Arduino or Genuino board you can
create files and read/write on them. You can also move through directories on the SD card.
+category=Data Storage
+url=http://www.arduino.cc/en/Reference/SD
+architectures=*
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/File.cpp
b/arduino/ForceSensorTFT/libraries/SD/src/File.cpp
new file mode 100644
index 000000000..5e37166b5
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/File.cpp
@@ -0,0 +1,168 @@
+/*
+
+ SD - a slightly more friendly wrapper for sdfatlib
+
+ This library aims to expose a subset of SD card functionality
+ in the form of a higher level "wrapper" object.
+
+ License: GNU General Public License V3
+ (Because sdfatlib is licensed with this.)
+
+ (C) Copyright 2010 SparkFun Electronics
+
+*/
+
+#include <SD.h>
+
+/* for debugging file open/close leaks
+ uint8_t nfilecount=0;
+*/
+
+File::File(SdFile f, const char *n) {
+ // oh man you are kidding me, new() doesn't exist? Ok we do it by hand!
+ _file = (SdFile *)malloc(sizeof(SdFile));
+ if (_file) {
+ memcpy(_file, &f, sizeof(SdFile));
+
+ strncpy(_name, n, 12);
+ _name[12] = 0;
+
+ /* for debugging file open/close leaks
+ nfilecount++;
+ Serial.print("Created \"");
+ Serial.print(n);
+ Serial.print("\": ");
+ Serial.println(nfilecount, DEC);
+ */
+ }
+}
+
+File::File(void) {
+ _file = 0;
+ _name[0] = 0;
+ //Serial.print("Created empty file object");
+}
+
+// returns a pointer to the file name
+char *File::name(void) {
+ return _name;
+}
+
+// a directory is a special type of file
+boolean File::isDirectory(void) {
+ return (_file && _file->isDir());
+}
+
+
+size_t File::write(uint8_t val) {
+ return write(&val, 1);
+}
+
+size_t File::write(const uint8_t *buf, size_t size) {
+ size_t t;
+ if (!_file) {
+ setWriteError();
+ return 0;
+ }
+ _file->clearWriteError();
+ t = _file->write(buf, size);
+ if (_file->getWriteError()) {
+ setWriteError();
+ return 0;
+ }
+ return t;
+}
+
+int File::availableForWrite() {
+ if (_file) {
+ return _file->availableForWrite();
+ }
+ return 0;
+}
+
+int File::peek() {
+ if (! _file) {
+ return 0;
+ }
+
+ int c = _file->read();
+ if (c != -1) {
+ _file->seekCur(-1);
+ }
+ return c;
+}
+
+int File::read() {
+ if (_file) {
+ return _file->read();
+ }
+ return -1;
+}
+
+// buffered read for more efficient, high speed reading
+int File::read(void *buf, uint16_t nbyte) {
+ if (_file) {
+ return _file->read(buf, nbyte);
+ }
+ return 0;
+}
+
+int File::available() {
+ if (! _file) {
+ return 0;
+ }
+
+ uint32_t n = size() - position();
+
+ return n > 0X7FFF ? 0X7FFF : n;
+}
+
+void File::flush() {
+ if (_file) {
+ _file->sync();
+ }
+}
+
+boolean File::seek(uint32_t pos) {
+ if (! _file) {
+ return false;
+ }
+
+ return _file->seekSet(pos);
+}
+
+uint32_t File::position() {
+ if (! _file) {
+ return -1;
+ }
+ return _file->curPosition();
+}
+
+uint32_t File::size() {
+ if (! _file) {
+ return 0;
+ }
+ return _file->fileSize();
+}
+
+void File::close() {
+ if (_file) {
+ _file->close();
+ free(_file);
+ _file = 0;
+
+ /* for debugging file open/close leaks
+ nfilecount--;
+ Serial.print("Deleted ");
+ Serial.println(nfilecount, DEC);
+ */
+ }
+}
+
+File::operator bool() {
+ if (_file) {
+ return _file->isOpen();
+ }
+ return false;
+}
+
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/README.txt
b/arduino/ForceSensorTFT/libraries/SD/src/README.txt
new file mode 100644
index 000000000..495ea4c79
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/README.txt
@@ -0,0 +1,13 @@
+
+** SD - a slightly more friendly wrapper for sdfatlib **
+
+This library aims to expose a subset of SD card functionality in the
+form of a higher level "wrapper" object.
+
+License: GNU General Public License V3
+ (Because sdfatlib is licensed with this.)
+
+(C) Copyright 2010 SparkFun Electronics
+
+Now better than ever with optimization, multiple file support, directory handling, etc - ladyada!
+
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/SD.cpp b/arduino/ForceSensorTFT/libraries/SD/src/SD.cpp
new file mode 100644
index 000000000..8c9a29e71
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/SD.cpp
@@ -0,0 +1,637 @@
+/*
+
+ SD - a slightly more friendly wrapper for sdfatlib
+
+ This library aims to expose a subset of SD card functionality
+ in the form of a higher level "wrapper" object.
+
+ License: GNU General Public License V3
+ (Because sdfatlib is licensed with this.)
+
+ (C) Copyright 2010 SparkFun Electronics
+
+
+ This library provides four key benefits:
+
+ Including `SD.h` automatically creates a global
+ `SD` object which can be interacted with in a similar
+ manner to other standard global objects like `Serial` and `Ethernet`.
+
+ Boilerplate initialisation code is contained in one method named
+ `begin` and no further objects need to be created in order to access
+ the SD card.
+
+ Calls to `open` can supply a full path name including parent
+ directories which simplifies interacting with files in subdirectories.
+
+ Utility methods are provided to determine whether a file exists
+ and to create a directory hierarchy.
+
+
+ Note however that not all functionality provided by the underlying
+ sdfatlib library is exposed.
+
+*/
+
+/*
+
+ Implementation Notes
+
+ In order to handle multi-directory path traversal, functionality that
+ requires this ability is implemented as callback functions.
+
+ Individual methods call the `walkPath` function which performs the actual
+ directory traversal (swapping between two different directory/file handles
+ along the way) and at each level calls the supplied callback function.
+
+ Some types of functionality will take an action at each level (e.g. exists
+ or make directory) which others will only take an action at the bottom
+ level (e.g. open).
+
+*/
+
+#include "SD.h"
+
+namespace SDLib {
+
+ // Used by `getNextPathComponent`
+#define MAX_COMPONENT_LEN 12 // What is max length?
+#define PATH_COMPONENT_BUFFER_LEN MAX_COMPONENT_LEN+1
+
+ bool getNextPathComponent(const char *path, unsigned int *p_offset,
+ char *buffer) {
+ /*
+
+ Parse individual path components from a path.
+
+ e.g. after repeated calls '/foo/bar/baz' will be split
+ into 'foo', 'bar', 'baz'.
+
+ This is similar to `strtok()` but copies the component into the
+ supplied buffer rather than modifying the original string.
+
+
+ `buffer` needs to be PATH_COMPONENT_BUFFER_LEN in size.
+
+ `p_offset` needs to point to an integer of the offset at
+ which the previous path component finished.
+
+ Returns `true` if more components remain.
+
+ Returns `false` if this is the last component.
+ (This means path ended with 'foo' or 'foo/'.)
+
+ */
+
+ // TODO: Have buffer local to this function, so we know it's the
+ // correct length?
+
+ int bufferOffset = 0;
+
+ int offset = *p_offset;
+
+ // Skip root or other separator
+ if (path[offset] == '/') {
+ offset++;
+ }
+
+ // Copy the next next path segment
+ while (bufferOffset < MAX_COMPONENT_LEN
+ && (path[offset] != '/')
+ && (path[offset] != '\0')) {
+ buffer[bufferOffset++] = path[offset++];
+ }
+
+ buffer[bufferOffset] = '\0';
+
+ // Skip trailing separator so we can determine if this
+ // is the last component in the path or not.
+ if (path[offset] == '/') {
+ offset++;
+ }
+
+ *p_offset = offset;
+
+ return (path[offset] != '\0');
+ }
+
+
+
+ boolean walkPath(const char *filepath, SdFile& parentDir,
+ boolean(*callback)(SdFile& parentDir,
+ const char *filePathComponent,
+ boolean isLastComponent,
+ void *object),
+ void *object = NULL) {
+ /*
+
+ When given a file path (and parent directory--normally root),
+ this function traverses the directories in the path and at each
+ level calls the supplied callback function while also providing
+ the supplied object for context if required.
+
+ e.g. given the path '/foo/bar/baz'
+ the callback would be called at the equivalent of
+ '/foo', '/foo/bar' and '/foo/bar/baz'.
+
+ The implementation swaps between two different directory/file
+ handles as it traverses the directories and does not use recursion
+ in an attempt to use memory efficiently.
+
+ If a callback wishes to stop the directory traversal it should
+ return false--in this case the function will stop the traversal,
+ tidy up and return false.
+
+ If a directory path doesn't exist at some point this function will
+ also return false and not subsequently call the callback.
+
+ If a directory path specified is complete, valid and the callback
+ did not indicate the traversal should be interrupted then this
+ function will return true.
+
+ */
+
+
+ SdFile subfile1;
+ SdFile subfile2;
+
+ char buffer[PATH_COMPONENT_BUFFER_LEN];
+
+ unsigned int offset = 0;
+
+ SdFile *p_parent;
+ SdFile *p_child;
+
+ SdFile *p_tmp_sdfile;
+
+ p_child = &subfile1;
+
+ p_parent = &parentDir;
+
+ while (true) {
+
+ boolean moreComponents = getNextPathComponent(filepath, &offset, buffer);
+
+ boolean shouldContinue = callback((*p_parent), buffer, !moreComponents, object);
+
+ if (!shouldContinue) {
+ // TODO: Don't repeat this code?
+ // If it's one we've created then we
+ // don't need the parent handle anymore.
+ if (p_parent != &parentDir) {
+ (*p_parent).close();
+ }
+ return false;
+ }
+
+ if (!moreComponents) {
+ break;
+ }
+
+ boolean exists = (*p_child).open(*p_parent, buffer, O_RDONLY);
+
+ // If it's one we've created then we
+ // don't need the parent handle anymore.
+ if (p_parent != &parentDir) {
+ (*p_parent).close();
+ }
+
+ // Handle case when it doesn't exist and we can't continue...
+ if (exists) {
+ // We alternate between two file handles as we go down
+ // the path.
+ if (p_parent == &parentDir) {
+ p_parent = &subfile2;
+ }
+
+ p_tmp_sdfile = p_parent;
+ p_parent = p_child;
+ p_child = p_tmp_sdfile;
+ } else {
+ return false;
+ }
+ }
+
+ if (p_parent != &parentDir) {
+ (*p_parent).close(); // TODO: Return/ handle different?
+ }
+
+ return true;
+ }
+
+
+
+ /*
+
+ The callbacks used to implement various functionality follow.
+
+ Each callback is supplied with a parent directory handle,
+ character string with the name of the current file path component,
+ a flag indicating if this component is the last in the path and
+ a pointer to an arbitrary object used for context.
+
+ */
+
+ boolean callback_pathExists(SdFile& parentDir, const char *filePathComponent,
+ boolean /* isLastComponent */, void * /* object */) {
+ /*
+
+ Callback used to determine if a file/directory exists in parent
+ directory.
+
+ Returns true if file path exists.
+
+ */
+ SdFile child;
+
+ boolean exists = child.open(parentDir, filePathComponent, O_RDONLY);
+
+ if (exists) {
+ child.close();
+ }
+
+ return exists;
+ }
+
+
+
+ boolean callback_makeDirPath(SdFile& parentDir, const char *filePathComponent,
+ boolean isLastComponent, void *object) {
+ /*
+
+ Callback used to create a directory in the parent directory if
+ it does not already exist.
+
+ Returns true if a directory was created or it already existed.
+
+ */
+ boolean result = false;
+ SdFile child;
+
+ result = callback_pathExists(parentDir, filePathComponent, isLastComponent, object);
+ if (!result) {
+ result = child.makeDir(parentDir, filePathComponent);
+ }
+
+ return result;
+ }
+
+
+ /*
+
+ boolean callback_openPath(SdFile& parentDir, char *filePathComponent,
+ boolean isLastComponent, void *object) {
+
+ Callback used to open a file specified by a filepath that may
+ specify one or more directories above it.
+
+ Expects the context object to be an instance of `SDClass` and
+ will use the `file` property of the instance to open the requested
+ file/directory with the associated file open mode property.
+
+ Always returns true if the directory traversal hasn't reached the
+ bottom of the directory hierarchy.
+
+ Returns false once the file has been opened--to prevent the traversal
+ from descending further. (This may be unnecessary.)
+
+ if (isLastComponent) {
+ SDClass *p_SD = static_cast<SDClass*>(object);
+ p_SD->file.open(parentDir, filePathComponent, p_SD->fileOpenMode);
+ if (p_SD->fileOpenMode == FILE_WRITE) {
+ p_SD->file.seekSet(p_SD->file.fileSize());
+ }
+ // TODO: Return file open result?
+ return false;
+ }
+ return true;
+ }
+ */
+
+
+
+ boolean callback_remove(SdFile& parentDir, const char *filePathComponent,
+ boolean isLastComponent, void * /* object */) {
+ if (isLastComponent) {
+ return SdFile::remove(parentDir, filePathComponent);
+ }
+ return true;
+ }
+
+ boolean callback_rmdir(SdFile& parentDir, const char *filePathComponent,
+ boolean isLastComponent, void * /* object */) {
+ if (isLastComponent) {
+ SdFile f;
+ if (!f.open(parentDir, filePathComponent, O_READ)) {
+ return false;
+ }
+ return f.rmDir();
+ }
+ return true;
+ }
+
+
+
+ /* Implementation of class used to create `SDCard` object. */
+
+
+
+ boolean SDClass::begin(uint8_t csPin) {
+ if (root.isOpen()) {
+ root.close();
+ }
+
+ /*
+
+ Performs the initialisation required by the sdfatlib library.
+
+ Return true if initialization succeeds, false otherwise.
+
+ */
+ return card.init(SPI_HALF_SPEED, csPin) &&
+ volume.init(card) &&
+ root.openRoot(volume);
+ }
+
+ boolean SDClass::begin(uint32_t clock, uint8_t csPin) {
+ if (root.isOpen()) {
+ root.close();
+ }
+
+ return card.init(SPI_HALF_SPEED, csPin) &&
+ card.setSpiClock(clock) &&
+ volume.init(card) &&
+ root.openRoot(volume);
+ }
+
+ //call this when a card is removed. It will allow you to insert and initialise a new card.
+ void SDClass::end() {
+ root.close();
+ }
+
+ // this little helper is used to traverse paths
+ SdFile SDClass::getParentDir(const char *filepath, int *index) {
+ // get parent directory
+ SdFile d1;
+ SdFile d2;
+
+ d1.openRoot(volume); // start with the mostparent, root!
+
+ // we'll use the pointers to swap between the two objects
+ SdFile *parent = &d1;
+ SdFile *subdir = &d2;
+
+ const char *origpath = filepath;
+
+ while (strchr(filepath, '/')) {
+
+ // get rid of leading /'s
+ if (filepath[0] == '/') {
+ filepath++;
+ continue;
+ }
+
+ if (! strchr(filepath, '/')) {
+ // it was in the root directory, so leave now
+ break;
+ }
+
+ // extract just the name of the next subdirectory
+ uint8_t idx = strchr(filepath, '/') - filepath;
+ if (idx > 12) {
+ idx = 12; // don't let them specify long names
+ }
+ char subdirname[13];
+ strncpy(subdirname, filepath, idx);
+ subdirname[idx] = 0;
+
+ // close the subdir (we reuse them) if open
+ subdir->close();
+ if (! subdir->open(parent, subdirname, O_READ)) {
+ // failed to open one of the subdirectories
+ return SdFile();
+ }
+ // move forward to the next subdirectory
+ filepath += idx;
+
+ // we reuse the objects, close it.
+ parent->close();
+
+ // swap the pointers
+ SdFile *t = parent;
+ parent = subdir;
+ subdir = t;
+ }
+
+ *index = (int)(filepath - origpath);
+ // parent is now the parent directory of the file!
+ return *parent;
+ }
+
+
+ File SDClass::open(const char *filepath, uint8_t mode) {
+ /*
+
+ Open the supplied file path for reading or writing.
+
+ The file content can be accessed via the `file` property of
+ the `SDClass` object--this property is currently
+ a standard `SdFile` object from `sdfatlib`.
+
+ Defaults to read only.
+
+ If `write` is true, default action (when `append` is true) is to
+ append data to the end of the file.
+
+ If `append` is false then the file will be truncated first.
+
+ If the file does not exist and it is opened for writing the file
+ will be created.
+
+ An attempt to open a file for reading that does not exist is an
+ error.
+
+ */
+
+ int pathidx;
+
+ // do the interactive search
+ SdFile parentdir = getParentDir(filepath, &pathidx);
+ // no more subdirs!
+
+ filepath += pathidx;
+
+ if (! filepath[0]) {
+ // it was the directory itself!
+ return File(parentdir, "/");
+ }
+
+ // Open the file itself
+ SdFile file;
+
+ // failed to open a subdir!
+ if (!parentdir.isOpen()) {
+ return File();
+ }
+
+ if (! file.open(parentdir, filepath, mode)) {
+ return File();
+ }
+ // close the parent
+ parentdir.close();
+
+ if ((mode & (O_APPEND | O_WRITE)) == (O_APPEND | O_WRITE)) {
+ file.seekSet(file.fileSize());
+ }
+ return File(file, filepath);
+ }
+
+
+ /*
+ File SDClass::open(char *filepath, uint8_t mode) {
+ //
+
+ Open the supplied file path for reading or writing.
+
+ The file content can be accessed via the `file` property of
+ the `SDClass` object--this property is currently
+ a standard `SdFile` object from `sdfatlib`.
+
+ Defaults to read only.
+
+ If `write` is true, default action (when `append` is true) is to
+ append data to the end of the file.
+
+ If `append` is false then the file will be truncated first.
+
+ If the file does not exist and it is opened for writing the file
+ will be created.
+
+ An attempt to open a file for reading that does not exist is an
+ error.
+
+ //
+
+ // TODO: Allow for read&write? (Possibly not, as it requires seek.)
+
+ fileOpenMode = mode;
+ walkPath(filepath, root, callback_openPath, this);
+
+ return File();
+
+ }
+ */
+
+
+ //boolean SDClass::close() {
+ // /*
+ //
+ // Closes the file opened by the `open` method.
+ //
+ // */
+ // file.close();
+ //}
+
+
+ boolean SDClass::exists(const char *filepath) {
+ /*
+
+ Returns true if the supplied file path exists.
+
+ */
+ return walkPath(filepath, root, callback_pathExists);
+ }
+
+
+ //boolean SDClass::exists(char *filepath, SdFile& parentDir) {
+ // /*
+ //
+ // Returns true if the supplied file path rooted at `parentDir`
+ // exists.
+ //
+ // */
+ // return walkPath(filepath, parentDir, callback_pathExists);
+ //}
+
+
+ boolean SDClass::mkdir(const char *filepath) {
+ /*
+
+ Makes a single directory or a hierarchy of directories.
+
+ A rough equivalent to `mkdir -p`.
+
+ */
+ return walkPath(filepath, root, callback_makeDirPath);
+ }
+
+ boolean SDClass::rmdir(const char *filepath) {
+ /*
+
+ Remove a single directory or a hierarchy of directories.
+
+ A rough equivalent to `rm -rf`.
+
+ */
+ return walkPath(filepath, root, callback_rmdir);
+ }
+
+ boolean SDClass::remove(const char *filepath) {
+ return walkPath(filepath, root, callback_remove);
+ }
+
+
+ // allows you to recurse into a directory
+ File File::openNextFile(uint8_t mode) {
+ dir_t p;
+
+ //Serial.print("\t\treading dir...");
+ while (_file->readDir(&p) > 0) {
+
+ // done if past last used entry
+ if (p.name[0] == DIR_NAME_FREE) {
+ //Serial.println("end");
+ return File();
+ }
+
+ // skip deleted entry and entries for . and ..
+ if (p.name[0] == DIR_NAME_DELETED || p.name[0] == '.') {
+ //Serial.println("dots");
+ continue;
+ }
+
+ // only list subdirectories and files
+ if (!DIR_IS_FILE_OR_SUBDIR(&p)) {
+ //Serial.println("notafile");
+ continue;
+ }
+
+ // print file name with possible blank fill
+ SdFile f;
+ char name[13];
+ _file->dirName(p, name);
+ //Serial.print("try to open file ");
+ //Serial.println(name);
+
+ if (f.open(_file, name, mode)) {
+ //Serial.println("OK!");
+ return File(f, name);
+ } else {
+ //Serial.println("ugh");
+ return File();
+ }
+ }
+
+ //Serial.println("nothing");
+ return File();
+ }
+
+ void File::rewindDirectory(void) {
+ if (isDirectory()) {
+ _file->rewind();
+ }
+ }
+
+ SDClass SD;
+
+};
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/SD.h b/arduino/ForceSensorTFT/libraries/SD/src/SD.h
new file mode 100644
index 000000000..fa34ccd5d
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/SD.h
@@ -0,0 +1,138 @@
+/*
+
+ SD - a slightly more friendly wrapper for sdfatlib
+
+ This library aims to expose a subset of SD card functionality
+ in the form of a higher level "wrapper" object.
+
+ License: GNU General Public License V3
+ (Because sdfatlib is licensed with this.)
+
+ (C) Copyright 2010 SparkFun Electronics
+
+*/
+
+#ifndef __SD_H__
+#define __SD_H__
+
+#include <Arduino.h>
+
+#include "utility/SdFat.h"
+#include "utility/SdFatUtil.h"
+
+#define FILE_READ O_READ
+#define FILE_WRITE (O_READ | O_WRITE | O_CREAT | O_APPEND)
+
+namespace SDLib {
+
+ class File : public Stream {
+ private:
+ char _name[13]; // our name
+ SdFile *_file; // underlying file pointer
+
+ public:
+ File(SdFile f, const char *name); // wraps an underlying SdFile
+ File(void); // 'empty' constructor
+ virtual size_t write(uint8_t);
+ virtual size_t write(const uint8_t *buf, size_t size);
+ virtual int availableForWrite();
+ virtual int read();
+ virtual int peek();
+ virtual int available();
+ virtual void flush();
+ int read(void *buf, uint16_t nbyte);
+ boolean seek(uint32_t pos);
+ uint32_t position();
+ uint32_t size();
+ void close();
+ operator bool();
+ char * name();
+
+ boolean isDirectory(void);
+ File openNextFile(uint8_t mode = O_RDONLY);
+ void rewindDirectory(void);
+
+ using Print::write;
+ };
+
+ class SDClass {
+
+ private:
+ // These are required for initialisation and use of sdfatlib
+ Sd2Card card;
+ SdVolume volume;
+ SdFile root;
+
+ // my quick&dirty iterator, should be replaced
+ SdFile getParentDir(const char *filepath, int *indx);
+ public:
+ // This needs to be called to set up the connection to the SD card
+ // before other methods are used.
+ boolean begin(uint8_t csPin = SD_CHIP_SELECT_PIN);
+ boolean begin(uint32_t clock, uint8_t csPin);
+
+ //call this when a card is removed. It will allow you to insert and initialise a new card.
+ void end();
+
+ // Open the specified file/directory with the supplied mode (e.g. read or
+ // write, etc). Returns a File object for interacting with the file.
+ // Note that currently only one file can be open at a time.
+ File open(const char *filename, uint8_t mode = FILE_READ);
+ File open(const String &filename, uint8_t mode = FILE_READ) {
+ return open(filename.c_str(), mode);
+ }
+
+ // Methods to determine if the requested file path exists.
+ boolean exists(const char *filepath);
+ boolean exists(const String &filepath) {
+ return exists(filepath.c_str());
+ }
+
+ // Create the requested directory heirarchy--if intermediate directories
+ // do not exist they will be created.
+ boolean mkdir(const char *filepath);
+ boolean mkdir(const String &filepath) {
+ return mkdir(filepath.c_str());
+ }
+
+ // Delete the file.
+ boolean remove(const char *filepath);
+ boolean remove(const String &filepath) {
+ return remove(filepath.c_str());
+ }
+
+ boolean rmdir(const char *filepath);
+ boolean rmdir(const String &filepath) {
+ return rmdir(filepath.c_str());
+ }
+
+ private:
+
+ // This is used to determine the mode used to open a file
+ // it's here because it's the easiest place to pass the
+ // information through the directory walking function. But
+ // it's probably not the best place for it.
+ // It shouldn't be set directly--it is set via the parameters to `open`.
+ int fileOpenMode;
+
+ friend class File;
+ friend boolean callback_openPath(SdFile&, const char *, boolean, void *);
+ };
+
+ extern SDClass SD;
+
+};
+
+// We enclose File and SD classes in namespace SDLib to avoid conflicts
+// with others legacy libraries that redefines File class.
+
+// This ensure compatibility with sketches that uses only SD library
+using namespace SDLib;
+
+// This allows sketches to use SDLib::File with other libraries (in the
+// sketch you must use SDFile instead of File to disambiguate)
+typedef SDLib::File SDFile;
+typedef SDLib::SDClass SDFileSystemClass;
+#define SDFileSystem SDLib::SD
+
+#endif
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/FatStructs.h
b/arduino/ForceSensorTFT/libraries/SD/src/utility/FatStructs.h
new file mode 100644
index 000000000..84c1cc71b
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/FatStructs.h
@@ -0,0 +1,418 @@
+/* Arduino SdFat Library
+ Copyright (C) 2009 by William Greiman
+
+ This file is part of the Arduino SdFat Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino SdFat Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+#ifndef FatStructs_h
+#define FatStructs_h
+/**
+ \file
+ FAT file structures
+*/
+/*
+ mostly from Microsoft document fatgen103.doc
+ http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx
+*/
+//------------------------------------------------------------------------------
+/** Value for byte 510 of boot block or MBR */
+uint8_t const BOOTSIG0 = 0X55;
+/** Value for byte 511 of boot block or MBR */
+uint8_t const BOOTSIG1 = 0XAA;
+//------------------------------------------------------------------------------
+/**
+ \struct partitionTable
+ \brief MBR partition table entry
+
+ A partition table entry for a MBR formatted storage device.
+ The MBR partition table has four entries.
+*/
+struct partitionTable {
+ /**
+ Boot Indicator . Indicates whether the volume is the active
+ partition. Legal values include: 0X00. Do not use for booting.
+ 0X80 Active partition.
+ */
+ uint8_t boot;
+ /**
+ Head part of Cylinder-head-sector address of the first block in
+ the partition. Legal values are 0-255. Only used in old PC BIOS.
+ */
+ uint8_t beginHead;
+ /**
+ Sector part of Cylinder-head-sector address of the first block in
+ the partition. Legal values are 1-63. Only used in old PC BIOS.
+ */
+ unsigned beginSector : 6;
+ /** High bits cylinder for first block in partition. */
+ unsigned beginCylinderHigh : 2;
+ /**
+ Combine beginCylinderLow with beginCylinderHigh. Legal values
+ are 0-1023. Only used in old PC BIOS.
+ */
+ uint8_t beginCylinderLow;
+ /**
+ Partition type. See defines that begin with PART_TYPE_ for
+ some Microsoft partition types.
+ */
+ uint8_t type;
+ /**
+ head part of cylinder-head-sector address of the last sector in the
+ partition. Legal values are 0-255. Only used in old PC BIOS.
+ */
+ uint8_t endHead;
+ /**
+ Sector part of cylinder-head-sector address of the last sector in
+ the partition. Legal values are 1-63. Only used in old PC BIOS.
+ */
+ unsigned endSector : 6;
+ /** High bits of end cylinder */
+ unsigned endCylinderHigh : 2;
+ /**
+ Combine endCylinderLow with endCylinderHigh. Legal values
+ are 0-1023. Only used in old PC BIOS.
+ */
+ uint8_t endCylinderLow;
+ /** Logical block address of the first block in the partition. */
+ uint32_t firstSector;
+ /** Length of the partition, in blocks. */
+ uint32_t totalSectors;
+} __attribute__((packed));
+/** Type name for partitionTable */
+typedef struct partitionTable part_t;
+//------------------------------------------------------------------------------
+/**
+ \struct masterBootRecord
+
+ \brief Master Boot Record
+
+ The first block of a storage device that is formatted with a MBR.
+*/
+struct masterBootRecord {
+ /** Code Area for master boot program. */
+ uint8_t codeArea[440];
+ /** Optional WindowsNT disk signature. May contain more boot code. */
+ uint32_t diskSignature;
+ /** Usually zero but may be more boot code. */
+ uint16_t usuallyZero;
+ /** Partition tables. */
+ part_t part[4];
+ /** First MBR signature byte. Must be 0X55 */
+ uint8_t mbrSig0;
+ /** Second MBR signature byte. Must be 0XAA */
+ uint8_t mbrSig1;
+} __attribute__((packed));
+/** Type name for masterBootRecord */
+typedef struct masterBootRecord mbr_t;
+//------------------------------------------------------------------------------
+/**
+ \struct biosParmBlock
+
+ \brief BIOS parameter block
+
+ The BIOS parameter block describes the physical layout of a FAT volume.
+*/
+struct biosParmBlock {
+ /**
+ Count of bytes per sector. This value may take on only the
+ following values: 512, 1024, 2048 or 4096
+ */
+ uint16_t bytesPerSector;
+ /**
+ Number of sectors per allocation unit. This value must be a
+ power of 2 that is greater than 0. The legal values are
+ 1, 2, 4, 8, 16, 32, 64, and 128.
+ */
+ uint8_t sectorsPerCluster;
+ /**
+ Number of sectors before the first FAT.
+ This value must not be zero.
+ */
+ uint16_t reservedSectorCount;
+ /** The count of FAT data structures on the volume. This field should
+ always contain the value 2 for any FAT volume of any type.
+ */
+ uint8_t fatCount;
+ /**
+ For FAT12 and FAT16 volumes, this field contains the count of
+ 32-byte directory entries in the root directory. For FAT32 volumes,
+ this field must be set to 0. For FAT12 and FAT16 volumes, this
+ value should always specify a count that when multiplied by 32
+ results in a multiple of bytesPerSector. FAT16 volumes should
+ use the value 512.
+ */
+ uint16_t rootDirEntryCount;
+ /**
+ This field is the old 16-bit total count of sectors on the volume.
+ This count includes the count of all sectors in all four regions
+ of the volume. This field can be 0; if it is 0, then totalSectors32
+ must be non-zero. For FAT32 volumes, this field must be 0. For
+ FAT12 and FAT16 volumes, this field contains the sector count, and
+ totalSectors32 is 0 if the total sector count fits
+ (is less than 0x10000).
+ */
+ uint16_t totalSectors16;
+ /**
+ This dates back to the old MS-DOS 1.x media determination and is
+ no longer usually used for anything. 0xF8 is the standard value
+ for fixed (non-removable) media. For removable media, 0xF0 is
+ frequently used. Legal values are 0xF0 or 0xF8-0xFF.
+ */
+ uint8_t mediaType;
+ /**
+ Count of sectors occupied by one FAT on FAT12/FAT16 volumes.
+ On FAT32 volumes this field must be 0, and sectorsPerFat32
+ contains the FAT size count.
+ */
+ uint16_t sectorsPerFat16;
+ /** Sectors per track for interrupt 0x13. Not used otherwise. */
+ uint16_t sectorsPerTrtack;
+ /** Number of heads for interrupt 0x13. Not used otherwise. */
+ uint16_t headCount;
+ /**
+ Count of hidden sectors preceding the partition that contains this
+ FAT volume. This field is generally only relevant for media
+ visible on interrupt 0x13.
+ */
+ uint32_t hidddenSectors;
+ /**
+ This field is the new 32-bit total count of sectors on the volume.
+ This count includes the count of all sectors in all four regions
+ of the volume. This field can be 0; if it is 0, then
+ totalSectors16 must be non-zero.
+ */
+ uint32_t totalSectors32;
+ /**
+ Count of sectors occupied by one FAT on FAT32 volumes.
+ */
+ uint32_t sectorsPerFat32;
+ /**
+ This field is only defined for FAT32 media and does not exist on
+ FAT12 and FAT16 media.
+ Bits 0-3 -- Zero-based number of active FAT.
+ Only valid if mirroring is disabled.
+ Bits 4-6 -- Reserved.
+ Bit 7 -- 0 means the FAT is mirrored at runtime into all FATs.
+ -- 1 means only one FAT is active; it is the one referenced in bits 0-3.
+ Bits 8-15 -- Reserved.
+ */
+ uint16_t fat32Flags;
+ /**
+ FAT32 version. High byte is major revision number.
+ Low byte is minor revision number. Only 0.0 define.
+ */
+ uint16_t fat32Version;
+ /**
+ Cluster number of the first cluster of the root directory for FAT32.
+ This usually 2 but not required to be 2.
+ */
+ uint32_t fat32RootCluster;
+ /**
+ Sector number of FSINFO structure in the reserved area of the
+ FAT32 volume. Usually 1.
+ */
+ uint16_t fat32FSInfo;
+ /**
+ If non-zero, indicates the sector number in the reserved area
+ of the volume of a copy of the boot record. Usually 6.
+ No value other than 6 is recommended.
+ */
+ uint16_t fat32BackBootBlock;
+ /**
+ Reserved for future expansion. Code that formats FAT32 volumes
+ should always set all of the bytes of this field to 0.
+ */
+ uint8_t fat32Reserved[12];
+} __attribute__((packed));
+/** Type name for biosParmBlock */
+typedef struct biosParmBlock bpb_t;
+//------------------------------------------------------------------------------
+/**
+ \struct fat32BootSector
+
+ \brief Boot sector for a FAT16 or FAT32 volume.
+
+*/
+struct fat32BootSector {
+ /** X86 jmp to boot program */
+ uint8_t jmpToBootCode[3];
+ /** informational only - don't depend on it */
+ char oemName[8];
+ /** BIOS Parameter Block */
+ bpb_t bpb;
+ /** for int0x13 use value 0X80 for hard drive */
+ uint8_t driveNumber;
+ /** used by Windows NT - should be zero for FAT */
+ uint8_t reserved1;
+ /** 0X29 if next three fields are valid */
+ uint8_t bootSignature;
+ /** usually generated by combining date and time */
+ uint32_t volumeSerialNumber;
+ /** should match volume label in root dir */
+ char volumeLabel[11];
+ /** informational only - don't depend on it */
+ char fileSystemType[8];
+ /** X86 boot code */
+ uint8_t bootCode[420];
+ /** must be 0X55 */
+ uint8_t bootSectorSig0;
+ /** must be 0XAA */
+ uint8_t bootSectorSig1;
+} __attribute__((packed));
+//------------------------------------------------------------------------------
+// End Of Chain values for FAT entries
+/** FAT16 end of chain value used by Microsoft. */
+uint16_t const FAT16EOC = 0XFFFF;
+/** Minimum value for FAT16 EOC. Use to test for EOC. */
+uint16_t const FAT16EOC_MIN = 0XFFF8;
+/** FAT32 end of chain value used by Microsoft. */
+uint32_t const FAT32EOC = 0X0FFFFFFF;
+/** Minimum value for FAT32 EOC. Use to test for EOC. */
+uint32_t const FAT32EOC_MIN = 0X0FFFFFF8;
+/** Mask a for FAT32 entry. Entries are 28 bits. */
+uint32_t const FAT32MASK = 0X0FFFFFFF;
+
+/** Type name for fat32BootSector */
+typedef struct fat32BootSector fbs_t;
+//------------------------------------------------------------------------------
+/**
+ \struct directoryEntry
+ \brief FAT short directory entry
+
+ Short means short 8.3 name, not the entry size.
+
+ Date Format. A FAT directory entry date stamp is a 16-bit field that is
+ basically a date relative to the MS-DOS epoch of 01/01/1980. Here is the
+ format (bit 0 is the LSB of the 16-bit word, bit 15 is the MSB of the
+ 16-bit word):
+
+ Bits 9-15: Count of years from 1980, valid value range 0-127
+ inclusive (1980-2107).
+
+ Bits 5-8: Month of year, 1 = January, valid value range 1-12 inclusive.
+
+ Bits 0-4: Day of month, valid value range 1-31 inclusive.
+
+ Time Format. A FAT directory entry time stamp is a 16-bit field that has
+ a granularity of 2 seconds. Here is the format (bit 0 is the LSB of the
+ 16-bit word, bit 15 is the MSB of the 16-bit word).
+
+ Bits 11-15: Hours, valid value range 0-23 inclusive.
+
+ Bits 5-10: Minutes, valid value range 0-59 inclusive.
+
+ Bits 0-4: 2-second count, valid value range 0-29 inclusive (0 - 58 seconds).
+
+ The valid time range is from Midnight 00:00:00 to 23:59:58.
+*/
+struct directoryEntry {
+ /**
+ Short 8.3 name.
+ The first eight bytes contain the file name with blank fill.
+ The last three bytes contain the file extension with blank fill.
+ */
+ uint8_t name[11];
+ /** Entry attributes.
+
+ The upper two bits of the attribute byte are reserved and should
+ always be set to 0 when a file is created and never modified or
+ looked at after that. See defines that begin with DIR_ATT_.
+ */
+ uint8_t attributes;
+ /**
+ Reserved for use by Windows NT. Set value to 0 when a file is
+ created and never modify or look at it after that.
+ */
+ uint8_t reservedNT;
+ /**
+ The granularity of the seconds part of creationTime is 2 seconds
+ so this field is a count of tenths of a second and its valid
+ value range is 0-199 inclusive. (WHG note - seems to be hundredths)
+ */
+ uint8_t creationTimeTenths;
+ /** Time file was created. */
+ uint16_t creationTime;
+ /** Date file was created. */
+ uint16_t creationDate;
+ /**
+ Last access date. Note that there is no last access time, only
+ a date. This is the date of last read or write. In the case of
+ a write, this should be set to the same date as lastWriteDate.
+ */
+ uint16_t lastAccessDate;
+ /**
+ High word of this entry's first cluster number (always 0 for a
+ FAT12 or FAT16 volume).
+ */
+ uint16_t firstClusterHigh;
+ /** Time of last write. File creation is considered a write. */
+ uint16_t lastWriteTime;
+ /** Date of last write. File creation is considered a write. */
+ uint16_t lastWriteDate;
+ /** Low word of this entry's first cluster number. */
+ uint16_t firstClusterLow;
+ /** 32-bit unsigned holding this file's size in bytes. */
+ uint32_t fileSize;
+} __attribute__((packed));
+//------------------------------------------------------------------------------
+// Definitions for directory entries
+//
+/** Type name for directoryEntry */
+typedef struct directoryEntry dir_t;
+/** escape for name[0] = 0XE5 */
+uint8_t const DIR_NAME_0XE5 = 0X05;
+/** name[0] value for entry that is free after being "deleted" */
+uint8_t const DIR_NAME_DELETED = 0XE5;
+/** name[0] value for entry that is free and no allocated entries follow */
+uint8_t const DIR_NAME_FREE = 0X00;
+/** file is read-only */
+uint8_t const DIR_ATT_READ_ONLY = 0X01;
+/** File should hidden in directory listings */
+uint8_t const DIR_ATT_HIDDEN = 0X02;
+/** Entry is for a system file */
+uint8_t const DIR_ATT_SYSTEM = 0X04;
+/** Directory entry contains the volume label */
+uint8_t const DIR_ATT_VOLUME_ID = 0X08;
+/** Entry is for a directory */
+uint8_t const DIR_ATT_DIRECTORY = 0X10;
+/** Old DOS archive bit for backup support */
+uint8_t const DIR_ATT_ARCHIVE = 0X20;
+/** Test value for long name entry. Test is
+ (d->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME. */
+uint8_t const DIR_ATT_LONG_NAME = 0X0F;
+/** Test mask for long name entry */
+uint8_t const DIR_ATT_LONG_NAME_MASK = 0X3F;
+/** defined attribute bits */
+uint8_t const DIR_ATT_DEFINED_BITS = 0X3F;
+/** Directory entry is part of a long name */
+static inline uint8_t DIR_IS_LONG_NAME(const dir_t* dir) {
+ return (dir->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME;
+}
+/** Mask for file/subdirectory tests */
+uint8_t const DIR_ATT_FILE_TYPE_MASK = (DIR_ATT_VOLUME_ID | DIR_ATT_DIRECTORY);
+/** Directory entry is for a file */
+static inline uint8_t DIR_IS_FILE(const dir_t* dir) {
+ return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == 0;
+}
+/** Directory entry is for a subdirectory */
+static inline uint8_t DIR_IS_SUBDIR(const dir_t* dir) {
+ return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == DIR_ATT_DIRECTORY;
+}
+/** Directory entry is for a file or subdirectory */
+static inline uint8_t DIR_IS_FILE_OR_SUBDIR(const dir_t* dir) {
+ return (dir->attributes & DIR_ATT_VOLUME_ID) == 0;
+}
+#endif // FatStructs_h
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/Sd2Card.cpp
b/arduino/ForceSensorTFT/libraries/SD/src/utility/Sd2Card.cpp
new file mode 100644
index 000000000..7cfbe73ee
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/Sd2Card.cpp
@@ -0,0 +1,777 @@
+/* Arduino Sd2Card Library
+ Copyright (C) 2009 by William Greiman
+
+ This file is part of the Arduino Sd2Card Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino Sd2Card Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+#define USE_SPI_LIB
+#include <Arduino.h>
+#include "Sd2Card.h"
+//------------------------------------------------------------------------------
+#ifndef SOFTWARE_SPI
+#ifdef USE_SPI_LIB
+
+ #ifndef SDCARD_SPI
+ #define SDCARD_SPI SPI
+ #endif
+
+ #include <SPI.h>
+ static SPISettings settings;
+#endif
+// functions for hardware SPI
+/** Send a byte to the card */
+static void spiSend(uint8_t b) {
+ #ifndef USE_SPI_LIB
+ SPDR = b;
+ while (!(SPSR & (1 << SPIF)))
+ ;
+ #else
+ SDCARD_SPI.transfer(b);
+ #endif
+}
+/** Receive a byte from the card */
+static uint8_t spiRec(void) {
+ #ifndef USE_SPI_LIB
+ spiSend(0XFF);
+ return SPDR;
+ #else
+ return SDCARD_SPI.transfer(0xFF);
+ #endif
+}
+#else // SOFTWARE_SPI
+//------------------------------------------------------------------------------
+/** nop to tune soft SPI timing */
+#define nop asm volatile ("nop\n\t")
+//------------------------------------------------------------------------------
+/** Soft SPI receive */
+uint8_t spiRec(void) {
+ uint8_t data = 0;
+ // no interrupts during byte receive - about 8 us
+ cli();
+ // output pin high - like sending 0XFF
+ fastDigitalWrite(SPI_MOSI_PIN, HIGH);
+
+ for (uint8_t i = 0; i < 8; i++) {
+ fastDigitalWrite(SPI_SCK_PIN, HIGH);
+
+ // adjust so SCK is nice
+ nop;
+ nop;
+
+ data <<= 1;
+
+ if (fastDigitalRead(SPI_MISO_PIN)) {
+ data |= 1;
+ }
+
+ fastDigitalWrite(SPI_SCK_PIN, LOW);
+ }
+ // enable interrupts
+ sei();
+ return data;
+}
+//------------------------------------------------------------------------------
+/** Soft SPI send */
+void spiSend(uint8_t data) {
+ // no interrupts during byte send - about 8 us
+ cli();
+ for (uint8_t i = 0; i < 8; i++) {
+ fastDigitalWrite(SPI_SCK_PIN, LOW);
+
+ fastDigitalWrite(SPI_MOSI_PIN, data & 0X80);
+
+ data <<= 1;
+
+ fastDigitalWrite(SPI_SCK_PIN, HIGH);
+ }
+ // hold SCK high for a few ns
+ nop;
+ nop;
+ nop;
+ nop;
+
+ fastDigitalWrite(SPI_SCK_PIN, LOW);
+ // enable interrupts
+ sei();
+}
+#endif // SOFTWARE_SPI
+//------------------------------------------------------------------------------
+// send command and return error code. Return zero for OK
+uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) {
+ // end read if in partialBlockRead mode
+ readEnd();
+
+ // select card
+ chipSelectLow();
+
+ // wait up to 300 ms if busy
+ waitNotBusy(300);
+
+ // send command
+ spiSend(cmd | 0x40);
+
+ // send argument
+ for (int8_t s = 24; s >= 0; s -= 8) {
+ spiSend(arg >> s);
+ }
+
+ // send CRC
+ uint8_t crc = 0XFF;
+ if (cmd == CMD0) {
+ crc = 0X95; // correct crc for CMD0 with arg 0
+ }
+ if (cmd == CMD8) {
+ crc = 0X87; // correct crc for CMD8 with arg 0X1AA
+ }
+ spiSend(crc);
+
+ // wait for response
+ for (uint8_t i = 0; ((status_ = spiRec()) & 0X80) && i != 0XFF; i++)
+ ;
+ return status_;
+}
+//------------------------------------------------------------------------------
+/**
+ Determine the size of an SD flash memory card.
+
+ \return The number of 512 byte data blocks in the card
+ or zero if an error occurs.
+*/
+uint32_t Sd2Card::cardSize(void) {
+ csd_t csd;
+ if (!readCSD(&csd)) {
+ return 0;
+ }
+ if (csd.v1.csd_ver == 0) {
+ uint8_t read_bl_len = csd.v1.read_bl_len;
+ uint16_t c_size = (csd.v1.c_size_high << 10)
+ | (csd.v1.c_size_mid << 2) | csd.v1.c_size_low;
+ uint8_t c_size_mult = (csd.v1.c_size_mult_high << 1)
+ | csd.v1.c_size_mult_low;
+ return (uint32_t)(c_size + 1) << (c_size_mult + read_bl_len - 7);
+ } else if (csd.v2.csd_ver == 1) {
+ uint32_t c_size = ((uint32_t)csd.v2.c_size_high << 16)
+ | (csd.v2.c_size_mid << 8) | csd.v2.c_size_low;
+ return (c_size + 1) << 10;
+ } else {
+ error(SD_CARD_ERROR_BAD_CSD);
+ return 0;
+ }
+}
+//------------------------------------------------------------------------------
+static uint8_t chip_select_asserted = 0;
+
+void Sd2Card::chipSelectHigh(void) {
+ digitalWrite(chipSelectPin_, HIGH);
+ #ifdef USE_SPI_LIB
+ if (chip_select_asserted) {
+ chip_select_asserted = 0;
+ SDCARD_SPI.endTransaction();
+ }
+ #endif
+}
+//------------------------------------------------------------------------------
+void Sd2Card::chipSelectLow(void) {
+ #ifdef USE_SPI_LIB
+ if (!chip_select_asserted) {
+ chip_select_asserted = 1;
+ SDCARD_SPI.beginTransaction(settings);
+ }
+ #endif
+ digitalWrite(chipSelectPin_, LOW);
+}
+//------------------------------------------------------------------------------
+/** Erase a range of blocks.
+
+ \param[in] firstBlock The address of the first block in the range.
+ \param[in] lastBlock The address of the last block in the range.
+
+ \note This function requests the SD card to do a flash erase for a
+ range of blocks. The data on the card after an erase operation is
+ either 0 or 1, depends on the card vendor. The card must support
+ single block erase.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
+ if (!eraseSingleBlockEnable()) {
+ error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);
+ goto fail;
+ }
+ if (type_ != SD_CARD_TYPE_SDHC) {
+ firstBlock <<= 9;
+ lastBlock <<= 9;
+ }
+ if (cardCommand(CMD32, firstBlock)
+ || cardCommand(CMD33, lastBlock)
+ || cardCommand(CMD38, 0)) {
+ error(SD_CARD_ERROR_ERASE);
+ goto fail;
+ }
+ if (!waitNotBusy(SD_ERASE_TIMEOUT)) {
+ error(SD_CARD_ERROR_ERASE_TIMEOUT);
+ goto fail;
+ }
+ chipSelectHigh();
+ return true;
+
+fail:
+ chipSelectHigh();
+ return false;
+}
+//------------------------------------------------------------------------------
+/** Determine if card supports single block erase.
+
+ \return The value one, true, is returned if single block erase is supported.
+ The value zero, false, is returned if single block erase is not supported.
+*/
+uint8_t Sd2Card::eraseSingleBlockEnable(void) {
+ csd_t csd;
+ return readCSD(&csd) ? csd.v1.erase_blk_en : 0;
+}
+//------------------------------------------------------------------------------
+/**
+ Initialize an SD flash memory card.
+
+ \param[in] sckRateID SPI clock rate selector. See setSckRate().
+ \param[in] chipSelectPin SD chip select pin number.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure. The reason for failure
+ can be determined by calling errorCode() and errorData().
+*/
+uint8_t Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
+ errorCode_ = inBlock_ = partialBlockRead_ = type_ = 0;
+ chipSelectPin_ = chipSelectPin;
+ // 16-bit init start time allows over a minute
+ unsigned int t0 = millis();
+ uint32_t arg;
+
+ // set pin modes
+ pinMode(chipSelectPin_, OUTPUT);
+ digitalWrite(chipSelectPin_, HIGH);
+ #ifndef USE_SPI_LIB
+ pinMode(SPI_MISO_PIN, INPUT);
+ pinMode(SPI_MOSI_PIN, OUTPUT);
+ pinMode(SPI_SCK_PIN, OUTPUT);
+ #endif
+
+ #ifndef SOFTWARE_SPI
+ #ifndef USE_SPI_LIB
+ // SS must be in output mode even it is not chip select
+ pinMode(SS_PIN, OUTPUT);
+ digitalWrite(SS_PIN, HIGH); // disable any SPI device using hardware SS pin
+ // Enable SPI, Master, clock rate f_osc/128
+ SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0);
+ // clear double speed
+ SPSR &= ~(1 << SPI2X);
+ #else // USE_SPI_LIB
+ SDCARD_SPI.begin();
+ settings = SPISettings(250000, MSBFIRST, SPI_MODE0);
+ #endif // USE_SPI_LIB
+ #endif // SOFTWARE_SPI
+
+ // must supply min of 74 clock cycles with CS high.
+ #ifdef USE_SPI_LIB
+ SDCARD_SPI.beginTransaction(settings);
+ #endif
+ for (uint8_t i = 0; i < 10; i++) {
+ spiSend(0XFF);
+ }
+ #ifdef USE_SPI_LIB
+ SDCARD_SPI.endTransaction();
+ #endif
+
+ chipSelectLow();
+
+ // command to go idle in SPI mode
+ while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {
+ unsigned int d = millis() - t0;
+ if (d > SD_INIT_TIMEOUT) {
+ error(SD_CARD_ERROR_CMD0);
+ goto fail;
+ }
+ }
+ // check SD version
+ if ((cardCommand(CMD8, 0x1AA) & R1_ILLEGAL_COMMAND)) {
+ type(SD_CARD_TYPE_SD1);
+ } else {
+ // only need last byte of r7 response
+ for (uint8_t i = 0; i < 4; i++) {
+ status_ = spiRec();
+ }
+ if (status_ != 0XAA) {
+ error(SD_CARD_ERROR_CMD8);
+ goto fail;
+ }
+ type(SD_CARD_TYPE_SD2);
+ }
+ // initialize card and send host supports SDHC if SD2
+ arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;
+
+ while ((status_ = cardAcmd(ACMD41, arg)) != R1_READY_STATE) {
+ // check for timeout
+ unsigned int d = millis() - t0;
+ if (d > SD_INIT_TIMEOUT) {
+ error(SD_CARD_ERROR_ACMD41);
+ goto fail;
+ }
+ }
+ // if SD2 read OCR register to check for SDHC card
+ if (type() == SD_CARD_TYPE_SD2) {
+ if (cardCommand(CMD58, 0)) {
+ error(SD_CARD_ERROR_CMD58);
+ goto fail;
+ }
+ if ((spiRec() & 0XC0) == 0XC0) {
+ type(SD_CARD_TYPE_SDHC);
+ }
+ // discard rest of ocr - contains allowed voltage range
+ for (uint8_t i = 0; i < 3; i++) {
+ spiRec();
+ }
+ }
+ chipSelectHigh();
+
+ #ifndef SOFTWARE_SPI
+ return setSckRate(sckRateID);
+ #else // SOFTWARE_SPI
+ return true;
+ #endif // SOFTWARE_SPI
+
+fail:
+ chipSelectHigh();
+ return false;
+}
+//------------------------------------------------------------------------------
+/**
+ Enable or disable partial block reads.
+
+ Enabling partial block reads improves performance by allowing a block
+ to be read over the SPI bus as several sub-blocks. Errors may occur
+ if the time between reads is too long since the SD card may timeout.
+ The SPI SS line will be held low until the entire block is read or
+ readEnd() is called.
+
+ Use this for applications like the Adafruit Wave Shield.
+
+ \param[in] value The value TRUE (non-zero) or FALSE (zero).)
+*/
+void Sd2Card::partialBlockRead(uint8_t value) {
+ readEnd();
+ partialBlockRead_ = value;
+}
+//------------------------------------------------------------------------------
+/**
+ Read a 512 byte block from an SD card device.
+
+ \param[in] block Logical block to be read.
+ \param[out] dst Pointer to the location that will receive the data.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::readBlock(uint32_t block, uint8_t* dst) {
+ return readData(block, 0, 512, dst);
+}
+//------------------------------------------------------------------------------
+/**
+ Read part of a 512 byte block from an SD card.
+
+ \param[in] block Logical block to be read.
+ \param[in] offset Number of bytes to skip at start of block
+ \param[out] dst Pointer to the location that will receive the data.
+ \param[in] count Number of bytes to read
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::readData(uint32_t block,
+ uint16_t offset, uint16_t count, uint8_t* dst) {
+ if (count == 0) {
+ return true;
+ }
+ if ((count + offset) > 512) {
+ goto fail;
+ }
+ if (!inBlock_ || block != block_ || offset < offset_) {
+ block_ = block;
+ // use address if not SDHC card
+ if (type() != SD_CARD_TYPE_SDHC) {
+ block <<= 9;
+ }
+ if (cardCommand(CMD17, block)) {
+ error(SD_CARD_ERROR_CMD17);
+ goto fail;
+ }
+ if (!waitStartBlock()) {
+ goto fail;
+ }
+ offset_ = 0;
+ inBlock_ = 1;
+ }
+
+ #ifdef OPTIMIZE_HARDWARE_SPI
+ // start first spi transfer
+ SPDR = 0XFF;
+
+ // skip data before offset
+ for (; offset_ < offset; offset_++) {
+ while (!(SPSR & (1 << SPIF)))
+ ;
+ SPDR = 0XFF;
+ }
+ // transfer data
+ n = count - 1;
+ for (uint16_t i = 0; i < n; i++) {
+ while (!(SPSR & (1 << SPIF)))
+ ;
+ dst[i] = SPDR;
+ SPDR = 0XFF;
+ }
+ // wait for last byte
+ while (!(SPSR & (1 << SPIF)))
+ ;
+ dst[n] = SPDR;
+
+ #else // OPTIMIZE_HARDWARE_SPI
+
+ // skip data before offset
+ for (; offset_ < offset; offset_++) {
+ spiRec();
+ }
+ // transfer data
+ for (uint16_t i = 0; i < count; i++) {
+ dst[i] = spiRec();
+ }
+ #endif // OPTIMIZE_HARDWARE_SPI
+
+ offset_ += count;
+ if (!partialBlockRead_ || offset_ >= 512) {
+ // read rest of data, checksum and set chip select high
+ readEnd();
+ }
+ return true;
+
+fail:
+ chipSelectHigh();
+ return false;
+}
+//------------------------------------------------------------------------------
+/** Skip remaining data in a block when in partial block read mode. */
+void Sd2Card::readEnd(void) {
+ if (inBlock_) {
+ // skip data and crc
+ #ifdef OPTIMIZE_HARDWARE_SPI
+ // optimize skip for hardware
+ SPDR = 0XFF;
+ while (offset_++ < 513) {
+ while (!(SPSR & (1 << SPIF)))
+ ;
+ SPDR = 0XFF;
+ }
+ // wait for last crc byte
+ while (!(SPSR & (1 << SPIF)))
+ ;
+ #else // OPTIMIZE_HARDWARE_SPI
+ while (offset_++ < 514) {
+ spiRec();
+ }
+ #endif // OPTIMIZE_HARDWARE_SPI
+ chipSelectHigh();
+ inBlock_ = 0;
+ }
+}
+//------------------------------------------------------------------------------
+/** read CID or CSR register */
+uint8_t Sd2Card::readRegister(uint8_t cmd, void* buf) {
+ uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
+ if (cardCommand(cmd, 0)) {
+ error(SD_CARD_ERROR_READ_REG);
+ goto fail;
+ }
+ if (!waitStartBlock()) {
+ goto fail;
+ }
+ // transfer data
+ for (uint16_t i = 0; i < 16; i++) {
+ dst[i] = spiRec();
+ }
+ spiRec(); // get first crc byte
+ spiRec(); // get second crc byte
+ chipSelectHigh();
+ return true;
+
+fail:
+ chipSelectHigh();
+ return false;
+}
+//------------------------------------------------------------------------------
+/**
+ Set the SPI clock rate.
+
+ \param[in] sckRateID A value in the range [0, 6].
+
+ The SPI clock will be set to F_CPU/pow(2, 1 + sckRateID). The maximum
+ SPI rate is F_CPU/2 for \a sckRateID = 0 and the minimum rate is F_CPU/128
+ for \a scsRateID = 6.
+
+ \return The value one, true, is returned for success and the value zero,
+ false, is returned for an invalid value of \a sckRateID.
+*/
+uint8_t Sd2Card::setSckRate(uint8_t sckRateID) {
+ if (sckRateID > 6) {
+ error(SD_CARD_ERROR_SCK_RATE);
+ return false;
+ }
+ #ifndef USE_SPI_LIB
+ // see avr processor datasheet for SPI register bit definitions
+ if ((sckRateID & 1) || sckRateID == 6) {
+ SPSR &= ~(1 << SPI2X);
+ } else {
+ SPSR |= (1 << SPI2X);
+ }
+ SPCR &= ~((1 << SPR1) | (1 << SPR0));
+ SPCR |= (sckRateID & 4 ? (1 << SPR1) : 0)
+ | (sckRateID & 2 ? (1 << SPR0) : 0);
+ #else // USE_SPI_LIB
+ switch (sckRateID) {
+ case 0: settings = SPISettings(25000000, MSBFIRST, SPI_MODE0); break;
+ case 1: settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); break;
+ case 2: settings = SPISettings(2000000, MSBFIRST, SPI_MODE0); break;
+ case 3: settings = SPISettings(1000000, MSBFIRST, SPI_MODE0); break;
+ case 4: settings = SPISettings(500000, MSBFIRST, SPI_MODE0); break;
+ case 5: settings = SPISettings(250000, MSBFIRST, SPI_MODE0); break;
+ default: settings = SPISettings(125000, MSBFIRST, SPI_MODE0);
+ }
+ #endif // USE_SPI_LIB
+ return true;
+}
+#ifdef USE_SPI_LIB
+//------------------------------------------------------------------------------
+// set the SPI clock frequency
+uint8_t Sd2Card::setSpiClock(uint32_t clock) {
+ settings = SPISettings(clock, MSBFIRST, SPI_MODE0);
+ return true;
+}
+#endif
+//------------------------------------------------------------------------------
+// wait for card to go not busy
+uint8_t Sd2Card::waitNotBusy(unsigned int timeoutMillis) {
+ unsigned int t0 = millis();
+ unsigned int d;
+ do {
+ if (spiRec() == 0XFF) {
+ return true;
+ }
+ d = millis() - t0;
+ } while (d < timeoutMillis);
+ return false;
+}
+//------------------------------------------------------------------------------
+/** Wait for start block token */
+uint8_t Sd2Card::waitStartBlock(void) {
+ unsigned int t0 = millis();
+ while ((status_ = spiRec()) == 0XFF) {
+ unsigned int d = millis() - t0;
+ if (d > SD_READ_TIMEOUT) {
+ error(SD_CARD_ERROR_READ_TIMEOUT);
+ goto fail;
+ }
+ }
+ if (status_ != DATA_START_BLOCK) {
+ error(SD_CARD_ERROR_READ);
+ goto fail;
+ }
+ return true;
+
+fail:
+ chipSelectHigh();
+ return false;
+}
+//------------------------------------------------------------------------------
+/**
+ Writes a 512 byte block to an SD card.
+
+ \param[in] blockNumber Logical block to be written.
+ \param[in] src Pointer to the location of the data to be written.
+ \param[in] blocking If the write should be blocking.
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src, uint8_t blocking) {
+ #if SD_PROTECT_BLOCK_ZERO
+ // don't allow write to first block
+ if (blockNumber == 0) {
+ error(SD_CARD_ERROR_WRITE_BLOCK_ZERO);
+ goto fail;
+ }
+ #endif // SD_PROTECT_BLOCK_ZERO
+
+ // use address if not SDHC card
+ if (type() != SD_CARD_TYPE_SDHC) {
+ blockNumber <<= 9;
+ }
+ if (cardCommand(CMD24, blockNumber)) {
+ error(SD_CARD_ERROR_CMD24);
+ goto fail;
+ }
+ if (!writeData(DATA_START_BLOCK, src)) {
+ goto fail;
+ }
+ if (blocking) {
+ // wait for flash programming to complete
+ if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+ error(SD_CARD_ERROR_WRITE_TIMEOUT);
+ goto fail;
+ }
+ // response is r2 so get and check two bytes for nonzero
+ if (cardCommand(CMD13, 0) || spiRec()) {
+ error(SD_CARD_ERROR_WRITE_PROGRAMMING);
+ goto fail;
+ }
+ }
+ chipSelectHigh();
+ return true;
+
+fail:
+ chipSelectHigh();
+ return false;
+}
+//------------------------------------------------------------------------------
+/** Write one data block in a multiple block write sequence */
+uint8_t Sd2Card::writeData(const uint8_t* src) {
+ // wait for previous write to finish
+ if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+ error(SD_CARD_ERROR_WRITE_MULTIPLE);
+ chipSelectHigh();
+ return false;
+ }
+ return writeData(WRITE_MULTIPLE_TOKEN, src);
+}
+//------------------------------------------------------------------------------
+// send one block of data for write block or write multiple blocks
+uint8_t Sd2Card::writeData(uint8_t token, const uint8_t* src) {
+ #ifdef OPTIMIZE_HARDWARE_SPI
+
+ // send data - optimized loop
+ SPDR = token;
+
+ // send two byte per iteration
+ for (uint16_t i = 0; i < 512; i += 2) {
+ while (!(SPSR & (1 << SPIF)))
+ ;
+ SPDR = src[i];
+ while (!(SPSR & (1 << SPIF)))
+ ;
+ SPDR = src[i + 1];
+ }
+
+ // wait for last data byte
+ while (!(SPSR & (1 << SPIF)))
+ ;
+
+ #else // OPTIMIZE_HARDWARE_SPI
+ spiSend(token);
+ for (uint16_t i = 0; i < 512; i++) {
+ spiSend(src[i]);
+ }
+ #endif // OPTIMIZE_HARDWARE_SPI
+ spiSend(0xff); // dummy crc
+ spiSend(0xff); // dummy crc
+
+ status_ = spiRec();
+ if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
+ error(SD_CARD_ERROR_WRITE);
+ chipSelectHigh();
+ return false;
+ }
+ return true;
+}
+//------------------------------------------------------------------------------
+/** Start a write multiple blocks sequence.
+
+ \param[in] blockNumber Address of first block in sequence.
+ \param[in] eraseCount The number of blocks to be pre-erased.
+
+ \note This function is used with writeData() and writeStop()
+ for optimized multiple block writes.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount) {
+ #if SD_PROTECT_BLOCK_ZERO
+ // don't allow write to first block
+ if (blockNumber == 0) {
+ error(SD_CARD_ERROR_WRITE_BLOCK_ZERO);
+ goto fail;
+ }
+ #endif // SD_PROTECT_BLOCK_ZERO
+ // send pre-erase count
+ if (cardAcmd(ACMD23, eraseCount)) {
+ error(SD_CARD_ERROR_ACMD23);
+ goto fail;
+ }
+ // use address if not SDHC card
+ if (type() != SD_CARD_TYPE_SDHC) {
+ blockNumber <<= 9;
+ }
+ if (cardCommand(CMD25, blockNumber)) {
+ error(SD_CARD_ERROR_CMD25);
+ goto fail;
+ }
+ return true;
+
+fail:
+ chipSelectHigh();
+ return false;
+}
+//------------------------------------------------------------------------------
+/** End a write multiple blocks sequence.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::writeStop(void) {
+ if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+ goto fail;
+ }
+ spiSend(STOP_TRAN_TOKEN);
+ if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+ goto fail;
+ }
+ chipSelectHigh();
+ return true;
+
+fail:
+ error(SD_CARD_ERROR_STOP_TRAN);
+ chipSelectHigh();
+ return false;
+}
+//------------------------------------------------------------------------------
+/** Check if the SD card is busy
+
+ \return The value one, true, is returned when is busy and
+ the value zero, false, is returned for when is NOT busy.
+*/
+uint8_t Sd2Card::isBusy(void) {
+ chipSelectLow();
+ byte b = spiRec();
+ chipSelectHigh();
+
+ return (b != 0XFF);
+}
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/Sd2Card.h
b/arduino/ForceSensorTFT/libraries/SD/src/utility/Sd2Card.h
new file mode 100644
index 000000000..5d91ebf51
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/Sd2Card.h
@@ -0,0 +1,273 @@
+/* Arduino Sd2Card Library
+ Copyright (C) 2009 by William Greiman
+
+ This file is part of the Arduino Sd2Card Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino Sd2Card Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+#ifndef Sd2Card_h
+#define Sd2Card_h
+/**
+ \file
+ Sd2Card class
+*/
+#include "Sd2PinMap.h"
+#include "SdInfo.h"
+/** Set SCK to max rate of F_CPU/2. See Sd2Card::setSckRate(). */
+uint8_t const SPI_FULL_SPEED = 0;
+/** Set SCK rate to F_CPU/4. See Sd2Card::setSckRate(). */
+uint8_t const SPI_HALF_SPEED = 1;
+/** Set SCK rate to F_CPU/8. Sd2Card::setSckRate(). */
+uint8_t const SPI_QUARTER_SPEED = 2;
+/**
+ USE_SPI_LIB: if set, use the SPI library bundled with Arduino IDE, otherwise
+ run with a standalone driver for AVR.
+*/
+#define USE_SPI_LIB
+/**
+ Define MEGA_SOFT_SPI non-zero to use software SPI on Mega Arduinos.
+ Pins used are SS 10, MOSI 11, MISO 12, and SCK 13.
+
+ MEGA_SOFT_SPI allows an unmodified Adafruit GPS Shield to be used
+ on Mega Arduinos. Software SPI works well with GPS Shield V1.1
+ but many SD cards will fail with GPS Shield V1.0.
+*/
+#define MEGA_SOFT_SPI 0
+//------------------------------------------------------------------------------
+#if MEGA_SOFT_SPI && (defined(__AVR_ATmega1280__)||defined(__AVR_ATmega2560__))
+ #define SOFTWARE_SPI
+#endif // MEGA_SOFT_SPI
+//------------------------------------------------------------------------------
+// SPI pin definitions
+//
+#ifndef SOFTWARE_SPI
+ // hardware pin defs
+
+ // include pins_arduino.h or variant.h depending on architecture, via Arduino.h
+ #include <Arduino.h>
+
+ /**
+ SD Chip Select pin
+
+ Warning if this pin is redefined the hardware SS will pin will be enabled
+ as an output by init(). An avr processor will not function as an SPI
+ master unless SS is set to output mode.
+ */
+ #ifndef SDCARD_SS_PIN
+ /** The default chip select pin for the SD card is SS. */
+ uint8_t const SD_CHIP_SELECT_PIN = SS;
+ #else
+ uint8_t const SD_CHIP_SELECT_PIN = SDCARD_SS_PIN;
+ #endif
+
+ // The following three pins must not be redefined for hardware SPI,
+ // so ensure that they are taken from pins_arduino.h or variant.h, depending on architecture.
+ #ifndef SDCARD_MOSI_PIN
+ /** SPI Master Out Slave In pin */
+ uint8_t const SPI_MOSI_PIN = MOSI;
+ /** SPI Master In Slave Out pin */
+ uint8_t const SPI_MISO_PIN = MISO;
+ /** SPI Clock pin */
+ uint8_t const SPI_SCK_PIN = SCK;
+ #else
+ uint8_t const SPI_MOSI_PIN = SDCARD_MOSI_PIN;
+ uint8_t const SPI_MISO_PIN = SDCARD_MISO_PIN;
+ uint8_t const SPI_SCK_PIN = SDCARD_SCK_PIN;
+ #endif
+
+ /** optimize loops for hardware SPI */
+ #ifndef USE_SPI_LIB
+ #define OPTIMIZE_HARDWARE_SPI
+ #endif
+
+#else // SOFTWARE_SPI
+ // define software SPI pins so Mega can use unmodified GPS Shield
+ /** SPI chip select pin */
+ uint8_t const SD_CHIP_SELECT_PIN = 10;
+ /** SPI Master Out Slave In pin */
+ uint8_t const SPI_MOSI_PIN = 11;
+ /** SPI Master In Slave Out pin */
+ uint8_t const SPI_MISO_PIN = 12;
+ /** SPI Clock pin */
+ uint8_t const SPI_SCK_PIN = 13;
+#endif // SOFTWARE_SPI
+//------------------------------------------------------------------------------
+/** Protect block zero from write if nonzero */
+#define SD_PROTECT_BLOCK_ZERO 1
+/** init timeout ms */
+unsigned int const SD_INIT_TIMEOUT = 2000;
+/** erase timeout ms */
+unsigned int const SD_ERASE_TIMEOUT = 10000;
+/** read timeout ms */
+unsigned int const SD_READ_TIMEOUT = 300;
+/** write time out ms */
+unsigned int const SD_WRITE_TIMEOUT = 600;
+//------------------------------------------------------------------------------
+// SD card errors
+/** timeout error for command CMD0 */
+uint8_t const SD_CARD_ERROR_CMD0 = 0X1;
+/** CMD8 was not accepted - not a valid SD card*/
+uint8_t const SD_CARD_ERROR_CMD8 = 0X2;
+/** card returned an error response for CMD17 (read block) */
+uint8_t const SD_CARD_ERROR_CMD17 = 0X3;
+/** card returned an error response for CMD24 (write block) */
+uint8_t const SD_CARD_ERROR_CMD24 = 0X4;
+/** WRITE_MULTIPLE_BLOCKS command failed */
+uint8_t const SD_CARD_ERROR_CMD25 = 0X05;
+/** card returned an error response for CMD58 (read OCR) */
+uint8_t const SD_CARD_ERROR_CMD58 = 0X06;
+/** SET_WR_BLK_ERASE_COUNT failed */
+uint8_t const SD_CARD_ERROR_ACMD23 = 0X07;
+/** card's ACMD41 initialization process timeout */
+uint8_t const SD_CARD_ERROR_ACMD41 = 0X08;
+/** card returned a bad CSR version field */
+uint8_t const SD_CARD_ERROR_BAD_CSD = 0X09;
+/** erase block group command failed */
+uint8_t const SD_CARD_ERROR_ERASE = 0X0A;
+/** card not capable of single block erase */
+uint8_t const SD_CARD_ERROR_ERASE_SINGLE_BLOCK = 0X0B;
+/** Erase sequence timed out */
+uint8_t const SD_CARD_ERROR_ERASE_TIMEOUT = 0X0C;
+/** card returned an error token instead of read data */
+uint8_t const SD_CARD_ERROR_READ = 0X0D;
+/** read CID or CSD failed */
+uint8_t const SD_CARD_ERROR_READ_REG = 0X0E;
+/** timeout while waiting for start of read data */
+uint8_t const SD_CARD_ERROR_READ_TIMEOUT = 0X0F;
+/** card did not accept STOP_TRAN_TOKEN */
+uint8_t const SD_CARD_ERROR_STOP_TRAN = 0X10;
+/** card returned an error token as a response to a write operation */
+uint8_t const SD_CARD_ERROR_WRITE = 0X11;
+/** attempt to write protected block zero */
+uint8_t const SD_CARD_ERROR_WRITE_BLOCK_ZERO = 0X12;
+/** card did not go ready for a multiple block write */
+uint8_t const SD_CARD_ERROR_WRITE_MULTIPLE = 0X13;
+/** card returned an error to a CMD13 status check after a write */
+uint8_t const SD_CARD_ERROR_WRITE_PROGRAMMING = 0X14;
+/** timeout occurred during write programming */
+uint8_t const SD_CARD_ERROR_WRITE_TIMEOUT = 0X15;
+/** incorrect rate selected */
+uint8_t const SD_CARD_ERROR_SCK_RATE = 0X16;
+//------------------------------------------------------------------------------
+// card types
+/** Standard capacity V1 SD card */
+uint8_t const SD_CARD_TYPE_SD1 = 1;
+/** Standard capacity V2 SD card */
+uint8_t const SD_CARD_TYPE_SD2 = 2;
+/** High Capacity SD card */
+uint8_t const SD_CARD_TYPE_SDHC = 3;
+//------------------------------------------------------------------------------
+/**
+ \class Sd2Card
+ \brief Raw access to SD and SDHC flash memory cards.
+*/
+class Sd2Card {
+ public:
+ /** Construct an instance of Sd2Card. */
+ Sd2Card(void) : errorCode_(0), inBlock_(0), partialBlockRead_(0), type_(0) {}
+ uint32_t cardSize(void);
+ uint8_t erase(uint32_t firstBlock, uint32_t lastBlock);
+ uint8_t eraseSingleBlockEnable(void);
+ /**
+ \return error code for last error. See Sd2Card.h for a list of error codes.
+ */
+ uint8_t errorCode(void) const {
+ return errorCode_;
+ }
+ /** \return error data for last error. */
+ uint8_t errorData(void) const {
+ return status_;
+ }
+ /**
+ Initialize an SD flash memory card with default clock rate and chip
+ select pin. See sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin).
+ */
+ uint8_t init(void) {
+ return init(SPI_FULL_SPEED, SD_CHIP_SELECT_PIN);
+ }
+ /**
+ Initialize an SD flash memory card with the selected SPI clock rate
+ and the default SD chip select pin.
+ See sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin).
+ */
+ uint8_t init(uint8_t sckRateID) {
+ return init(sckRateID, SD_CHIP_SELECT_PIN);
+ }
+ uint8_t init(uint8_t sckRateID, uint8_t chipSelectPin);
+ void partialBlockRead(uint8_t value);
+ /** Returns the current value, true or false, for partial block read. */
+ uint8_t partialBlockRead(void) const {
+ return partialBlockRead_;
+ }
+ uint8_t readBlock(uint32_t block, uint8_t* dst);
+ uint8_t readData(uint32_t block,
+ uint16_t offset, uint16_t count, uint8_t* dst);
+ /**
+ Read a cards CID register. The CID contains card identification
+ information such as Manufacturer ID, Product name, Product serial
+ number and Manufacturing date. */
+ uint8_t readCID(cid_t* cid) {
+ return readRegister(CMD10, cid);
+ }
+ /**
+ Read a cards CSD register. The CSD contains Card-Specific Data that
+ provides information regarding access to the card's contents. */
+ uint8_t readCSD(csd_t* csd) {
+ return readRegister(CMD9, csd);
+ }
+ void readEnd(void);
+ uint8_t setSckRate(uint8_t sckRateID);
+ #ifdef USE_SPI_LIB
+ uint8_t setSpiClock(uint32_t clock);
+ #endif
+ /** Return the card type: SD V1, SD V2 or SDHC */
+ uint8_t type(void) const {
+ return type_;
+ }
+ uint8_t writeBlock(uint32_t blockNumber, const uint8_t* src, uint8_t blocking = 1);
+ uint8_t writeData(const uint8_t* src);
+ uint8_t writeStart(uint32_t blockNumber, uint32_t eraseCount);
+ uint8_t writeStop(void);
+ uint8_t isBusy(void);
+ private:
+ uint32_t block_;
+ uint8_t chipSelectPin_;
+ uint8_t errorCode_;
+ uint8_t inBlock_;
+ uint16_t offset_;
+ uint8_t partialBlockRead_;
+ uint8_t status_;
+ uint8_t type_;
+ // private functions
+ uint8_t cardAcmd(uint8_t cmd, uint32_t arg) {
+ cardCommand(CMD55, 0);
+ return cardCommand(cmd, arg);
+ }
+ uint8_t cardCommand(uint8_t cmd, uint32_t arg);
+ void error(uint8_t code) {
+ errorCode_ = code;
+ }
+ uint8_t readRegister(uint8_t cmd, void* buf);
+ uint8_t sendWriteCommand(uint32_t blockNumber, uint32_t eraseCount);
+ void chipSelectHigh(void);
+ void chipSelectLow(void);
+ void type(uint8_t value) {
+ type_ = value;
+ }
+ uint8_t waitNotBusy(unsigned int timeoutMillis);
+ uint8_t writeData(uint8_t token, const uint8_t* src);
+ uint8_t waitStartBlock(void);
+};
+#endif // Sd2Card_h
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/Sd2PinMap.h
b/arduino/ForceSensorTFT/libraries/SD/src/utility/Sd2PinMap.h
new file mode 100644
index 000000000..0609ffe33
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/Sd2PinMap.h
@@ -0,0 +1,525 @@
+/* Arduino SdFat Library
+ Copyright (C) 2010 by William Greiman
+
+ This file is part of the Arduino SdFat Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino SdFat Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+#if defined(__arm__) // Arduino Due Board follows
+
+#ifndef Sd2PinMap_h
+ #define Sd2PinMap_h
+
+ #include <Arduino.h>
+
+ uint8_t const SS_PIN = SS;
+ uint8_t const MOSI_PIN = MOSI;
+ uint8_t const MISO_PIN = MISO;
+ uint8_t const SCK_PIN = SCK;
+
+#endif // Sd2PinMap_h
+
+#elif defined(__AVR_ATmega4809__) // Arduino UNO WiFI Rev2 follows
+
+#ifndef Sd2PinMap_h
+ #define Sd2PinMap_h
+
+ #include <Arduino.h>
+
+ uint8_t const SS_PIN = SS;
+ uint8_t const MOSI_PIN = MOSI;
+ uint8_t const MISO_PIN = MISO;
+ uint8_t const SCK_PIN = SCK;
+
+#endif // Sd2PinMap_h
+
+#elif defined(__AVR__) // Other AVR based Boards follows
+
+// Warning this file was generated by a program.
+#ifndef Sd2PinMap_h
+#define Sd2PinMap_h
+#include <avr/io.h>
+
+//------------------------------------------------------------------------------
+/** struct for mapping digital pins */
+struct pin_map_t {
+ volatile uint8_t* ddr;
+ volatile uint8_t* pin;
+ volatile uint8_t* port;
+ uint8_t bit;
+};
+//------------------------------------------------------------------------------
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+// Mega
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 20;
+uint8_t const SCL_PIN = 21;
+
+// SPI port
+uint8_t const SS_PIN = 53;
+uint8_t const MOSI_PIN = 51;
+uint8_t const MISO_PIN = 50;
+uint8_t const SCK_PIN = 52;
+
+static const pin_map_t digitalPinMap[] = {
+ {&DDRE, &PINE, &PORTE, 0}, // E0 0
+ {&DDRE, &PINE, &PORTE, 1}, // E1 1
+ {&DDRE, &PINE, &PORTE, 4}, // E4 2
+ {&DDRE, &PINE, &PORTE, 5}, // E5 3
+ {&DDRG, &PING, &PORTG, 5}, // G5 4
+ {&DDRE, &PINE, &PORTE, 3}, // E3 5
+ {&DDRH, &PINH, &PORTH, 3}, // H3 6
+ {&DDRH, &PINH, &PORTH, 4}, // H4 7
+ {&DDRH, &PINH, &PORTH, 5}, // H5 8
+ {&DDRH, &PINH, &PORTH, 6}, // H6 9
+ {&DDRB, &PINB, &PORTB, 4}, // B4 10
+ {&DDRB, &PINB, &PORTB, 5}, // B5 11
+ {&DDRB, &PINB, &PORTB, 6}, // B6 12
+ {&DDRB, &PINB, &PORTB, 7}, // B7 13
+ {&DDRJ, &PINJ, &PORTJ, 1}, // J1 14
+ {&DDRJ, &PINJ, &PORTJ, 0}, // J0 15
+ {&DDRH, &PINH, &PORTH, 1}, // H1 16
+ {&DDRH, &PINH, &PORTH, 0}, // H0 17
+ {&DDRD, &PIND, &PORTD, 3}, // D3 18
+ {&DDRD, &PIND, &PORTD, 2}, // D2 19
+ {&DDRD, &PIND, &PORTD, 1}, // D1 20
+ {&DDRD, &PIND, &PORTD, 0}, // D0 21
+ {&DDRA, &PINA, &PORTA, 0}, // A0 22
+ {&DDRA, &PINA, &PORTA, 1}, // A1 23
+ {&DDRA, &PINA, &PORTA, 2}, // A2 24
+ {&DDRA, &PINA, &PORTA, 3}, // A3 25
+ {&DDRA, &PINA, &PORTA, 4}, // A4 26
+ {&DDRA, &PINA, &PORTA, 5}, // A5 27
+ {&DDRA, &PINA, &PORTA, 6}, // A6 28
+ {&DDRA, &PINA, &PORTA, 7}, // A7 29
+ {&DDRC, &PINC, &PORTC, 7}, // C7 30
+ {&DDRC, &PINC, &PORTC, 6}, // C6 31
+ {&DDRC, &PINC, &PORTC, 5}, // C5 32
+ {&DDRC, &PINC, &PORTC, 4}, // C4 33
+ {&DDRC, &PINC, &PORTC, 3}, // C3 34
+ {&DDRC, &PINC, &PORTC, 2}, // C2 35
+ {&DDRC, &PINC, &PORTC, 1}, // C1 36
+ {&DDRC, &PINC, &PORTC, 0}, // C0 37
+ {&DDRD, &PIND, &PORTD, 7}, // D7 38
+ {&DDRG, &PING, &PORTG, 2}, // G2 39
+ {&DDRG, &PING, &PORTG, 1}, // G1 40
+ {&DDRG, &PING, &PORTG, 0}, // G0 41
+ {&DDRL, &PINL, &PORTL, 7}, // L7 42
+ {&DDRL, &PINL, &PORTL, 6}, // L6 43
+ {&DDRL, &PINL, &PORTL, 5}, // L5 44
+ {&DDRL, &PINL, &PORTL, 4}, // L4 45
+ {&DDRL, &PINL, &PORTL, 3}, // L3 46
+ {&DDRL, &PINL, &PORTL, 2}, // L2 47
+ {&DDRL, &PINL, &PORTL, 1}, // L1 48
+ {&DDRL, &PINL, &PORTL, 0}, // L0 49
+ {&DDRB, &PINB, &PORTB, 3}, // B3 50
+ {&DDRB, &PINB, &PORTB, 2}, // B2 51
+ {&DDRB, &PINB, &PORTB, 1}, // B1 52
+ {&DDRB, &PINB, &PORTB, 0}, // B0 53
+ {&DDRF, &PINF, &PORTF, 0}, // F0 54
+ {&DDRF, &PINF, &PORTF, 1}, // F1 55
+ {&DDRF, &PINF, &PORTF, 2}, // F2 56
+ {&DDRF, &PINF, &PORTF, 3}, // F3 57
+ {&DDRF, &PINF, &PORTF, 4}, // F4 58
+ {&DDRF, &PINF, &PORTF, 5}, // F5 59
+ {&DDRF, &PINF, &PORTF, 6}, // F6 60
+ {&DDRF, &PINF, &PORTF, 7}, // F7 61
+ {&DDRK, &PINK, &PORTK, 0}, // K0 62
+ {&DDRK, &PINK, &PORTK, 1}, // K1 63
+ {&DDRK, &PINK, &PORTK, 2}, // K2 64
+ {&DDRK, &PINK, &PORTK, 3}, // K3 65
+ {&DDRK, &PINK, &PORTK, 4}, // K4 66
+ {&DDRK, &PINK, &PORTK, 5}, // K5 67
+ {&DDRK, &PINK, &PORTK, 6}, // K6 68
+ {&DDRK, &PINK, &PORTK, 7} // K7 69
+};
+//------------------------------------------------------------------------------
+#elif (defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__)) && defined(CORE_MICRODUINO)
+// Microduino Core+
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 20;
+uint8_t const SCL_PIN = 21;
+
+// SPI port
+uint8_t const SS_PIN = 10;
+uint8_t const MOSI_PIN = 11;
+uint8_t const MISO_PIN = 12;
+uint8_t const SCK_PIN = 13;
+
+static const pin_map_t digitalPinMap[] = {
+ {&DDRD, &PIND, &PORTD, 0}, // D0 PD0
+ {&DDRD, &PIND, &PORTD, 1}, // D1 PD1
+ {&DDRD, &PIND, &PORTD, 2}, // D2 PD2
+ {&DDRD, &PIND, &PORTD, 3}, // D3 PD3
+ {&DDRB, &PINB, &PORTB, 0}, // D4 PB0
+ {&DDRB, &PINB, &PORTB, 1}, // D5 PB1
+ {&DDRB, &PINB, &PORTB, 2}, // D6 PB2
+ {&DDRB, &PINB, &PORTB, 3}, // D7 PB3
+ {&DDRD, &PIND, &PORTD, 6}, // D8 PD6
+ {&DDRD, &PIND, &PORTD, 5}, // D9 PD5
+ {&DDRB, &PINB, &PORTB, 4}, // D10 PB4
+ {&DDRB, &PINB, &PORTB, 5}, // D11 PB5
+ {&DDRB, &PINB, &PORTB, 6}, // D12 PB6
+ {&DDRB, &PINB, &PORTB, 7}, // D13 PB7
+ {&DDRC, &PINC, &PORTC, 7}, // D14 PC7
+ {&DDRC, &PINC, &PORTC, 6}, // D15 PC6
+ {&DDRC, &PINC, &PORTC, 5}, // D16 PC5
+ {&DDRC, &PINC, &PORTC, 4}, // D17 PC4
+ {&DDRC, &PINC, &PORTC, 3}, // D18 PC3
+ {&DDRC, &PINC, &PORTC, 2}, // D19 PC2
+ {&DDRC, &PINC, &PORTC, 1}, // D20 PC1
+ {&DDRC, &PINC, &PORTC, 0}, // D21 PC0
+ {&DDRD, &PIND, &PORTD, 4}, // D22 PD4
+ {&DDRD, &PIND, &PORTD, 7}, // D23 PD7
+ {&DDRA, &PINA, &PORTA, 7}, // D24 PA7
+ {&DDRA, &PINA, &PORTA, 6}, // D25 PA6
+ {&DDRA, &PINA, &PORTA, 5}, // D26 PA5
+ {&DDRA, &PINA, &PORTA, 4}, // D27 PA4
+ {&DDRA, &PINA, &PORTA, 3}, // D28 PA3
+ {&DDRA, &PINA, &PORTA, 2}, // D29 PA2
+ {&DDRA, &PINA, &PORTA, 1}, // D30 PA1
+ {&DDRA, &PINA, &PORTA, 0} // D31 PA0
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_ATmega128RFA1__) && defined(CORE_MICRODUINO)
+// Microduino Core RF
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 18;
+uint8_t const SCL_PIN = 19;
+
+// SPI port
+uint8_t const SS_PIN = 10;
+uint8_t const MOSI_PIN = 11;
+uint8_t const MISO_PIN = 12;
+uint8_t const SCK_PIN = 13;
+
+static const pin_map_t digitalPinMap[] = {
+ {&DDRD, &PINE, &PORTE, 0}, // D0 PE0
+ {&DDRD, &PINE, &PORTE, 1}, // D1 PE1
+ {&DDRD, &PIND, &PORTD, 2}, // D2 PD2
+ {&DDRD, &PIND, &PORTD, 3}, // D3 PD3
+ {&DDRB, &PINE, &PORTE, 3}, // D4 PE3
+ {&DDRB, &PINE, &PORTE, 4}, // D5 PE4
+ {&DDRB, &PINE, &PORTE, 5}, // D6 PE5
+ {&DDRB, &PINB, &PORTB, 7}, // D7 PB7
+ {&DDRD, &PINB, &PORTB, 6}, // D8 PB6
+ {&DDRD, &PINB, &PORTB, 5}, // D9 PB5
+ {&DDRB, &PINB, &PORTB, 4}, // D10 PB4
+ {&DDRB, &PINB, &PORTB, 2}, // D11 PB2
+ {&DDRB, &PINB, &PORTB, 3}, // D12 PB3
+ {&DDRB, &PINB, &PORTB, 1}, // D13 PB1
+ {&DDRF, &PINF, &PORTF, 7}, // D14 PF7
+ {&DDRF, &PINF, &PORTF, 6}, // D15 PF6
+ {&DDRF, &PINF, &PORTF, 5}, // D16 PF5
+ {&DDRF, &PINF, &PORTF, 4}, // D17 PF4
+ {&DDRD, &PIND, &PORTD, 1}, // D18 PD1
+ {&DDRD, &PIND, &PORTD, 0}, // D19 PD0
+ {&DDRF, &PINF, &PORTF, 3}, // D20 PF3
+ {&DDRF, &PINF, &PORTF, 2}, // D21 PF2
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_ATmega32U4__) && defined(CORE_MICRODUINO)
+// Microduino Core USB
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 18;
+uint8_t const SCL_PIN = 19;
+
+// SPI port
+uint8_t const SS_PIN = 10;
+uint8_t const MOSI_PIN = 11;
+uint8_t const MISO_PIN = 12;
+uint8_t const SCK_PIN = 13;
+
+static const pin_map_t digitalPinMap[] = {
+ {&DDRD, &PIND, &PORTD, 2}, // D0 - PD2
+ {&DDRD, &PIND, &PORTD, 3}, // D1 - PD3
+ {&DDRE, &PINE, &PORTE, 6}, // D2 - PE6
+ {&DDRD, &PIND, &PORTD, 6}, // D3 - PD6
+ {&DDRD, &PIND, &PORTD, 7}, // D4 - PD7
+ {&DDRC, &PINC, &PORTC, 6}, // D5 - PC6
+ {&DDRC, &PINC, &PORTC, 7}, // D6 - PC7
+ {&DDRE, &PINE, &PORTE, 7}, // D7 - PE7
+ {&DDRB, &PINB, &PORTB, 6}, // D8 - PB6
+ {&DDRB, &PINB, &PORTB, 5}, // D9 - PB5
+ {&DDRB, &PINB, &PORTB, 0}, // D10 - PB0
+ {&DDRB, &PINB, &PORTB, 2}, // D11 - MOSI - PB2
+ {&DDRB, &PINB, &PORTB, 3}, // D12 -MISO - PB3
+ {&DDRB, &PINB, &PORTB, 1}, // D13 -SCK - PB1
+ {&DDRF, &PINF, &PORTF, 7}, // D14 - A0 - PF7
+ {&DDRF, &PINF, &PORTF, 6}, // D15 - A1 - PF6
+ {&DDRF, &PINF, &PORTF, 5}, // D16 - A2 - PF5
+ {&DDRF, &PINF, &PORTF, 4}, // D17 - A3 - PF4
+ {&DDRD, &PIND, &PORTD, 1}, // D18 - PD1
+ {&DDRD, &PIND, &PORTD, 0}, // D19 - PD0
+ {&DDRF, &PINF, &PORTF, 1}, // D20 - A6 - PF1
+ {&DDRF, &PINF, &PORTF, 0}, // D21 - A7 - PF0
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)
+// Sanguino
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 17;
+uint8_t const SCL_PIN = 18;
+
+// SPI port
+uint8_t const SS_PIN = 4;
+uint8_t const MOSI_PIN = 5;
+uint8_t const MISO_PIN = 6;
+uint8_t const SCK_PIN = 7;
+
+static const pin_map_t digitalPinMap[] = {
+ {&DDRB, &PINB, &PORTB, 0}, // B0 0
+ {&DDRB, &PINB, &PORTB, 1}, // B1 1
+ {&DDRB, &PINB, &PORTB, 2}, // B2 2
+ {&DDRB, &PINB, &PORTB, 3}, // B3 3
+ {&DDRB, &PINB, &PORTB, 4}, // B4 4
+ {&DDRB, &PINB, &PORTB, 5}, // B5 5
+ {&DDRB, &PINB, &PORTB, 6}, // B6 6
+ {&DDRB, &PINB, &PORTB, 7}, // B7 7
+ {&DDRD, &PIND, &PORTD, 0}, // D0 8
+ {&DDRD, &PIND, &PORTD, 1}, // D1 9
+ {&DDRD, &PIND, &PORTD, 2}, // D2 10
+ {&DDRD, &PIND, &PORTD, 3}, // D3 11
+ {&DDRD, &PIND, &PORTD, 4}, // D4 12
+ {&DDRD, &PIND, &PORTD, 5}, // D5 13
+ {&DDRD, &PIND, &PORTD, 6}, // D6 14
+ {&DDRD, &PIND, &PORTD, 7}, // D7 15
+ {&DDRC, &PINC, &PORTC, 0}, // C0 16
+ {&DDRC, &PINC, &PORTC, 1}, // C1 17
+ {&DDRC, &PINC, &PORTC, 2}, // C2 18
+ {&DDRC, &PINC, &PORTC, 3}, // C3 19
+ {&DDRC, &PINC, &PORTC, 4}, // C4 20
+ {&DDRC, &PINC, &PORTC, 5}, // C5 21
+ {&DDRC, &PINC, &PORTC, 6}, // C6 22
+ {&DDRC, &PINC, &PORTC, 7}, // C7 23
+ {&DDRA, &PINA, &PORTA, 7}, // A7 24
+ {&DDRA, &PINA, &PORTA, 6}, // A6 25
+ {&DDRA, &PINA, &PORTA, 5}, // A5 26
+ {&DDRA, &PINA, &PORTA, 4}, // A4 27
+ {&DDRA, &PINA, &PORTA, 3}, // A3 28
+ {&DDRA, &PINA, &PORTA, 2}, // A2 29
+ {&DDRA, &PINA, &PORTA, 1}, // A1 30
+ {&DDRA, &PINA, &PORTA, 0} // A0 31
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_ATmega32U4__)
+// Leonardo
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 2;
+uint8_t const SCL_PIN = 3;
+
+// SPI port
+uint8_t const SS_PIN = 17;
+uint8_t const MOSI_PIN = 16;
+uint8_t const MISO_PIN = 14;
+uint8_t const SCK_PIN = 15;
+
+static const pin_map_t digitalPinMap[] = {
+ {&DDRD, &PIND, &PORTD, 2}, // D2 0
+ {&DDRD, &PIND, &PORTD, 3}, // D3 1
+ {&DDRD, &PIND, &PORTD, 1}, // D1 2
+ {&DDRD, &PIND, &PORTD, 0}, // D0 3
+ {&DDRD, &PIND, &PORTD, 4}, // D4 4
+ {&DDRC, &PINC, &PORTC, 6}, // C6 5
+ {&DDRD, &PIND, &PORTD, 7}, // D7 6
+ {&DDRE, &PINE, &PORTE, 6}, // E6 7
+ {&DDRB, &PINB, &PORTB, 4}, // B4 8
+ {&DDRB, &PINB, &PORTB, 5}, // B5 9
+ {&DDRB, &PINB, &PORTB, 6}, // B6 10
+ {&DDRB, &PINB, &PORTB, 7}, // B7 11
+ {&DDRD, &PIND, &PORTD, 6}, // D6 12
+ {&DDRC, &PINC, &PORTC, 7}, // C7 13
+ {&DDRB, &PINB, &PORTB, 3}, // B3 14
+ {&DDRB, &PINB, &PORTB, 1}, // B1 15
+ {&DDRB, &PINB, &PORTB, 2}, // B2 16
+ {&DDRB, &PINB, &PORTB, 0}, // B0 17
+ {&DDRF, &PINF, &PORTF, 7}, // F7 18
+ {&DDRF, &PINF, &PORTF, 6}, // F6 19
+ {&DDRF, &PINF, &PORTF, 5}, // F5 20
+ {&DDRF, &PINF, &PORTF, 4}, // F4 21
+ {&DDRF, &PINF, &PORTF, 1}, // F1 22
+ {&DDRF, &PINF, &PORTF, 0}, // F0 23
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)
+// Teensy++ 1.0 & 2.0
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 1;
+uint8_t const SCL_PIN = 0;
+
+// SPI port
+uint8_t const SS_PIN = 20;
+uint8_t const MOSI_PIN = 22;
+uint8_t const MISO_PIN = 23;
+uint8_t const SCK_PIN = 21;
+
+static const pin_map_t digitalPinMap[] = {
+ {&DDRD, &PIND, &PORTD, 0}, // D0 0
+ {&DDRD, &PIND, &PORTD, 1}, // D1 1
+ {&DDRD, &PIND, &PORTD, 2}, // D2 2
+ {&DDRD, &PIND, &PORTD, 3}, // D3 3
+ {&DDRD, &PIND, &PORTD, 4}, // D4 4
+ {&DDRD, &PIND, &PORTD, 5}, // D5 5
+ {&DDRD, &PIND, &PORTD, 6}, // D6 6
+ {&DDRD, &PIND, &PORTD, 7}, // D7 7
+ {&DDRE, &PINE, &PORTE, 0}, // E0 8
+ {&DDRE, &PINE, &PORTE, 1}, // E1 9
+ {&DDRC, &PINC, &PORTC, 0}, // C0 10
+ {&DDRC, &PINC, &PORTC, 1}, // C1 11
+ {&DDRC, &PINC, &PORTC, 2}, // C2 12
+ {&DDRC, &PINC, &PORTC, 3}, // C3 13
+ {&DDRC, &PINC, &PORTC, 4}, // C4 14
+ {&DDRC, &PINC, &PORTC, 5}, // C5 15
+ {&DDRC, &PINC, &PORTC, 6}, // C6 16
+ {&DDRC, &PINC, &PORTC, 7}, // C7 17
+ {&DDRE, &PINE, &PORTE, 6}, // E6 18
+ {&DDRE, &PINE, &PORTE, 7}, // E7 19
+ {&DDRB, &PINB, &PORTB, 0}, // B0 20
+ {&DDRB, &PINB, &PORTB, 1}, // B1 21
+ {&DDRB, &PINB, &PORTB, 2}, // B2 22
+ {&DDRB, &PINB, &PORTB, 3}, // B3 23
+ {&DDRB, &PINB, &PORTB, 4}, // B4 24
+ {&DDRB, &PINB, &PORTB, 5}, // B5 25
+ {&DDRB, &PINB, &PORTB, 6}, // B6 26
+ {&DDRB, &PINB, &PORTB, 7}, // B7 27
+ {&DDRA, &PINA, &PORTA, 0}, // A0 28
+ {&DDRA, &PINA, &PORTA, 1}, // A1 29
+ {&DDRA, &PINA, &PORTA, 2}, // A2 30
+ {&DDRA, &PINA, &PORTA, 3}, // A3 31
+ {&DDRA, &PINA, &PORTA, 4}, // A4 32
+ {&DDRA, &PINA, &PORTA, 5}, // A5 33
+ {&DDRA, &PINA, &PORTA, 6}, // A6 34
+ {&DDRA, &PINA, &PORTA, 7}, // A7 35
+ {&DDRE, &PINE, &PORTE, 4}, // E4 36
+ {&DDRE, &PINE, &PORTE, 5}, // E5 37
+ {&DDRF, &PINF, &PORTF, 0}, // F0 38
+ {&DDRF, &PINF, &PORTF, 1}, // F1 39
+ {&DDRF, &PINF, &PORTF, 2}, // F2 40
+ {&DDRF, &PINF, &PORTF, 3}, // F3 41
+ {&DDRF, &PINF, &PORTF, 4}, // F4 42
+ {&DDRF, &PINF, &PORTF, 5}, // F5 43
+ {&DDRF, &PINF, &PORTF, 6}, // F6 44
+ {&DDRF, &PINF, &PORTF, 7} // F7 45
+};
+//------------------------------------------------------------------------------
+#else // defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+// 168 and 328 Arduinos
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 18;
+uint8_t const SCL_PIN = 19;
+
+// SPI port
+uint8_t const SS_PIN = 10;
+uint8_t const MOSI_PIN = 11;
+uint8_t const MISO_PIN = 12;
+uint8_t const SCK_PIN = 13;
+
+static const pin_map_t digitalPinMap[] = {
+ {&DDRD, &PIND, &PORTD, 0}, // D0 0
+ {&DDRD, &PIND, &PORTD, 1}, // D1 1
+ {&DDRD, &PIND, &PORTD, 2}, // D2 2
+ {&DDRD, &PIND, &PORTD, 3}, // D3 3
+ {&DDRD, &PIND, &PORTD, 4}, // D4 4
+ {&DDRD, &PIND, &PORTD, 5}, // D5 5
+ {&DDRD, &PIND, &PORTD, 6}, // D6 6
+ {&DDRD, &PIND, &PORTD, 7}, // D7 7
+ {&DDRB, &PINB, &PORTB, 0}, // B0 8
+ {&DDRB, &PINB, &PORTB, 1}, // B1 9
+ {&DDRB, &PINB, &PORTB, 2}, // B2 10
+ {&DDRB, &PINB, &PORTB, 3}, // B3 11
+ {&DDRB, &PINB, &PORTB, 4}, // B4 12
+ {&DDRB, &PINB, &PORTB, 5}, // B5 13
+ {&DDRC, &PINC, &PORTC, 0}, // C0 14
+ {&DDRC, &PINC, &PORTC, 1}, // C1 15
+ {&DDRC, &PINC, &PORTC, 2}, // C2 16
+ {&DDRC, &PINC, &PORTC, 3}, // C3 17
+ {&DDRC, &PINC, &PORTC, 4}, // C4 18
+ {&DDRC, &PINC, &PORTC, 5} // C5 19
+};
+#endif // defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+//------------------------------------------------------------------------------
+static const uint8_t digitalPinCount = sizeof(digitalPinMap) / sizeof(pin_map_t);
+
+uint8_t badPinNumber(void)
+__attribute__((error("Pin number is too large or not a constant")));
+
+static inline __attribute__((always_inline))
+uint8_t getPinMode(uint8_t pin) {
+ if (__builtin_constant_p(pin) && pin < digitalPinCount) {
+ return (*digitalPinMap[pin].ddr >> digitalPinMap[pin].bit) & 1;
+ } else {
+ return badPinNumber();
+ }
+}
+static inline __attribute__((always_inline))
+void setPinMode(uint8_t pin, uint8_t mode) {
+ if (__builtin_constant_p(pin) && pin < digitalPinCount) {
+ if (mode) {
+ *digitalPinMap[pin].ddr |= 1 << digitalPinMap[pin].bit;
+ } else {
+ *digitalPinMap[pin].ddr &= ~(1 << digitalPinMap[pin].bit);
+ }
+ } else {
+ badPinNumber();
+ }
+}
+static inline __attribute__((always_inline))
+uint8_t fastDigitalRead(uint8_t pin) {
+ if (__builtin_constant_p(pin) && pin < digitalPinCount) {
+ return (*digitalPinMap[pin].pin >> digitalPinMap[pin].bit) & 1;
+ } else {
+ return badPinNumber();
+ }
+}
+static inline __attribute__((always_inline))
+void fastDigitalWrite(uint8_t pin, uint8_t value) {
+ if (__builtin_constant_p(pin) && pin < digitalPinCount) {
+ if (value) {
+ *digitalPinMap[pin].port |= 1 << digitalPinMap[pin].bit;
+ } else {
+ *digitalPinMap[pin].port &= ~(1 << digitalPinMap[pin].bit);
+ }
+ } else {
+ badPinNumber();
+ }
+}
+#endif // Sd2PinMap_h
+
+#elif defined (__CPU_ARC__)
+
+#if defined (__ARDUINO_ARC__)
+ // Two Wire (aka I2C) ports
+ uint8_t const SDA_PIN = 18;
+ uint8_t const SCL_PIN = 19;
+
+ // SPI port
+ uint8_t const SS_PIN = 10;
+ uint8_t const MOSI_PIN = 11;
+ uint8_t const MISO_PIN = 12;
+ uint8_t const SCK_PIN = 13;
+
+#endif // Arduino ARC
+
+#else
+#error Architecture or board not supported.
+#endif
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFat.h
b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFat.h
new file mode 100644
index 000000000..e57974df8
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFat.h
@@ -0,0 +1,641 @@
+/* Arduino SdFat Library
+ Copyright (C) 2009 by William Greiman
+
+ This file is part of the Arduino SdFat Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino SdFat Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+#ifndef SdFat_h
+#define SdFat_h
+/**
+ \file
+ SdFile and SdVolume classes
+*/
+#if defined (__AVR__) || defined (__CPU_ARC__)
+ #include <avr/pgmspace.h>
+#endif
+#include "Sd2Card.h"
+#include "FatStructs.h"
+#include <Print.h>
+//------------------------------------------------------------------------------
+/**
+ Allow use of deprecated functions if non-zero
+*/
+#define ALLOW_DEPRECATED_FUNCTIONS 1
+//------------------------------------------------------------------------------
+// forward declaration since SdVolume is used in SdFile
+class SdVolume;
+//==============================================================================
+// SdFile class
+
+#ifdef O_RDONLY //ARDUINO_ARCH_MBED
+#undef O_READ
+#undef O_RDONLY
+#undef O_WRITE
+#undef O_WRONLY
+#undef O_RDWR
+#undef O_ACCMODE
+#undef O_APPEND
+#undef O_SYNC
+#undef O_CREAT
+#undef O_EXCL
+#undef O_TRUNC
+#endif
+
+// flags for ls()
+/** ls() flag to print modify date */
+uint8_t const LS_DATE = 1;
+/** ls() flag to print file size */
+uint8_t const LS_SIZE = 2;
+/** ls() flag for recursive list of subdirectories */
+uint8_t const LS_R = 4;
+
+// use the gnu style oflag in open()
+/** open() oflag for reading */
+uint8_t const O_READ = 0X01;
+/** open() oflag - same as O_READ */
+uint8_t const O_RDONLY = O_READ;
+/** open() oflag for write */
+uint8_t const O_WRITE = 0X02;
+/** open() oflag - same as O_WRITE */
+uint8_t const O_WRONLY = O_WRITE;
+/** open() oflag for reading and writing */
+uint8_t const O_RDWR = (O_READ | O_WRITE);
+/** open() oflag mask for access modes */
+uint8_t const O_ACCMODE = (O_READ | O_WRITE);
+/** The file offset shall be set to the end of the file prior to each write. */
+uint8_t const O_APPEND = 0X04;
+/** synchronous writes - call sync() after each write */
+uint8_t const O_SYNC = 0X08;
+/** create the file if nonexistent */
+uint8_t const O_CREAT = 0X10;
+/** If O_CREAT and O_EXCL are set, open() shall fail if the file exists */
+uint8_t const O_EXCL = 0X20;
+/** truncate the file to zero length */
+uint8_t const O_TRUNC = 0X40;
+
+// flags for timestamp
+/** set the file's last access date */
+uint8_t const T_ACCESS = 1;
+/** set the file's creation date and time */
+uint8_t const T_CREATE = 2;
+/** Set the file's write date and time */
+uint8_t const T_WRITE = 4;
+// values for type_
+/** This SdFile has not been opened. */
+uint8_t const FAT_FILE_TYPE_CLOSED = 0;
+/** SdFile for a file */
+uint8_t const FAT_FILE_TYPE_NORMAL = 1;
+/** SdFile for a FAT16 root directory */
+uint8_t const FAT_FILE_TYPE_ROOT16 = 2;
+/** SdFile for a FAT32 root directory */
+uint8_t const FAT_FILE_TYPE_ROOT32 = 3;
+/** SdFile for a subdirectory */
+uint8_t const FAT_FILE_TYPE_SUBDIR = 4;
+/** Test value for directory type */
+uint8_t const FAT_FILE_TYPE_MIN_DIR = FAT_FILE_TYPE_ROOT16;
+
+/** date field for FAT directory entry */
+static inline uint16_t FAT_DATE(uint16_t year, uint8_t month, uint8_t day) {
+ return (year - 1980) << 9 | month << 5 | day;
+}
+/** year part of FAT directory date field */
+static inline uint16_t FAT_YEAR(uint16_t fatDate) {
+ return 1980 + (fatDate >> 9);
+}
+/** month part of FAT directory date field */
+static inline uint8_t FAT_MONTH(uint16_t fatDate) {
+ return (fatDate >> 5) & 0XF;
+}
+/** day part of FAT directory date field */
+static inline uint8_t FAT_DAY(uint16_t fatDate) {
+ return fatDate & 0X1F;
+}
+/** time field for FAT directory entry */
+static inline uint16_t FAT_TIME(uint8_t hour, uint8_t minute, uint8_t second) {
+ return hour << 11 | minute << 5 | second >> 1;
+}
+/** hour part of FAT directory time field */
+static inline uint8_t FAT_HOUR(uint16_t fatTime) {
+ return fatTime >> 11;
+}
+/** minute part of FAT directory time field */
+static inline uint8_t FAT_MINUTE(uint16_t fatTime) {
+ return (fatTime >> 5) & 0X3F;
+}
+/** second part of FAT directory time field */
+static inline uint8_t FAT_SECOND(uint16_t fatTime) {
+ return 2 * (fatTime & 0X1F);
+}
+/** Default date for file timestamps is 1 Jan 2000 */
+uint16_t const FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;
+/** Default time for file timestamp is 1 am */
+uint16_t const FAT_DEFAULT_TIME = (1 << 11);
+//------------------------------------------------------------------------------
+/**
+ \class SdFile
+ \brief Access FAT16 and FAT32 files on SD and SDHC cards.
+*/
+class SdFile : public Print {
+ public:
+ /** Create an instance of SdFile. */
+ SdFile(void) : type_(FAT_FILE_TYPE_CLOSED) {}
+ /**
+ writeError is set to true if an error occurs during a write().
+ Set writeError to false before calling print() and/or write() and check
+ for true after calls to print() and/or write().
+ */
+ //bool writeError;
+ /**
+ Cancel unbuffered reads for this file.
+ See setUnbufferedRead()
+ */
+ void clearUnbufferedRead(void) {
+ flags_ &= ~F_FILE_UNBUFFERED_READ;
+ }
+ uint8_t close(void);
+ uint8_t contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock);
+ uint8_t createContiguous(SdFile* dirFile,
+ const char* fileName, uint32_t size);
+ /** \return The current cluster number for a file or directory. */
+ uint32_t curCluster(void) const {
+ return curCluster_;
+ }
+ /** \return The current position for a file or directory. */
+ uint32_t curPosition(void) const {
+ return curPosition_;
+ }
+ /**
+ Set the date/time callback function
+
+ \param[in] dateTime The user's call back function. The callback
+ function is of the form:
+
+ \code
+ void dateTime(uint16_t* date, uint16_t* time) {
+ uint16_t year;
+ uint8_t month, day, hour, minute, second;
+
+ // User gets date and time from GPS or real-time clock here
+
+ // return date using FAT_DATE macro to format fields
+ * *date = FAT_DATE(year, month, day);
+
+ // return time using FAT_TIME macro to format fields
+ * *time = FAT_TIME(hour, minute, second);
+ }
+ \endcode
+
+ Sets the function that is called when a file is created or when
+ a file's directory entry is modified by sync(). All timestamps,
+ access, creation, and modify, are set when a file is created.
+ sync() maintains the last access date and last modify date/time.
+
+ See the timestamp() function.
+ */
+ static void dateTimeCallback(
+ void (*dateTime)(uint16_t* date, uint16_t* time)) {
+ dateTime_ = dateTime;
+ }
+ /**
+ Cancel the date/time callback function.
+ */
+ static void dateTimeCallbackCancel(void) {
+ // use explicit zero since NULL is not defined for Sanguino
+ dateTime_ = 0;
+ }
+ /** \return Address of the block that contains this file's directory. */
+ uint32_t dirBlock(void) const {
+ return dirBlock_;
+ }
+ uint8_t dirEntry(dir_t* dir);
+ /** \return Index of this file's directory in the block dirBlock. */
+ uint8_t dirIndex(void) const {
+ return dirIndex_;
+ }
+ static void dirName(const dir_t& dir, char* name);
+ /** \return The total number of bytes in a file or directory. */
+ uint32_t fileSize(void) const {
+ return fileSize_;
+ }
+ /** \return The first cluster number for a file or directory. */
+ uint32_t firstCluster(void) const {
+ return firstCluster_;
+ }
+ /** \return True if this is a SdFile for a directory else false. */
+ uint8_t isDir(void) const {
+ return type_ >= FAT_FILE_TYPE_MIN_DIR;
+ }
+ /** \return True if this is a SdFile for a file else false. */
+ uint8_t isFile(void) const {
+ return type_ == FAT_FILE_TYPE_NORMAL;
+ }
+ /** \return True if this is a SdFile for an open file/directory else false. */
+ uint8_t isOpen(void) const {
+ return type_ != FAT_FILE_TYPE_CLOSED;
+ }
+ /** \return True if this is a SdFile for a subdirectory else false. */
+ uint8_t isSubDir(void) const {
+ return type_ == FAT_FILE_TYPE_SUBDIR;
+ }
+ /** \return True if this is a SdFile for the root directory. */
+ uint8_t isRoot(void) const {
+ return type_ == FAT_FILE_TYPE_ROOT16 || type_ == FAT_FILE_TYPE_ROOT32;
+ }
+ void ls(uint8_t flags = 0, uint8_t indent = 0);
+ uint8_t makeDir(SdFile* dir, const char* dirName);
+ uint8_t open(SdFile* dirFile, uint16_t index, uint8_t oflag);
+ uint8_t open(SdFile* dirFile, const char* fileName, uint8_t oflag);
+
+ uint8_t openRoot(SdVolume* vol);
+ static void printDirName(const dir_t& dir, uint8_t width);
+ static void printFatDate(uint16_t fatDate);
+ static void printFatTime(uint16_t fatTime);
+ static void printTwoDigits(uint8_t v);
+ /**
+ Read the next byte from a file.
+
+ \return For success read returns the next byte in the file as an int.
+ If an error occurs or end of file is reached -1 is returned.
+ */
+ int16_t read(void) {
+ uint8_t b;
+ return read(&b, 1) == 1 ? b : -1;
+ }
+ int16_t read(void* buf, uint16_t nbyte);
+ int8_t readDir(dir_t* dir);
+ static uint8_t remove(SdFile* dirFile, const char* fileName);
+ uint8_t remove(void);
+ /** Set the file's current position to zero. */
+ void rewind(void) {
+ curPosition_ = curCluster_ = 0;
+ }
+ uint8_t rmDir(void);
+ uint8_t rmRfStar(void);
+ /** Set the files position to current position + \a pos. See seekSet(). */
+ uint8_t seekCur(uint32_t pos) {
+ return seekSet(curPosition_ + pos);
+ }
+ /**
+ Set the files current position to end of file. Useful to position
+ a file for append. See seekSet().
+ */
+ uint8_t seekEnd(void) {
+ return seekSet(fileSize_);
+ }
+ uint8_t seekSet(uint32_t pos);
+ /**
+ Use unbuffered reads to access this file. Used with Wave
+ Shield ISR. Used with Sd2Card::partialBlockRead() in WaveRP.
+
+ Not recommended for normal applications.
+ */
+ void setUnbufferedRead(void) {
+ if (isFile()) {
+ flags_ |= F_FILE_UNBUFFERED_READ;
+ }
+ }
+ uint8_t timestamp(uint8_t flag, uint16_t year, uint8_t month, uint8_t day,
+ uint8_t hour, uint8_t minute, uint8_t second);
+ uint8_t sync(uint8_t blocking = 1);
+ /** Type of this SdFile. You should use isFile() or isDir() instead of type()
+ if possible.
+
+ \return The file or directory type.
+ */
+ uint8_t type(void) const {
+ return type_;
+ }
+ uint8_t truncate(uint32_t size);
+ /** \return Unbuffered read flag. */
+ uint8_t unbufferedRead(void) const {
+ return flags_ & F_FILE_UNBUFFERED_READ;
+ }
+ /** \return SdVolume that contains this file. */
+ SdVolume* volume(void) const {
+ return vol_;
+ }
+ size_t write(uint8_t b);
+ size_t write(const void* buf, uint16_t nbyte);
+ size_t write(const char* str);
+ #ifdef __AVR__
+ void write_P(PGM_P str);
+ void writeln_P(PGM_P str);
+ #endif
+ int availableForWrite(void);
+ //------------------------------------------------------------------------------
+ #if ALLOW_DEPRECATED_FUNCTIONS
+ // Deprecated functions - suppress cpplint warnings with NOLINT comment
+ /** \deprecated Use:
+ uint8_t SdFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock);
+ */
+ uint8_t contiguousRange(uint32_t& bgnBlock, uint32_t& endBlock) { // NOLINT
+ return contiguousRange(&bgnBlock, &endBlock);
+ }
+ /** \deprecated Use:
+ uint8_t SdFile::createContiguous(SdFile* dirFile,
+ const char* fileName, uint32_t size)
+ */
+ uint8_t createContiguous(SdFile& dirFile, // NOLINT
+ const char* fileName, uint32_t size) {
+ return createContiguous(&dirFile, fileName, size);
+ }
+
+ /**
+ \deprecated Use:
+ static void SdFile::dateTimeCallback(
+ void (*dateTime)(uint16_t* date, uint16_t* time));
+ */
+ static void dateTimeCallback(
+ void (*dateTime)(uint16_t& date, uint16_t& time)) { // NOLINT
+ oldDateTime_ = dateTime;
+ dateTime_ = dateTime ? oldToNew : 0;
+ }
+ /** \deprecated Use: uint8_t SdFile::dirEntry(dir_t* dir); */
+ uint8_t dirEntry(dir_t& dir) {
+ return dirEntry(&dir); // NOLINT
+ }
+ /** \deprecated Use:
+ uint8_t SdFile::makeDir(SdFile* dir, const char* dirName);
+ */
+ uint8_t makeDir(SdFile& dir, const char* dirName) { // NOLINT
+ return makeDir(&dir, dirName);
+ }
+ /** \deprecated Use:
+ uint8_t SdFile::open(SdFile* dirFile, const char* fileName, uint8_t oflag);
+ */
+ uint8_t open(SdFile& dirFile, // NOLINT
+ const char* fileName, uint8_t oflag) {
+ return open(&dirFile, fileName, oflag);
+ }
+ /** \deprecated Do not use in new apps */
+ uint8_t open(SdFile& dirFile, const char* fileName) { // NOLINT
+ return open(dirFile, fileName, O_RDWR);
+ }
+ /** \deprecated Use:
+ uint8_t SdFile::open(SdFile* dirFile, uint16_t index, uint8_t oflag);
+ */
+ uint8_t open(SdFile& dirFile, uint16_t index, uint8_t oflag) { // NOLINT
+ return open(&dirFile, index, oflag);
+ }
+ /** \deprecated Use: uint8_t SdFile::openRoot(SdVolume* vol); */
+ uint8_t openRoot(SdVolume& vol) {
+ return openRoot(&vol); // NOLINT
+ }
+
+ /** \deprecated Use: int8_t SdFile::readDir(dir_t* dir); */
+ int8_t readDir(dir_t& dir) {
+ return readDir(&dir); // NOLINT
+ }
+ /** \deprecated Use:
+ static uint8_t SdFile::remove(SdFile* dirFile, const char* fileName);
+ */
+ static uint8_t remove(SdFile& dirFile, const char* fileName) { // NOLINT
+ return remove(&dirFile, fileName);
+ }
+ //------------------------------------------------------------------------------
+ // rest are private
+ private:
+ static void (*oldDateTime_)(uint16_t& date, uint16_t& time); // NOLINT
+ static void oldToNew(uint16_t* date, uint16_t* time) {
+ uint16_t d;
+ uint16_t t;
+ oldDateTime_(d, t);
+ *date = d;
+ *time = t;
+ }
+ #endif // ALLOW_DEPRECATED_FUNCTIONS
+ private:
+ // bits defined in flags_
+ // should be 0XF
+ static uint8_t const F_OFLAG = (O_ACCMODE | O_APPEND | O_SYNC);
+ // available bits
+ static uint8_t const F_FILE_NON_BLOCKING_WRITE = 0X10;
+ // a new cluster was added to the file
+ static uint8_t const F_FILE_CLUSTER_ADDED = 0X20;
+ // use unbuffered SD read
+ static uint8_t const F_FILE_UNBUFFERED_READ = 0X40;
+ // sync of directory entry required
+ static uint8_t const F_FILE_DIR_DIRTY = 0X80;
+
+ // make sure F_OFLAG is ok
+ #if ((F_FILE_NON_BLOCKING_WRITE | F_FILE_CLUSTER_ADDED | F_FILE_UNBUFFERED_READ | F_FILE_DIR_DIRTY) &
F_OFLAG)
+#error flags_ bits conflict
+ #endif // flags_ bits
+
+ // private data
+ uint8_t flags_; // See above for definition of flags_ bits
+ uint8_t type_; // type of file see above for values
+ uint32_t curCluster_; // cluster for current file position
+ uint32_t curPosition_; // current file position in bytes from beginning
+ uint32_t dirBlock_; // SD block that contains directory entry for file
+ uint8_t dirIndex_; // index of entry in dirBlock 0 <= dirIndex_ <= 0XF
+ uint32_t fileSize_; // file size in bytes
+ uint32_t firstCluster_; // first cluster of file
+ SdVolume* vol_; // volume where file is located
+
+ // private functions
+ uint8_t addCluster(void);
+ uint8_t addDirCluster(void);
+ dir_t* cacheDirEntry(uint8_t action);
+ static void (*dateTime_)(uint16_t* date, uint16_t* time);
+ static uint8_t make83Name(const char* str, uint8_t* name);
+ uint8_t openCachedEntry(uint8_t cacheIndex, uint8_t oflags);
+ dir_t* readDirCache(void);
+};
+//==============================================================================
+// SdVolume class
+/**
+ \brief Cache for an SD data block
+*/
+union cache_t {
+ /** Used to access cached file data blocks. */
+ uint8_t data[512];
+ /** Used to access cached FAT16 entries. */
+ uint16_t fat16[256];
+ /** Used to access cached FAT32 entries. */
+ uint32_t fat32[128];
+ /** Used to access cached directory entries. */
+ dir_t dir[16];
+ /** Used to access a cached MasterBoot Record. */
+ mbr_t mbr;
+ /** Used to access to a cached FAT boot sector. */
+ fbs_t fbs;
+};
+//------------------------------------------------------------------------------
+/**
+ \class SdVolume
+ \brief Access FAT16 and FAT32 volumes on SD and SDHC cards.
+*/
+class SdVolume {
+ public:
+ /** Create an instance of SdVolume */
+ SdVolume(void) : allocSearchStart_(2), fatType_(0) {}
+ /** Clear the cache and returns a pointer to the cache. Used by the WaveRP
+ recorder to do raw write to the SD card. Not for normal apps.
+ */
+ static uint8_t* cacheClear(void) {
+ cacheFlush();
+ cacheBlockNumber_ = 0XFFFFFFFF;
+ return cacheBuffer_.data;
+ }
+ /**
+ Initialize a FAT volume. Try partition one first then try super
+ floppy format.
+
+ \param[in] dev The Sd2Card where the volume is located.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure. Reasons for
+ failure include not finding a valid partition, not finding a valid
+ FAT file system or an I/O error.
+ */
+ uint8_t init(Sd2Card* dev) {
+ return init(dev, 1) ? true : init(dev, 0);
+ }
+ uint8_t init(Sd2Card* dev, uint8_t part);
+
+ // inline functions that return volume info
+ /** \return The volume's cluster size in blocks. */
+ uint8_t blocksPerCluster(void) const {
+ return blocksPerCluster_;
+ }
+ /** \return The number of blocks in one FAT. */
+ uint32_t blocksPerFat(void) const {
+ return blocksPerFat_;
+ }
+ /** \return The total number of clusters in the volume. */
+ uint32_t clusterCount(void) const {
+ return clusterCount_;
+ }
+ /** \return The shift count required to multiply by blocksPerCluster. */
+ uint8_t clusterSizeShift(void) const {
+ return clusterSizeShift_;
+ }
+ /** \return The logical block number for the start of file data. */
+ uint32_t dataStartBlock(void) const {
+ return dataStartBlock_;
+ }
+ /** \return The number of FAT structures on the volume. */
+ uint8_t fatCount(void) const {
+ return fatCount_;
+ }
+ /** \return The logical block number for the start of the first FAT. */
+ uint32_t fatStartBlock(void) const {
+ return fatStartBlock_;
+ }
+ /** \return The FAT type of the volume. Values are 12, 16 or 32. */
+ uint8_t fatType(void) const {
+ return fatType_;
+ }
+ /** \return The number of entries in the root directory for FAT16 volumes. */
+ uint32_t rootDirEntryCount(void) const {
+ return rootDirEntryCount_;
+ }
+ /** \return The logical block number for the start of the root directory
+ on FAT16 volumes or the first cluster number on FAT32 volumes. */
+ uint32_t rootDirStart(void) const {
+ return rootDirStart_;
+ }
+ /** return a pointer to the Sd2Card object for this volume */
+ static Sd2Card* sdCard(void) {
+ return sdCard_;
+ }
+ //------------------------------------------------------------------------------
+ #if ALLOW_DEPRECATED_FUNCTIONS
+ // Deprecated functions - suppress cpplint warnings with NOLINT comment
+ /** \deprecated Use: uint8_t SdVolume::init(Sd2Card* dev); */
+ uint8_t init(Sd2Card& dev) {
+ return init(&dev); // NOLINT
+ }
+
+ /** \deprecated Use: uint8_t SdVolume::init(Sd2Card* dev, uint8_t vol); */
+ uint8_t init(Sd2Card& dev, uint8_t part) { // NOLINT
+ return init(&dev, part);
+ }
+ #endif // ALLOW_DEPRECATED_FUNCTIONS
+ //------------------------------------------------------------------------------
+ private:
+ // Allow SdFile access to SdVolume private data.
+ friend class SdFile;
+
+ // value for action argument in cacheRawBlock to indicate read from cache
+ static uint8_t const CACHE_FOR_READ = 0;
+ // value for action argument in cacheRawBlock to indicate cache dirty
+ static uint8_t const CACHE_FOR_WRITE = 1;
+
+ static cache_t cacheBuffer_; // 512 byte cache for device blocks
+ static uint32_t cacheBlockNumber_; // Logical number of block in the cache
+ static Sd2Card* sdCard_; // Sd2Card object for cache
+ static uint8_t cacheDirty_; // cacheFlush() will write block if true
+ static uint32_t cacheMirrorBlock_; // block number for mirror FAT
+ //
+ uint32_t allocSearchStart_; // start cluster for alloc search
+ uint8_t blocksPerCluster_; // cluster size in blocks
+ uint32_t blocksPerFat_; // FAT size in blocks
+ uint32_t clusterCount_; // clusters in one FAT
+ uint8_t clusterSizeShift_; // shift to convert cluster count to block count
+ uint32_t dataStartBlock_; // first data block number
+ uint8_t fatCount_; // number of FATs on volume
+ uint32_t fatStartBlock_; // start block for first FAT
+ uint8_t fatType_; // volume type (12, 16, OR 32)
+ uint16_t rootDirEntryCount_; // number of entries in FAT16 root dir
+ uint32_t rootDirStart_; // root start block for FAT16, cluster for FAT32
+ //----------------------------------------------------------------------------
+ uint8_t allocContiguous(uint32_t count, uint32_t* curCluster);
+ uint8_t blockOfCluster(uint32_t position) const {
+ return (position >> 9) & (blocksPerCluster_ - 1);
+ }
+ uint32_t clusterStartBlock(uint32_t cluster) const {
+ return dataStartBlock_ + ((cluster - 2) << clusterSizeShift_);
+ }
+ uint32_t blockNumber(uint32_t cluster, uint32_t position) const {
+ return clusterStartBlock(cluster) + blockOfCluster(position);
+ }
+ static uint8_t cacheFlush(uint8_t blocking = 1);
+ static uint8_t cacheMirrorBlockFlush(uint8_t blocking);
+ static uint8_t cacheRawBlock(uint32_t blockNumber, uint8_t action);
+ static void cacheSetDirty(void) {
+ cacheDirty_ |= CACHE_FOR_WRITE;
+ }
+ static uint8_t cacheZeroBlock(uint32_t blockNumber);
+ uint8_t chainSize(uint32_t beginCluster, uint32_t* size) const;
+ uint8_t fatGet(uint32_t cluster, uint32_t* value) const;
+ uint8_t fatPut(uint32_t cluster, uint32_t value);
+ uint8_t fatPutEOC(uint32_t cluster) {
+ return fatPut(cluster, 0x0FFFFFFF);
+ }
+ uint8_t freeChain(uint32_t cluster);
+ uint8_t isEOC(uint32_t cluster) const {
+ return cluster >= (fatType_ == 16 ? FAT16EOC_MIN : FAT32EOC_MIN);
+ }
+ uint8_t readBlock(uint32_t block, uint8_t* dst) {
+ return sdCard_->readBlock(block, dst);
+ }
+ uint8_t readData(uint32_t block, uint16_t offset,
+ uint16_t count, uint8_t* dst) {
+ return sdCard_->readData(block, offset, count, dst);
+ }
+ uint8_t writeBlock(uint32_t block, const uint8_t* dst, uint8_t blocking = 1) {
+ return sdCard_->writeBlock(block, dst, blocking);
+ }
+ uint8_t isBusy(void) {
+ return sdCard_->isBusy();
+ }
+ uint8_t isCacheMirrorBlockDirty(void) {
+ return (cacheMirrorBlock_ != 0);
+ }
+};
+#endif // SdFat_h
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFatUtil.h
b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFatUtil.h
new file mode 100644
index 000000000..4b93de8a8
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFatUtil.h
@@ -0,0 +1,77 @@
+/* Arduino SdFat Library
+ Copyright (C) 2008 by William Greiman
+
+ This file is part of the Arduino SdFat Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino SdFat Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+#ifndef SdFatUtil_h
+#define SdFatUtil_h
+/**
+ \file
+ Useful utility functions.
+*/
+#include <Arduino.h>
+#ifdef __AVR__
+ #include <avr/pgmspace.h>
+ /** Store and print a string in flash memory.*/
+ #define PgmPrint(x) SerialPrint_P(PSTR(x))
+ /** Store and print a string in flash memory followed by a CR/LF.*/
+ #define PgmPrintln(x) SerialPrintln_P(PSTR(x))
+ /** Defined so doxygen works for function definitions. */
+#endif
+#define NOINLINE __attribute__((noinline,unused))
+#define UNUSEDOK __attribute__((unused))
+//------------------------------------------------------------------------------
+/** Return the number of bytes currently free in RAM. */
+static UNUSEDOK int FreeRam(void) {
+ extern int __bss_end;
+ extern int* __brkval;
+ int free_memory;
+ if (reinterpret_cast<int>(__brkval) == 0) {
+ // if no heap use from end of bss section
+ free_memory = reinterpret_cast<int>(&free_memory)
+ - reinterpret_cast<int>(&__bss_end);
+ } else {
+ // use from top of stack to heap
+ free_memory = reinterpret_cast<int>(&free_memory)
+ - reinterpret_cast<int>(__brkval);
+ }
+ return free_memory;
+}
+#ifdef __AVR__
+//------------------------------------------------------------------------------
+/**
+ %Print a string in flash memory to the serial port.
+
+ \param[in] str Pointer to string stored in flash memory.
+*/
+static NOINLINE void SerialPrint_P(PGM_P str) {
+ for (uint8_t c; (c = pgm_read_byte(str)); str++) {
+ Serial.write(c);
+ }
+}
+//------------------------------------------------------------------------------
+/**
+ %Print a string in flash memory followed by a CR/LF.
+
+ \param[in] str Pointer to string stored in flash memory.
+*/
+static NOINLINE void SerialPrintln_P(PGM_P str) {
+ SerialPrint_P(str);
+ Serial.println();
+}
+#endif // __AVR__
+#endif // #define SdFatUtil_h
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFatmainpage.h
b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFatmainpage.h
new file mode 100644
index 000000000..1e6d96f9c
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFatmainpage.h
@@ -0,0 +1,202 @@
+/* Arduino SdFat Library
+ Copyright (C) 2009 by William Greiman
+
+ This file is part of the Arduino SdFat Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino SdFat Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ \mainpage Arduino SdFat Library
+ <CENTER>Copyright © 2009 by William Greiman
+ </CENTER>
+
+ \section Intro Introduction
+ The Arduino SdFat Library is a minimal implementation of FAT16 and FAT32
+ file systems on SD flash memory cards. Standard SD and high capacity
+ SDHC cards are supported.
+
+ The SdFat only supports short 8.3 names.
+
+ The main classes in SdFat are Sd2Card, SdVolume, and SdFile.
+
+ The Sd2Card class supports access to standard SD cards and SDHC cards. Most
+ applications will only need to call the Sd2Card::init() member function.
+
+ The SdVolume class supports FAT16 and FAT32 partitions. Most applications
+ will only need to call the SdVolume::init() member function.
+
+ The SdFile class provides file access functions such as open(), read(),
+ remove(), write(), close() and sync(). This class supports access to the root
+ directory and subdirectories.
+
+ A number of example are provided in the SdFat/examples folder. These were
+ developed to test SdFat and illustrate its use.
+
+ SdFat was developed for high speed data recording. SdFat was used to implement
+ an audio record/play class, WaveRP, for the Adafruit Wave Shield. This
+ application uses special Sd2Card calls to write to contiguous files in raw mode.
+ These functions reduce write latency so that audio can be recorded with the
+ small amount of RAM in the Arduino.
+
+ \section SDcard SD\SDHC Cards
+
+ Arduinos access SD cards using the cards SPI protocol. PCs, Macs, and
+ most consumer devices use the 4-bit parallel SD protocol. A card that
+ functions well on A PC or Mac may not work well on the Arduino.
+
+ Most cards have good SPI read performance but cards vary widely in SPI
+ write performance. Write performance is limited by how efficiently the
+ card manages internal erase/remapping operations. The Arduino cannot
+ optimize writes to reduce erase operations because of its limit RAM.
+
+ SanDisk cards generally have good write performance. They seem to have
+ more internal RAM buffering than other cards and therefore can limit
+ the number of flash erase operations that the Arduino forces due to its
+ limited RAM.
+
+ \section Hardware Hardware Configuration
+
+ SdFat was developed using an
+ <A HREF = "http://www.adafruit.com/";> Adafruit Industries</A>
+ <A HREF = "http://www.ladyada.net/make/waveshield/";> Wave Shield</A>.
+
+ The hardware interface to the SD card should not use a resistor based level
+ shifter. SdFat sets the SPI bus frequency to 8 MHz which results in signal
+ rise times that are too slow for the edge detectors in many newer SD card
+ controllers when resistor voltage dividers are used.
+
+ The 5 to 3.3 V level shifter for 5 V Arduinos should be IC based like the
+ 74HC4050N based circuit shown in the file SdLevel.png. The Adafruit Wave Shield
+ uses a 74AHC125N. Gravitech sells SD and MicroSD Card Adapters based on the
+ 74LCX245.
+
+ If you are using a resistor based level shifter and are having problems try
+ setting the SPI bus frequency to 4 MHz. This can be done by using
+ card.init(SPI_HALF_SPEED) to initialize the SD card.
+
+ \section comment Bugs and Comments
+
+ If you wish to report bugs or have comments, send email to fat16lib sbcglobal net.
+
+ \section SdFatClass SdFat Usage
+
+ SdFat uses a slightly restricted form of short names.
+ Only printable ASCII characters are supported. No characters with code point
+ values greater than 127 are allowed. Space is not allowed even though space
+ was allowed in the API of early versions of DOS.
+
+ Short names are limited to 8 characters followed by an optional period (.)
+ and extension of up to 3 characters. The characters may be any combination
+ of letters and digits. The following special characters are also allowed:
+
+ $ % ' - _ @ ~ ` ! ( ) { } ^ # &
+
+ Short names are always converted to upper case and their original case
+ value is lost.
+
+ \note
+ The Arduino Print class uses character
+ at a time writes so it was necessary to use a \link SdFile::sync() sync() \endlink
+ function to control when data is written to the SD card.
+
+ \par
+ An application which writes to a file using \link Print::print() print()\endlink,
+ \link Print::println() println() \endlink
+ or \link SdFile::write write() \endlink must call \link SdFile::sync() sync() \endlink
+ at the appropriate time to force data and directory information to be written
+ to the SD Card. Data and directory information are also written to the SD card
+ when \link SdFile::close() close() \endlink is called.
+
+ \par
+ Applications must use care calling \link SdFile::sync() sync() \endlink
+ since 2048 bytes of I/O is required to update file and
+ directory information. This includes writing the current data block, reading
+ the block that contains the directory entry for update, writing the directory
+ block back and reading back the current data block.
+
+ It is possible to open a file with two or more instances of SdFile. A file may
+ be corrupted if data is written to the file by more than one instance of SdFile.
+
+ \section HowTo How to format SD Cards as FAT Volumes
+
+ You should use a freshly formatted SD card for best performance. FAT
+ file systems become slower if many files have been created and deleted.
+ This is because the directory entry for a deleted file is marked as deleted,
+ but is not deleted. When a new file is created, these entries must be scanned
+ before creating the file, a flaw in the FAT design. Also files can become
+ fragmented which causes reads and writes to be slower.
+
+ Microsoft operating systems support removable media formatted with a
+ Master Boot Record, MBR, or formatted as a super floppy with a FAT Boot Sector
+ in block zero.
+
+ Microsoft operating systems expect MBR formatted removable media
+ to have only one partition. The first partition should be used.
+
+ Microsoft operating systems do not support partitioning SD flash cards.
+ If you erase an SD card with a program like KillDisk, Most versions of
+ Windows will format the card as a super floppy.
+
+ The best way to restore an SD card's format is to use SDFormatter
+ which can be downloaded from:
+
+ http://www.sdcard.org/consumers/formatter/
+
+ SDFormatter aligns flash erase boundaries with file
+ system structures which reduces write latency and file system overhead.
+
+ SDFormatter does not have an option for FAT type so it may format
+ small cards as FAT12.
+
+ After the MBR is restored by SDFormatter you may need to reformat small
+ cards that have been formatted FAT12 to force the volume type to be FAT16.
+
+ If you reformat the SD card with an OS utility, choose a cluster size that
+ will result in:
+
+ 4084 < CountOfClusters && CountOfClusters < 65525
+
+ The volume will then be FAT16.
+
+ If you are formatting an SD card on OS X or Linux, be sure to use the first
+ partition. Format this partition with a cluster count in above range.
+
+ \section References References
+
+ Adafruit Industries:
+
+ http://www.adafruit.com/
+
+ http://www.ladyada.net/make/waveshield/
+
+ The Arduino site:
+
+ http://www.arduino.cc/
+
+ For more information about FAT file systems see:
+
+ http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx
+
+ For information about using SD cards as SPI devices see:
+
+ http://www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf
+
+ The ATmega328 datasheet:
+
+ http://www.atmel.com/dyn/resources/prod_documents/doc8161.pdf
+
+
+*/
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFile.cpp
b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFile.cpp
new file mode 100644
index 000000000..18a1db6e7
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdFile.cpp
@@ -0,0 +1,1527 @@
+/* Arduino SdFat Library
+ Copyright (C) 2009 by William Greiman
+
+ This file is part of the Arduino SdFat Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino SdFat Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+#include "SdFat.h"
+#ifdef __AVR__
+ #include <avr/pgmspace.h>
+#endif
+#include <Arduino.h>
+//------------------------------------------------------------------------------
+// callback function for date/time
+void (*SdFile::dateTime_)(uint16_t* date, uint16_t* time) = NULL;
+
+#if ALLOW_DEPRECATED_FUNCTIONS
+ // suppress cpplint warnings with NOLINT comment
+ void (*SdFile::oldDateTime_)(uint16_t& date, uint16_t& time) = NULL; // NOLINT
+#endif // ALLOW_DEPRECATED_FUNCTIONS
+//------------------------------------------------------------------------------
+// add a cluster to a file
+uint8_t SdFile::addCluster() {
+ if (!vol_->allocContiguous(1, &curCluster_)) {
+ return false;
+ }
+
+ // if first cluster of file link to directory entry
+ if (firstCluster_ == 0) {
+ firstCluster_ = curCluster_;
+ flags_ |= F_FILE_DIR_DIRTY;
+ }
+ flags_ |= F_FILE_CLUSTER_ADDED;
+ return true;
+}
+//------------------------------------------------------------------------------
+// Add a cluster to a directory file and zero the cluster.
+// return with first block of cluster in the cache
+uint8_t SdFile::addDirCluster(void) {
+ if (!addCluster()) {
+ return false;
+ }
+
+ // zero data in cluster insure first cluster is in cache
+ uint32_t block = vol_->clusterStartBlock(curCluster_);
+ for (uint8_t i = vol_->blocksPerCluster_; i != 0; i--) {
+ if (!SdVolume::cacheZeroBlock(block + i - 1)) {
+ return false;
+ }
+ }
+ // Increase directory file size by cluster size
+ fileSize_ += 512UL << vol_->clusterSizeShift_;
+ return true;
+}
+//------------------------------------------------------------------------------
+// cache a file's directory entry
+// return pointer to cached entry or null for failure
+dir_t* SdFile::cacheDirEntry(uint8_t action) {
+ if (!SdVolume::cacheRawBlock(dirBlock_, action)) {
+ return NULL;
+ }
+ return SdVolume::cacheBuffer_.dir + dirIndex_;
+}
+//------------------------------------------------------------------------------
+/**
+ Close a file and force cached data and directory information
+ to be written to the storage device.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include no file is open or an I/O error.
+*/
+uint8_t SdFile::close(void) {
+ if (!sync()) {
+ return false;
+ }
+ type_ = FAT_FILE_TYPE_CLOSED;
+ return true;
+}
+//------------------------------------------------------------------------------
+/**
+ Check for contiguous file and return its raw block range.
+
+ \param[out] bgnBlock the first block address for the file.
+ \param[out] endBlock the last block address for the file.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include file is not contiguous, file has zero length
+ or an I/O error occurred.
+*/
+uint8_t SdFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock) {
+ // error if no blocks
+ if (firstCluster_ == 0) {
+ return false;
+ }
+
+ for (uint32_t c = firstCluster_; ; c++) {
+ uint32_t next;
+ if (!vol_->fatGet(c, &next)) {
+ return false;
+ }
+
+ // check for contiguous
+ if (next != (c + 1)) {
+ // error if not end of chain
+ if (!vol_->isEOC(next)) {
+ return false;
+ }
+ *bgnBlock = vol_->clusterStartBlock(firstCluster_);
+ *endBlock = vol_->clusterStartBlock(c)
+ + vol_->blocksPerCluster_ - 1;
+ return true;
+ }
+ }
+}
+//------------------------------------------------------------------------------
+/**
+ Create and open a new contiguous file of a specified size.
+
+ \note This function only supports short DOS 8.3 names.
+ See open() for more information.
+
+ \param[in] dirFile The directory where the file will be created.
+ \param[in] fileName A valid DOS 8.3 file name.
+ \param[in] size The desired file size.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include \a fileName contains
+ an invalid DOS 8.3 file name, the FAT volume has not been initialized,
+ a file is already open, the file already exists, the root
+ directory is full or an I/O error.
+
+*/
+uint8_t SdFile::createContiguous(SdFile* dirFile,
+ const char* fileName, uint32_t size) {
+ // don't allow zero length file
+ if (size == 0) {
+ return false;
+ }
+ if (!open(dirFile, fileName, O_CREAT | O_EXCL | O_RDWR)) {
+ return false;
+ }
+
+ // calculate number of clusters needed
+ uint32_t count = ((size - 1) >> (vol_->clusterSizeShift_ + 9)) + 1;
+
+ // allocate clusters
+ if (!vol_->allocContiguous(count, &firstCluster_)) {
+ remove();
+ return false;
+ }
+ fileSize_ = size;
+
+ // insure sync() will update dir entry
+ flags_ |= F_FILE_DIR_DIRTY;
+ return sync();
+}
+//------------------------------------------------------------------------------
+/**
+ Return a files directory entry
+
+ \param[out] dir Location for return of the files directory entry.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t SdFile::dirEntry(dir_t* dir) {
+ // make sure fields on SD are correct
+ if (!sync()) {
+ return false;
+ }
+
+ // read entry
+ dir_t* p = cacheDirEntry(SdVolume::CACHE_FOR_READ);
+ if (!p) {
+ return false;
+ }
+
+ // copy to caller's struct
+ memcpy(dir, p, sizeof(dir_t));
+ return true;
+}
+//------------------------------------------------------------------------------
+/**
+ Format the name field of \a dir into the 13 byte array
+ \a name in standard 8.3 short name format.
+
+ \param[in] dir The directory structure containing the name.
+ \param[out] name A 13 byte char array for the formatted name.
+*/
+void SdFile::dirName(const dir_t& dir, char* name) {
+ uint8_t j = 0;
+ for (uint8_t i = 0; i < 11; i++) {
+ if (dir.name[i] == ' ') {
+ continue;
+ }
+ if (i == 8) {
+ name[j++] = '.';
+ }
+ name[j++] = dir.name[i];
+ }
+ name[j] = 0;
+}
+//------------------------------------------------------------------------------
+/** List directory contents to Serial.
+
+ \param[in] flags The inclusive OR of
+
+ LS_DATE - %Print file modification date
+
+ LS_SIZE - %Print file size.
+
+ LS_R - Recursive list of subdirectories.
+
+ \param[in] indent Amount of space before file name. Used for recursive
+ list to indicate subdirectory level.
+*/
+void SdFile::ls(uint8_t flags, uint8_t indent) {
+ dir_t* p;
+
+ rewind();
+ while ((p = readDirCache())) {
+ // done if past last used entry
+ if (p->name[0] == DIR_NAME_FREE) {
+ break;
+ }
+
+ // skip deleted entry and entries for . and ..
+ if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
+ continue;
+ }
+
+ // only list subdirectories and files
+ if (!DIR_IS_FILE_OR_SUBDIR(p)) {
+ continue;
+ }
+
+ // print any indent spaces
+ for (int8_t i = 0; i < indent; i++) {
+ Serial.print(' ');
+ }
+
+ // print file name with possible blank fill
+ printDirName(*p, flags & (LS_DATE | LS_SIZE) ? 14 : 0);
+
+ // print modify date/time if requested
+ if (flags & LS_DATE) {
+ printFatDate(p->lastWriteDate);
+ Serial.print(' ');
+ printFatTime(p->lastWriteTime);
+ }
+ // print size if requested
+ if (!DIR_IS_SUBDIR(p) && (flags & LS_SIZE)) {
+ Serial.print(' ');
+ Serial.print(p->fileSize);
+ }
+ Serial.println();
+
+ // list subdirectory content if requested
+ if ((flags & LS_R) && DIR_IS_SUBDIR(p)) {
+ uint16_t index = curPosition() / 32 - 1;
+ SdFile s;
+ if (s.open(this, index, O_READ)) {
+ s.ls(flags, indent + 2);
+ }
+ seekSet(32 * (index + 1));
+ }
+ }
+}
+//------------------------------------------------------------------------------
+// format directory name field from a 8.3 name string
+uint8_t SdFile::make83Name(const char* str, uint8_t* name) {
+ uint8_t c;
+ uint8_t n = 7; // max index for part before dot
+ uint8_t i = 0;
+ // blank fill name and extension
+ while (i < 11) {
+ name[i++] = ' ';
+ }
+ i = 0;
+ while ((c = *str++) != '\0') {
+ if (c == '.') {
+ if (n == 10) {
+ return false; // only one dot allowed
+ }
+ n = 10; // max index for full 8.3 name
+ i = 8; // place for extension
+ } else {
+ // illegal FAT characters
+ uint8_t b;
+ #if defined(__AVR__)
+ PGM_P p = PSTR("|<>^+=?/[];,*\"\\");
+ while ((b = pgm_read_byte(p++))) if (b == c) {
+ return false;
+ }
+ #elif defined(__arm__)
+ const uint8_t valid[] = "|<>^+=?/[];,*\"\\";
+ const uint8_t *p = valid;
+ while ((b = *p++)) if (b == c) {
+ return false;
+ }
+ #endif
+ // check size and only allow ASCII printable characters
+ if (i > n || c < 0X21 || c > 0X7E) {
+ return false;
+ }
+ // only upper case allowed in 8.3 names - convert lower to upper
+ name[i++] = c < 'a' || c > 'z' ? c : c + ('A' - 'a');
+ }
+ }
+ // must have a file name, extension is optional
+ return name[0] != ' ';
+}
+//------------------------------------------------------------------------------
+/** Make a new directory.
+
+ \param[in] dir An open SdFat instance for the directory that will containing
+ the new directory.
+
+ \param[in] dirName A valid 8.3 DOS name for the new directory.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include this SdFile is already open, \a dir is not a
+ directory, \a dirName is invalid or already exists in \a dir.
+*/
+uint8_t SdFile::makeDir(SdFile* dir, const char* dirName) {
+ dir_t d;
+
+ // create a normal file
+ if (!open(dir, dirName, O_CREAT | O_EXCL | O_RDWR)) {
+ return false;
+ }
+
+ // convert SdFile to directory
+ flags_ = O_READ;
+ type_ = FAT_FILE_TYPE_SUBDIR;
+
+ // allocate and zero first cluster
+ if (!addDirCluster()) {
+ return false;
+ }
+
+ // force entry to SD
+ if (!sync()) {
+ return false;
+ }
+
+ // cache entry - should already be in cache due to sync() call
+ dir_t* p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+ if (!p) {
+ return false;
+ }
+
+ // change directory entry attribute
+ p->attributes = DIR_ATT_DIRECTORY;
+
+ // make entry for '.'
+ memcpy(&d, p, sizeof(d));
+ for (uint8_t i = 1; i < 11; i++) {
+ d.name[i] = ' ';
+ }
+ d.name[0] = '.';
+
+ // cache block for '.' and '..'
+ uint32_t block = vol_->clusterStartBlock(firstCluster_);
+ if (!SdVolume::cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) {
+ return false;
+ }
+
+ // copy '.' to block
+ memcpy(&SdVolume::cacheBuffer_.dir[0], &d, sizeof(d));
+
+ // make entry for '..'
+ d.name[1] = '.';
+ if (dir->isRoot()) {
+ d.firstClusterLow = 0;
+ d.firstClusterHigh = 0;
+ } else {
+ d.firstClusterLow = dir->firstCluster_ & 0XFFFF;
+ d.firstClusterHigh = dir->firstCluster_ >> 16;
+ }
+ // copy '..' to block
+ memcpy(&SdVolume::cacheBuffer_.dir[1], &d, sizeof(d));
+
+ // set position after '..'
+ curPosition_ = 2 * sizeof(d);
+
+ // write first block
+ return SdVolume::cacheFlush();
+}
+//------------------------------------------------------------------------------
+/**
+ Open a file or directory by name.
+
+ \param[in] dirFile An open SdFat instance for the directory containing the
+ file to be opened.
+
+ \param[in] fileName A valid 8.3 DOS name for a file to be opened.
+
+ \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
+ OR of flags from the following list
+
+ O_READ - Open for reading.
+
+ O_RDONLY - Same as O_READ.
+
+ O_WRITE - Open for writing.
+
+ O_WRONLY - Same as O_WRITE.
+
+ O_RDWR - Open for reading and writing.
+
+ O_APPEND - If set, the file offset shall be set to the end of the
+ file prior to each write.
+
+ O_CREAT - If the file exists, this flag has no effect except as noted
+ under O_EXCL below. Otherwise, the file shall be created
+
+ O_EXCL - If O_CREAT and O_EXCL are set, open() shall fail if the file exists.
+
+ O_SYNC - Call sync() after each write. This flag should not be used with
+ write(uint8_t), write_P(PGM_P), writeln_P(PGM_P), or the Arduino Print class.
+ These functions do character at a time writes so sync() will be called
+ after each byte.
+
+ O_TRUNC - If the file exists and is a regular file, and the file is
+ successfully opened and is not read only, its length shall be truncated to 0.
+
+ \note Directory files must be opened read only. Write and truncation is
+ not allowed for directory files.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include this SdFile is already open, \a difFile is not
+ a directory, \a fileName is invalid, the file does not exist
+ or can't be opened in the access mode specified by oflag.
+*/
+uint8_t SdFile::open(SdFile* dirFile, const char* fileName, uint8_t oflag) {
+ uint8_t dname[11];
+ dir_t* p;
+
+ // error if already open
+ if (isOpen()) {
+ return false;
+ }
+
+ if (!make83Name(fileName, dname)) {
+ return false;
+ }
+ vol_ = dirFile->vol_;
+ dirFile->rewind();
+
+ // bool for empty entry found
+ uint8_t emptyFound = false;
+
+ // search for file
+ while (dirFile->curPosition_ < dirFile->fileSize_) {
+ uint8_t index = 0XF & (dirFile->curPosition_ >> 5);
+ p = dirFile->readDirCache();
+ if (p == NULL) {
+ return false;
+ }
+
+ if (p->name[0] == DIR_NAME_FREE || p->name[0] == DIR_NAME_DELETED) {
+ // remember first empty slot
+ if (!emptyFound) {
+ emptyFound = true;
+ dirIndex_ = index;
+ dirBlock_ = SdVolume::cacheBlockNumber_;
+ }
+ // done if no entries follow
+ if (p->name[0] == DIR_NAME_FREE) {
+ break;
+ }
+ } else if (!memcmp(dname, p->name, 11)) {
+ // don't open existing file if O_CREAT and O_EXCL
+ if ((oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) {
+ return false;
+ }
+
+ // open found file
+ return openCachedEntry(0XF & index, oflag);
+ }
+ }
+ // only create file if O_CREAT and O_WRITE
+ if ((oflag & (O_CREAT | O_WRITE)) != (O_CREAT | O_WRITE)) {
+ return false;
+ }
+
+ // cache found slot or add cluster if end of file
+ if (emptyFound) {
+ p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+ if (!p) {
+ return false;
+ }
+ } else {
+ if (dirFile->type_ == FAT_FILE_TYPE_ROOT16) {
+ return false;
+ }
+
+ // add and zero cluster for dirFile - first cluster is in cache for write
+ if (!dirFile->addDirCluster()) {
+ return false;
+ }
+
+ // use first entry in cluster
+ dirIndex_ = 0;
+ p = SdVolume::cacheBuffer_.dir;
+ }
+ // initialize as empty file
+ memset(p, 0, sizeof(dir_t));
+ memcpy(p->name, dname, 11);
+
+ // set timestamps
+ if (dateTime_) {
+ // call user function
+ dateTime_(&p->creationDate, &p->creationTime);
+ } else {
+ // use default date/time
+ p->creationDate = FAT_DEFAULT_DATE;
+ p->creationTime = FAT_DEFAULT_TIME;
+ }
+ p->lastAccessDate = p->creationDate;
+ p->lastWriteDate = p->creationDate;
+ p->lastWriteTime = p->creationTime;
+
+ // force write of entry to SD
+ if (!SdVolume::cacheFlush()) {
+ return false;
+ }
+
+ // open entry in cache
+ return openCachedEntry(dirIndex_, oflag);
+}
+//------------------------------------------------------------------------------
+/**
+ Open a file by index.
+
+ \param[in] dirFile An open SdFat instance for the directory.
+
+ \param[in] index The \a index of the directory entry for the file to be
+ opened. The value for \a index is (directory file position)/32.
+
+ \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
+ OR of flags O_READ, O_WRITE, O_TRUNC, and O_SYNC.
+
+ See open() by fileName for definition of flags and return values.
+
+*/
+uint8_t SdFile::open(SdFile* dirFile, uint16_t index, uint8_t oflag) {
+ // error if already open
+ if (isOpen()) {
+ return false;
+ }
+
+ // don't open existing file if O_CREAT and O_EXCL - user call error
+ if ((oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) {
+ return false;
+ }
+
+ vol_ = dirFile->vol_;
+
+ // seek to location of entry
+ if (!dirFile->seekSet(32 * index)) {
+ return false;
+ }
+
+ // read entry into cache
+ dir_t* p = dirFile->readDirCache();
+ if (p == NULL) {
+ return false;
+ }
+
+ // error if empty slot or '.' or '..'
+ if (p->name[0] == DIR_NAME_FREE ||
+ p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
+ return false;
+ }
+ // open cached entry
+ return openCachedEntry(index & 0XF, oflag);
+}
+//------------------------------------------------------------------------------
+// open a cached directory entry. Assumes vol_ is initializes
+uint8_t SdFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
+ // location of entry in cache
+ dir_t* p = SdVolume::cacheBuffer_.dir + dirIndex;
+
+ // write or truncate is an error for a directory or read-only file
+ if (p->attributes & (DIR_ATT_READ_ONLY | DIR_ATT_DIRECTORY)) {
+ if (oflag & (O_WRITE | O_TRUNC)) {
+ return false;
+ }
+ }
+ // remember location of directory entry on SD
+ dirIndex_ = dirIndex;
+ dirBlock_ = SdVolume::cacheBlockNumber_;
+
+ // copy first cluster number for directory fields
+ firstCluster_ = (uint32_t)p->firstClusterHigh << 16;
+ firstCluster_ |= p->firstClusterLow;
+
+ // make sure it is a normal file or subdirectory
+ if (DIR_IS_FILE(p)) {
+ fileSize_ = p->fileSize;
+ type_ = FAT_FILE_TYPE_NORMAL;
+ } else if (DIR_IS_SUBDIR(p)) {
+ if (!vol_->chainSize(firstCluster_, &fileSize_)) {
+ return false;
+ }
+ type_ = FAT_FILE_TYPE_SUBDIR;
+ } else {
+ return false;
+ }
+ // save open flags for read/write
+ flags_ = oflag & (O_ACCMODE | O_SYNC | O_APPEND);
+
+ // set to start of file
+ curCluster_ = 0;
+ curPosition_ = 0;
+
+ // truncate file to zero length if requested
+ if (oflag & O_TRUNC) {
+ return truncate(0);
+ }
+ return true;
+}
+//------------------------------------------------------------------------------
+/**
+ Open a volume's root directory.
+
+ \param[in] vol The FAT volume containing the root directory to be opened.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include the FAT volume has not been initialized
+ or it a FAT12 volume.
+*/
+uint8_t SdFile::openRoot(SdVolume* vol) {
+ // error if file is already open
+ if (isOpen()) {
+ return false;
+ }
+
+ if (vol->fatType() == 16) {
+ type_ = FAT_FILE_TYPE_ROOT16;
+ firstCluster_ = 0;
+ fileSize_ = 32 * vol->rootDirEntryCount();
+ } else if (vol->fatType() == 32) {
+ type_ = FAT_FILE_TYPE_ROOT32;
+ firstCluster_ = vol->rootDirStart();
+ if (!vol->chainSize(firstCluster_, &fileSize_)) {
+ return false;
+ }
+ } else {
+ // volume is not initialized or FAT12
+ return false;
+ }
+ vol_ = vol;
+ // read only
+ flags_ = O_READ;
+
+ // set to start of file
+ curCluster_ = 0;
+ curPosition_ = 0;
+
+ // root has no directory entry
+ dirBlock_ = 0;
+ dirIndex_ = 0;
+ return true;
+}
+//------------------------------------------------------------------------------
+/** %Print the name field of a directory entry in 8.3 format to Serial.
+
+ \param[in] dir The directory structure containing the name.
+ \param[in] width Blank fill name if length is less than \a width.
+*/
+void SdFile::printDirName(const dir_t& dir, uint8_t width) {
+ uint8_t w = 0;
+ for (uint8_t i = 0; i < 11; i++) {
+ if (dir.name[i] == ' ') {
+ continue;
+ }
+ if (i == 8) {
+ Serial.print('.');
+ w++;
+ }
+ Serial.write(dir.name[i]);
+ w++;
+ }
+ if (DIR_IS_SUBDIR(&dir)) {
+ Serial.print('/');
+ w++;
+ }
+ while (w < width) {
+ Serial.print(' ');
+ w++;
+ }
+}
+//------------------------------------------------------------------------------
+/** %Print a directory date field to Serial.
+
+ Format is yyyy-mm-dd.
+
+ \param[in] fatDate The date field from a directory entry.
+*/
+void SdFile::printFatDate(uint16_t fatDate) {
+ Serial.print(FAT_YEAR(fatDate));
+ Serial.print('-');
+ printTwoDigits(FAT_MONTH(fatDate));
+ Serial.print('-');
+ printTwoDigits(FAT_DAY(fatDate));
+}
+//------------------------------------------------------------------------------
+/** %Print a directory time field to Serial.
+
+ Format is hh:mm:ss.
+
+ \param[in] fatTime The time field from a directory entry.
+*/
+void SdFile::printFatTime(uint16_t fatTime) {
+ printTwoDigits(FAT_HOUR(fatTime));
+ Serial.print(':');
+ printTwoDigits(FAT_MINUTE(fatTime));
+ Serial.print(':');
+ printTwoDigits(FAT_SECOND(fatTime));
+}
+//------------------------------------------------------------------------------
+/** %Print a value as two digits to Serial.
+
+ \param[in] v Value to be printed, 0 <= \a v <= 99
+*/
+void SdFile::printTwoDigits(uint8_t v) {
+ char str[3];
+ str[0] = '0' + v / 10;
+ str[1] = '0' + v % 10;
+ str[2] = 0;
+ Serial.print(str);
+}
+//------------------------------------------------------------------------------
+/**
+ Read data from a file starting at the current position.
+
+ \param[out] buf Pointer to the location that will receive the data.
+
+ \param[in] nbyte Maximum number of bytes to read.
+
+ \return For success read() returns the number of bytes read.
+ A value less than \a nbyte, including zero, will be returned
+ if end of file is reached.
+ If an error occurs, read() returns -1. Possible errors include
+ read() called before a file has been opened, corrupt file system
+ or an I/O error occurred.
+*/
+int16_t SdFile::read(void* buf, uint16_t nbyte) {
+ uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
+
+ // error if not open or write only
+ if (!isOpen() || !(flags_ & O_READ)) {
+ return -1;
+ }
+
+ // max bytes left in file
+ if (nbyte > (fileSize_ - curPosition_)) {
+ nbyte = fileSize_ - curPosition_;
+ }
+
+ // amount left to read
+ uint16_t toRead = nbyte;
+ while (toRead > 0) {
+ uint32_t block; // raw device block number
+ uint16_t offset = curPosition_ & 0X1FF; // offset in block
+ if (type_ == FAT_FILE_TYPE_ROOT16) {
+ block = vol_->rootDirStart() + (curPosition_ >> 9);
+ } else {
+ uint8_t blockOfCluster = vol_->blockOfCluster(curPosition_);
+ if (offset == 0 && blockOfCluster == 0) {
+ // start of new cluster
+ if (curPosition_ == 0) {
+ // use first cluster in file
+ curCluster_ = firstCluster_;
+ } else {
+ // get next cluster from FAT
+ if (!vol_->fatGet(curCluster_, &curCluster_)) {
+ return -1;
+ }
+ }
+ }
+ block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
+ }
+ uint16_t n = toRead;
+
+ // amount to be read from current block
+ if (n > (512 - offset)) {
+ n = 512 - offset;
+ }
+
+ // no buffering needed if n == 512 or user requests no buffering
+ if ((unbufferedRead() || n == 512) &&
+ block != SdVolume::cacheBlockNumber_) {
+ if (!vol_->readData(block, offset, n, dst)) {
+ return -1;
+ }
+ dst += n;
+ } else {
+ // read block to cache and copy data to caller
+ if (!SdVolume::cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) {
+ return -1;
+ }
+ uint8_t* src = SdVolume::cacheBuffer_.data + offset;
+ uint8_t* end = src + n;
+ while (src != end) {
+ *dst++ = *src++;
+ }
+ }
+ curPosition_ += n;
+ toRead -= n;
+ }
+ return nbyte;
+}
+//------------------------------------------------------------------------------
+/**
+ Read the next directory entry from a directory file.
+
+ \param[out] dir The dir_t struct that will receive the data.
+
+ \return For success readDir() returns the number of bytes read.
+ A value of zero will be returned if end of file is reached.
+ If an error occurs, readDir() returns -1. Possible errors include
+ readDir() called before a directory has been opened, this is not
+ a directory file or an I/O error occurred.
+*/
+int8_t SdFile::readDir(dir_t* dir) {
+ int8_t n;
+ // if not a directory file or miss-positioned return an error
+ if (!isDir() || (0X1F & curPosition_)) {
+ return -1;
+ }
+
+ while ((n = read(dir, sizeof(dir_t))) == sizeof(dir_t)) {
+ // last entry if DIR_NAME_FREE
+ if (dir->name[0] == DIR_NAME_FREE) {
+ break;
+ }
+ // skip empty entries and entry for . and ..
+ if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') {
+ continue;
+ }
+ // return if normal file or subdirectory
+ if (DIR_IS_FILE_OR_SUBDIR(dir)) {
+ return n;
+ }
+ }
+ // error, end of file, or past last entry
+ return n < 0 ? -1 : 0;
+}
+//------------------------------------------------------------------------------
+// Read next directory entry into the cache
+// Assumes file is correctly positioned
+dir_t* SdFile::readDirCache(void) {
+ // error if not directory
+ if (!isDir()) {
+ return NULL;
+ }
+
+ // index of entry in cache
+ uint8_t i = (curPosition_ >> 5) & 0XF;
+
+ // use read to locate and cache block
+ if (read() < 0) {
+ return NULL;
+ }
+
+ // advance to next entry
+ curPosition_ += 31;
+
+ // return pointer to entry
+ return (SdVolume::cacheBuffer_.dir + i);
+}
+//------------------------------------------------------------------------------
+/**
+ Remove a file.
+
+ The directory entry and all data for the file are deleted.
+
+ \note This function should not be used to delete the 8.3 version of a
+ file that has a long name. For example if a file has the long name
+ "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include the file read-only, is a directory,
+ or an I/O error occurred.
+*/
+uint8_t SdFile::remove(void) {
+ // free any clusters - will fail if read-only or directory
+ if (!truncate(0)) {
+ return false;
+ }
+
+ // cache directory entry
+ dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+ if (!d) {
+ return false;
+ }
+
+ // mark entry deleted
+ d->name[0] = DIR_NAME_DELETED;
+
+ // set this SdFile closed
+ type_ = FAT_FILE_TYPE_CLOSED;
+
+ // write entry to SD
+ return SdVolume::cacheFlush();
+}
+//------------------------------------------------------------------------------
+/**
+ Remove a file.
+
+ The directory entry and all data for the file are deleted.
+
+ \param[in] dirFile The directory that contains the file.
+ \param[in] fileName The name of the file to be removed.
+
+ \note This function should not be used to delete the 8.3 version of a
+ file that has a long name. For example if a file has the long name
+ "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include the file is a directory, is read only,
+ \a dirFile is not a directory, \a fileName is not found
+ or an I/O error occurred.
+*/
+uint8_t SdFile::remove(SdFile* dirFile, const char* fileName) {
+ SdFile file;
+ if (!file.open(dirFile, fileName, O_WRITE)) {
+ return false;
+ }
+ return file.remove();
+}
+//------------------------------------------------------------------------------
+/** Remove a directory file.
+
+ The directory file will be removed only if it is empty and is not the
+ root directory. rmDir() follows DOS and Windows and ignores the
+ read-only attribute for the directory.
+
+ \note This function should not be used to delete the 8.3 version of a
+ directory that has a long name. For example if a directory has the
+ long name "New folder" you should not delete the 8.3 name "NEWFOL~1".
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include the file is not a directory, is the root
+ directory, is not empty, or an I/O error occurred.
+*/
+uint8_t SdFile::rmDir(void) {
+ // must be open subdirectory
+ if (!isSubDir()) {
+ return false;
+ }
+
+ rewind();
+
+ // make sure directory is empty
+ while (curPosition_ < fileSize_) {
+ dir_t* p = readDirCache();
+ if (p == NULL) {
+ return false;
+ }
+ // done if past last used entry
+ if (p->name[0] == DIR_NAME_FREE) {
+ break;
+ }
+ // skip empty slot or '.' or '..'
+ if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
+ continue;
+ }
+ // error not empty
+ if (DIR_IS_FILE_OR_SUBDIR(p)) {
+ return false;
+ }
+ }
+ // convert empty directory to normal file for remove
+ type_ = FAT_FILE_TYPE_NORMAL;
+ flags_ |= O_WRITE;
+ return remove();
+}
+//------------------------------------------------------------------------------
+/** Recursively delete a directory and all contained files.
+
+ This is like the Unix/Linux 'rm -rf *' if called with the root directory
+ hence the name.
+
+ Warning - This will remove all contents of the directory including
+ subdirectories. The directory will then be removed if it is not root.
+ The read-only attribute for files will be ignored.
+
+ \note This function should not be used to delete the 8.3 version of
+ a directory that has a long name. See remove() and rmDir().
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t SdFile::rmRfStar(void) {
+ rewind();
+ while (curPosition_ < fileSize_) {
+ SdFile f;
+
+ // remember position
+ uint16_t index = curPosition_ / 32;
+
+ dir_t* p = readDirCache();
+ if (!p) {
+ return false;
+ }
+
+ // done if past last entry
+ if (p->name[0] == DIR_NAME_FREE) {
+ break;
+ }
+
+ // skip empty slot or '.' or '..'
+ if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
+ continue;
+ }
+
+ // skip if part of long file name or volume label in root
+ if (!DIR_IS_FILE_OR_SUBDIR(p)) {
+ continue;
+ }
+
+ if (!f.open(this, index, O_READ)) {
+ return false;
+ }
+ if (f.isSubDir()) {
+ // recursively delete
+ if (!f.rmRfStar()) {
+ return false;
+ }
+ } else {
+ // ignore read-only
+ f.flags_ |= O_WRITE;
+ if (!f.remove()) {
+ return false;
+ }
+ }
+ // position to next entry if required
+ if (curPosition_ != (32u * (index + 1))) {
+ if (!seekSet(32u * (index + 1))) {
+ return false;
+ }
+ }
+ }
+ // don't try to delete root
+ if (isRoot()) {
+ return true;
+ }
+ return rmDir();
+}
+//------------------------------------------------------------------------------
+/**
+ Sets a file's position.
+
+ \param[in] pos The new position in bytes from the beginning of the file.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t SdFile::seekSet(uint32_t pos) {
+ // error if file not open or seek past end of file
+ if (!isOpen() || pos > fileSize_) {
+ return false;
+ }
+
+ if (type_ == FAT_FILE_TYPE_ROOT16) {
+ curPosition_ = pos;
+ return true;
+ }
+ if (pos == 0) {
+ // set position to start of file
+ curCluster_ = 0;
+ curPosition_ = 0;
+ return true;
+ }
+ // calculate cluster index for cur and new position
+ uint32_t nCur = (curPosition_ - 1) >> (vol_->clusterSizeShift_ + 9);
+ uint32_t nNew = (pos - 1) >> (vol_->clusterSizeShift_ + 9);
+
+ if (nNew < nCur || curPosition_ == 0) {
+ // must follow chain from first cluster
+ curCluster_ = firstCluster_;
+ } else {
+ // advance from curPosition
+ nNew -= nCur;
+ }
+ while (nNew--) {
+ if (!vol_->fatGet(curCluster_, &curCluster_)) {
+ return false;
+ }
+ }
+ curPosition_ = pos;
+ return true;
+}
+//------------------------------------------------------------------------------
+/**
+ The sync() call causes all modified data and directory fields
+ to be written to the storage device.
+
+ \param[in] blocking If the sync should block until fully complete.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include a call to sync() before a file has been
+ opened or an I/O error.
+*/
+uint8_t SdFile::sync(uint8_t blocking) {
+ // only allow open files and directories
+ if (!isOpen()) {
+ return false;
+ }
+
+ if (flags_ & F_FILE_DIR_DIRTY) {
+ dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+ if (!d) {
+ return false;
+ }
+
+ // do not set filesize for dir files
+ if (!isDir()) {
+ d->fileSize = fileSize_;
+ }
+
+ // update first cluster fields
+ d->firstClusterLow = firstCluster_ & 0XFFFF;
+ d->firstClusterHigh = firstCluster_ >> 16;
+
+ // set modify time if user supplied a callback date/time function
+ if (dateTime_) {
+ dateTime_(&d->lastWriteDate, &d->lastWriteTime);
+ d->lastAccessDate = d->lastWriteDate;
+ }
+ // clear directory dirty
+ flags_ &= ~F_FILE_DIR_DIRTY;
+ }
+
+ if (!blocking) {
+ flags_ &= ~F_FILE_NON_BLOCKING_WRITE;
+ }
+
+ return SdVolume::cacheFlush(blocking);
+}
+//------------------------------------------------------------------------------
+/**
+ Set a file's timestamps in its directory entry.
+
+ \param[in] flags Values for \a flags are constructed by a bitwise-inclusive
+ OR of flags from the following list
+
+ T_ACCESS - Set the file's last access date.
+
+ T_CREATE - Set the file's creation date and time.
+
+ T_WRITE - Set the file's last write/modification date and time.
+
+ \param[in] year Valid range 1980 - 2107 inclusive.
+
+ \param[in] month Valid range 1 - 12 inclusive.
+
+ \param[in] day Valid range 1 - 31 inclusive.
+
+ \param[in] hour Valid range 0 - 23 inclusive.
+
+ \param[in] minute Valid range 0 - 59 inclusive.
+
+ \param[in] second Valid range 0 - 59 inclusive
+
+ \note It is possible to set an invalid date since there is no check for
+ the number of days in a month.
+
+ \note
+ Modify and access timestamps may be overwritten if a date time callback
+ function has been set by dateTimeCallback().
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+*/
+uint8_t SdFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
+ uint8_t day, uint8_t hour, uint8_t minute, uint8_t second) {
+ if (!isOpen()
+ || year < 1980
+ || year > 2107
+ || month < 1
+ || month > 12
+ || day < 1
+ || day > 31
+ || hour > 23
+ || minute > 59
+ || second > 59) {
+ return false;
+ }
+ dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+ if (!d) {
+ return false;
+ }
+
+ uint16_t dirDate = FAT_DATE(year, month, day);
+ uint16_t dirTime = FAT_TIME(hour, minute, second);
+ if (flags & T_ACCESS) {
+ d->lastAccessDate = dirDate;
+ }
+ if (flags & T_CREATE) {
+ d->creationDate = dirDate;
+ d->creationTime = dirTime;
+ // seems to be units of 1/100 second not 1/10 as Microsoft states
+ d->creationTimeTenths = second & 1 ? 100 : 0;
+ }
+ if (flags & T_WRITE) {
+ d->lastWriteDate = dirDate;
+ d->lastWriteTime = dirTime;
+ }
+ SdVolume::cacheSetDirty();
+ return sync();
+}
+//------------------------------------------------------------------------------
+/**
+ Truncate a file to a specified length. The current file position
+ will be maintained if it is less than or equal to \a length otherwise
+ it will be set to end of file.
+
+ \param[in] length The desired length for the file.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure.
+ Reasons for failure include file is read only, file is a directory,
+ \a length is greater than the current file size or an I/O error occurs.
+*/
+uint8_t SdFile::truncate(uint32_t length) {
+ // error if not a normal file or read-only
+ if (!isFile() || !(flags_ & O_WRITE)) {
+ return false;
+ }
+
+ // error if length is greater than current size
+ if (length > fileSize_) {
+ return false;
+ }
+
+ // fileSize and length are zero - nothing to do
+ if (fileSize_ == 0) {
+ return true;
+ }
+
+ // remember position for seek after truncation
+ uint32_t newPos = curPosition_ > length ? length : curPosition_;
+
+ // position to last cluster in truncated file
+ if (!seekSet(length)) {
+ return false;
+ }
+
+ if (length == 0) {
+ // free all clusters
+ if (!vol_->freeChain(firstCluster_)) {
+ return false;
+ }
+ firstCluster_ = 0;
+ } else {
+ uint32_t toFree;
+ if (!vol_->fatGet(curCluster_, &toFree)) {
+ return false;
+ }
+
+ if (!vol_->isEOC(toFree)) {
+ // free extra clusters
+ if (!vol_->freeChain(toFree)) {
+ return false;
+ }
+
+ // current cluster is end of chain
+ if (!vol_->fatPutEOC(curCluster_)) {
+ return false;
+ }
+ }
+ }
+ fileSize_ = length;
+
+ // need to update directory entry
+ flags_ |= F_FILE_DIR_DIRTY;
+
+ if (!sync()) {
+ return false;
+ }
+
+ // set file to correct position
+ return seekSet(newPos);
+}
+//------------------------------------------------------------------------------
+/**
+ Write data to an open file.
+
+ \note Data is moved to the cache but may not be written to the
+ storage device until sync() is called.
+
+ \param[in] buf Pointer to the location of the data to be written.
+
+ \param[in] nbyte Number of bytes to write.
+
+ \return For success write() returns the number of bytes written, always
+ \a nbyte. If an error occurs, write() returns 0. Possible errors
+ include write() is called before a file has been opened, write is called
+ for a read-only file, device is full, a corrupt file system or an I/O error.
+
+*/
+size_t SdFile::write(const void* buf, uint16_t nbyte) {
+ // convert void* to uint8_t* - must be before goto statements
+ const uint8_t* src = reinterpret_cast<const uint8_t*>(buf);
+
+ // number of bytes left to write - must be before goto statements
+ uint16_t nToWrite = nbyte;
+ // if blocking writes should be used
+ uint8_t blocking = (flags_ & F_FILE_NON_BLOCKING_WRITE) == 0x00;
+
+ // error if not a normal file or is read-only
+ if (!isFile() || !(flags_ & O_WRITE)) {
+ goto writeErrorReturn;
+ }
+
+ // seek to end of file if append flag
+ if ((flags_ & O_APPEND) && curPosition_ != fileSize_) {
+ if (!seekEnd()) {
+ goto writeErrorReturn;
+ }
+ }
+
+ while (nToWrite > 0) {
+ uint8_t blockOfCluster = vol_->blockOfCluster(curPosition_);
+ uint16_t blockOffset = curPosition_ & 0X1FF;
+ if (blockOfCluster == 0 && blockOffset == 0) {
+ // start of new cluster
+ if (curCluster_ == 0) {
+ if (firstCluster_ == 0) {
+ // allocate first cluster of file
+ if (!addCluster()) {
+ goto writeErrorReturn;
+ }
+ } else {
+ curCluster_ = firstCluster_;
+ }
+ } else {
+ uint32_t next;
+ if (!vol_->fatGet(curCluster_, &next)) {
+ return false;
+ }
+ if (vol_->isEOC(next)) {
+ // add cluster if at end of chain
+ if (!addCluster()) {
+ goto writeErrorReturn;
+ }
+ } else {
+ curCluster_ = next;
+ }
+ }
+ }
+ // max space in block
+ uint16_t n = 512 - blockOffset;
+
+ // lesser of space and amount to write
+ if (n > nToWrite) {
+ n = nToWrite;
+ }
+
+ // block for data write
+ uint32_t block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
+ if (n == 512) {
+ // full block - don't need to use cache
+ // invalidate cache if block is in cache
+ if (SdVolume::cacheBlockNumber_ == block) {
+ SdVolume::cacheBlockNumber_ = 0XFFFFFFFF;
+ }
+ if (!vol_->writeBlock(block, src, blocking)) {
+ goto writeErrorReturn;
+ }
+ src += 512;
+ } else {
+ if (blockOffset == 0 && curPosition_ >= fileSize_) {
+ // start of new block don't need to read into cache
+ if (!SdVolume::cacheFlush()) {
+ goto writeErrorReturn;
+ }
+ SdVolume::cacheBlockNumber_ = block;
+ SdVolume::cacheSetDirty();
+ } else {
+ // rewrite part of block
+ if (!SdVolume::cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) {
+ goto writeErrorReturn;
+ }
+ }
+ uint8_t* dst = SdVolume::cacheBuffer_.data + blockOffset;
+ uint8_t* end = dst + n;
+ while (dst != end) {
+ *dst++ = *src++;
+ }
+ }
+ nToWrite -= n;
+ curPosition_ += n;
+ }
+ if (curPosition_ > fileSize_) {
+ // update fileSize and insure sync will update dir entry
+ fileSize_ = curPosition_;
+ flags_ |= F_FILE_DIR_DIRTY;
+ } else if (dateTime_ && nbyte) {
+ // insure sync will update modified date and time
+ flags_ |= F_FILE_DIR_DIRTY;
+ }
+
+ if (flags_ & O_SYNC) {
+ if (!sync()) {
+ goto writeErrorReturn;
+ }
+ }
+ return nbyte;
+
+writeErrorReturn:
+ // return for write error
+ //writeError = true;
+ setWriteError();
+ return 0;
+}
+//------------------------------------------------------------------------------
+/**
+ Write a byte to a file. Required by the Arduino Print class.
+
+ Use SdFile::writeError to check for errors.
+*/
+size_t SdFile::write(uint8_t b) {
+ return write(&b, 1);
+}
+//------------------------------------------------------------------------------
+/**
+ Write a string to a file. Used by the Arduino Print class.
+
+ Use SdFile::writeError to check for errors.
+*/
+size_t SdFile::write(const char* str) {
+ return write(str, strlen(str));
+}
+#ifdef __AVR__
+//------------------------------------------------------------------------------
+/**
+ Write a PROGMEM string to a file.
+
+ Use SdFile::writeError to check for errors.
+*/
+void SdFile::write_P(PGM_P str) {
+ for (uint8_t c; (c = pgm_read_byte(str)); str++) {
+ write(c);
+ }
+}
+//------------------------------------------------------------------------------
+/**
+ Write a PROGMEM string followed by CR/LF to a file.
+
+ Use SdFile::writeError to check for errors.
+*/
+void SdFile::writeln_P(PGM_P str) {
+ write_P(str);
+ println();
+}
+#endif
+//------------------------------------------------------------------------------
+/**
+ Check how many bytes can be written without blocking.
+
+ \return The number of bytes that can be written without blocking.
+*/
+int SdFile::availableForWrite() {
+ if (!isFile() || !(flags_ & O_WRITE)) {
+ return 0;
+ }
+
+ // seek to end of file if append flag
+ if ((flags_ & O_APPEND) && curPosition_ != fileSize_) {
+ if (!seekEnd()) {
+ return 0;
+ }
+ }
+
+ if (vol_->isBusy()) {
+ return 0;
+ }
+
+ if (flags_ & F_FILE_CLUSTER_ADDED) {
+ // new cluster added, trigger a non-blocking sync
+ sync(0);
+ flags_ &= ~F_FILE_CLUSTER_ADDED;
+ return 0;
+ }
+
+ if (vol_->isCacheMirrorBlockDirty()) {
+ // cache mirror block is dirty, trigger a non-blocking sync
+ vol_->cacheMirrorBlockFlush(0);
+ return 0;
+ }
+
+ flags_ |= F_FILE_NON_BLOCKING_WRITE;
+
+ uint16_t blockOffset = curPosition_ & 0X1FF;
+ uint16_t n = 512 - blockOffset;
+
+ return n;
+}
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/SdInfo.h
b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdInfo.h
new file mode 100644
index 000000000..6a0e087f4
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdInfo.h
@@ -0,0 +1,232 @@
+/* Arduino Sd2Card Library
+ Copyright (C) 2009 by William Greiman
+
+ This file is part of the Arduino Sd2Card Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino Sd2Card Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+#ifndef SdInfo_h
+#define SdInfo_h
+#include <stdint.h>
+// Based on the document:
+//
+// SD Specifications
+// Part 1
+// Physical Layer
+// Simplified Specification
+// Version 2.00
+// September 25, 2006
+//
+// www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf
+//------------------------------------------------------------------------------
+// SD card commands
+/** GO_IDLE_STATE - init card in spi mode if CS low */
+uint8_t const CMD0 = 0X00;
+/** SEND_IF_COND - verify SD Memory Card interface operating condition.*/
+uint8_t const CMD8 = 0X08;
+/** SEND_CSD - read the Card Specific Data (CSD register) */
+uint8_t const CMD9 = 0X09;
+/** SEND_CID - read the card identification information (CID register) */
+uint8_t const CMD10 = 0X0A;
+/** SEND_STATUS - read the card status register */
+uint8_t const CMD13 = 0X0D;
+/** READ_BLOCK - read a single data block from the card */
+uint8_t const CMD17 = 0X11;
+/** WRITE_BLOCK - write a single data block to the card */
+uint8_t const CMD24 = 0X18;
+/** WRITE_MULTIPLE_BLOCK - write blocks of data until a STOP_TRANSMISSION */
+uint8_t const CMD25 = 0X19;
+/** ERASE_WR_BLK_START - sets the address of the first block to be erased */
+uint8_t const CMD32 = 0X20;
+/** ERASE_WR_BLK_END - sets the address of the last block of the continuous
+ range to be erased*/
+uint8_t const CMD33 = 0X21;
+/** ERASE - erase all previously selected blocks */
+uint8_t const CMD38 = 0X26;
+/** APP_CMD - escape for application specific command */
+uint8_t const CMD55 = 0X37;
+/** READ_OCR - read the OCR register of a card */
+uint8_t const CMD58 = 0X3A;
+/** SET_WR_BLK_ERASE_COUNT - Set the number of write blocks to be
+ pre-erased before writing */
+uint8_t const ACMD23 = 0X17;
+/** SD_SEND_OP_COMD - Sends host capacity support information and
+ activates the card's initialization process */
+uint8_t const ACMD41 = 0X29;
+//------------------------------------------------------------------------------
+/** status for card in the ready state */
+uint8_t const R1_READY_STATE = 0X00;
+/** status for card in the idle state */
+uint8_t const R1_IDLE_STATE = 0X01;
+/** status bit for illegal command */
+uint8_t const R1_ILLEGAL_COMMAND = 0X04;
+/** start data token for read or write single block*/
+uint8_t const DATA_START_BLOCK = 0XFE;
+/** stop token for write multiple blocks*/
+uint8_t const STOP_TRAN_TOKEN = 0XFD;
+/** start data token for write multiple blocks*/
+uint8_t const WRITE_MULTIPLE_TOKEN = 0XFC;
+/** mask for data response tokens after a write block operation */
+uint8_t const DATA_RES_MASK = 0X1F;
+/** write data accepted token */
+uint8_t const DATA_RES_ACCEPTED = 0X05;
+//------------------------------------------------------------------------------
+typedef struct CID {
+ // byte 0
+ uint8_t mid; // Manufacturer ID
+ // byte 1-2
+ char oid[2]; // OEM/Application ID
+ // byte 3-7
+ char pnm[5]; // Product name
+ // byte 8
+ unsigned prv_m : 4; // Product revision n.m
+ unsigned prv_n : 4;
+ // byte 9-12
+ uint32_t psn; // Product serial number
+ // byte 13
+ unsigned mdt_year_high : 4; // Manufacturing date
+ unsigned reserved : 4;
+ // byte 14
+ unsigned mdt_month : 4;
+ unsigned mdt_year_low : 4;
+ // byte 15
+ unsigned always1 : 1;
+ unsigned crc : 7;
+} cid_t;
+//------------------------------------------------------------------------------
+// CSD for version 1.00 cards
+typedef struct CSDV1 {
+ // byte 0
+ unsigned reserved1 : 6;
+ unsigned csd_ver : 2;
+ // byte 1
+ uint8_t taac;
+ // byte 2
+ uint8_t nsac;
+ // byte 3
+ uint8_t tran_speed;
+ // byte 4
+ uint8_t ccc_high;
+ // byte 5
+ unsigned read_bl_len : 4;
+ unsigned ccc_low : 4;
+ // byte 6
+ unsigned c_size_high : 2;
+ unsigned reserved2 : 2;
+ unsigned dsr_imp : 1;
+ unsigned read_blk_misalign : 1;
+ unsigned write_blk_misalign : 1;
+ unsigned read_bl_partial : 1;
+ // byte 7
+ uint8_t c_size_mid;
+ // byte 8
+ unsigned vdd_r_curr_max : 3;
+ unsigned vdd_r_curr_min : 3;
+ unsigned c_size_low : 2;
+ // byte 9
+ unsigned c_size_mult_high : 2;
+ unsigned vdd_w_cur_max : 3;
+ unsigned vdd_w_curr_min : 3;
+ // byte 10
+ unsigned sector_size_high : 6;
+ unsigned erase_blk_en : 1;
+ unsigned c_size_mult_low : 1;
+ // byte 11
+ unsigned wp_grp_size : 7;
+ unsigned sector_size_low : 1;
+ // byte 12
+ unsigned write_bl_len_high : 2;
+ unsigned r2w_factor : 3;
+ unsigned reserved3 : 2;
+ unsigned wp_grp_enable : 1;
+ // byte 13
+ unsigned reserved4 : 5;
+ unsigned write_partial : 1;
+ unsigned write_bl_len_low : 2;
+ // byte 14
+ unsigned reserved5: 2;
+ unsigned file_format : 2;
+ unsigned tmp_write_protect : 1;
+ unsigned perm_write_protect : 1;
+ unsigned copy : 1;
+ unsigned file_format_grp : 1;
+ // byte 15
+ unsigned always1 : 1;
+ unsigned crc : 7;
+} csd1_t;
+//------------------------------------------------------------------------------
+// CSD for version 2.00 cards
+typedef struct CSDV2 {
+ // byte 0
+ unsigned reserved1 : 6;
+ unsigned csd_ver : 2;
+ // byte 1
+ uint8_t taac;
+ // byte 2
+ uint8_t nsac;
+ // byte 3
+ uint8_t tran_speed;
+ // byte 4
+ uint8_t ccc_high;
+ // byte 5
+ unsigned read_bl_len : 4;
+ unsigned ccc_low : 4;
+ // byte 6
+ unsigned reserved2 : 4;
+ unsigned dsr_imp : 1;
+ unsigned read_blk_misalign : 1;
+ unsigned write_blk_misalign : 1;
+ unsigned read_bl_partial : 1;
+ // byte 7
+ unsigned reserved3 : 2;
+ unsigned c_size_high : 6;
+ // byte 8
+ uint8_t c_size_mid;
+ // byte 9
+ uint8_t c_size_low;
+ // byte 10
+ unsigned sector_size_high : 6;
+ unsigned erase_blk_en : 1;
+ unsigned reserved4 : 1;
+ // byte 11
+ unsigned wp_grp_size : 7;
+ unsigned sector_size_low : 1;
+ // byte 12
+ unsigned write_bl_len_high : 2;
+ unsigned r2w_factor : 3;
+ unsigned reserved5 : 2;
+ unsigned wp_grp_enable : 1;
+ // byte 13
+ unsigned reserved6 : 5;
+ unsigned write_partial : 1;
+ unsigned write_bl_len_low : 2;
+ // byte 14
+ unsigned reserved7: 2;
+ unsigned file_format : 2;
+ unsigned tmp_write_protect : 1;
+ unsigned perm_write_protect : 1;
+ unsigned copy : 1;
+ unsigned file_format_grp : 1;
+ // byte 15
+ unsigned always1 : 1;
+ unsigned crc : 7;
+} csd2_t;
+//------------------------------------------------------------------------------
+// union of old and new style CSD register
+union csd_t {
+ csd1_t v1;
+ csd2_t v2;
+};
+#endif // SdInfo_h
diff --git a/arduino/ForceSensorTFT/libraries/SD/src/utility/SdVolume.cpp
b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdVolume.cpp
new file mode 100644
index 000000000..60375c471
--- /dev/null
+++ b/arduino/ForceSensorTFT/libraries/SD/src/utility/SdVolume.cpp
@@ -0,0 +1,351 @@
+/* Arduino SdFat Library
+ Copyright (C) 2009 by William Greiman
+
+ This file is part of the Arduino SdFat Library
+
+ This Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with the Arduino SdFat Library. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+#include "SdFat.h"
+//------------------------------------------------------------------------------
+// raw block cache
+// init cacheBlockNumber_to invalid SD block number
+uint32_t SdVolume::cacheBlockNumber_ = 0XFFFFFFFF;
+cache_t SdVolume::cacheBuffer_; // 512 byte cache for Sd2Card
+Sd2Card* SdVolume::sdCard_; // pointer to SD card object
+uint8_t SdVolume::cacheDirty_ = 0; // cacheFlush() will write block if true
+uint32_t SdVolume::cacheMirrorBlock_ = 0; // mirror block for second FAT
+//------------------------------------------------------------------------------
+// find a contiguous group of clusters
+uint8_t SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
+ // start of group
+ uint32_t bgnCluster;
+
+ // flag to save place to start next search
+ uint8_t setStart;
+
+ // set search start cluster
+ if (*curCluster) {
+ // try to make file contiguous
+ bgnCluster = *curCluster + 1;
+
+ // don't save new start location
+ setStart = false;
+ } else {
+ // start at likely place for free cluster
+ bgnCluster = allocSearchStart_;
+
+ // save next search start if one cluster
+ setStart = 1 == count;
+ }
+ // end of group
+ uint32_t endCluster = bgnCluster;
+
+ // last cluster of FAT
+ uint32_t fatEnd = clusterCount_ + 1;
+
+ // search the FAT for free clusters
+ for (uint32_t n = 0;; n++, endCluster++) {
+ // can't find space checked all clusters
+ if (n >= clusterCount_) {
+ return false;
+ }
+
+ // past end - start from beginning of FAT
+ if (endCluster > fatEnd) {
+ bgnCluster = endCluster = 2;
+ }
+ uint32_t f;
+ if (!fatGet(endCluster, &f)) {
+ return false;
+ }
+
+ if (f != 0) {
+ // cluster in use try next cluster as bgnCluster
+ bgnCluster = endCluster + 1;
+ } else if ((endCluster - bgnCluster + 1) == count) {
+ // done - found space
+ break;
+ }
+ }
+ // mark end of chain
+ if (!fatPutEOC(endCluster)) {
+ return false;
+ }
+
+ // link clusters
+ while (endCluster > bgnCluster) {
+ if (!fatPut(endCluster - 1, endCluster)) {
+ return false;
+ }
+ endCluster--;
+ }
+ if (*curCluster != 0) {
+ // connect chains
+ if (!fatPut(*curCluster, bgnCluster)) {
+ return false;
+ }
+ }
+ // return first cluster number to caller
+ *curCluster = bgnCluster;
+
+ // remember possible next free cluster
+ if (setStart) {
+ allocSearchStart_ = bgnCluster + 1;
+ }
+
+ return true;
+}
+//------------------------------------------------------------------------------
+uint8_t SdVolume::cacheFlush(uint8_t blocking) {
+ if (cacheDirty_) {
+ if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data, blocking)) {
+ return false;
+ }
+
+ if (!blocking) {
+ return true;
+ }
+
+ // mirror FAT tables
+ if (!cacheMirrorBlockFlush(blocking)) {
+ return false;
+ }
+ cacheDirty_ = 0;
+ }
+ return true;
+}
+//------------------------------------------------------------------------------
+uint8_t SdVolume::cacheMirrorBlockFlush(uint8_t blocking) {
+ if (cacheMirrorBlock_) {
+ if (!sdCard_->writeBlock(cacheMirrorBlock_, cacheBuffer_.data, blocking)) {
+ return false;
+ }
+ cacheMirrorBlock_ = 0;
+ }
+ return true;
+}
+//------------------------------------------------------------------------------
+uint8_t SdVolume::cacheRawBlock(uint32_t blockNumber, uint8_t action) {
+ if (cacheBlockNumber_ != blockNumber) {
+ if (!cacheFlush()) {
+ return false;
+ }
+ if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) {
+ return false;
+ }
+ cacheBlockNumber_ = blockNumber;
+ }
+ cacheDirty_ |= action;
+ return true;
+}
+//------------------------------------------------------------------------------
+// cache a zero block for blockNumber
+uint8_t SdVolume::cacheZeroBlock(uint32_t blockNumber) {
+ if (!cacheFlush()) {
+ return false;
+ }
+
+ // loop take less flash than memset(cacheBuffer_.data, 0, 512);
+ for (uint16_t i = 0; i < 512; i++) {
+ cacheBuffer_.data[i] = 0;
+ }
+ cacheBlockNumber_ = blockNumber;
+ cacheSetDirty();
+ return true;
+}
+//------------------------------------------------------------------------------
+// return the size in bytes of a cluster chain
+uint8_t SdVolume::chainSize(uint32_t cluster, uint32_t* size) const {
+ uint32_t s = 0;
+ do {
+ if (!fatGet(cluster, &cluster)) {
+ return false;
+ }
+ s += 512UL << clusterSizeShift_;
+ } while (!isEOC(cluster));
+ *size = s;
+ return true;
+}
+//------------------------------------------------------------------------------
+// Fetch a FAT entry
+uint8_t SdVolume::fatGet(uint32_t cluster, uint32_t* value) const {
+ if (cluster > (clusterCount_ + 1)) {
+ return false;
+ }
+ uint32_t lba = fatStartBlock_;
+ lba += fatType_ == 16 ? cluster >> 8 : cluster >> 7;
+ if (lba != cacheBlockNumber_) {
+ if (!cacheRawBlock(lba, CACHE_FOR_READ)) {
+ return false;
+ }
+ }
+ if (fatType_ == 16) {
+ *value = cacheBuffer_.fat16[cluster & 0XFF];
+ } else {
+ *value = cacheBuffer_.fat32[cluster & 0X7F] & FAT32MASK;
+ }
+ return true;
+}
+//------------------------------------------------------------------------------
+// Store a FAT entry
+uint8_t SdVolume::fatPut(uint32_t cluster, uint32_t value) {
+ // error if reserved cluster
+ if (cluster < 2) {
+ return false;
+ }
+
+ // error if not in FAT
+ if (cluster > (clusterCount_ + 1)) {
+ return false;
+ }
+
+ // calculate block address for entry
+ uint32_t lba = fatStartBlock_;
+ lba += fatType_ == 16 ? cluster >> 8 : cluster >> 7;
+
+ if (lba != cacheBlockNumber_) {
+ if (!cacheRawBlock(lba, CACHE_FOR_READ)) {
+ return false;
+ }
+ }
+ // store entry
+ if (fatType_ == 16) {
+ cacheBuffer_.fat16[cluster & 0XFF] = value;
+ } else {
+ cacheBuffer_.fat32[cluster & 0X7F] = value;
+ }
+ cacheSetDirty();
+
+ // mirror second FAT
+ if (fatCount_ > 1) {
+ cacheMirrorBlock_ = lba + blocksPerFat_;
+ }
+ return true;
+}
+//------------------------------------------------------------------------------
+// free a cluster chain
+uint8_t SdVolume::freeChain(uint32_t cluster) {
+ // clear free cluster location
+ allocSearchStart_ = 2;
+
+ do {
+ uint32_t next;
+ if (!fatGet(cluster, &next)) {
+ return false;
+ }
+
+ // free cluster
+ if (!fatPut(cluster, 0)) {
+ return false;
+ }
+
+ cluster = next;
+ } while (!isEOC(cluster));
+
+ return true;
+}
+//------------------------------------------------------------------------------
+/**
+ Initialize a FAT volume.
+
+ \param[in] dev The SD card where the volume is located.
+
+ \param[in] part The partition to be used. Legal values for \a part are
+ 1-4 to use the corresponding partition on a device formatted with
+ a MBR, Master Boot Record, or zero if the device is formatted as
+ a super floppy with the FAT boot sector in block zero.
+
+ \return The value one, true, is returned for success and
+ the value zero, false, is returned for failure. Reasons for
+ failure include not finding a valid partition, not finding a valid
+ FAT file system in the specified partition or an I/O error.
+*/
+uint8_t SdVolume::init(Sd2Card* dev, uint8_t part) {
+ uint32_t volumeStartBlock = 0;
+ sdCard_ = dev;
+ // if part == 0 assume super floppy with FAT boot sector in block zero
+ // if part > 0 assume mbr volume with partition table
+ if (part) {
+ if (part > 4) {
+ return false;
+ }
+ if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) {
+ return false;
+ }
+ part_t* p = &cacheBuffer_.mbr.part[part - 1];
+ if ((p->boot & 0X7F) != 0 ||
+ p->totalSectors < 100 ||
+ p->firstSector == 0) {
+ // not a valid partition
+ return false;
+ }
+ volumeStartBlock = p->firstSector;
+ }
+ if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) {
+ return false;
+ }
+ bpb_t* bpb = &cacheBuffer_.fbs.bpb;
+ if (bpb->bytesPerSector != 512 ||
+ bpb->fatCount == 0 ||
+ bpb->reservedSectorCount == 0 ||
+ bpb->sectorsPerCluster == 0) {
+ // not valid FAT volume
+ return false;
+ }
+ fatCount_ = bpb->fatCount;
+ blocksPerCluster_ = bpb->sectorsPerCluster;
+
+ // determine shift that is same as multiply by blocksPerCluster_
+ clusterSizeShift_ = 0;
+ while (blocksPerCluster_ != (1 << clusterSizeShift_)) {
+ // error if not power of 2
+ if (clusterSizeShift_++ > 7) {
+ return false;
+ }
+ }
+ blocksPerFat_ = bpb->sectorsPerFat16 ?
+ bpb->sectorsPerFat16 : bpb->sectorsPerFat32;
+
+ fatStartBlock_ = volumeStartBlock + bpb->reservedSectorCount;
+
+ // count for FAT16 zero for FAT32
+ rootDirEntryCount_ = bpb->rootDirEntryCount;
+
+ // directory start for FAT16 dataStart for FAT32
+ rootDirStart_ = fatStartBlock_ + bpb->fatCount * blocksPerFat_;
+
+ // data start for FAT16 and FAT32
+ dataStartBlock_ = rootDirStart_ + ((32 * bpb->rootDirEntryCount + 511) / 512);
+
+ // total blocks for FAT16 or FAT32
+ uint32_t totalBlocks = bpb->totalSectors16 ?
+ bpb->totalSectors16 : bpb->totalSectors32;
+ // total data blocks
+ clusterCount_ = totalBlocks - (dataStartBlock_ - volumeStartBlock);
+
+ // divide by cluster size to get cluster count
+ clusterCount_ >>= clusterSizeShift_;
+
+ // FAT type is determined by cluster count
+ if (clusterCount_ < 4085) {
+ fatType_ = 12;
+ } else if (clusterCount_ < 65525) {
+ fatType_ = 16;
+ } else {
+ rootDirStart_ = bpb->fat32RootCluster;
+ fatType_ = 32;
+ }
+ return true;
+}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
