157 lines
4.1 KiB
C++
157 lines
4.1 KiB
C++
#include "storage.h"
|
|
#include "esp_check.h"
|
|
#include "esp_log.h"
|
|
#include "esp_spiffs.h"
|
|
#include "simulator.h"
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
static const char *TAG = "storage";
|
|
|
|
static bool is_spiffs_mounted = false;
|
|
|
|
void initialize_storage()
|
|
{
|
|
if (is_spiffs_mounted)
|
|
{
|
|
return;
|
|
}
|
|
|
|
esp_vfs_spiffs_conf_t conf = {
|
|
.base_path = "/spiffs",
|
|
.partition_label = NULL,
|
|
.max_files = 5,
|
|
.format_if_mount_failed = false,
|
|
};
|
|
|
|
esp_err_t ret = esp_vfs_spiffs_register(&conf);
|
|
|
|
if (ret != ESP_OK)
|
|
{
|
|
if (ret == ESP_FAIL)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to mount or format filesystem");
|
|
}
|
|
else if (ret == ESP_ERR_NOT_FOUND)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to find SPIFFS partition");
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "Failed to initialize SPIFFS (%s)", esp_err_to_name(ret));
|
|
}
|
|
return;
|
|
}
|
|
|
|
is_spiffs_mounted = true;
|
|
}
|
|
|
|
void load_file(const char *filename)
|
|
{
|
|
ESP_LOGI(TAG, "Loading file: %s", filename);
|
|
int line_count = 0;
|
|
char **lines = read_lines_filtered(filename, &line_count);
|
|
uint8_t line_number = 0;
|
|
for (int i = 0; i < line_count; ++i)
|
|
{
|
|
char time[10] = {0};
|
|
int red, green, blue, white, brightness, saturation;
|
|
int items_scanned =
|
|
sscanf(lines[i], "%d,%d,%d,%d,%d,%d", &red, &green, &blue, &white, &brightness, &saturation);
|
|
if (items_scanned == 6)
|
|
{
|
|
int total_minutes = line_number * 30;
|
|
int hours = total_minutes / 60;
|
|
int minutes = total_minutes % 60;
|
|
snprintf(time, sizeof(time), "%02d%02d", hours, minutes);
|
|
add_light_item(time, red, green, blue, white, brightness, saturation);
|
|
line_number++;
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGW(TAG, "Could not parse line: %s", lines[i]);
|
|
}
|
|
}
|
|
free_lines(lines, line_count);
|
|
ESP_LOGI(TAG, "Finished loading file. Loaded %d entries.", line_number);
|
|
}
|
|
|
|
char **read_lines_filtered(const char *filename, int *out_count)
|
|
{
|
|
char fullpath[128];
|
|
snprintf(fullpath, sizeof(fullpath), "/spiffs/%s", filename[0] == '/' ? filename + 1 : filename);
|
|
FILE *f = fopen(fullpath, "r");
|
|
if (!f)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to open file: %s", fullpath);
|
|
*out_count = 0;
|
|
return NULL;
|
|
}
|
|
|
|
size_t capacity = 16;
|
|
size_t count = 0;
|
|
char **lines = (char **)malloc(capacity * sizeof(char *));
|
|
char line[256];
|
|
while (fgets(line, sizeof(line), f))
|
|
{
|
|
// Zeilenumbruch entfernen
|
|
char *pos = strchr(line, '\n');
|
|
if (pos)
|
|
*pos = '\0';
|
|
// Trim vorne
|
|
char *trimmed = line;
|
|
while (*trimmed == ' ' || *trimmed == '\t')
|
|
trimmed++;
|
|
// Leere oder Kommentarzeile überspringen
|
|
if (*trimmed == '\0' || *trimmed == '#')
|
|
continue;
|
|
// Trim hinten
|
|
size_t len = strlen(trimmed);
|
|
while (len > 0 && (trimmed[len - 1] == ' ' || trimmed[len - 1] == '\t'))
|
|
trimmed[--len] = '\0';
|
|
// Kopieren
|
|
if (count >= capacity)
|
|
{
|
|
capacity *= 2;
|
|
lines = (char **)realloc(lines, capacity * sizeof(char *));
|
|
}
|
|
lines[count++] = strdup(trimmed);
|
|
}
|
|
fclose(f);
|
|
*out_count = (int)count;
|
|
return lines;
|
|
}
|
|
|
|
void free_lines(char **lines, int count)
|
|
{
|
|
for (int i = 0; i < count; ++i)
|
|
free(lines[i]);
|
|
free(lines);
|
|
}
|
|
|
|
esp_err_t write_lines(const char *filename, char **lines, int count)
|
|
{
|
|
char fullpath[128];
|
|
snprintf(fullpath, sizeof(fullpath), "/spiffs/%s", filename[0] == '/' ? filename + 1 : filename);
|
|
FILE *f = fopen(fullpath, "w");
|
|
if (!f)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to open file for writing: %s", fullpath);
|
|
return ESP_FAIL;
|
|
}
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
if (fprintf(f, "%s\n", lines[i]) < 0)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to write line %d", i);
|
|
fclose(f);
|
|
return ESP_FAIL;
|
|
}
|
|
}
|
|
fclose(f);
|
|
ESP_LOGI(TAG, "Wrote %d lines to %s", count, fullpath);
|
|
return ESP_OK;
|
|
}
|