MICROSD.cpp - main - electronic_modules/microSD

MICROSD.cpp
282 строки7 KB
Электронные Модули | Electronic Modules
Add files via upload
21 окт 2025, 22:09
21 окт 2025, 22:09c1735bc
#include "MICROSD.h"

MICRO_SD::MICRO_SD(int MSD_CMD, int MSD_CLK, int MSD_DAT0, int MSD_DAT1, int MSD_DAT2, int MSD_DAT3) {
    _MSD_CMD = MSD_CMD;
    _MSD_CLK = MSD_CLK;
    _MSD_DAT0 = MSD_DAT0;
    _MSD_DAT1 = MSD_DAT1;
    _MSD_DAT2 = MSD_DAT2;
    _MSD_DAT3 = MSD_DAT3;
    _initialized = false;
}

bool MICRO_SD::initial() {
    // For Arduino Uno, we'll use SPI mode as fallback since SDIO is not supported
    // Use one of the data pins as CS for SPI
    if (!SD.begin(_MSD_DAT3)) { // Using DAT3 as CS pin for SPI
        Serial.println(F("MicroSD initialization failed!"));
        _initialized = false;
        return false;
    }
    
    _initialized = true;
    Serial.println(F("MicroSD initialized successfully (SPI fallback)"));
    return true;
}

void MICRO_SD::finish() {
    _initialized = false;
    Serial.println(F("MicroSD finished"));
}

MicroSDIOFile MICRO_SD::open(const char *filename, uint8_t mode) {
    if (!_initialized) return MicroSDIOFile();
    
    File file = SD.open(filename, mode);
    if (file) {
        return MicroSDIOFile(file, filename);
    }
    return MicroSDIOFile();
}

MicroSDIOFile MICRO_SD::open(const String &filename, uint8_t mode) {
    return open(filename.c_str(), mode);
}

bool MICRO_SD::exists(const char *filepath) {
    if (!_initialized) return false;
    return SD.exists(filepath);
}

bool MICRO_SD::exists(const String &filepath) {
    return exists(filepath.c_str());
}

bool MICRO_SD::mkdir(const char *filepath) {
    if (!_initialized) return false;
    return SD.mkdir(filepath);
}

bool MICRO_SD::mkdir(const String &filepath) {
    return mkdir(filepath.c_str());
}

bool MICRO_SD::remove(const char *filepath) {
    if (!_initialized) return false;
    return SD.remove(filepath);
}

bool MICRO_SD::remove(const String &filepath) {
    return remove(filepath.c_str());
}

bool MICRO_SD::rmdir(const char *filepath) {
    if (!_initialized) return false;
    return SD.rmdir(filepath);
}

bool MICRO_SD::rmdir(const String &filepath) {
    return rmdir(filepath.c_str());
}

uint64_t MICRO_SD::totalBytes() {
    return 0; // Not available in standard SD library
}

uint64_t MICRO_SD::usedBytes() {
    return 0; // Not available in standard SD library
}

uint64_t MICRO_SD::freeBytes() {
    return 0; // Not available in standard SD library
}

bool MICRO_SD::isInitialized() {
    return _initialized;
}

void MICRO_SD::listFiles(const char *dirname) {
    if (!_initialized) return;
    
    File root = SD.open(dirname);
    if (!root) {
        Serial.print(F("Failed to open directory: "));
        Serial.println(dirname);
        return;
    }
    
    if (!root.isDirectory()) {
        Serial.print(F("Not a directory: "));
        Serial.println(dirname);
        root.close();
        return;
    }
    
    Serial.print(F("Contents of "));
    Serial.println(dirname);
    
    File file = root.openNextFile();
    while (file) {
        Serial.print("  ");
        Serial.print(file.name());
        if (file.isDirectory()) {
            Serial.println("/");
        } else {
            Serial.print(" (");
            Serial.print(file.size());
            Serial.println(" bytes)");
        }
        file.close();
        file = root.openNextFile();
    }
    root.close();
}

bool MICRO_SD::format() {
    Serial.println(F("Formatting not implemented"));
    return false;
}

bool MICRO_SD::set4BitMode() {
    Serial.println(F("4-bit mode not supported in SPI fallback"));
    return false;
}

bool MICRO_SD::set1BitMode() {
    Serial.println(F("1-bit mode not supported in SPI fallback"));
    return false;
}

uint32_t MICRO_SD::getCID() {
    return 0; // Not available in standard SD library
}

uint32_t MICRO_SD::getCSD() {
    return 0; // Not available in standard SD library
}

// MicroSDIOFile implementation
MicroSDIOFile::MicroSDIOFile() : _file(nullptr), _isOpen(false) {
    _name[0] = '\0';
}

MicroSDIOFile::MicroSDIOFile(File f, const char *name) : _file(new File(f)), _isOpen(true) {
    strncpy(_name, name, sizeof(_name) - 1);
    _name[sizeof(_name) - 1] = '\0';
}

MicroSDIOFile::~MicroSDIOFile() {
    close();
}

size_t MicroSDIOFile::write(uint8_t data) {
    if (!_isOpen || !_file) return 0;
    return _file->write(data);
}

size_t MicroSDIOFile::write(const uint8_t *buf, size_t size) {
    if (!_isOpen || !_file) return 0;
    return _file->write(buf, size);
}

int MicroSDIOFile::read() {
    if (!_isOpen || !_file) return -1;
    return _file->read();
}

int MicroSDIOFile::peek() {
    if (!_isOpen || !_file) return -1;
    return _file->peek();
}

int MicroSDIOFile::available() {
    if (!_isOpen || !_file) return 0;
    return _file->available();
}

void MicroSDIOFile::flush() {
    if (_isOpen && _file) _file->flush();
}

int MicroSDIOFile::read(void *buf, uint16_t nbyte) {
    if (!_isOpen || !_file) return 0;
    return _file->read(buf, nbyte);
}

bool MicroSDIOFile::seek(uint32_t pos) {
    if (!_isOpen || !_file) return false;
    return _file->seek(pos);
}

uint32_t MicroSDIOFile::position() {
    if (!_isOpen || !_file) return 0;
    return _file->position();
}

uint32_t MicroSDIOFile::size() {
    if (!_isOpen || !_file) return 0;
    return _file->size();
}

void MicroSDIOFile::close() {
    if (_file) {
        _file->close();
        delete _file;
        _file = nullptr;
    }
    _isOpen = false;
}

MicroSDIOFile::operator bool() {
    return _isOpen && _file;
}

char* MicroSDIOFile::name() {
    return _name;
}

bool MicroSDIOFile::isDirectory(void) {
    if (!_isOpen || !_file) return false;
    return _file->isDirectory();
}

MicroSDIOFile MicroSDIOFile::openNextFile(uint8_t mode) {
    return MicroSDIOFile();
}

void MicroSDIOFile::rewindDirectory(void) {
}

// Print methods implementation
size_t MicroSDIOFile::println(const char* str) {
    size_t n = print(str);
    n += write('\r');
    n += write('\n');
    return n;
}

size_t MicroSDIOFile::println(const String &str) {
    return println(str.c_str());
}

size_t MicroSDIOFile::println(int num) {
    size_t n = print(num);
    n += write('\r');
    n += write('\n');
    return n;
}

size_t MicroSDIOFile::print(const char* str) {
    if (!_isOpen || !_file) return 0;
    return _file->print(str);
}

size_t MicroSDIOFile::print(const String &str) {
    if (!_isOpen || !_file) return 0;
    return _file->print(str);
}

size_t MicroSDIOFile::print(int num) {
    if (!_isOpen || !_file) return 0;
    return _file->print(num);
}