e.adame/Modbus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added max_points in .ini, increased spiff csv file character limit, and file name limit. Added more prints for how many devices you can configure based on current memory size and max_points.

Browse Source
This commit is contained in:
Eddy Adame Vences
2026-06-23 15:39:28 -05:00
parent fcd2a46c93
commit df0f1aa2aa
7 changed files with 349 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
main/config_store.c
View File

@@ -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));
}
}
}

5
main/config_store.h
View File

@@ -6,7 +6,6 @@
#include <stddef.h>
#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);

195
main/main.c
View File

@@ -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)

103
main/modbus_points.c
View File

@@ -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;
}
}

8
main/modbus_points.h
View File

@@ -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,