shinys000114/odroid-power-mate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete logger, Add littlefs init function

Browse Source 
Signed-off-by: YoungSoo Shin <shinys000114@gmail.com>
This commit is contained in:
YoungSoo Shin
2025-09-25 17:17:31 +09:00
parent 23c72790ef
commit 7f6308bb6f
7 changed files with 62 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
main/app/odroid-power-mate.c
View File

@@ -11,6 +11,7 @@
#include "nvs_flash.h" #include "nvs_flash.h"
#include "system.h" #include "system.h"
#include "wifi.h" #include "wifi.h"
#include "storage.h"
void app_main(void) void app_main(void)
{ {
@@ -30,6 +31,8 @@ void app_main(void)
} }
ESP_ERROR_CHECK(ret); ESP_ERROR_CHECK(ret);
storage_init();
ESP_ERROR_CHECK(esp_netif_init()); ESP_ERROR_CHECK(esp_netif_init());
ESP_ERROR_CHECK(esp_event_loop_create_default()); ESP_ERROR_CHECK(esp_event_loop_create_default());

6
main/include/storage.h Normal file
View File

@@ -0,0 +1,6 @@
#ifndef STORAGE_H_
#define STORAGE_H_
void storage_init(void);
#endif /* STORAGE_H_ */

157
main/service/datalog.c
View File

@@ -1,157 +0,0 @@
#include "datalog.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "esp_littlefs.h"
#include "esp_log.h"
static const char* TAG = "datalog";
static const char* LOG_FILE_PATH = "/littlefs/datalog.csv";
#define MAX_LOG_SIZE (700 * 1024)
void datalog_init(void)
{
ESP_LOGI(TAG, "Initializing DataLog with LittleFS");
esp_vfs_littlefs_conf_t conf = {
.base_path = "/littlefs",
.partition_label = "littlefs",
.format_if_mount_failed = true,
.dont_mount = false,
};
esp_err_t ret = esp_vfs_littlefs_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 LittleFS partition");
}
else
{
ESP_LOGE(TAG, "Failed to initialize LittleFS (%s)", esp_err_to_name(ret));
}
return;
}
size_t total = 0, used = 0;
ret = esp_littlefs_info(conf.partition_label, &total, &used);
if (ret != ESP_OK)
{
ESP_LOGE(TAG, "Failed to get LittleFS partition information (%s)", esp_err_to_name(ret));
}
else
{
ESP_LOGI(TAG, "Partition size: total: %d, used: %d", total, used);
}
// Check if file exists
FILE* f = fopen(LOG_FILE_PATH, "r");
if (f == NULL)
{
ESP_LOGI(TAG, "Log file not found, creating new one.");
FILE* f_write = fopen(LOG_FILE_PATH, "w");
if (f_write == NULL)
{
ESP_LOGE(TAG, "Failed to create log file.");
}
else
{
// Add header for 3 channels
fprintf(f_write,
"timestamp,usb_voltage,usb_current,usb_power,main_voltage,main_current,main_power,vin_voltage,vin_"
"current,vin_power\n");
fclose(f_write);
}
}
else
{
// Here we could check if the header is correct, but for now we assume it is.
ESP_LOGI(TAG, "Log file found.");
fclose(f);
}
}
void datalog_add(uint32_t timestamp, const channel_data_t* channel_data)
{
struct stat st;
if (stat(LOG_FILE_PATH, &st) == 0)
{
if (st.st_size >= MAX_LOG_SIZE)
{
ESP_LOGI(TAG, "Log file size (%ld) >= MAX_LOG_SIZE (%d). Truncating.", st.st_size, MAX_LOG_SIZE);
const char* temp_path = "/littlefs/datalog.tmp";
FILE* f_read = fopen(LOG_FILE_PATH, "r");
FILE* f_write = fopen(temp_path, "w");
if (f_read == NULL || f_write == NULL)
{
ESP_LOGE(TAG, "Failed to open files for truncation.");
if (f_read)
fclose(f_read);
if (f_write)
fclose(f_write);
return;
}
char line[256];
// Copy header
if (fgets(line, sizeof(line), f_read) != NULL)
{
fputs(line, f_write);
}
// Skip the oldest data line
if (fgets(line, sizeof(line), f_read) == NULL)
{
// No data lines to skip, something is wrong if we are truncating
}
// Copy the rest of the lines
while (fgets(line, sizeof(line), f_read) != NULL)
{
fputs(line, f_write);
}
fclose(f_read);
fclose(f_write);
// Replace the old log with the new one
if (remove(LOG_FILE_PATH) != 0)
{
ESP_LOGE(TAG, "Failed to remove old log file.");
}
if (rename(temp_path, LOG_FILE_PATH) != 0)
{
ESP_LOGE(TAG, "Failed to rename temp file.");
return;
}
}
}
FILE* f = fopen(LOG_FILE_PATH, "a");
if (f == NULL)
{
ESP_LOGE(TAG, "Failed to open log file for appending.");
return;
}
fprintf(f, "%lu", timestamp);
for (int i = 0; i < 3; ++i)
{
fprintf(f, ",%.3f,%.3f,%.3f", channel_data[i].voltage, channel_data[i].current, channel_data[i].power);
}
fprintf(f, "\n");
fclose(f);
}
const char* datalog_get_path(void) { return LOG_FILE_PATH; }

19
main/service/datalog.h
View File

@@ -1,19 +0,0 @@
#ifndef MAIN_SERVICE_DATALOG_H_
#define MAIN_SERVICE_DATALOG_H_
#include <stdint.h>
#define NUM_CHANNELS 3
typedef struct
{
float voltage;
float current;
float power;
} channel_data_t;
void datalog_init(void);
void datalog_add(uint32_t timestamp, const channel_data_t* channel_data);
const char* datalog_get_path(void);
#endif /* MAIN_SERVICE_DATALOG_H_ */

8
main/service/monitor.c
View File

@@ -6,7 +6,6 @@
#include <nconfig.h> #include <nconfig.h>
#include <time.h> #include <time.h>
#include "climit.h" #include "climit.h"
#include "datalog.h"
#include "esp_log.h" #include "esp_log.h"
#include "esp_netif.h" #include "esp_netif.h"
#include "esp_timer.h" #include "esp_timer.h"
@@ -94,8 +93,6 @@ static void sensor_timer_callback(void* arg)
uint32_t uptime_sec = (uint32_t)(uptime_us / 1000000); uint32_t uptime_sec = (uint32_t)(uptime_us / 1000000);
uint32_t timestamp = (uint32_t)time(NULL); uint32_t timestamp = (uint32_t)time(NULL);
channel_data_t channel_data_log[NUM_CHANNELS];
StatusMessage message = StatusMessage_init_zero; StatusMessage message = StatusMessage_init_zero;
message.which_payload = StatusMessage_sensor_data_tag; message.which_payload = StatusMessage_sensor_data_tag;
SensorData* sensor_data = &message.payload.sensor_data; SensorData* sensor_data = &message.payload.sensor_data;
@@ -115,9 +112,6 @@ static void sensor_timer_callback(void* arg)
current /= 1000.0f; // mA to A current /= 1000.0f; // mA to A
power = voltage * current; power = voltage * current;
// For datalog
channel_data_log[i] = (channel_data_t){.voltage = voltage, .current = current, .power = power};
// For protobuf // For protobuf
channels[i]->voltage = voltage; channels[i]->voltage = voltage;
channels[i]->current = current; channels[i]->current = current;
@@ -282,8 +276,6 @@ void init_status_monitor()
lim = atof(buf); lim = atof(buf);
climit_set_usb(lim); climit_set_usb(lim);
datalog_init();
const esp_timer_create_args_t sensor_timer_args = {.callback = &sensor_timer_callback, const esp_timer_create_args_t sensor_timer_args = {.callback = &sensor_timer_callback,
.name = "sensor_reading_timer"}; .name = "sensor_reading_timer"};
const esp_timer_create_args_t wifi_timer_args = {.callback = &status_wifi_callback, .name = "wifi_status_timer"}; const esp_timer_create_args_t wifi_timer_args = {.callback = &status_wifi_callback, .name = "wifi_status_timer"};

53
main/service/storage.c Normal file
View File

@@ -0,0 +1,53 @@
#include "storage.h"
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "esp_littlefs.h"
#include "esp_log.h"
static const char* TAG = "datalog";
#define MAX_LOG_SIZE (700 * 1024)
void storage_init(void)
{
ESP_LOGI(TAG, "Initializing DataLog with LittleFS");
esp_vfs_littlefs_conf_t conf = {
.base_path = "/littlefs",
.partition_label = "littlefs",
.format_if_mount_failed = true,
.dont_mount = false,
};
esp_err_t ret = esp_vfs_littlefs_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 LittleFS partition");
}
else
{
ESP_LOGE(TAG, "Failed to initialize LittleFS (%s)", esp_err_to_name(ret));
}
return;
}
size_t total = 0, used = 0;
ret = esp_littlefs_info(conf.partition_label, &total, &used);
if (ret != ESP_OK)
{
ESP_LOGE(TAG, "Failed to get LittleFS partition information (%s)", esp_err_to_name(ret));
}
else
{
ESP_LOGI(TAG, "Partition size: total: %d, used: %d", total, used);
}
}

37
main/service/webserver.c
View File

@@ -1,7 +1,6 @@
#include "webserver.h" #include "webserver.h"
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include "datalog.h"
#include "esp_http_server.h" #include "esp_http_server.h"
#include "esp_log.h" #include "esp_log.h"
#include "esp_wifi.h" #include "esp_wifi.h"
@@ -43,38 +42,6 @@ static esp_err_t index_handler(httpd_req_t* req)
return ESP_OK; return ESP_OK;
} }
static esp_err_t datalog_download_handler(httpd_req_t* req)
{
const char* filepath = datalog_get_path();
FILE* f = fopen(filepath, "r");
if (f == NULL)
{
ESP_LOGE(TAG, "Failed to open datalog file for reading");
httpd_resp_send_404(req);
return ESP_FAIL;
}
httpd_resp_set_type(req, "text/csv");
httpd_resp_set_hdr(req, "Content-Disposition", "attachment; filename=\"datalog.csv\"");
char buffer[1024];
size_t bytes_read;
while ((bytes_read = fread(buffer, 1, sizeof(buffer), f)) > 0)
{
if (httpd_resp_send_chunk(req, buffer, bytes_read) != ESP_OK)
{
ESP_LOGE(TAG, "File sending failed!");
fclose(f);
httpd_resp_send_chunk(req, NULL, 0);
httpd_resp_send_500(req);
return ESP_FAIL;
}
}
fclose(f);
httpd_resp_send_chunk(req, NULL, 0);
return ESP_OK;
}
void start_webserver(void) void start_webserver(void)
{ {
@@ -94,10 +61,6 @@ void start_webserver(void)
httpd_uri_t index = {.uri = "/", .method = HTTP_GET, .handler = index_handler, .user_ctx = NULL}; httpd_uri_t index = {.uri = "/", .method = HTTP_GET, .handler = index_handler, .user_ctx = NULL};
httpd_register_uri_handler(server, &index); httpd_register_uri_handler(server, &index);
httpd_uri_t datalog_uri = {
.uri = "/datalog.csv", .method = HTTP_GET, .handler = datalog_download_handler, .user_ctx = NULL};
httpd_register_uri_handler(server, &datalog_uri);
register_wifi_endpoint(server); register_wifi_endpoint(server);
register_ws_endpoint(server); register_ws_endpoint(server);
register_control_endpoint(server); register_control_endpoint(server);