) ?
#define CJ_ID "teensySDproto.c"
/* Initialises an SD card and analyzes its structure using either
1) grieman's SdFat_beta for teensy 3.5/6 at
https://github.com/greiman/SdFat-beta/blob/master/changes.txt or
2) teensy SD library (SDIO = 0) */
// 15Jan: SPI mode not working (but SDIO mode working)
#define USE_SDIO 0 // 0: access SD via SPI, 1:use SDIO
#define sdErrorMsg(msg) sd.errorPrint(F(msg)); // store error strings in flash
#include <SPI.h>
#include <SdFat.h> // grieman's SdFat_beta
/* Default SD chip select (CS) is the SPI SS pin. Other common pins:
- Arduino Ethernet shield, pin 4.
- SparkFun SD shield, pin 8.
- Adafruit SD shields and modules, pin 10 */
//const uint8_t SD_CHIP_SELECT = SS;
const uint8_t SD_CHIP_SELECT = BUILTIN_SDCARD;
/* Set DISABLE_CHIP_SELECT to disable a second SPI device. For example, with the
* Ethernet shield, set DISABLE_CHIP_SELECT = 10 to disable the Ethernet controller. */
const int8_t DISABLE_CHIP_SELECT = -1;
#if USE_SDIO
//SdFatSdio sd;
SdFatSdioEX sd; // faster
#else
SdFat sd;
#endif
ArduinoOutStream cout(Serial); // serial output steam
uint32_t cardSize;
uint32_t eraseSize;
//------------------------------------------------------------------------------
void setup() {
delay(2000);
Serial.begin(9600);
while (!Serial && (millis() <= 4000)) {SysCall::yield();} // Wait up to 4 seconds for USB Serial
cout << uppercase << showbase << '\n'; // use uppercase hex and 0X base prefix
cout << F("SdFat version: ") << SD_FAT_VERSION << '\n';
#if !USE_SDIO
if (DISABLE_CHIP_SELECT < 0) {
cout << F("\nAssuming the SD is the only SPI device.\n"
"Edit DISABLE_CHIP_SELECT to disable another device.\n");
}
else {
cout << F("\nDisabling SPI device on pin ");
cout << int(DISABLE_CHIP_SELECT) << endl;
pinMode(DISABLE_CHIP_SELECT, OUTPUT);
digitalWrite(DISABLE_CHIP_SELECT, HIGH);
}
cout << F("\nAssuming the SD chip select pin is: ") <<int(SD_CHIP_SELECT);
cout << F("\nEdit SD_CHIP_SELECT to change the SD chip select pin.\n");
#endif
}
//------------------------------------------------------------------------------
void loop() {
do {delay(10);} while (Serial.available() && Serial.read() >= 0); // Flush any existing Serial data.
cout << F("\ntype any character to start\n");
while (!Serial.available()) {SysCall::yield();}
uint32_t t = millis();
#if USE_SDIO
if (!sd.cardBegin()) {sdErrorMsg("\ncardBegin failed"); return;}
#else // Initialize at the highest speed supported by the board that is
// not over 50 MHz. Try a lower speed if SPI errors occur.
if (!sd.cardBegin(SD_CHIP_SELECT, SD_SCK_MHZ(50))) {
sdErrorMsg("cardBegin failed"); return;}
#endif
t = millis() - t;
cardSize = sd.card()->cardSize();
if (cardSize == 0) {
sdErrorMsg("cardSize failed");
return;}
cout << F("\ninit time: ") << t << " ms" << '\n';
cout << F("\nCard type: ");
switch (sd.card()->type()) {
case SD_CARD_TYPE_SD1:
cout << F("SD1\n");
break;
case SD_CARD_TYPE_SD2:
cout << F("SD2\n");
break;
case SD_CARD_TYPE_SDHC:
if (cardSize < 70000000) {cout << F("SDHC\n");}
else {cout << F("SDXC\n");}
break;
default: cout << F("Unknown\n");
}
if (!cidDmp()) {return; }
if (!csdDmp()) {return;}
uint32_t ocr;
if (!sd.card()->readOCR(&ocr)) {
sdErrorMsg("\nreadOCR failed");
return;}
cout << F("OCR: ") << hex << ocr << dec << '\n';
if (!partDmp()){return;}
if (!sd.fsBegin()) {
sdErrorMsg("\nFile System initialization failed.\n");
return;}
volDmp();
}//------------------------------------------------------------------------------
// store error strings in flash
//#define sdErrorMsg(msg) sd.errorPrint(F(msg));
//------------------------------------------------------------------------------
uint8_t cidDmp() {
cid_t cid;
if (!sd.card()->readCID(&cid)) {
sdErrorMsg("readCID failed");
return false;
}
cout << F("\nManufacturer ID: ");
cout << hex << int(cid.mid) << dec << '\n';
cout << F("OEM ID: ") << cid.oid[0] << cid.oid[1] << '\n';
cout << F("Product: ");
for (uint8_t i = 0; i < 5; i++) {
cout << cid.pnm[i];
}
cout << F("\nVersion: ");
cout << int(cid.prv_n) << '.' << int(cid.prv_m) << '\n';
cout << F("Serial number: ") << hex << cid.psn << dec << '\n';
cout << F("Manufacturing date: ");
cout << int(cid.mdt_month) << '/';
cout << (2000 + cid.mdt_year_low + 10 * cid.mdt_year_high) << '\n';
cout << '\n';
return true;
}
//------------------------------------------------------------------------------
uint8_t csdDmp() {
csd_t csd;
uint8_t eraseSingleBlock;
if (!sd.card()->readCSD(&csd)) {
sdErrorMsg("readCSD failed");
return false;
}
if (csd.v1.csd_ver == 0) {
eraseSingleBlock = csd.v1.erase_blk_en;
eraseSize = (csd.v1.sector_size_high << 1) | csd.v1.sector_size_low;
} else if (csd.v2.csd_ver == 1) {
eraseSingleBlock = csd.v2.erase_blk_en;
eraseSize = (csd.v2.sector_size_high << 1) | csd.v2.sector_size_low;
} else {
cout << F("csd version error\n");
return false;
}
eraseSize++;
cout << F("cardSize: ") << 0.000512*cardSize;
cout << F(" MB (MB = 1,000,000 bytes)\n");
cout << F("flashEraseSize: ") << int(eraseSize) << F(" blocks\n");
cout << F("eraseSingleBlock: ");
if (eraseSingleBlock) {
cout << F("true\n");
} else {
cout << F("false\n");
}
return true;
}
//------------------------------------------------------------------------------
// print partition table
uint8_t partDmp() {
mbr_t mbr;
if (!sd.card()->readBlock(0, (uint8_t*)&mbr)) {
sdErrorMsg("read MBR failed");
return false;
}
for (uint8_t ip = 1; ip < 5; ip++) {
part_t *pt = &mbr.part[ip - 1];
if ((pt->boot & 0X7F) != 0 || pt->firstSector > cardSize) {
cout << F("\nNo MBR. Assuming Super Floppy format.\n");
return true;
}
}
cout << F("\nSD Partition Table\n");
cout << F("part,boot,type,start,length\n");
for (uint8_t ip = 1; ip < 5; ip++) {
part_t *pt = &mbr.part[ip - 1];
cout << int(ip) << ',' << hex << int(pt->boot) << ',' << int(pt->type);
cout << dec << ',' << pt->firstSector <<',' << pt->totalSectors << '\n';
}
return true;
}
//------------------------------------------------------------------------------
void volDmp() {
cout << F("\nVolume is FAT") << int(sd.vol()->fatType()) << '\n';
cout << F("blocksPerCluster: ") << int(sd.vol()->blocksPerCluster()) << '\n';
cout << F("clusterCount: ") << sd.vol()->clusterCount() << '\n';
cout << F("freeClusters: ");
uint32_t volFree = sd.vol()->freeClusterCount();
cout << volFree << '\n';
float fs = 0.000512*volFree*sd.vol()->blocksPerCluster();
cout << F("freeSpace: ") << fs << F(" MB (MB = 1,000,000 bytes)\n");
cout << F("fatStartBlock: ") << sd.vol()->fatStartBlock() << '\n';
cout << F("fatCount: ") << int(sd.vol()->fatCount()) << '\n';
cout << F("blocksPerFat: ") << sd.vol()->blocksPerFat() << '\n';
cout << F("rootDirStart: ") << sd.vol()->rootDirStart() << '\n';
cout << F("dataStartBlock: ") << sd.vol()->dataStartBlock() << '\n';
if (sd.vol()->dataStartBlock() % eraseSize) {
cout << F("Data area is not aligned on flash erase boundaries!\n");
cout << F("Download and use formatter from www.sdcard.org!\n");
}
}#include <SdFat.h> // microSD interface
#include <SPI.h>
#include <Streaming.h> // for simplified Serial string commands
.
.
#define CS_pin 48 // (microSD:8, EtherMEGA:4, adafruit shield:10)
.
.
SdFat SD;
boolean SD_OK = true; // assume SD card OK as default
File root; // SD card top directory
File logfile; // SD card logfile
.
.
void setup(){
pinMode(CS_pin, OUTPUT);
if (!SD.begin(CS_pin)){
Serial << F("[SD init FAILED]\n");
SD_OK = false;
}
else {
Serial << F("[SD OK]\n");
root = SD.open("/");
printDirectory(root, 0);
}
}
void loop(){
.
.
if (logButtonPressed) processLogButton(); // see toggleLogging Interrupt Service Routine
if (loggingActive) {addLogEntry();}
.
.
}
void processLogButton(){
if (!loggingActive){ // if first time in this logging session
loggingActive = true; // start logging, but only if SD OK
Serial << F("LOGGING to: <") << logFileName << ">\n";
logfile = SD.open(logFileName,FILE_WRITE); // only Open/Close once, not every row
else { // button pressed while logging is active = request for OFF
loggingActive = false; // toggle logging OFF
logfile.close(); // close the file (once only, not every row)
}
}
void addLogEntry(){
.
.
if (logfile){
logfile << entryNo << ',' << data1 << ',' << data2 << '\n';
.
.
}
}AFAIK yes
It's there .... but commented out in lieu of "SdFatSdioEX sd" as suggested by bill (code is in my post #32). EDIT: also tried "SdFatSdio sd;" - no luck
I am using Bills latest, but I searched and there is no mention of BUILTIN_SDCARD therein, so presumably it makes no sense to use BUILTIN_SDCARD with SdFat lib ?
There's no other SdFat version. I have always been trying to use Bill Greiman's SdFat-beta library (per your link) throughout this discussion. And I reloaded it again recently, just in case.
Yes
See below - I'm only using the built in SD socket on a T3.5.
Are you sure that will not be linked in? The solution in my case was to delete SKETCHES/libraries/SD directory