Merge pull request #5 from Sani7/feature/llfs

LLFS file system api

docs/llfs.md

@@ -0,0 +1,57 @@
+# LLFS (Linked List File System)
+
+## Introduction
+The llfs filesystem can be generated using the mkllfss utility. 
+It is a simple filesystem that uses a linked list to store files. 
+The filesystem is stored in a single c file (`llfs_data.c`), which can be compiled and read by the llfs library.
+The llfs filesystem is a flat filesystem, meaning that it does not support directories.
+
+## Usage of the llfs API
+### Getting a list of files
+```c
+#include "llfs.h"
+
+void main(void) {
+    // Allocate space for 10 files
+    llfs_file_t file_list[10];
+    
+    // Get the file list
+    size_t file_count = llfs_file_list(file_list, 10, NULL);
+    
+    // Loop through the files and print their names and sizes
+    for (int i = 0; i < file_count; i++) {
+        LOG_INFO(TAG, "File: %s, size: %d", file_list[i].name, file_list[i].len);
+    }
+}
+```
+Result:
+```
+[Info]      (2009) [main]: File: image.bmp, size: 9270
+[Info]      (2013) [main]: File: python_file.py, size: 645
+[Info]      (2019) [main]: File: image2.bmp, size: 7738
+[Info]      (2024) [main]: File: filename with a space.txt, size: 61
+[Info]      (2031) [main]: File: file1.txt, size: 77
+```
+
+### Reading a file
+```c
+#include "llfs.h"
+
+void main(void) {
+    // Get a file by name
+    llfs_file_t *file = llfs_file_open("filename with a space.txt");
+    
+    if (file != NULL) {
+        // Print the file name, size and data
+        LOG_INFO(TAG, "File found: %s, size: %d", file->name, file->len);
+        LOG_INFO(TAG, "File data: %s", file->data);
+    } else {
+        LOG_WARN(TAG, "File not found");
+    }
+}
+```
+Result:
+```
+[Info]      (2040) [main]: File found: filename with a space.txt, size: 61
+[Info]      (2047) [main]: File data: This is a file with a space in it's filename.
+```

project/Core/Inc/llfs.h

@@ -0,0 +1,61 @@
+/**
+ * @file llfs.h
+ * @brief Linked List Filesystem header (llfs)
+ * @author Lorenz C.
+ */
+
+#ifndef LLFS_H
+#define LLFS_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * @brief Representation of a file in the llfs filesystem
+ */
+typedef struct llfs_file {
+    const uint8_t* data; // Pointer to the file data (len bytes)
+    const char* name;    // Null-terminated string with the filename
+    size_t len;          // Length of the file data
+} llfs_file_t;
+
+/**
+ * @brief Internal representation of a file in the filesystem
+ * @warning This struct should only be used in the llfs_data.c file.
+ */
+struct llfs_data_file {
+    const uint8_t* data;
+    const char* name;
+    const size_t len;
+    const struct llfs_data_file* next;
+};
+
+/**
+ * @brief Get a list of files in the filesystem
+ * Get a list of all the files in the filesystem.
+ *
+ * Use the filter to filter out files with a filename that do not match the filter. (e.g. "*.txt" or "*.png|*.jpg") (not
+ * implemented yet) Multiple filters can be used by separating them with a pipe (|).
+ *
+ * The following members of the llfs_file_t struct are set: name, len and data. @ref llfs_file_t
+ *
+ * @todo Implement file filter
+ *
+ * @param[out] file_list A pointer to an array of llfs_file_t to store the files in @ref llfs_file_t
+ * @param[in] max_files The maximum number of files to return (size of file_list)
+ * @param[in] filter A string with file extensions to filter out. (e.g. "*.txt" or "*.png|*.jpg")
+ * @return The number of files returned
+ */
+size_t llfs_file_list(llfs_file_t* file_list, size_t max_files, char* filter);
+
+/**
+ * @brief Open a file
+ * Get a file from the filesystem by name.
+ *
+ * @param[in] name The name of the file to open
+ * @return A pointer to a llfs_file_t with the file data @ref llfs_file_t
+ *         NULL if the file does not exist
+ */
+llfs_file_t* llfs_file_open(const char* name);
+
+#endif // LLFS_H

project/Core/Src/llfs.c

@@ -0,0 +1,52 @@
+/**
+ * @file llfs.c
+ * @brief Linked List Filesystem implementation (llfs)
+ * @author Lorenz C.
+ * @todo Implement file extension filter
+ */
+
+#include <string.h>
+#define LOGGER_LEVEL_WARN
+#include "log.h"
+#include "llfs.h"
+
+extern struct llfs_data_file *llfs_root;
+const char* TAG = "llfs";
+
+
+// TODO: Implement file extension filter
+size_t llfs_file_list(llfs_file_t *file_list, size_t max_files, char* filter) {
+    size_t file_count = 0;
+    const struct llfs_data_file *file = llfs_root;
+
+    LOG_DEBUG(TAG, "Getting file list with filter: %s", filter);
+
+    while (file != NULL && file_count < max_files) {
+        file_list[file_count].data = file->data;
+        file_list[file_count].name = file->name;
+        file_list[file_count].len = file->len;
+        file_count++;
+        file = file->next;
+    }
+
+    LOG_DEBUG(TAG, "Files found: %d", file_count);
+    return file_count;
+}
+
+llfs_file_t *llfs_file_open(const char *name) {
+    const struct llfs_data_file *file = llfs_root;
+
+    LOG_DEBUG(TAG, "Opening file: %s", name);
+
+    while (file != NULL) {
+        if (strcmp(file->name, name) == 0) {
+            LOG_DEBUG(TAG, "File found: %s, size: %d", file->name, file->len);
+            return (llfs_file_t *) file;
+        }
+        file = file->next;
+    }
+
+    LOG_DEBUG(TAG, "File not found: %s", name);
+    return NULL;
+}
+