chargeflow/components/evse/evse_config.c

#include <inttypes.h> // For PRI macros
#include "evse_config.h"
#include "board_config.h"
#include "evse_limits.h"
#include "evse_api.h"
#include "esp_log.h"
#include "nvs.h"
#include "esp_timer.h"

static const char *TAG = "evse_config";

static nvs_handle_t nvs;

// ========================
// Configurable parameters
// ========================
static uint8_t max_charging_current = MAX_CHARGING_CURRENT_LIMIT;
static uint16_t charging_current;             // Persisted (NVS)
static uint16_t charging_current_runtime = 0; // Runtime only
static bool socket_outlet;
static bool rcm;
static uint8_t temp_threshold = 60;
static bool require_auth;

// Availability / Enable flags
static bool is_available = true;
static bool is_enabled = true;

// ========================
// Initialization
// ========================
esp_err_t evse_config_init(void)
{
    ESP_LOGD(TAG, "Initializing NVS configuration...");
    return nvs_open("evse", NVS_READWRITE, &nvs);
}

void evse_check_defaults(void)
{
    esp_err_t err;
    uint8_t u8;
    uint16_t u16;
    uint32_t u32;
    bool needs_commit = false;
    uint8_t u8_bool;

    ESP_LOGD(TAG, "Checking default parameters...");

    // Max charging current
    err = nvs_get_u8(nvs, "max_chrg_curr", &u8);
    if (err != ESP_OK || u8 < MIN_CHARGING_CURRENT_LIMIT || u8 > MAX_CHARGING_CURRENT_LIMIT)
    {
        max_charging_current = MAX_CHARGING_CURRENT_LIMIT;
        nvs_set_u8(nvs, "max_chrg_curr", max_charging_current);
        needs_commit = true;
        ESP_LOGW(TAG, "Invalid or missing max_chrg_curr, resetting to %d", max_charging_current);
    }
    else
    {
        max_charging_current = u8;
    }

    // Charging current (default, persisted)
    err = nvs_get_u16(nvs, "def_chrg_curr", &u16);
    if (err != ESP_OK || u16 < (MIN_CHARGING_CURRENT_LIMIT) || u16 > (max_charging_current))
    {
        charging_current = max_charging_current;
        nvs_set_u16(nvs, "def_chrg_curr", charging_current);
        needs_commit = true;
        ESP_LOGW(TAG, "Invalid or missing def_chrg_curr, resetting to %d", charging_current);
    }
    else
    {
        charging_current = u16;
    }

    // Runtime charging current inicializado a partir do default persistido
    charging_current_runtime = charging_current;
    ESP_LOGD(TAG, "Runtime charging current initialized to: %d", charging_current_runtime);

    // Auth required
    err = nvs_get_u8(nvs, "require_auth", &u8);
    require_auth = (err == ESP_OK && u8 <= 1) ? u8 : false;
    if (err != ESP_OK)
    {
        nvs_set_u8(nvs, "require_auth", require_auth);
        needs_commit = true;
    }

    // Socket outlet
    err = nvs_get_u8(nvs, "socket_outlet", &u8);
    socket_outlet = (err == ESP_OK && u8) && board_config.proximity;
    if (err != ESP_OK)
    {
        nvs_set_u8(nvs, "socket_outlet", socket_outlet);
        needs_commit = true;
    }

    // RCM
    err = nvs_get_u8(nvs, "rcm", &u8);
    rcm = (err == ESP_OK && u8) && board_config.rcm;
    if (err != ESP_OK)
    {
        nvs_set_u8(nvs, "rcm", rcm);
        needs_commit = true;
    }

    // Temp threshold
    err = nvs_get_u8(nvs, "temp_threshold", &u8);
    temp_threshold = (err == ESP_OK && u8 >= 40 && u8 <= 80) ? u8 : 60;
    if (err != ESP_OK)
    {
        nvs_set_u8(nvs, "temp_threshold", temp_threshold);
        needs_commit = true;
    }

    // Optional limits
    if (nvs_get_u32(nvs, "def_cons_lim", &u32) == ESP_OK)
        evse_set_consumption_limit(u32);

    if (nvs_get_u32(nvs, "def_ch_time_lim", &u32) == ESP_OK)
        evse_set_charging_time_limit(u32);

    if (nvs_get_u16(nvs, "def_un_pwr_lim", &u16) == ESP_OK)
        evse_set_under_power_limit(u16);

    // Availability (persist)
    if (nvs_get_u8(nvs, "available", &u8_bool) == ESP_OK && u8_bool <= 1)
    {
        is_available = (u8_bool != 0);
    }
    else
    {
        is_available = true; // default
        nvs_set_u8(nvs, "available", (uint8_t)is_available);
        needs_commit = true;
        ESP_LOGW(TAG, "Missing 'available' -> default=true (persisted).");
    }

    // Enabled (persist)
    if (nvs_get_u8(nvs, "enabled", &u8_bool) == ESP_OK && u8_bool <= 1)
    {
        is_enabled = (u8_bool != 0);
    }
    else
    {
        is_enabled = true; // default
        nvs_set_u8(nvs, "enabled", (uint8_t)is_enabled);
        needs_commit = true;
        ESP_LOGW(TAG, "Missing 'enabled' -> default=true (persisted).");
    }

    if (needs_commit)
    {
        err = nvs_commit(nvs);
        if (err == ESP_OK)
        {
            ESP_LOGD(TAG, "Configuration committed to NVS.");
        }
        else
        {
            ESP_LOGE(TAG, "Failed to commit configuration to NVS: %s", esp_err_to_name(err));
        }
    }
}

// ========================
// Charging current getters/setters
// ========================
uint8_t evse_get_max_charging_current(void)
{
    return max_charging_current;
}

esp_err_t evse_set_max_charging_current(uint8_t value)
{
    if (value < MIN_CHARGING_CURRENT_LIMIT || value > MAX_CHARGING_CURRENT_LIMIT)
        return ESP_ERR_INVALID_ARG;
    max_charging_current = value;
    evse_set_runtime_charging_current(value);
    nvs_set_u8(nvs, "max_chrg_curr", value);
    return nvs_commit(nvs);
}

uint16_t evse_get_charging_current(void)
{
    return charging_current;
}

esp_err_t evse_set_charging_current(uint16_t value)
{
    if (value < (MIN_CHARGING_CURRENT_LIMIT) || value > (max_charging_current))
        return ESP_ERR_INVALID_ARG;
    charging_current = value;
    nvs_set_u16(nvs, "def_chrg_curr", value);
    return nvs_commit(nvs);
}

uint16_t evse_get_default_charging_current(void)
{
    uint16_t value;
    if (nvs_get_u16(nvs, "def_chrg_curr", &value) == ESP_OK)
        return value;
    return charging_current;
}

esp_err_t evse_set_default_charging_current(uint16_t value)
{
    if (value < (MIN_CHARGING_CURRENT_LIMIT) || value > (max_charging_current))
        return ESP_ERR_INVALID_ARG;
    nvs_set_u16(nvs, "def_chrg_curr", value);
    return nvs_commit(nvs);
}

// ========================
// Runtime current (not saved)
// ========================
void evse_set_runtime_charging_current(uint16_t value)
{
    if (value > max_charging_current)
    {
        value = max_charging_current;
    }
    else if (value < MIN_CHARGING_CURRENT_LIMIT)
    {
        value = MIN_CHARGING_CURRENT_LIMIT;
    }

    charging_current_runtime = value;

    ESP_LOGI(TAG, "Runtime charging current updated: %d", charging_current_runtime);

    evse_config_event_data_t evt = {
        .charging = evse_state_is_charging(evse_get_state()),
        .hw_max_current = (float)evse_get_max_charging_current(),
        .runtime_current = (float)evse_get_runtime_charging_current(),
        .timestamp_us = esp_timer_get_time()};

    esp_event_post(EVSE_EVENTS,
                   EVSE_EVENT_CONFIG_UPDATED,
                   &evt,
                   sizeof(evt),
                   portMAX_DELAY);
}

uint16_t evse_get_runtime_charging_current(void)
{
    return charging_current_runtime;
}

// ========================
// Socket outlet
// ========================
bool evse_get_socket_outlet(void)
{
    return socket_outlet;
}

esp_err_t evse_set_socket_outlet(bool value)
{
    if (value && !board_config.proximity)
        return ESP_ERR_INVALID_ARG;
    socket_outlet = value;
    nvs_set_u8(nvs, "socket_outlet", value);
    return nvs_commit(nvs);
}

// ========================
// RCM
// ========================
bool evse_is_rcm(void)
{
    return rcm;
}

esp_err_t evse_set_rcm(bool value)
{
    if (value && !board_config.rcm)
        return ESP_ERR_INVALID_ARG;
    rcm = value;
    nvs_set_u8(nvs, "rcm", value);
    return nvs_commit(nvs);
}

// ========================
// Temperature
// ========================
uint8_t evse_get_temp_threshold(void)
{
    return temp_threshold;
}

esp_err_t evse_set_temp_threshold(uint8_t value)
{
    if (value < 40 || value > 80)
        return ESP_ERR_INVALID_ARG;
    temp_threshold = value;
    nvs_set_u8(nvs, "temp_threshold", value);
    return nvs_commit(nvs);
}

// ========================
// Availability
// ========================
bool evse_config_is_available(void)
{
    return is_available;
}

void evse_config_set_available(bool available)
{
    is_available = available ? true : false;

    esp_err_t err = nvs_set_u8(nvs, "available", (uint8_t)is_available);
    if (err == ESP_OK)
        err = nvs_commit(nvs);
    if (err != ESP_OK)
    {
        ESP_LOGE(TAG, "Failed to persist 'available': %s", esp_err_to_name(err));
    }

    evse_available_event_data_t e = {
        .available = is_available,
        .timestamp_us = esp_timer_get_time()};
    esp_event_post(EVSE_EVENTS, EVSE_EVENT_AVAILABLE_UPDATED, &e, sizeof(e), portMAX_DELAY);
}

// ========================
// Enable/Disable
// ========================
bool evse_config_is_enabled(void)
{
    return is_enabled;
}

void evse_config_set_enabled(bool enabled)
{
    is_enabled = enabled ? true : false;

    esp_err_t err = nvs_set_u8(nvs, "enabled", (uint8_t)is_enabled);
    if (err == ESP_OK)
        err = nvs_commit(nvs);
    if (err != ESP_OK)
    {
        ESP_LOGE(TAG, "Failed to persist 'enabled': %s", esp_err_to_name(err));
    }

    evse_enable_event_data_t e = {
        .enabled = is_enabled,
        .timestamp_us = esp_timer_get_time()};
    esp_event_post(EVSE_EVENTS, EVSE_EVENT_ENABLE_UPDATED, &e, sizeof(e), portMAX_DELAY);
}