You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
247 lines
7.1 KiB
C++
247 lines
7.1 KiB
C++
/*
|
|
* This program attempts to initialize an SD card and analyze its structure.
|
|
*/
|
|
#include <SPI.h>
|
|
#include "SdFat.h"
|
|
|
|
// Set USE_SDIO to zero for SPI card access.
|
|
#define USE_SDIO 0
|
|
/*
|
|
* SD chip select pin. Common values are:
|
|
*
|
|
* Arduino Ethernet shield, pin 4.
|
|
* SparkFun SD shield, pin 8.
|
|
* Adafruit SD shields and modules, pin 10.
|
|
* Default SD chip select is the SPI SS pin.
|
|
*/
|
|
const uint8_t SD_CHIP_SELECT = SS;
|
|
/*
|
|
* Set DISABLE_CHIP_SELECT to disable a second SPI device.
|
|
* For example, with the Ethernet shield, set DISABLE_CHIP_SELECT
|
|
* to 10 to disable the Ethernet controller.
|
|
*/
|
|
const int8_t DISABLE_CHIP_SELECT = -1;
|
|
|
|
#if USE_SDIO
|
|
// Use faster SdioCardEX
|
|
SdFatSdioEX sd;
|
|
// SdFatSdio sd;
|
|
#else // USE_SDIO
|
|
SdFat sd;
|
|
#endif // USE_SDIO
|
|
|
|
// serial output steam
|
|
ArduinoOutStream cout(Serial);
|
|
|
|
// global for card size
|
|
uint32_t cardSize;
|
|
|
|
// global for card erase size
|
|
uint32_t eraseSize;
|
|
//------------------------------------------------------------------------------
|
|
// 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 << endl;
|
|
cout << F("OEM ID: ") << cid.oid[0] << cid.oid[1] << endl;
|
|
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) << endl;
|
|
cout << F("Serial number: ") << hex << cid.psn << dec << endl;
|
|
cout << F("Manufacturing date: ");
|
|
cout << int(cid.mdt_month) << '/';
|
|
cout << (2000 + cid.mdt_year_low + 10 * cid.mdt_year_high) << endl;
|
|
cout << endl;
|
|
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 << endl;
|
|
}
|
|
return true;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void volDmp() {
|
|
cout << F("\nVolume is FAT") << int(sd.vol()->fatType()) << endl;
|
|
cout << F("blocksPerCluster: ") << int(sd.vol()->blocksPerCluster()) << endl;
|
|
cout << F("clusterCount: ") << sd.vol()->clusterCount() << endl;
|
|
cout << F("freeClusters: ");
|
|
uint32_t volFree = sd.vol()->freeClusterCount();
|
|
cout << volFree << endl;
|
|
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() << endl;
|
|
cout << F("fatCount: ") << int(sd.vol()->fatCount()) << endl;
|
|
cout << F("blocksPerFat: ") << sd.vol()->blocksPerFat() << endl;
|
|
cout << F("rootDirStart: ") << sd.vol()->rootDirStart() << endl;
|
|
cout << F("dataStartBlock: ") << sd.vol()->dataStartBlock() << endl;
|
|
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");
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void setup() {
|
|
Serial.begin(9600);
|
|
|
|
// Wait for USB Serial
|
|
while (!Serial) {
|
|
SysCall::yield();
|
|
}
|
|
|
|
// use uppercase in hex and use 0X base prefix
|
|
cout << uppercase << showbase << endl;
|
|
|
|
// F stores strings in flash to save RAM
|
|
cout << F("SdFat version: ") << SD_FAT_VERSION << endl;
|
|
#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 // !USE_SDIO
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void loop() {
|
|
// Read any existing Serial data.
|
|
do {
|
|
delay(10);
|
|
} while (Serial.available() && Serial.read() >= 0);
|
|
|
|
// F stores strings in flash to save RAM
|
|
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 // USE_SDIO
|
|
// 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 // USE_SDIO
|
|
t = millis() - t;
|
|
|
|
cardSize = sd.card()->cardSize();
|
|
if (cardSize == 0) {
|
|
sdErrorMsg("cardSize failed");
|
|
return;
|
|
}
|
|
cout << F("\ninit time: ") << t << " ms" << endl;
|
|
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 << endl;
|
|
if (!partDmp()) {
|
|
return;
|
|
}
|
|
if (!sd.fsBegin()) {
|
|
sdErrorMsg("\nFile System initialization failed.\n");
|
|
return;
|
|
}
|
|
volDmp();
|
|
} |