SdFat.h

/*
  SDFat.h 
  Copyright (c) 2025 Phil Schatzmann. All right reserved.
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
 
#include "Stream.h"
#include <fstream>
#include <iostream>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#ifdef USE_FILESYSTEM
#include <filesystem>
#endif
 
#define SD_SCK_MHZ(maxMhz) (1000000UL * (maxMhz))
#define SPI_FULL_SPEED SD_SCK_MHZ(50)
#define SPI_DIV3_SPEED SD_SCK_MHZ(16)
#define SPI_HALF_SPEED SD_SCK_MHZ(4)
#define SPI_DIV6_SPEED SD_SCK_MHZ(8)
#define SPI_QUARTER_SPEED SD_SCK_MHZ(2)
#define SPI_EIGHTH_SPEED SD_SCK_MHZ(1)
#define SPI_SIXTEENTH_SPEED SD_SCK_HZ(500000)
 
#define O_RDONLY ios::in          
#define O_WRONLY ios::out         
#define O_RDWR ios::in | ios::out 
#define O_AT_END ios::ate         
#define O_APPEND ios::ate         
#define O_CREAT ios::trunc                 
#define O_TRUNC ios::trunc        
#define O_EXCL 0                  
#define O_SYNC 0                  
#define O_READ O_RDONLY
#define O_WRITE O_WRONLY
 
#ifndef SS
#define SS 0
#endif
 
using namespace std;
 
class SdSpiConfig {
  SdSpiConfig(int a = 0, int b = 0, int c = 0) {}
};
 
class SdFat {
public:
  bool begin(int cs = SS, int speed = 0) { return true; }
  bool begin(SdSpiConfig &cfg) { return true; }
  void errorHalt(const char *msg) {
    Serial.println(msg);
    exit(0);
  }
  void initErrorHalt() { exit(0); }
 
  bool exists(char *name) {
    struct stat info;
    return stat(name, &info) == 0;
  }
  void end(){}
};
class SdFile : public Stream {
public:
  bool isOpen() {
    bool result = file.is_open();
    return result;
  }
 
  bool open(const char *name, int flags) {
    this->filename = name;
    struct stat info;
    int rc = stat(name, &info);
    if ((flags == O_RDONLY) && rc == -1){
      // if we want to read but the file does not exist we fail
      return false;
    } else if (rc == 0 && info.st_mode & S_IFDIR) {
      // file exists and it is a directory
      is_dir = true;
      size = 0;
#ifdef USE_FILESYSTEM
      dir_path = std::filesystem::path(filename);
      iterator = std::filesystem::directory_iterator({dir_path});
#endif
      return true;
    } else {
      is_dir = false;
      size = rc!=-1 ? info.st_size: 0;
      file.open(filename.c_str(), (std::ios_base::openmode)flags);
      return isOpen();
    }
  }
 
  bool close() {
    file.close();
    return !isOpen();
  }
 
  size_t readBytes(uint8_t *buffer, size_t length) {
    return file.readsome((char *)buffer, length);
  }
  size_t write(const uint8_t *buffer, size_t size) override {
    file.write((const char *)buffer, size);
    return file.good() ? size : 0;
  }
  size_t write(uint8_t ch) override {
    file.put(ch);
    return file.good() ? 1 : 0;
  }
  int available() override { return size - file.tellg(); };
  int availableForWrite() override { return 1024; }
  int read() override { return file.get(); }
  int peek() override { return file.peek(); }
  void flush() override {}
  void getName(char *str, size_t len) { strncpy(str, filename.c_str(), len); }
  bool isDir() { return is_dir; }
  bool isHidden() { return false; }
  bool rewind() {
    pos = 0;
    return is_dir;
  }
  bool openNext(SdFile &dir, int flags = O_RDONLY) {
  #ifdef USE_FILESYSTEM
    if (dir.isDir() && dir.iterator != end(dir.iterator)) {
      std::filesystem::directory_entry entry = *dir.iterator++;
      return open(entry.path().c_str(), flags);
    }
  #endif
    return false;
  }
  int dirIndex() { return pos; }
 
protected:
  std::fstream file;
  size_t size = 0;
  bool is_dir;
  int pos = 0;
  std::string filename;
#ifdef USE_FILESYSTEM
  std::filesystem::directory_iterator iterator;
  std::filesystem::path dir_path;
#endif
};