Merge pull request #72 from CU-Robotics/SD-wrapper

Pandabear1125 · web-flow · commit fef4e2b03d11 · 2024-09-20T12:20:10.000-06:00
SDManager wrapper class
diff --git a/Makefile b/Makefile
@@ -31,7 +31,7 @@ LIBRARY_LIB = libs
 PROJECT_DIR = .
 PROJECT_SRC_DIR = src
 PROJECT_SOURCE = $(shell find $(PROJECT_SRC_DIR) -name "*.cpp") $(shell find $(PROJECT_SRC_DIR) -name "*.c")
-PROJECT_INCLUDE = src
+PROJECT_INCLUDE = -Isrc
 # application filename will end up as PROJECT_NAME.hex once built
 PROJECT_NAME = firmware
 
@@ -82,7 +82,7 @@ GIT_SCRAPER = ./tools/git_scraper.cpp
 # builds source, links with libraries, and constructs the .elf and .hex to be uploaded
 build: clean git_scraper
 	@echo [Building Source]
-	@$(COMPILER_CPP) $(COMPILE_FLAGS) $(CPP_FLAGS) $(PROJECT_SOURCE) $(LIBRARY_LIB_NAME) $(TEENSY_LIB_NAME) $(LIBRARY_INCLUDE) $(TEENSY_INCLUDE) $(LINKING_FLAGS) -o $(PROJECT_NAME).elf
+	@$(COMPILER_CPP) $(COMPILE_FLAGS) $(CPP_FLAGS) $(PROJECT_SOURCE) $(PROJECT_INCLUDE) $(LIBRARY_LIB_NAME) $(TEENSY_LIB_NAME) $(LIBRARY_INCLUDE) $(TEENSY_INCLUDE) $(LINKING_FLAGS) -o $(PROJECT_NAME).elf
 	@echo [Constructing $(PROJECT_NAME).hex]
 	@$(OBJCOPY) -O ihex -R .eeprom $(PROJECT_NAME).elf $(PROJECT_NAME).hex
 	@chmod +x $(PROJECT_NAME).hex
diff --git a/src/comms/SDManager.cpp b/src/comms/SDManager.cpp
@@ -0,0 +1,197 @@
+#include "SDManager.hpp"
+
+SDManager::SDManager() {
+    if (!SDinternal.begin()) {
+        Serial.println("SD_ERROR::SDManager card initialization failed");
+        // TODO: perhaps there should be a better error handler here?? 
+    }
+}
+
+int SDManager::open(const char* filepath, int setting) {
+    // check if exists
+    if (!exists(filepath)) {
+        Serial.print("SD_NOTICE::filepath ");
+        Serial.print(filepath);
+        Serial.println(" does not exist or contains no file");
+        return -1;
+    }
+    if (file) file.close();
+    file = SDinternal.open(filepath, setting);
+    return 0;
+}
+
+int SDManager::open(const char* filepath) {
+    return open(filepath, FILE_WRITE_APPEND);
+}
+
+void SDManager::close() {
+    file.close();
+    return;
+}
+
+int SDManager::touch(const char* filename) {
+    if (SDinternal.exists(filename)) {
+        Serial.print("SD_NOTICE::file located at ");
+        Serial.print(filename);
+        Serial.println(" already exists");
+        return -1;
+    }
+    if (!SDinternal.open(filename, FILE_WRITE)) {
+        Serial.print("SD_NOTICE::file located at ");
+        Serial.print(filename);
+        Serial.println(" could not be created (directory may not exist)");
+        return -1;
+    };
+    return 0;
+}
+
+int SDManager::mkdir(const char* dirname) {
+    if (!SDinternal.mkdir(dirname)) {
+        Serial.print("SD_NOTICE::directory ");
+        Serial.print(dirname);
+        Serial.println(" could not be created");
+        return -1;
+    }
+    return 0;
+}
+
+int SDManager::rm(const char* filename) {
+    return rm(filename, 0);
+}
+
+int SDManager::rm(const char* filename, bool r) {
+    // check if file or directory
+    File cur;
+    if (SDinternal.exists(filename)) cur = SDinternal.open(filename);
+    else {
+        Serial.print("SD_NOTICE::file at ");
+        Serial.print(filename);
+        Serial.println(" could not be erased (no such file or directory)");
+        return FILE_NOT_FOUND;
+    }
+
+    if (cur.isDirectory()) {
+        // attempt to remove dir
+        if (!r) {     // non-recursive erase
+            if (!SDinternal.rmdir(filename)) {
+                Serial.print("SD_NOTICE::file at ");
+                Serial.print(filename);
+                Serial.println(" could not be erased");
+                return RM_ERR_DIR_MISC;
+            }
+        } else {
+            // recursive erase
+            File tmp = cur.openNextFile();
+            while (tmp) {
+                char name[SD_DIR_LENGTH];
+                memset(name, 0, SD_DIR_LENGTH);
+                memcpy(name, filename, strlen(filename));
+                if (!(filename[strlen(filename) - 1] == '/')) strcat(name, "/");
+                strcat(name, tmp.name());
+                rm(name, 1);
+                tmp = cur.openNextFile();
+            }
+            SDinternal.rmdir(filename);
+        }
+    } else {
+        // attempt to remove file
+        if (!SDinternal.remove(filename)) {
+            Serial.print("SD_NOTICE::file at ");
+            Serial.print(filename);
+            Serial.println(" could not be erased");
+            return RM_ERR_FILE_MISC;
+        }
+    }
+    return 0;
+}
+
+int SDManager::read(uint8_t* dest, unsigned int len) {
+    if (!file) {
+        Serial.println("SD_NOTICE::file cannot be read (no file open)");
+        return -1;
+    }
+    return file.read(dest, len);
+}
+
+int SDManager::write(uint8_t* src, unsigned int len) {
+    if (!file) {
+        Serial.println("SD_NOTICE::file cannot be written to (no file open)");
+        return -1;
+    }
+    return file.write(src, len);
+}
+
+int SDManager::lseek(int offset, int whence) {
+    int flag = 0;
+    switch (whence) {
+    case SEEK_SET:
+        flag = file.seek(offset);
+        break;
+    case SEEK_CUR:
+        flag = file.seek(file.position() + offset);
+        break;
+    case SEEK_END:
+        flag = file.seek(file.size() + offset);
+        break;
+    }
+    if (flag) return file.position();
+    else return -1;
+}
+
+bool SDManager::exists(const char* filepath) {
+    return SDinternal.exists(filepath);
+}
+
+void SDManager::enumerate_files(const char* root, bool r) {
+    enumerate_files(root, r, 0);
+}
+
+void SDManager::enumerate_files(const char* root, bool r, int tabs) {
+    // check current
+
+    if (!exists(root)) {
+        Serial.print("SD_NOTICE::file ");
+        Serial.print(root);
+        Serial.println(" does not exist");
+        return;
+    }
+
+    File dir = SDinternal.open(root);
+
+    // print current
+
+    for (int i = 0; i < tabs; i++) {
+        Serial.print("-\t");
+    }
+    Serial.print(dir.name());
+
+    // if not dir, then exit
+    if (!dir.isDirectory()) {
+        Serial.println("");
+        return;
+    }
+
+    Serial.println(" (dir)");   // label directory
+
+    // if not recursive, then exit
+    if ((!r) && tabs > 0) return;
+
+    // open tmp file, and loop through all contents of dir
+    File tmp = dir.openNextFile();
+
+    while (tmp) {
+        // print current file
+        char cur_path[SD_DIR_LENGTH] = { 0 };
+        memset(cur_path, 0, SD_DIR_LENGTH);
+        memcpy(cur_path, root, strlen(root));
+        if (!(root[strlen(root) - 1] == '/')) strcat(cur_path, "/");
+        strcat(cur_path, tmp.name());
+
+        enumerate_files(cur_path, r, tabs + 1);
+
+        // iterate tmp
+        tmp = dir.openNextFile();
+    }
+    tmp.close();
+    dir.close();
+}
diff --git a/src/comms/SDManager.hpp b/src/comms/SDManager.hpp
@@ -0,0 +1,102 @@
+#ifndef SD_WRAP
+#define SD_WRAP
+
+#include "../../libraries/SD/SD.h"
+#include "../../libraries/SPI/SPI.h"
+
+#define SD_DIR_LENGTH 256
+
+#define FILE_NOT_FOUND 1
+#define RM_ERR_DIR_MISC 2
+#define RM_ERR_FILE_MISC 3
+
+/// @brief Wrapper for built in SD card
+class SDManager {
+public:
+
+    /// @brief Constructor, initializes SD objects
+    SDManager();
+
+    /// @brief Opens to internal file
+    /// @param filepath path to file
+    /// @return 0 on success, -1 on failure
+    int open(const char* filepath);
+
+    /// @brief Opens to internal file, choose open setting from FILE_READ, FILE_WRITE, FILE_WRITE_APPEND
+    /// @param filepath 
+    /// @param setting 
+    /// @return 0 on success, -1 on failure
+    /// @note FILE_READ opens from start of file, FILE_WRITE opens at end and truncates file, FILE_WRITE_APPEND opens at end and appends to file
+    int open(const char* filepath, int setting);
+
+    /// @brief Close currently open file
+    void close();
+
+    /// @brief Create new file at filename
+    /// @param filename path to new file (e.g. /folder/text.txt creates text.txt inside /folder/)
+    /// @return 0 on success, -1 on failure
+    int touch(const char* filename);
+
+    /// @brief Creates new directory at dirname
+    /// @param dirname location of new directory (e.g. /folder/newdir creates directory newdir inside /folder/)
+    /// @return 0 on success, -1 on failure
+    int mkdir(const char* dirname);
+
+    /// @brief Removes file or directory
+    /// @param filename path to file to remove
+    /// @param r recursive flag, 1 for recursive removal, 0 for non-recursive 
+    /// @return 0 on success, -1 on failure
+    /// @note Directory is only removed when empty, or when removed recursively (r==1)
+    int rm(const char* filename, bool r);
+
+    /// @brief Removes file or directory
+    /// @param filename path to file to remove
+    /// @return 0 on success, -1 on failure
+    /// @note Overload for removing files by default, sets recursive flag to 0
+    int rm(const char* filename);
+
+    /// @brief Reads bytes from file into dest at file location
+    /// @param dest destination buffer for data
+    /// @param len number of bytes to read
+    /// @return number of bytes read
+    int read(uint8_t* dest, unsigned int len);
+
+    /// @brief Writes bytes from src into file at file location
+    /// @param src source buffer
+    /// @param len number of bytes to write
+    /// @return number of bytes written
+    int write(uint8_t* src, unsigned int len);
+
+    /// @brief Changes location in file based on offset and whence value
+    /// @param offset amount to change location by
+    /// @param whence setting for lseek configuration (SEEK_SET, SEEK_CUR, SEEK_END)
+    /// @return location in file after seek, or -1 on failure
+    /// @note SEEK_SET sets location to offset, SEEK_CUR sets location to location + offset, SEEK_END sets location to file size + offset
+    int lseek(int offset, int whence);
+
+    /// @brief Checks if file at filepath exists
+    /// @param filepath path to file
+    /// @return true if exists, false if not
+    bool exists(const char* filepath);
+
+    /// @brief Prints all files present in directory root
+    /// @param root root directory to enumerate
+    /// @param r recursive flag, set true to print contents of all subdirectories
+    void enumerate_files(const char* root, bool r);
+
+private:
+
+    /// @brief Prints all files present in directory root
+    /// @param root root directory to enumerate
+    /// @param r recursive flag, set true to print contents of all subdirectories
+    /// @param tabs number of tabs to print (used internally for inner dir printing)
+    void enumerate_files(const char* root, bool r, int tabs);
+
+    /// @brief Internal instance of SDClass object used by Teensy
+    SDClass SDinternal;
+
+    /// @brief Internal File object that represents currently opened file on SD card
+    File file;
+};
+
+#endif
diff --git a/src/main.cpp b/src/main.cpp
@@ -14,6 +14,7 @@
 #include "sensors/RefSystem.hpp"
 #include "sensors/d200.hpp"
 #include "sensors/ACS712.hpp"
+#include "comms/SDManager.hpp"
 
 #include <TeensyDebug.h>
 
@@ -86,7 +87,6 @@ int main() {
 
     Serial.begin(115200); // the serial monitor is actually always active (for debug use Serial.println & tycmd)
     debug.begin(SerialUSB1);
-
     print_logo();
 
     // Execute setup functions
@@ -104,7 +104,6 @@ int main() {
     uint8_t packet_subsection_sizes[MAX_CONFIG_PACKETS] = { 0 };
     CommsPacket config_packets[MAX_CONFIG_PACKETS];
     // Config config
-
     Serial.println("Configuring...");
     while (!config_layer.is_configured()) {
         comms.ping();
diff --git a/src/utils/profiler.hpp b/src/utils/profiler.hpp
@@ -8,7 +8,7 @@
 
 #define PROF_MAX_SECTIONS 4  // max number of active profiling sections
 #define PROF_MAX_NAME 16      // max length of section name
-#define PROF_MAX_TIMES (1 << 20)   // max number of start/end times per section
+#define PROF_MAX_TIMES (60000)   // max number of start/end times per section
 
 /// @brief Object for profiling sections of code.
 struct Profiler {
diff --git a/teensy4/Time.cpp b/teensy4/Time.cpp
