mirror of
https://git.mirrors.martin98.com/https://github.com/luc-github/ESP3D.git
synced 2025-07-31 22:32:02 +08:00
375 lines
10 KiB
C++
375 lines
10 KiB
C++
/*
|
|
sd_native_esp32.cpp - ESP3D sd support class
|
|
|
|
Copyright (c) 2014 Luc Lebosse. All rights reserved.
|
|
|
|
This code 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 code 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 code; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
#include "../../../include/esp3d_config.h"
|
|
#if defined(ARDUINO_ARCH_ESP32) && defined(SD_DEVICE)
|
|
#if (SD_DEVICE == ESP_SD_NATIVE)
|
|
#include <stack>
|
|
|
|
#include "../../../core/settings_esp3d.h"
|
|
#include "../esp_sd.h"
|
|
#include "FS.h"
|
|
#include "SD.h"
|
|
|
|
// TBC: base frequency
|
|
// or use (1000000 * ESP.getCpuFreqMHz())
|
|
#define ESP_SPI_FREQ 4000000
|
|
|
|
extern File tSDFile_handle[ESP_MAX_SD_OPENHANDLE];
|
|
|
|
uint8_t ESP_SD::getState(bool refresh) {
|
|
#if defined(ESP_SD_DETECT_PIN) && ESP_SD_DETECT_PIN != -1
|
|
// no need to go further if SD detect is not correct
|
|
if (!((digitalRead(ESP_SD_DETECT_PIN) == ESP_SD_DETECT_VALUE) ? true
|
|
: false)) {
|
|
_state = ESP_SDCARD_NOT_PRESENT;
|
|
return _state;
|
|
}
|
|
#endif // ESP_SD_DETECT_PIN
|
|
// if busy doing something return state
|
|
if (!((_state == ESP_SDCARD_NOT_PRESENT) || _state == ESP_SDCARD_IDLE)) {
|
|
return _state;
|
|
}
|
|
if (!refresh) {
|
|
return _state; // to avoid refresh=true + busy to reset SD and waste time
|
|
} else {
|
|
_sizechanged = true;
|
|
}
|
|
// SD is idle or not detected, let see if still the case
|
|
|
|
SD.end();
|
|
_state = ESP_SDCARD_NOT_PRESENT;
|
|
// using default value for speed ? should be parameter
|
|
// refresh content if card was removed
|
|
log_esp3d("Spi : CS: %d, Miso: %d, Mosi: %d, SCK: %d",
|
|
ESP_SD_CS_PIN != -1 ? ESP_SD_CS_PIN : SS,
|
|
ESP_SD_MISO_PIN != -1 ? ESP_SD_MISO_PIN : MISO,
|
|
ESP_SD_MOSI_PIN != -1 ? ESP_SD_MOSI_PIN : MOSI,
|
|
ESP_SD_SCK_PIN != -1 ? ESP_SD_SCK_PIN : SCK);
|
|
if (SD.begin((ESP_SD_CS_PIN == -1) ? SS : ESP_SD_CS_PIN, SPI,
|
|
ESP_SPI_FREQ / _spi_speed_divider)) {
|
|
if (SD.cardSize() > 0) {
|
|
_state = ESP_SDCARD_IDLE;
|
|
}
|
|
}
|
|
return _state;
|
|
}
|
|
|
|
bool ESP_SD::begin() {
|
|
_started = true;
|
|
_state = ESP_SDCARD_NOT_PRESENT;
|
|
_spi_speed_divider = Settings_ESP3D::read_byte(ESP_SD_SPEED_DIV);
|
|
// sanity check
|
|
if (_spi_speed_divider <= 0) {
|
|
_spi_speed_divider = 1;
|
|
}
|
|
// Setup pins
|
|
#if defined(ESP_SD_DETECT_PIN) && ESP_SD_DETECT_PIN != -1
|
|
pinMode(ESP_SD_DETECT_PIN, INPUT);
|
|
#endif // ESP_SD_DETECT_PIN
|
|
#if SD_DEVICE_CONNECTION == ESP_SHARED_SD
|
|
#if defined(ESP_FLAG_SHARED_SD_PIN) && ESP_FLAG_SHARED_SD_PIN != -1
|
|
pinMode(ESP_FLAG_SHARED_SD_PIN, OUTPUT);
|
|
digitalWrite(ESP_FLAG_SHARED_SD_PIN, !ESP_FLAG_SHARED_SD_VALUE);
|
|
#endif // ESP_FLAG_SHARED_SD_PIN
|
|
#if SD_CARD_TYPE == ESP_FYSETC_WIFI_PRO_SDCARD
|
|
#if defined(ESP_SD_CS_SENSE)
|
|
log_esp3d("Setup SD sense pin %d", ESP_SD_CS_SENSE);
|
|
pinMode(ESP_SD_CS_SENSE, INPUT_PULLUP);
|
|
#endif // defined(ESP_SD_CS_SENSE)
|
|
#if defined(ESP_SD_POWER_PIN) && ESP_SD_POWER_PIN != -1
|
|
log_esp3d("Setup SD power pin %d", ESP_SD_POWER_PIN);
|
|
pinMode(ESP_SD_POWER_PIN, OUTPUT);
|
|
digitalWrite(ESP_SD_POWER_PIN, ESP_POWER_SD_VALUE);
|
|
#endif // defined(ESP3D_POWER_SD_PIN)
|
|
#endif // SD_CARD_TYPE == ESP_FYSETC_WIFI_PRO_SDCARD
|
|
#endif // SD_DEVICE_CONNECTION == ESP_SHARED_SD
|
|
#if (ESP_SD_CS_PIN != -1) || (ESP_SD_MISO_PIN != -1) || \
|
|
(ESP_SD_MOSI_PIN != -1) || (ESP_SD_SCK_PIN != -1)
|
|
log_esp3d("Custom spi : CS: %d, Miso: %d, Mosi: %d, SCK: %d", ESP_SD_CS_PIN,
|
|
ESP_SD_MISO_PIN, ESP_SD_MOSI_PIN, ESP_SD_SCK_PIN);
|
|
SPI.begin(ESP_SD_SCK_PIN, ESP_SD_MISO_PIN, ESP_SD_MOSI_PIN, ESP_SD_CS_PIN);
|
|
#endif
|
|
#if SD_CARD_TYPE == ESP_FYSETC_WIFI_PRO_SDCARD && \
|
|
SD_DEVICE_CONNECTION == ESP_SHARED_SD
|
|
SPI.end();
|
|
#endif // SD_CARD_TYPE == ESP_FYSETC_WIFI_PRO_SDCARD
|
|
return _started;
|
|
}
|
|
|
|
void ESP_SD::end() {
|
|
SD.end();
|
|
_state = ESP_SDCARD_NOT_PRESENT;
|
|
_started = false;
|
|
}
|
|
|
|
void ESP_SD::refreshStats(bool force) {
|
|
if (force || _sizechanged) {
|
|
freeBytes(true);
|
|
}
|
|
_sizechanged = false;
|
|
}
|
|
|
|
uint64_t ESP_SD::totalBytes(bool refresh) {
|
|
static uint64_t _totalBytes = 0;
|
|
if (refresh || _totalBytes == 0) {
|
|
_totalBytes = SD.totalBytes();
|
|
;
|
|
}
|
|
return _totalBytes;
|
|
}
|
|
|
|
uint64_t ESP_SD::usedBytes(bool refresh) {
|
|
static uint64_t _usedBytes = 0;
|
|
if (refresh || _usedBytes == 0) {
|
|
_usedBytes = SD.usedBytes();
|
|
}
|
|
return _usedBytes;
|
|
}
|
|
|
|
uint64_t ESP_SD::freeBytes(bool refresh) {
|
|
return (totalBytes(refresh) - usedBytes(refresh));
|
|
}
|
|
|
|
uint ESP_SD::maxPathLength() { return 255; }
|
|
|
|
bool ESP_SD::rename(const char *oldpath, const char *newpath) {
|
|
return SD.rename(oldpath, newpath);
|
|
}
|
|
|
|
bool ESP_SD::format(ESP3DOutput *output) {
|
|
// not available yet
|
|
if (output) {
|
|
output->printERROR("Not implemented!");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ESP_SDFile ESP_SD::open(const char *path, uint8_t mode) {
|
|
// do some check
|
|
if (((strcmp(path, "/") == 0) &&
|
|
((mode == ESP_FILE_WRITE) || (mode == ESP_FILE_APPEND))) ||
|
|
(strlen(path) == 0)) {
|
|
return ESP_SDFile();
|
|
}
|
|
// path must start by '/'
|
|
if (path[0] != '/') {
|
|
return ESP_SDFile();
|
|
}
|
|
if (mode != ESP_FILE_READ) {
|
|
// check container exists
|
|
String p = path;
|
|
p.remove(p.lastIndexOf('/') + 1);
|
|
if (!exists(p.c_str())) {
|
|
log_esp3d("Error opening: %s", path);
|
|
return ESP_SDFile();
|
|
}
|
|
}
|
|
File tmp = SD.open(path, (mode == ESP_FILE_READ) ? FILE_READ
|
|
: (mode == ESP_FILE_WRITE) ? FILE_WRITE
|
|
: FILE_APPEND);
|
|
ESP_SDFile esptmp(&tmp, tmp.isDirectory(),
|
|
(mode == ESP_FILE_READ) ? false : true, path);
|
|
return esptmp;
|
|
}
|
|
|
|
bool ESP_SD::exists(const char *path) {
|
|
bool res = false;
|
|
String p = path;
|
|
// root should always be there if started
|
|
if (p == "/") {
|
|
return _started;
|
|
}
|
|
if (p.endsWith("/")) {
|
|
p.remove(p.length() - 1, 1);
|
|
}
|
|
res = SD.exists(p);
|
|
if (!res) {
|
|
ESP_SDFile root = ESP_SD::open(p.c_str(), ESP_FILE_READ);
|
|
if (root) {
|
|
res = root.isDirectory();
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
bool ESP_SD::remove(const char *path) { return SD.remove(path); }
|
|
|
|
bool ESP_SD::mkdir(const char *path) {
|
|
String p = path;
|
|
if (p.endsWith("/")) {
|
|
p.remove(p.length() - 1, 1);
|
|
}
|
|
return SD.mkdir(p.c_str());
|
|
}
|
|
|
|
bool ESP_SD::rmdir(const char *path) {
|
|
String p = path;
|
|
if (!p.startsWith("/")) {
|
|
p = '/' + p;
|
|
}
|
|
if (p != "/") {
|
|
if (p.endsWith("/")) {
|
|
p.remove(p.length() - 1);
|
|
}
|
|
}
|
|
if (!exists(p.c_str())) {
|
|
return false;
|
|
}
|
|
bool res = true;
|
|
std::stack<String> pathlist;
|
|
pathlist.push(p);
|
|
while (pathlist.size() > 0 && res) {
|
|
File dir = SD.open(pathlist.top().c_str());
|
|
File f = dir.openNextFile();
|
|
bool candelete = true;
|
|
while (f && res) {
|
|
if (f.isDirectory()) {
|
|
candelete = false;
|
|
String newdir = pathlist.top() + '/';
|
|
newdir += f.name();
|
|
pathlist.push(newdir);
|
|
f.close();
|
|
f = File();
|
|
} else {
|
|
String filepath = pathlist.top() + '/';
|
|
filepath += f.name();
|
|
f.close();
|
|
if (!SD.remove(filepath.c_str())) {
|
|
res = false;
|
|
}
|
|
f = dir.openNextFile();
|
|
}
|
|
}
|
|
if (candelete) {
|
|
if (pathlist.top() != "/") {
|
|
res = SD.rmdir(pathlist.top().c_str());
|
|
}
|
|
pathlist.pop();
|
|
}
|
|
dir.close();
|
|
}
|
|
p = String();
|
|
log_esp3d("count %d", pathlist.size());
|
|
return res;
|
|
}
|
|
|
|
void ESP_SD::closeAll() {
|
|
for (uint8_t i = 0; i < ESP_MAX_SD_OPENHANDLE; i++) {
|
|
tSDFile_handle[i].close();
|
|
tSDFile_handle[i] = File();
|
|
}
|
|
}
|
|
|
|
ESP_SDFile::ESP_SDFile(void *handle, bool isdir, bool iswritemode,
|
|
const char *path) {
|
|
_isdir = isdir;
|
|
_dirlist = "";
|
|
_index = -1;
|
|
_filename = "";
|
|
_name = "";
|
|
_lastwrite = 0;
|
|
_iswritemode = iswritemode;
|
|
_size = 0;
|
|
if (!handle) {
|
|
return;
|
|
}
|
|
bool set = false;
|
|
for (uint8_t i = 0; (i < ESP_MAX_SD_OPENHANDLE) && !set; i++) {
|
|
if (!tSDFile_handle[i]) {
|
|
tSDFile_handle[i] = *((File *)handle);
|
|
// filename
|
|
_name = tSDFile_handle[i].name();
|
|
_filename = path;
|
|
if (_name.endsWith("/")) {
|
|
_name.remove(_name.length() - 1, 1);
|
|
_isdir = true;
|
|
}
|
|
if (_name[0] == '/') {
|
|
_name.remove(0, 1);
|
|
}
|
|
int pos = _name.lastIndexOf('/');
|
|
if (pos != -1) {
|
|
_name.remove(0, pos + 1);
|
|
}
|
|
if (_name.length() == 0) {
|
|
_name = "/";
|
|
}
|
|
// size
|
|
_size = tSDFile_handle[i].size();
|
|
// time
|
|
_lastwrite = tSDFile_handle[i].getLastWrite();
|
|
_index = i;
|
|
// log_esp3d("Opening File at index %d",_index);
|
|
set = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ESP_SDFile::seek(uint32_t pos, uint8_t mode) {
|
|
return tSDFile_handle[_index].seek(pos, (SeekMode)mode);
|
|
}
|
|
|
|
void ESP_SDFile::close() {
|
|
if (_index != -1) {
|
|
// log_esp3d("Closing File at index %d", _index);
|
|
tSDFile_handle[_index].close();
|
|
// reopen if mode = write
|
|
// udate size + date
|
|
if (_iswritemode && !_isdir) {
|
|
File ftmp = SD.open(_filename.c_str());
|
|
if (ftmp) {
|
|
_size = ftmp.size();
|
|
_lastwrite = ftmp.getLastWrite();
|
|
ftmp.close();
|
|
}
|
|
}
|
|
tSDFile_handle[_index] = File();
|
|
// log_esp3d("Closing File at index %d",_index);
|
|
_index = -1;
|
|
}
|
|
}
|
|
|
|
ESP_SDFile ESP_SDFile::openNextFile() {
|
|
if ((_index == -1) || !_isdir) {
|
|
log_esp3d("openNextFile failed");
|
|
return ESP_SDFile();
|
|
}
|
|
File tmp = tSDFile_handle[_index].openNextFile();
|
|
if (tmp) {
|
|
log_esp3d("tmp name :%s %s %s", tmp.name(),
|
|
(tmp.isDirectory()) ? "isDir" : "isFile", _filename.c_str());
|
|
String s = tmp.name();
|
|
// if (s!="/")s+="/";
|
|
// s += tmp.name();
|
|
ESP_SDFile esptmp(&tmp, tmp.isDirectory(), false, s.c_str());
|
|
esptmp.close();
|
|
return esptmp;
|
|
}
|
|
return ESP_SDFile();
|
|
}
|
|
|
|
// TODO need to find reliable way
|
|
const char *ESP_SDFile::shortname() const { return _name.c_str(); }
|
|
|
|
const char *ESP_SD::FilesystemName() { return "SD native"; }
|
|
|
|
#endif // SD_DEVICE == ESP_SD_NATIVE
|
|
#endif // ARCH_ESP32 && SD_DEVICE
|