diff --git a/main/config_store.c b/main/config_store.c index 684d09a..5c8412e 100644 --- a/main/config_store.c +++ b/main/config_store.c @@ -101,6 +101,32 @@ static void copy_str(char *dst, size_t dst_size, const char *src) dst[dst_size - 1U] = '\0'; } +static bool copy_dyn_str(char **dst, const char *src) +{ + char *new_value; + size_t len; + + if (dst == NULL) + return false; + + if (src == NULL) + src = ""; + + len = strlen(src); + + new_value = malloc(len + 1U); + if (new_value == NULL) + return false; + + memcpy(new_value, src, len + 1U); + + if (*dst != NULL) + free(*dst); + + *dst = new_value; + return true; +} + static int parse_device_section_index(const char *section) { unsigned long idx; @@ -149,7 +175,7 @@ static void set_device_defaults(virtual_device_settings_t *dev, uint8_t index) snprintf(default_name, sizeof(default_name), "Device_%u", (unsigned)(index + 1U)); copy_str(dev->name, sizeof(dev->name), default_name); - dev->csv[0] = '\0'; + dev->csv = NULL; } void config_store_set_defaults(device_config_t *cfg) @@ -171,20 +197,91 @@ void config_store_set_defaults(device_config_t *cfg) cfg->modbus.port = 502; cfg->modbus.max_clients = 4; cfg->modbus.device_count = 1; + cfg->modbus.max_points = 150; for (i = 0; i < MAX_VIRTUAL_DEVICES; i++) set_device_defaults(&cfg->devices[i], (uint8_t)i); } +void config_store_free(device_config_t *cfg) +{ + size_t i; + + if (cfg == NULL) + return; + + for (i = 0; i < MAX_VIRTUAL_DEVICES; i++) + { + if (cfg->devices[i].csv != NULL) + { + free(cfg->devices[i].csv); + cfg->devices[i].csv = NULL; + } + } +} + +static bool read_dynamic_line(FILE *fp, char **out_line) +{ + char *line = NULL; + size_t capacity = 128U; + size_t length = 0U; + int ch; + + if (fp == NULL || out_line == NULL) + return false; + + *out_line = NULL; + + line = malloc(capacity); + if (line == NULL) + return false; + + while ((ch = fgetc(fp)) != EOF) + { + char *new_line; + + if (length + 1U >= capacity) + { + size_t new_capacity = capacity * 2U; + + new_line = realloc(line, new_capacity); + if (new_line == NULL) + { + free(line); + return false; + } + + line = new_line; + capacity = new_capacity; + } + + line[length++] = (char)ch; + + if (ch == '\n') + break; + } + + if (length == 0U && ch == EOF) + { + free(line); + return false; + } + + line[length] = '\0'; + *out_line = line; + return true; +} + bool config_store_load(const char *filename, device_config_t *cfg) { FILE *fp; - char line[256]; + char *line = NULL; char section[32]; if (filename == NULL || cfg == NULL) return false; + config_store_free(cfg); config_store_set_defaults(cfg); memset(section, 0, sizeof(section)); @@ -192,7 +289,7 @@ bool config_store_load(const char *filename, device_config_t *cfg) if (fp == NULL) return false; - while (fgets(line, sizeof(line), fp) != NULL) + while (read_dynamic_line(fp, &line)) { char *eq; char *key; @@ -202,10 +299,19 @@ bool config_store_load(const char *filename, device_config_t *cfg) trim_whitespace(line); if (line[0] == '\0') + { + free(line); + line = NULL; continue; + } + if (line[0] == ';' || line[0] == '#') + { + free(line); + line = NULL; continue; + } if (line[0] == '[') { @@ -217,12 +323,18 @@ bool config_store_load(const char *filename, device_config_t *cfg) copy_str(section, sizeof(section), &line[1]); trim_whitespace(section); } + free(line); + line = NULL; continue; } eq = strchr(line, '='); if (eq == NULL) + { + free(line); + line = NULL; continue; + } *eq = '\0'; key = line; @@ -274,6 +386,13 @@ bool config_store_load(const char *filename, device_config_t *cfg) cfg->modbus.device_count = (uint8_t)v; } } + else if (str_ieq(key, "max_points")) + { + if (parse_u32(value, &v) && v > 0U) + { + cfg->modbus.max_points = (size_t)v; + } + } } else { @@ -301,16 +420,28 @@ bool config_store_load(const char *filename, device_config_t *cfg) } else if (str_ieq(key, "csv")) { - copy_str(dev->csv, sizeof(dev->csv), value); + if (!copy_dyn_str(&dev->csv, value)) + { + free(line); + line = NULL; + fclose(fp); + config_store_free(cfg); + return false; + } } } } + free(line); + line = NULL; } fclose(fp); if (cfg->wifi.ssid[0] == '\0') + { + printf("CONFIG ERROR: wifi.ssid is empty\n"); return false; + } if (cfg->modbus.port == 0U) return false; @@ -318,6 +449,9 @@ bool config_store_load(const char *filename, device_config_t *cfg) if (cfg->modbus.max_clients == 0U) return false; + if (cfg->modbus.max_points == 0U) + return false; + if (cfg->modbus.device_count == 0U || cfg->modbus.device_count > MAX_VIRTUAL_DEVICES) return false; @@ -330,10 +464,17 @@ bool config_store_load(const char *filename, device_config_t *cfg) continue; if (dev->unit_id == 0U) + { + printf("CONFIG ERROR: enable device %u has invalid unit_id 0\n", + (unsigned)(i + 1U)); return false; + } - if (dev->csv[0] == '\0') + if (dev->csv == NULL || dev->csv[0] == '\0') + { + printf("CONFIG ERROR: enabled device %u has empty csv\n", (unsigned)(i + 1U)); return false; + } if (dev->name[0] == '\0') { @@ -348,7 +489,12 @@ bool config_store_load(const char *filename, device_config_t *cfg) continue; if (dev->unit_id == cfg->devices[j].unit_id) - return false; + { + printf("CONFIG ERROR: duplicate unit_id %u between device %u and device %u\n", + (unsigned)dev->unit_id, + (unsigned)(i + 1U), + (unsigned)(j + 1U)); + } } } diff --git a/main/config_store.h b/main/config_store.h index d6f5325..2a2f35c 100644 --- a/main/config_store.h +++ b/main/config_store.h @@ -6,7 +6,6 @@ #include #define DEVICE_NAME_MAX_LEN 32 -#define DEVICE_CSV_MAX_LEN 64 #define WIFI_SSID_MAX_LEN 32 #define WIFI_PASSWORD_MAX_LEN 64 #define IPV4_STR_MAX_LEN 16 @@ -29,6 +28,7 @@ typedef struct uint16_t port; uint8_t max_clients; uint8_t device_count; + size_t max_points; } modbus_settings_t; typedef struct @@ -36,7 +36,7 @@ typedef struct bool enabled; uint8_t unit_id; char name[DEVICE_NAME_MAX_LEN]; - char csv[DEVICE_CSV_MAX_LEN]; + char *csv; } virtual_device_settings_t; typedef struct @@ -46,6 +46,7 @@ typedef struct virtual_device_settings_t devices[MAX_VIRTUAL_DEVICES]; } device_config_t; +void config_store_free(device_config_t *cfg); void config_store_set_defaults(device_config_t *cfg); bool config_store_load(const char *filename, device_config_t *cfg); diff --git a/main/main.c b/main/main.c index 2316529..7b1c59d 100644 --- a/main/main.c +++ b/main/main.c @@ -49,7 +49,7 @@ typedef struct { uint8_t unit_id; char name[DEVICE_NAME_MAX_LEN]; - char csv_path[128]; + char *csv_path; modbus_db_t db; modbus_memory_t mem; @@ -91,6 +91,41 @@ static bool file_exists(const char *path) return true; } +static char *build_spiffs_path(const char *filename) +{ + const char *prefix = "/spiffs/"; + char *path; + size_t prefix_len; + size_t filename_len; + + if (filename == NULL || filename[0] == '\0') + return NULL; + + if (filename[0] == '/') + { + filename_len = strlen(filename); + + path = heap_caps_malloc(filename_len + 1U, MALLOC_CAP_8BIT); + if (path == NULL) + return NULL; + + memcpy(path, filename, filename_len + 1U); + return path; + } + + prefix_len = strlen(prefix); + filename_len = strlen(filename); + + path = heap_caps_malloc(prefix_len + filename_len + 1U, MALLOC_CAP_8BIT); + if (path == NULL) + return NULL; + + memcpy(path, prefix, prefix_len); + memcpy(path + prefix_len, filename, filename_len + 1U); + + return path; +} + static void spiffs_list_files(void) { DIR *dir; @@ -847,6 +882,7 @@ void app_main(void) ESP_LOGI(TAG, "Modbus Port: %u", (unsigned)g_device_cfg.modbus.port); ESP_LOGI(TAG, "Configured device_count = %u", (unsigned)g_device_cfg.modbus.device_count); + ESP_LOGI(TAG, "Configured max_points per device = %u", (unsigned)g_device_cfg.modbus.max_points); for (i = 0; i < g_device_cfg.modbus.device_count; i++) { @@ -856,7 +892,7 @@ void app_main(void) g_device_cfg.devices[i].enabled ? 1 : 0, (unsigned)g_device_cfg.devices[i].unit_id, g_device_cfg.devices[i].name, - g_device_cfg.devices[i].csv); + (g_device_cfg.devices[i].csv != NULL) ? g_device_cfg.devices[i].csv : ""); } if (g_device_cfg.modbus.device_count == 0U) @@ -932,10 +968,14 @@ void app_main(void) strncpy(dev->name, cfg_dev->name, sizeof(dev->name) - 1U); dev->name[sizeof(dev->name) - 1U] = '\0'; - snprintf(dev->csv_path, - sizeof(dev->csv_path), - "/spiffs/%s", - cfg_dev->csv); + dev->csv_path = build_spiffs_path(cfg_dev->csv); + if (dev->csv_path == NULL) + { + ESP_LOGE(TAG, "Failed to allocate CSV path for device %u", + (unsigned)dev->unit_id); + heap_caps_free(dev); + continue; + } ESP_LOGI(TAG, "Preparing device[%u]: unit_id=%u name=%s csv=%s", @@ -949,6 +989,8 @@ void app_main(void) ESP_LOGE(TAG, "CSV file not found for device %u: %s", (unsigned)dev->unit_id, dev->csv_path); + if(dev->csv_path != NULL) + heap_caps_free(dev->csv_path); heap_caps_free(dev); continue; } @@ -959,42 +1001,36 @@ void app_main(void) modbus_points_init(&dev->db); - if (!modbus_points_load(&dev->db, dev->csv_path)) + if (!modbus_points_load(&dev->db, dev->csv_path, g_device_cfg.modbus.max_points)) { ESP_LOGE(TAG, "Failed to load CSV for device %u: %s", (unsigned)dev->unit_id, dev->csv_path); + + if(dev->csv_path != NULL) + heap_caps_free(dev->csv_path); heap_caps_free(dev); continue; } - /* Safety check: prevent memory overflow */ - if (dev->db.count > MODBUS_MAX_POINTS) - { - ESP_LOGE(TAG, - "Device %u exceeded MODBUS_MAX_POINTS (%u > %u)", - (unsigned)dev->unit_id, - (unsigned)dev->db.count, - (unsigned)MODBUS_MAX_POINTS); - - ESP_LOGE(TAG, "Startup aborted to prevent memory corruption."); - - heap_caps_free(dev); - abort(); - } - if (!modbus_memory_init(&dev->mem, &dev->db)) { ESP_LOGE(TAG, "Memory init failed for device %u", (unsigned)dev->unit_id); + + modbus_points_reset(&dev->db); + + if(dev->csv_path != NULL) + heap_caps_free(dev->csv_path); heap_caps_free(dev); continue; } - ESP_LOGI(TAG, "Device %u (%s) loaded %u Modbus points from %s", + ESP_LOGI(TAG, "Device %u (%s) loaded %u / %u Modbus point entries from %s", (unsigned)dev->unit_id, dev->name, (unsigned)dev->db.count, + (unsigned)dev->db.capacity, dev->csv_path); g_devices[g_device_count] = dev; @@ -1020,17 +1056,23 @@ void app_main(void) { size_t total_points_used = 0; - size_t total_points_capacity = g_device_count * MODBUS_MAX_POINTS; + size_t total_points_capacity = 0; size_t total_points_remaining = 0; size_t free_heap = heap_caps_get_free_size(MALLOC_CAP_8BIT); size_t largest_block = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT); size_t point_struct_size = sizeof(modbus_point_t); - size_t heap_equivalent_points = 0; + size_t configured_points_per_device = g_device_cfg.modbus.max_points; + size_t configured_db_bytes_per_device = configured_points_per_device * point_struct_size; + size_t estimated_additional_devices_free_heap = 0; + size_t estimated_additional_devices_largest_block = 0; - if (point_struct_size > 0U) - heap_equivalent_points = free_heap / point_struct_size; + if (configured_db_bytes_per_device > 0U) + { + estimated_additional_devices_free_heap = free_heap / configured_db_bytes_per_device; + estimated_additional_devices_largest_block = largest_block / configured_db_bytes_per_device; + } for (i = 0; i < g_device_count; i++) { @@ -1038,46 +1080,56 @@ void app_main(void) size_t remaining = 0; float pct = 0.0f; - if (dev->db.count < MODBUS_MAX_POINTS) - remaining = MODBUS_MAX_POINTS - dev->db.count; + if (dev == NULL) + continue; - if (MODBUS_MAX_POINTS > 0U) - pct = (100.0f * (float)dev->db.count) / (float)MODBUS_MAX_POINTS; + if (dev->db.count < dev->db.capacity) + remaining = dev->db.capacity - dev->db.count; + + if (dev->db.capacity > 0U) + pct = (100.0f * (float)dev->db.count) / (float)dev->db.capacity; ESP_LOGI(TAG, - "Device %u (%s): used=%u / max=%u, remaining=%u (%.1f%% used)", - (unsigned)dev->unit_id, - dev->name, - (unsigned)dev->db.count, - (unsigned)MODBUS_MAX_POINTS, - (unsigned)remaining, - pct); + "Device %u (%s): used=%u / max=%u, remaining=%u (%.1f%% used)", + (unsigned)dev->unit_id, + dev->name, + (unsigned)dev->db.count, + (unsigned)dev->db.capacity, + (unsigned)remaining, + pct); total_points_used += dev->db.count; + total_points_capacity += dev->db.capacity; total_points_remaining += remaining; } ESP_LOGI(TAG, - "Configured capacity: used=%u / max=%u, remaining=%u", - (unsigned)total_points_used, - (unsigned)total_points_capacity, - (unsigned)total_points_remaining); + "Configured point capacity: used=%u / max=%u, remaining=%u", + (unsigned)total_points_used, + (unsigned)total_points_capacity, + (unsigned)total_points_remaining); ESP_LOGI(TAG, - "Free heap: %u bytes, largest block: %u bytes, point size: %u bytes", - (unsigned)free_heap, - (unsigned)largest_block, - (unsigned)point_struct_size); + "Configured max_points per device=%u, point size=%u bytes, DB bytes per device=%u", + (unsigned)configured_points_per_device, + (unsigned)point_struct_size, + (unsigned)configured_db_bytes_per_device); ESP_LOGI(TAG, - "Heap-equivalent points available (informational only): %u", - (unsigned)heap_equivalent_points); + "Free heap=%u bytes, largest block=%u bytes", + (unsigned)free_heap, + (unsigned)largest_block); + + ESP_LOGI(TAG, + "Estimated additional devices possible with current max_points: free_heap=%u, largest_block=%u", + (unsigned)estimated_additional_devices_free_heap, + (unsigned)estimated_additional_devices_largest_block); } ESP_LOGI(TAG, "---------------------------------"); ESP_LOGI(TAG, "----- Point Cost Guide -----"); - ESP_LOGI(TAG, "Internal point usage (counts against MODBUS_MAX_POINTS):"); + ESP_LOGI(TAG, "Internal point usage (counts against configured max_points):"); ESP_LOGI(TAG, " data_type=bool -> 1 point"); ESP_LOGI(TAG, " data_type=uint16 -> 1 point"); ESP_LOGI(TAG, " data_type=uint32 -> 2 points"); @@ -1107,30 +1159,39 @@ void app_main(void) ESP_LOGI(TAG, "----- Modbus Memory Usage -----"); - size_t total_points = 0; - - for (size_t d = 0; d < g_device_count; d++) { - const modbus_device_t *dev = g_devices[d]; + size_t total_points = 0; + size_t total_capacity = 0; - if (dev == NULL) - continue; + for (size_t d = 0; d < g_device_count; d++) + { + const modbus_device_t *dev = g_devices[d]; + float pct = 0.0f; + + if (dev == NULL) + continue; + + if (dev->db.capacity > 0U) + pct = (100.0f * (float)dev->db.count) / (float)dev->db.capacity; + + ESP_LOGI(TAG, + "Device %u (%s): %u / %u points used (%.1f%%)", + (unsigned)dev->unit_id, + dev->name, + (unsigned)dev->db.count, + (unsigned)dev->db.capacity, + pct); + + total_points += dev->db.count; + total_capacity += dev->db.capacity; + } ESP_LOGI(TAG, - "Device %u (%s): %u / %u points used (%.1f%%)", - (unsigned)dev->unit_id, - dev->name, - (unsigned)dev->db.count, - (unsigned)MODBUS_MAX_POINTS, - (100.0f * (float)dev->db.count) / (float)MODBUS_MAX_POINTS); - - total_points += dev->db.count; + "TOTAL POINTS LOADED: %u / %u", + (unsigned)total_points, + (unsigned)total_capacity); } - ESP_LOGI(TAG, - "TOTAL POINTS LOADED: %u", - (unsigned)total_points); - ESP_LOGI(TAG, "--------------------------------"); if (g_device_count == 0U) diff --git a/main/modbus_points.c b/main/modbus_points.c index 4ef1ff7..90310bd 100644 --- a/main/modbus_points.c +++ b/main/modbus_points.c @@ -41,6 +41,17 @@ static bool str_equals(const char *a, const char *b) return strcmp(a, b) == 0; } +static bool line_starts_with_valid_point_type(const char *line) +{ + if (line == NULL) + return false; + + return strncmp(line, "Coil,", 5U) == 0 || + strncmp(line, "Discrete_Input,", 15U) == 0 || + strncmp(line, "Input_Register,", 15U) == 0 || + strncmp(line, "Holding_Register,", 17U) == 0; +} + static modbus_point_type_t parse_point_type(const char *s) { if (str_equals(s, "Coil")) @@ -413,7 +424,7 @@ static bool append_helper_points(modbus_db_t *db, const modbus_point_t *base_pt) helper.reg_value = 0U; - if (db->count >= MODBUS_MAX_POINTS) + if (db->count >= db->capacity) return false; @@ -602,7 +613,12 @@ static bool parse_csv_line(const char *line_in, modbus_point_t *pt) void modbus_points_init(modbus_db_t *db) { - modbus_points_reset(db); + if (db == NULL) + return; + + db->points = NULL; + db->count = 0; + db->capacity = 0; } void modbus_points_reset(modbus_db_t *db) @@ -610,10 +626,17 @@ void modbus_points_reset(modbus_db_t *db) if (db == NULL) return; - memset(db, 0, sizeof(*db)); + if (db->points != NULL) + { + free(db->points); + db->points = NULL; + } + + db->count = 0; + db->capacity = 0; } -bool modbus_points_load(modbus_db_t *db, const char *filename) +bool modbus_points_load(modbus_db_t *db, const char *filename, size_t max_points) { FILE *fp; char line[MODBUS_MAX_CSV_LINE_LEN]; @@ -629,8 +652,26 @@ bool modbus_points_load(modbus_db_t *db, const char *filename) return false; } + if (max_points == 0U) + { + printf("CSV ERROR: max_points cannot be 0\n"); + fclose(fp); + return false; + } + modbus_points_reset(db); + db->capacity = max_points; + db->points = calloc(db->capacity, sizeof(modbus_point_t)); + if (db->points == NULL) + { + printf("CSV ERROR: failed to allocate point table (%u points, %u bytes)\n", + (unsigned)max_points, + (unsigned)(max_points * sizeof(modbus_point_t))); + fclose(fp); + return false; + } + while (fgets(line, sizeof(line), fp) != NULL) { modbus_point_t pt; @@ -654,53 +695,21 @@ bool modbus_points_load(modbus_db_t *db, const char *filename) if (line_num == 1U) continue; + if (!line_starts_with_valid_point_type(line)) { - char temp_line[MODBUS_MAX_CSV_LINE_LEN]; - char *fields[8]; - size_t field_count = 0; - char *p; - bool all_fields_empty = true; - size_t i; - - strncpy(temp_line, line, sizeof(temp_line) - 1U); - temp_line[sizeof(temp_line) - 1U] = '\0'; - - p = temp_line; - fields[field_count++] = p; - - while (*p != '\0' && field_count < 8U) - { - if (*p == ',') - { - *p = '\0'; - fields[field_count++] = p + 1; - } - p++; - } - - if (field_count == 8U) - { - for (i = 0; i < field_count; i++) - { - trim_whitespace(fields[i]); - if (fields[i][0] != '\0') - { - all_fields_empty = false; - break; - } - } - - if (all_fields_empty) - continue; - } + printf("CSV WARNING line %u: skipping non-data line: %s\n", + (unsigned)line_num, + line); + continue; } - if (db->count >= MODBUS_MAX_POINTS) + if (db->count >= db->capacity) { - printf("CSV ERROR line %u: exceeded MODBUS_MAX_POINTS (%u)\n", + printf("CSV ERROR line %u: exceeded configured max_points (%u)\n", (unsigned)line_num, - (unsigned)MODBUS_MAX_POINTS); + (unsigned)db->capacity); fclose(fp); + modbus_points_reset(db); return false; } @@ -710,6 +719,7 @@ bool modbus_points_load(modbus_db_t *db, const char *filename) (unsigned)line_num, line); fclose(fp); + modbus_points_reset(db); return false; } @@ -721,6 +731,7 @@ bool modbus_points_load(modbus_db_t *db, const char *filename) (unsigned)pt.offset); fclose(fp); + modbus_points_reset(db); return false; } @@ -736,6 +747,7 @@ bool modbus_points_load(modbus_db_t *db, const char *filename) (unsigned)pt.pics_offset, (unsigned)pt.pics_reg_span); fclose(fp); + modbus_points_reset(db); return false; } @@ -746,6 +758,7 @@ bool modbus_points_load(modbus_db_t *db, const char *filename) printf("CSV ERROR line %u: failed to append helper points\n", (unsigned)line_num); fclose(fp); + modbus_points_reset(db); return false; } } diff --git a/main/modbus_points.h b/main/modbus_points.h index 1448737..88a9031 100644 --- a/main/modbus_points.h +++ b/main/modbus_points.h @@ -7,7 +7,6 @@ #include "modbus_memory.h" -#define MODBUS_MAX_POINTS 80 /* Max point entries per device, including helper registers */ /* Modbus Data Type - bool = 1 register @@ -23,7 +22,7 @@ */ -#define MODBUS_MAX_CSV_LINE_LEN 256 +#define MODBUS_MAX_CSV_LINE_LEN 512 typedef enum { @@ -86,8 +85,9 @@ typedef struct modbus_point typedef struct modbus_db { - modbus_point_t points[MODBUS_MAX_POINTS]; + modbus_point_t *points; size_t count; + size_t capacity; } modbus_db_t; /* Initialize / clear point database */ @@ -95,7 +95,7 @@ void modbus_points_init(modbus_db_t *db); void modbus_points_reset(modbus_db_t *db); /* Load points from CSV */ -bool modbus_points_load(modbus_db_t *db, const char *filename); +bool modbus_points_load(modbus_db_t *db, const char *filename, size_t max_points); /* Lookup helpers */ const modbus_point_t *modbus_points_find_by_type_offset(const modbus_db_t *db, diff --git a/sdkconfig b/sdkconfig index cc442ad..9f936ac 100644 --- a/sdkconfig +++ b/sdkconfig @@ -2247,7 +2247,8 @@ CONFIG_LWIP_TIMERS_ONDEMAND=y CONFIG_LWIP_ND6=y # default: # CONFIG_LWIP_FORCE_ROUTER_FORWARDING is not set -CONFIG_LWIP_MAX_SOCKETS=16 +# default: +CONFIG_LWIP_MAX_SOCKETS=10 # default: # CONFIG_LWIP_USE_ONLY_LWIP_SELECT is not set # default: @@ -3103,8 +3104,7 @@ CONFIG_SPIFFS_GC_MAX_RUNS=10 # CONFIG_SPIFFS_GC_STATS is not set # default: CONFIG_SPIFFS_PAGE_SIZE=256 -# default: -CONFIG_SPIFFS_OBJ_NAME_LEN=32 +CONFIG_SPIFFS_OBJ_NAME_LEN=128 # default: # CONFIG_SPIFFS_FOLLOW_SYMLINKS is not set # default: diff --git a/sdkconfig.defaults b/sdkconfig.defaults new file mode 100644 index 0000000..748a0e8 --- /dev/null +++ b/sdkconfig.defaults @@ -0,0 +1 @@ +CONFIG_SPIFFS_OBJ_NAME_LEN=128