SdFat.h

Go to the documentation of this file.

 
#ifndef SdFat_h
#define SdFat_h
#include "ExFatLib/ExFatLib.h"
#include "FatLib/FatLib.h"
#include "FsLib/FsLib.h"
#include "SdCard/SdCard.h"
#include "common/SysCall.h"
#if INCLUDE_SDIOS
#include "sdios.h"
#endif // INCLUDE_SDIOS
//------------------------------------------------------------------------------
#define SD_FAT_VERSION 20007
#define SD_FAT_VERSION_STR "2.0.7"
//==============================================================================
template <class Vol> class SdBase : public Vol
{
  public:
    //----------------------------------------------------------------------------
    bool begin(SdCsPin_t csPin = SS)
    {
#ifdef BUILTIN_SDCARD
        if (csPin == BUILTIN_SDCARD)
        {
            return begin(SdioConfig(FIFO_SDIO));
        }
#endif // BUILTIN_SDCARD
        return begin(SdSpiConfig(csPin, SHARED_SPI));
    }
    //----------------------------------------------------------------------------
    bool begin(SdCsPin_t csPin, uint32_t maxSck)
    {
        return begin(SdSpiConfig(csPin, SHARED_SPI, maxSck));
    }
    //----------------------------------------------------------------------------
    bool begin(SdSpiConfig spiConfig)
    {
        return cardBegin(spiConfig) && Vol::begin(m_card);
    }
    //---------------------------------------------------------------------------
    bool begin(SdioConfig sdioConfig)
    {
        return cardBegin(sdioConfig) && Vol::begin(m_card);
    }
    //----------------------------------------------------------------------------
    SdCard *card()
    {
        return m_card;
    }
    //----------------------------------------------------------------------------
    bool cardBegin(SdSpiConfig spiConfig)
    {
        m_card = m_cardFactory.newCard(spiConfig);
        return m_card && !m_card->errorCode();
    }
    //----------------------------------------------------------------------------
    bool cardBegin(SdioConfig sdioConfig)
    {
        m_card = m_cardFactory.newCard(sdioConfig);
        return m_card && !m_card->errorCode();
    }
    //----------------------------------------------------------------------------
    void errorHalt(print_t *pr)
    {
        if (sdErrorCode())
        {
            pr->print(F("SdError: 0X"));
            pr->print(sdErrorCode(), HEX);
            pr->print(F(",0X"));
            pr->println(sdErrorData(), HEX);
        }
        else if (!Vol::fatType())
        {
            pr->println(F("Check SD format."));
        }
        SysCall::halt();
    }
    //----------------------------------------------------------------------------
    void errorHalt(print_t *pr, const char *msg)
    {
        pr->print(F("error: "));
        pr->println(msg);
        errorHalt(pr);
    }
    //----------------------------------------------------------------------------
    void errorHalt(print_t *pr, const __FlashStringHelper *msg)
    {
        pr->print(F("error: "));
        pr->println(msg);
        errorHalt(pr);
    }
    //----------------------------------------------------------------------------
    void initErrorHalt(print_t *pr)
    {
        initErrorPrint(pr);
        SysCall::halt();
    }
    //----------------------------------------------------------------------------
    void initErrorHalt(print_t *pr, const char *msg)
    {
        pr->println(msg);
        initErrorHalt(pr);
    }
    //----------------------------------------------------------------------------
    void initErrorHalt(Print *pr, const __FlashStringHelper *msg)
    {
        pr->println(msg);
        initErrorHalt(pr);
    }
    //----------------------------------------------------------------------------
    void initErrorPrint(Print *pr)
    {
        pr->println(F("begin() failed"));
        if (sdErrorCode())
        {
            pr->println(F("Do not reformat the SD."));
            if (sdErrorCode() == SD_CARD_ERROR_CMD0)
            {
                pr->println(F("No card, wrong chip select pin, or wiring error?"));
            }
        }
        errorPrint(pr);
    }
    //----------------------------------------------------------------------------
    void printFatType(print_t *pr)
    {
        if (Vol::fatType() == FAT_TYPE_EXFAT)
        {
            pr->print(F("exFAT"));
        }
        else
        {
            pr->print(F("FAT"));
            pr->print(Vol::fatType());
        }
    }
    //----------------------------------------------------------------------------
    void errorPrint(print_t *pr)
    {
        if (sdErrorCode())
        {
            pr->print(F("SdError: 0X"));
            pr->print(sdErrorCode(), HEX);
            pr->print(F(",0X"));
            pr->println(sdErrorData(), HEX);
        }
        else if (!Vol::fatType())
        {
            pr->println(F("Check SD format."));
        }
    }
    //----------------------------------------------------------------------------
    void errorPrint(print_t *pr, char const *msg)
    {
        pr->print(F("error: "));
        pr->println(msg);
        errorPrint(pr);
    }
 
    void errorPrint(Print *pr, const __FlashStringHelper *msg)
    {
        pr->print(F("error: "));
        pr->println(msg);
        errorPrint(pr);
    }
    //----------------------------------------------------------------------------
    void printSdError(print_t *pr)
    {
        if (sdErrorCode())
        {
            if (sdErrorCode() == SD_CARD_ERROR_CMD0)
            {
                pr->println(F("No card, wrong chip select pin, or wiring error?"));
            }
            pr->print(F("SD error: "));
            printSdErrorSymbol(pr, sdErrorCode());
            pr->print(F(" = 0x"));
            pr->print(sdErrorCode(), HEX);
            pr->print(F(",0x"));
            pr->println(sdErrorData(), HEX);
        }
        else if (!Vol::fatType())
        {
            pr->println(F("Check SD format."));
        }
    }
    //----------------------------------------------------------------------------
    uint8_t sdErrorCode()
    {
        if (m_card)
        {
            return m_card->errorCode();
        }
        return SD_CARD_ERROR_INVALID_CARD_CONFIG;
    }
    //----------------------------------------------------------------------------
    uint8_t sdErrorData()
    {
        return m_card ? m_card->errorData() : 0;
    }
    //----------------------------------------------------------------------------
    Vol *vol()
    {
        return reinterpret_cast<Vol *>(this);
    }
    //----------------------------------------------------------------------------
    bool volumeBegin()
    {
        return Vol::begin(m_card);
    }
#if ENABLE_ARDUINO_SERIAL
    void initErrorPrint()
    {
        initErrorPrint(&Serial);
    }
    //----------------------------------------------------------------------------
    void errorHalt(const __FlashStringHelper *msg)
    {
        errorHalt(&Serial, msg);
    }
    //----------------------------------------------------------------------------
    void errorHalt()
    {
        errorHalt(&Serial);
    }
    //----------------------------------------------------------------------------
    void errorHalt(const char *msg)
    {
        errorHalt(&Serial, msg);
    }
    //----------------------------------------------------------------------------
    void initErrorHalt()
    {
        initErrorHalt(&Serial);
    }
    //----------------------------------------------------------------------------
    void errorPrint(const char *msg)
    {
        errorPrint(&Serial, msg);
    }
    void errorPrint(const __FlashStringHelper *msg)
    {
        errorPrint(&Serial, msg);
    }
    //----------------------------------------------------------------------------
    void initErrorHalt(const char *msg)
    {
        initErrorHalt(&Serial, msg);
    }
    //----------------------------------------------------------------------------
    void initErrorHalt(const __FlashStringHelper *msg)
    {
        initErrorHalt(&Serial, msg);
    }
#endif // ENABLE_ARDUINO_SERIAL
       //----------------------------------------------------------------------------
  private:
    SdCard *m_card;
    SdCardFactory m_cardFactory;
};
//------------------------------------------------------------------------------
class SdFat32 : public SdBase<FatVolume>
{
  public:
    bool format(print_t *pr = nullptr)
    {
        FatFormatter fmt;
        uint8_t *cache = cacheClear();
        if (!cache)
        {
            return false;
        }
        return fmt.format(card(), cache, pr);
    }
};
//------------------------------------------------------------------------------
class SdExFat : public SdBase<ExFatVolume>
{
  public:
    bool format(print_t *pr = nullptr)
    {
        ExFatFormatter fmt;
        uint8_t *cache = cacheClear();
        if (!cache)
        {
            return false;
        }
        return fmt.format(card(), cache, pr);
    }
};
//------------------------------------------------------------------------------
class SdFs : public SdBase<FsVolume>
{
  public:
    bool format(print_t *pr = nullptr)
    {
        static_assert(sizeof(m_volMem) >= 512, "m_volMem too small");
        uint32_t sectorCount = card()->sectorCount();
        if (sectorCount == 0)
        {
            return false;
        }
        end();
        if (sectorCount > 67108864)
        {
            ExFatFormatter fmt;
            return fmt.format(card(), reinterpret_cast<uint8_t *>(m_volMem), pr);
        }
        else
        {
            FatFormatter fmt;
            return fmt.format(card(), reinterpret_cast<uint8_t *>(m_volMem), pr);
        }
    }
};
//------------------------------------------------------------------------------
#if SDFAT_FILE_TYPE == 1
typedef SdFat32 SdFat;
#if !defined(__has_include) || !__has_include(<FS.h>)
typedef File32 File;
#endif
typedef FatFile SdBaseFile;
#elif SDFAT_FILE_TYPE == 2
typedef SdExFat SdFat;
#if !defined(__has_include) || !__has_include(<FS.h>)
typedef ExFile File;
#endif
typedef ExFatFile SdBaseFile;
#elif SDFAT_FILE_TYPE == 3
typedef SdFs SdFat;
#if !defined(__has_include) || !__has_include(<FS.h>)
typedef FsFile File;
#endif
typedef FsBaseFile SdBaseFile;
#else // SDFAT_FILE_TYPE
#error Invalid SDFAT_FILE_TYPE
#endif // SDFAT_FILE_TYPE
class SdFile : public PrintFile<SdBaseFile>
{
  public:
    SdFile()
    {
    }
    SdFile(const char *path, oflag_t oflag)
    {
        open(path, oflag);
    }
    static void dateTimeCallback(void (*dateTime)(uint16_t *date, uint16_t *time))
    {
        FsDateTime::setCallback(dateTime);
    }
    static void dateTimeCallbackCancel()
    {
        FsDateTime::clearCallback();
    }
};
#endif // SdFat_h