Prvni ulozeni z chegewara githubu

libraries/SD_MMC/examples/SDMMC_Test/SDMMC_Test.ino

@@ -0,0 +1,218 @@
+/*
+ * Connect the SD card to the following pins:
+ *
+ * SD Card | ESP32
+ *    D2       12
+ *    D3       13
+ *    CMD      15
+ *    VSS      GND
+ *    VDD      3.3V
+ *    CLK      14
+ *    VSS      GND
+ *    D0       2  (add 1K pull up after flashing)
+ *    D1       4
+ */
+
+#include "FS.h"
+#include "SD_MMC.h"
+
+void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
+    Serial.printf("Listing directory: %s\n", dirname);
+
+    File root = fs.open(dirname);
+    if(!root){
+        Serial.println("Failed to open directory");
+        return;
+    }
+    if(!root.isDirectory()){
+        Serial.println("Not a directory");
+        return;
+    }
+
+    File file = root.openNextFile();
+    while(file){
+        if(file.isDirectory()){
+            Serial.print("  DIR : ");
+            Serial.println(file.name());
+            if(levels){
+                listDir(fs, file.path(), levels -1);
+            }
+        } else {
+            Serial.print("  FILE: ");
+            Serial.print(file.name());
+            Serial.print("  SIZE: ");
+            Serial.println(file.size());
+        }
+        file = root.openNextFile();
+    }
+}
+
+void createDir(fs::FS &fs, const char * path){
+    Serial.printf("Creating Dir: %s\n", path);
+    if(fs.mkdir(path)){
+        Serial.println("Dir created");
+    } else {
+        Serial.println("mkdir failed");
+    }
+}
+
+void removeDir(fs::FS &fs, const char * path){
+    Serial.printf("Removing Dir: %s\n", path);
+    if(fs.rmdir(path)){
+        Serial.println("Dir removed");
+    } else {
+        Serial.println("rmdir failed");
+    }
+}
+
+void readFile(fs::FS &fs, const char * path){
+    Serial.printf("Reading file: %s\n", path);
+
+    File file = fs.open(path);
+    if(!file){
+        Serial.println("Failed to open file for reading");
+        return;
+    }
+
+    Serial.print("Read from file: ");
+    while(file.available()){
+        Serial.write(file.read());
+    }
+}
+
+void writeFile(fs::FS &fs, const char * path, const char * message){
+    Serial.printf("Writing file: %s\n", path);
+
+    File file = fs.open(path, FILE_WRITE);
+    if(!file){
+        Serial.println("Failed to open file for writing");
+        return;
+    }
+    if(file.print(message)){
+        Serial.println("File written");
+    } else {
+        Serial.println("Write failed");
+    }
+}
+
+void appendFile(fs::FS &fs, const char * path, const char * message){
+    Serial.printf("Appending to file: %s\n", path);
+
+    File file = fs.open(path, FILE_APPEND);
+    if(!file){
+        Serial.println("Failed to open file for appending");
+        return;
+    }
+    if(file.print(message)){
+        Serial.println("Message appended");
+    } else {
+        Serial.println("Append failed");
+    }
+}
+
+void renameFile(fs::FS &fs, const char * path1, const char * path2){
+    Serial.printf("Renaming file %s to %s\n", path1, path2);
+    if (fs.rename(path1, path2)) {
+        Serial.println("File renamed");
+    } else {
+        Serial.println("Rename failed");
+    }
+}
+
+void deleteFile(fs::FS &fs, const char * path){
+    Serial.printf("Deleting file: %s\n", path);
+    if(fs.remove(path)){
+        Serial.println("File deleted");
+    } else {
+        Serial.println("Delete failed");
+    }
+}
+
+void testFileIO(fs::FS &fs, const char * path){
+    File file = fs.open(path);
+    static uint8_t buf[512];
+    size_t len = 0;
+    uint32_t start = millis();
+    uint32_t end = start;
+    if(file){
+        len = file.size();
+        size_t flen = len;
+        start = millis();
+        while(len){
+            size_t toRead = len;
+            if(toRead > 512){
+                toRead = 512;
+            }
+            file.read(buf, toRead);
+            len -= toRead;
+        }
+        end = millis() - start;
+        Serial.printf("%u bytes read for %u ms\n", flen, end);
+        file.close();
+    } else {
+        Serial.println("Failed to open file for reading");
+    }
+
+
+    file = fs.open(path, FILE_WRITE);
+    if(!file){
+        Serial.println("Failed to open file for writing");
+        return;
+    }
+
+    size_t i;
+    start = millis();
+    for(i=0; i<2048; i++){
+        file.write(buf, 512);
+    }
+    end = millis() - start;
+    Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
+    file.close();
+}
+
+void setup(){
+    Serial.begin(115200);
+    if(!SD_MMC.begin()){
+        Serial.println("Card Mount Failed");
+        return;
+    }
+    uint8_t cardType = SD_MMC.cardType();
+
+    if(cardType == CARD_NONE){
+        Serial.println("No SD_MMC card attached");
+        return;
+    }
+
+    Serial.print("SD_MMC Card Type: ");
+    if(cardType == CARD_MMC){
+        Serial.println("MMC");
+    } else if(cardType == CARD_SD){
+        Serial.println("SDSC");
+    } else if(cardType == CARD_SDHC){
+        Serial.println("SDHC");
+    } else {
+        Serial.println("UNKNOWN");
+    }
+
+    uint64_t cardSize = SD_MMC.cardSize() / (1024 * 1024);
+    Serial.printf("SD_MMC Card Size: %lluMB\n", cardSize);
+
+    listDir(SD_MMC, "/", 0);
+    createDir(SD_MMC, "/mydir");
+    listDir(SD_MMC, "/", 0);
+    removeDir(SD_MMC, "/mydir");
+    listDir(SD_MMC, "/", 2);
+    writeFile(SD_MMC, "/hello.txt", "Hello ");
+    appendFile(SD_MMC, "/hello.txt", "World!\n");
+    readFile(SD_MMC, "/hello.txt");
+    deleteFile(SD_MMC, "/foo.txt");
+    renameFile(SD_MMC, "/hello.txt", "/foo.txt");
+    readFile(SD_MMC, "/foo.txt");
+    testFileIO(SD_MMC, "/test.txt");
+    Serial.printf("Total space: %lluMB\n", SD_MMC.totalBytes() / (1024 * 1024));
+    Serial.printf("Used space: %lluMB\n", SD_MMC.usedBytes() / (1024 * 1024));
+}
+
+void loop(){
+
+}

libraries/SD_MMC/examples/SDMMC_time/SDMMC_time.ino

@@ -0,0 +1,213 @@
+/*
+ * Connect the SD card to the following pins:
+ *
+ * SD Card | ESP32
+ *    D2       -
+ *    D3       SS
+ *    CMD      MOSI
+ *    VSS      GND
+ *    VDD      3.3V
+ *    CLK      SCK
+ *    VSS      GND
+ *    D0       MISO
+ *    D1       -
+ */
+
+#include "FS.h"
+#include "SD_MMC.h"
+#include "SPI.h"
+#include <time.h> 
+#include <WiFi.h>
+
+const char* ssid     = "your-ssid";
+const char* password = "your-password";
+
+long timezone = 1; 
+byte daysavetime = 1;
+
+void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
+    Serial.printf("Listing directory: %s\n", dirname);
+
+    File root = fs.open(dirname);
+    if(!root){
+        Serial.println("Failed to open directory");
+        return;
+    }
+    if(!root.isDirectory()){
+        Serial.println("Not a directory");
+        return;
+    }
+
+    File file = root.openNextFile();
+    while(file){
+        if(file.isDirectory()){
+            Serial.print("  DIR : ");
+            Serial.print (file.name());
+            time_t t= file.getLastWrite();
+            struct tm * tmstruct = localtime(&t);
+            Serial.printf("  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n",(tmstruct->tm_year)+1900,( tmstruct->tm_mon)+1, tmstruct->tm_mday,tmstruct->tm_hour , tmstruct->tm_min, tmstruct->tm_sec);
+            if(levels){
+                listDir(fs, file.path(), levels -1);
+            }
+        } else {
+            Serial.print("  FILE: ");
+            Serial.print(file.name());
+            Serial.print("  SIZE: ");
+            Serial.print(file.size());
+            time_t t= file.getLastWrite();
+            struct tm * tmstruct = localtime(&t);
+            Serial.printf("  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n",(tmstruct->tm_year)+1900,( tmstruct->tm_mon)+1, tmstruct->tm_mday,tmstruct->tm_hour , tmstruct->tm_min, tmstruct->tm_sec);
+        }
+        file = root.openNextFile();
+    }
+}
+
+void createDir(fs::FS &fs, const char * path){
+    Serial.printf("Creating Dir: %s\n", path);
+    if(fs.mkdir(path)){
+        Serial.println("Dir created");
+    } else {
+        Serial.println("mkdir failed");
+    }
+}
+
+void removeDir(fs::FS &fs, const char * path){
+    Serial.printf("Removing Dir: %s\n", path);
+    if(fs.rmdir(path)){
+        Serial.println("Dir removed");
+    } else {
+        Serial.println("rmdir failed");
+    }
+}
+
+void readFile(fs::FS &fs, const char * path){
+    Serial.printf("Reading file: %s\n", path);
+
+    File file = fs.open(path);
+    if(!file){
+        Serial.println("Failed to open file for reading");
+        return;
+    }
+
+    Serial.print("Read from file: ");
+    while(file.available()){
+        Serial.write(file.read());
+    }
+    file.close();
+}
+
+void writeFile(fs::FS &fs, const char * path, const char * message){
+    Serial.printf("Writing file: %s\n", path);
+
+    File file = fs.open(path, FILE_WRITE);
+    if(!file){
+        Serial.println("Failed to open file for writing");
+        return;
+    }
+    if(file.print(message)){
+        Serial.println("File written");
+    } else {
+        Serial.println("Write failed");
+    }
+    file.close();
+}
+
+void appendFile(fs::FS &fs, const char * path, const char * message){
+    Serial.printf("Appending to file: %s\n", path);
+
+    File file = fs.open(path, FILE_APPEND);
+    if(!file){
+        Serial.println("Failed to open file for appending");
+        return;
+    }
+    if(file.print(message)){
+        Serial.println("Message appended");
+    } else {
+        Serial.println("Append failed");
+    }
+    file.close();
+}
+
+void renameFile(fs::FS &fs, const char * path1, const char * path2){
+    Serial.printf("Renaming file %s to %s\n", path1, path2);
+    if (fs.rename(path1, path2)) {
+        Serial.println("File renamed");
+    } else {
+        Serial.println("Rename failed");
+    }
+}
+
+void deleteFile(fs::FS &fs, const char * path){
+    Serial.printf("Deleting file: %s\n", path);
+    if(fs.remove(path)){
+        Serial.println("File deleted");
+    } else {
+        Serial.println("Delete failed");
+    }
+}
+
+void setup(){
+    Serial.begin(115200);
+    // We start by connecting to a WiFi network
+    Serial.println();
+    Serial.println();
+    Serial.print("Connecting to ");
+    Serial.println(ssid);
+
+    WiFi.begin(ssid, password);
+
+    while (WiFi.status() != WL_CONNECTED) {
+        delay(500);
+        Serial.print(".");
+    }
+    Serial.println("WiFi connected");
+    Serial.println("IP address: ");
+    Serial.println(WiFi.localIP());
+    Serial.println("Contacting Time Server");
+	configTime(3600*timezone, daysavetime*3600, "time.nist.gov", "0.pool.ntp.org", "1.pool.ntp.org");
+	struct tm tmstruct ;
+    delay(2000);
+    tmstruct.tm_year = 0;
+    getLocalTime(&tmstruct, 5000);
+	Serial.printf("\nNow is : %d-%02d-%02d %02d:%02d:%02d\n",(tmstruct.tm_year)+1900,( tmstruct.tm_mon)+1, tmstruct.tm_mday,tmstruct.tm_hour , tmstruct.tm_min, tmstruct.tm_sec);
+    Serial.println("");
+    
+    if(!SD_MMC.begin()){
+        Serial.println("Card Mount Failed");
+        return;
+    }
+    uint8_t cardType = SD_MMC.cardType();
+
+    if(cardType == CARD_NONE){
+        Serial.println("No SD card attached");
+        return;
+    }
+
+    Serial.print("SD Card Type: ");
+    if(cardType == CARD_MMC){
+        Serial.println("MMC");
+    } else if(cardType == CARD_SD){
+        Serial.println("SDSC");
+    } else if(cardType == CARD_SDHC){
+        Serial.println("SDHC");
+    } else {
+        Serial.println("UNKNOWN");
+    }
+
+    uint64_t cardSize = SD_MMC.cardSize() / (1024 * 1024);
+    Serial.printf("SD Card Size: %lluMB\n", cardSize);
+
+    listDir(SD_MMC, "/", 0);
+    removeDir(SD_MMC, "/mydir");
+    createDir(SD_MMC, "/mydir");
+    deleteFile(SD_MMC, "/hello.txt");
+    writeFile(SD_MMC, "/hello.txt", "Hello ");
+    appendFile(SD_MMC, "/hello.txt", "World!\n");
+	listDir(SD_MMC, "/", 0);
+}
+
+void loop(){
+
+}
+
+

libraries/SD_MMC/library.properties

@@ -0,0 +1,9 @@
+name=SD_MMC
+version=2.0.0
+author=Hristo Gochkov, Ivan Grokhtkov
+maintainer=Hristo Gochkov <hristo@espressif.com>
+sentence=ESP32 SDMMC File System
+paragraph=
+category=Data Storage
+url=
+architectures=esp32

libraries/SD_MMC/src/SD_MMC.cpp

@@ -0,0 +1,201 @@
+// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "pins_arduino.h"
+#include "SD_MMC.h"
+#ifdef SOC_SDMMC_HOST_SUPPORTED
+#include "vfs_api.h"
+
+#include <dirent.h>
+#include "esp_vfs_fat.h"
+#include "driver/sdmmc_host.h"
+#include "driver/sdmmc_defs.h"
+#include "sdmmc_cmd.h"
+#include "soc/sdmmc_pins.h"
+#include "ff.h"
+
+using namespace fs;
+
+
+SDMMCFS::SDMMCFS(FSImplPtr impl)
+    : FS(impl), _card(nullptr)
+{
+#if defined(SOC_SDMMC_USE_GPIO_MATRIX) && defined(BOARD_HAS_SDMMC)
+    _pin_clk = SDMMC_CLK;
+    _pin_cmd = SDMMC_CMD;
+    _pin_d0 = SDMMC_D0;
+#ifndef BOARD_HAS_1BIT_SDMMC
+    _pin_d1 = SDMMC_D1;
+    _pin_d2 = SDMMC_D2;
+    _pin_d3 = SDMMC_D3;
+#endif // BOARD_HAS_1BIT_SDMMC
+#endif // defined(SOC_SDMMC_USE_GPIO_MATRIX) && defined(BOARD_HAS_SDMMC)
+}
+
+bool SDMMCFS::setPins(int clk, int cmd, int d0)
+{
+    return setPins(clk, cmd, d0, GPIO_NUM_NC, GPIO_NUM_NC, GPIO_NUM_NC);
+}
+
+bool SDMMCFS::setPins(int clk, int cmd, int d0, int d1, int d2, int d3)
+{
+    if (_card != nullptr) {
+        log_e("SD_MMC.setPins must be called before SD_MMC.begin");
+        return false;
+    }
+#ifdef SOC_SDMMC_USE_GPIO_MATRIX
+    // SoC supports SDMMC pin configuration via GPIO matrix. Save the pins for later use in SDMMCFS::begin.
+    _pin_clk = (int8_t) clk;
+    _pin_cmd = (int8_t) cmd;
+    _pin_d0 = (int8_t) d0;
+    _pin_d1 = (int8_t) d1;
+    _pin_d2 = (int8_t) d2;
+    _pin_d3 = (int8_t) d3;
+    return true;
+#elif CONFIG_IDF_TARGET_ESP32
+    // ESP32 doesn't support SDMMC pin configuration via GPIO matrix.
+    // Since SDMMCFS::begin hardcodes the usage of slot 1, only check if
+    // the pins match slot 1 pins.
+    bool pins_ok = (clk == (int)SDMMC_SLOT1_IOMUX_PIN_NUM_CLK) &&
+        (cmd == (int)SDMMC_SLOT1_IOMUX_PIN_NUM_CMD) &&
+        (d0 == (int)SDMMC_SLOT1_IOMUX_PIN_NUM_D0) &&
+        (((d1 == -1) && (d2 == -1) && (d3 == -1)) ||
+         ((d1 == (int)SDMMC_SLOT1_IOMUX_PIN_NUM_D1) &&
+         (d1 == (int)SDMMC_SLOT1_IOMUX_PIN_NUM_D2) &&
+         (d1 == (int)SDMMC_SLOT1_IOMUX_PIN_NUM_D3)));
+    if (!pins_ok) {
+        log_e("SDMMCFS: specified pins are not supported by this chip.");
+        return false;
+    }
+    return true;
+#else
+#error SoC not supported
+#endif
+}
+
+bool SDMMCFS::begin(const char * mountpoint, bool mode1bit, bool format_if_mount_failed, int sdmmc_frequency, uint8_t maxOpenFiles)
+{
+    if(_card) {
+        return true;
+    }
+    //mount
+    sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
+#ifdef SOC_SDMMC_USE_GPIO_MATRIX
+    // SoC supports SDMMC pin configuration via GPIO matrix.
+    // Chech that the pins have been set either in the constructor or setPins function.
+    if (_pin_cmd == -1 || _pin_clk == -1 || _pin_d0 == -1
+        || (!mode1bit && (_pin_d1 == -1 || _pin_d2 == -1 || _pin_d3 == -1))) {
+        log_e("SDMMCFS: some SD pins are not set");
+        return false;
+    }
+
+    slot_config.clk = (gpio_num_t) _pin_clk;
+    slot_config.cmd = (gpio_num_t) _pin_cmd;
+    slot_config.d0 = (gpio_num_t) _pin_d0;
+    slot_config.d1 = (gpio_num_t) _pin_d1;
+    slot_config.d2 = (gpio_num_t) _pin_d2;
+    slot_config.d3 = (gpio_num_t) _pin_d3;
+    slot_config.width = 4;
+#endif // SOC_SDMMC_USE_GPIO_MATRIX
+    sdmmc_host_t host = SDMMC_HOST_DEFAULT();
+    host.flags = SDMMC_HOST_FLAG_4BIT;
+    host.slot = SDMMC_HOST_SLOT_1;
+    host.max_freq_khz = sdmmc_frequency;
+#ifdef BOARD_HAS_1BIT_SDMMC
+    mode1bit = true;
+#endif
+    if(mode1bit) {
+        host.flags = SDMMC_HOST_FLAG_1BIT; //use 1-line SD mode
+        slot_config.width = 1;
+    }
+
+    esp_vfs_fat_sdmmc_mount_config_t mount_config = {
+        .format_if_mount_failed = format_if_mount_failed,
+        .max_files = maxOpenFiles,
+        .allocation_unit_size = 0
+    };
+
+    esp_err_t ret = esp_vfs_fat_sdmmc_mount(mountpoint, &host, &slot_config, &mount_config, &_card);
+    if (ret != ESP_OK) {
+        if (ret == ESP_FAIL) {
+            log_e("Failed to mount filesystem. If you want the card to be formatted, set format_if_mount_failed = true.");
+        } else if (ret == ESP_ERR_INVALID_STATE) {
+            _impl->mountpoint(mountpoint);
+            log_w("SD Already mounted");
+            return true;
+        } else {
+            log_e("Failed to initialize the card (0x%x). Make sure SD card lines have pull-up resistors in place.", ret);
+        }
+        _card = NULL;
+        return false;
+    }
+    _impl->mountpoint(mountpoint);
+    return true;
+}
+
+void SDMMCFS::end()
+{
+    if(_card) {
+        esp_vfs_fat_sdmmc_unmount();
+        _impl->mountpoint(NULL);
+        _card = NULL;
+    }
+}
+
+sdcard_type_t SDMMCFS::cardType()
+{
+    if(!_card) {
+        return CARD_NONE;
+    }
+    return (_card->ocr & SD_OCR_SDHC_CAP)?CARD_SDHC:CARD_SD;
+}
+
+uint64_t SDMMCFS::cardSize()
+{
+    if(!_card) {
+        return 0;
+    }
+    return (uint64_t)_card->csd.capacity * _card->csd.sector_size;
+}
+
+uint64_t SDMMCFS::totalBytes()
+{
+	FATFS* fsinfo;
+	DWORD fre_clust;
+	if(f_getfree("0:",&fre_clust,&fsinfo)!= 0) return 0;
+    uint64_t size = ((uint64_t)(fsinfo->csize))*(fsinfo->n_fatent - 2)
+#if _MAX_SS != 512
+        *(fsinfo->ssize);
+#else
+        *512;
+#endif
+	return size;
+}
+
+uint64_t SDMMCFS::usedBytes()
+{
+	FATFS* fsinfo;
+	DWORD fre_clust;
+	if(f_getfree("0:",&fre_clust,&fsinfo)!= 0) return 0;
+	uint64_t size = ((uint64_t)(fsinfo->csize))*((fsinfo->n_fatent - 2) - (fsinfo->free_clst))
+#if _MAX_SS != 512
+        *(fsinfo->ssize);
+#else
+        *512;
+#endif
+	return size;
+}
+
+SDMMCFS SD_MMC = SDMMCFS(FSImplPtr(new VFSImpl()));
+#endif /* SOC_SDMMC_HOST_SUPPORTED */

libraries/SD_MMC/src/SD_MMC.h

@@ -0,0 +1,66 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef _SDMMC_H_
+#define _SDMMC_H_
+
+#include "sdkconfig.h"
+#include "soc/soc_caps.h"
+#ifdef SOC_SDMMC_HOST_SUPPORTED
+
+#include "FS.h"
+#include "driver/sdmmc_types.h"
+#include "sd_defines.h"
+
+// If reading/writing to the SD card is unstable, 
+// you can define BOARD_MAX_SDMMC_FREQ with lower value (Ex. SDMMC_FREQ_DEFAULT) 
+// in pins_arduino.h for your board variant.
+#ifndef BOARD_MAX_SDMMC_FREQ
+#define BOARD_MAX_SDMMC_FREQ SDMMC_FREQ_HIGHSPEED
+#endif
+
+namespace fs
+{
+
+class SDMMCFS : public FS
+{
+protected:
+    sdmmc_card_t* _card;
+
+#ifdef SOC_SDMMC_USE_GPIO_MATRIX
+    int8_t _pin_clk = -1;
+    int8_t _pin_cmd = -1;
+    int8_t _pin_d0 = -1;
+    int8_t _pin_d1 = -1;
+    int8_t _pin_d2 = -1;
+    int8_t _pin_d3 = -1;
+#endif
+
+public:
+    SDMMCFS(FSImplPtr impl);
+    bool setPins(int clk, int cmd, int d0);
+    bool setPins(int clk, int cmd, int d0, int d1, int d2, int d3);
+    bool begin(const char * mountpoint="/sdcard", bool mode1bit=false, bool format_if_mount_failed=false, int sdmmc_frequency=BOARD_MAX_SDMMC_FREQ, uint8_t maxOpenFiles = 5);
+    void end();
+    sdcard_type_t cardType();
+    uint64_t cardSize();
+    uint64_t totalBytes();
+    uint64_t usedBytes();
+};
+
+}
+
+extern fs::SDMMCFS SD_MMC;
+
+#endif /* SOC_SDMMC_HOST_SUPPORTED */
+#endif /* _SDMMC_H_ */

libraries/SD_MMC/src/sd_defines.h

@@ -0,0 +1,25 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef _SD_DEFINES_H_
+#define _SD_DEFINES_H_
+
+typedef enum {
+    CARD_NONE,
+    CARD_MMC,
+    CARD_SD,
+    CARD_SDHC,
+    CARD_UNKNOWN
+} sdcard_type_t;
+
+#endif /* _SD_DISKIO_H_ */