MICROSD_SPI.cpp - main - electronic_modules/microSD

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

MICROSD_SPI::MICROSD_SPI(int MSD_SPI_CS, int MSD_SPI_DI, int MSD_SPI_SCLK, int MSD_SPI_DO) {
    _MSD_SPI_CS = MSD_SPI_CS;
    _MSD_SPI_DI = MSD_SPI_DI;
    _MSD_SPI_SCLK = MSD_SPI_SCLK;
    _MSD_SPI_DO = MSD_SPI_DO;
    _initialized = false;
}

bool MICROSD_SPI::initial() {
    return initial(_MSD_SPI_CS);
}

bool MICROSD_SPI::initial(uint8_t csPin) {
    if (!SD.begin(csPin)) {
        Serial.println(F("MicroSD SPI initialization failed!"));
        _initialized = false;
        return false;
    }
    
    _initialized = true;
    Serial.println(F("MicroSD SPI initialized successfully"));
    return true;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void MICROSD_SPI::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 MICROSD_SPI::format() {
    Serial.println(F("Formatting not implemented in this version"));
    return false;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void MicroSDFile::rewindDirectory(void) {
}

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

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

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

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

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

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