admin/chargeflow
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

new upgrade

Browse Source
This commit is contained in:
PlxEV
2025-12-21 23:28:26 +00:00
parent 82fa194bd8
commit 023644a887
99 changed files with 7457 additions and 7079 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/network/CMakeLists.txt
View File

@@ -5,4 +5,4 @@ set(srcs
idf_component_register(SRCS "${srcs}"
INCLUDE_DIRS "include"
PRIV_REQUIRES nvs_flash esp_netif esp_wifi mdns esp_event)
PRIV_REQUIRES nvs_flash esp_netif esp_wifi storage_service mdns esp_event)

226
components/network/src/network.c
View File

@@ -11,22 +11,24 @@
#include "freertos/event_groups.h"
#include "esp_log.h"
#include "esp_err.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_mac.h"
#include "nvs.h"
#include "nvs_flash.h"
#include "mdns.h"
#include "network_events.h"
#include "network.h"
// NEW:
#include "storage_service.h"
// -----------------------------------------------------------------------------
// Config
// -----------------------------------------------------------------------------
#define AP_SSID "plx-%02x%02x%02x" // SSID do AP (usa 3 bytes do MAC)
#define MDNS_SSID "plx%02x" // hostname mDNS (usa 2 bytes do MAC)
#define AP_SSID "plx-%02x%02x%02x"
#define MDNS_SSID "plx%02x"
#define NVS_NAMESPACE "wifi"
#define NVS_ENABLED "enabled"
@@ -35,60 +37,106 @@
// Comprimentos com terminador
#define SSID_MAX_LEN 32
#define PASS_MAX_LEN 64 // 63 chars + '\0'
#define SSID_BUF_SZ (SSID_MAX_LEN + 1) // 33
#define PASS_BUF_SZ (PASS_MAX_LEN + 1) // 65
#define PASS_MAX_LEN 64
#define SSID_BUF_SZ (SSID_MAX_LEN + 1)
#define PASS_BUF_SZ (PASS_MAX_LEN + 1)
static const char *TAG = "wifi";
// Storage timeouts
#define STORE_TO pdMS_TO_TICKS(800)
#define STORE_FLUSH_TO pdMS_TO_TICKS(2000)
// -----------------------------------------------------------------------------
// Estado global
// -----------------------------------------------------------------------------
static nvs_handle_t nvs;
static esp_netif_t *sta_netif;
static esp_netif_t *ap_netif;
EventGroupHandle_t wifi_event_group;
// Backoff simples para reconexão STA (agora sem delay no event handler)
// Backoff simples para reconexão STA
static int s_retry_count = 0;
static const int s_retry_max = 7;
// -----------------------------------------------------------------------------
// Helpers
// Helpers storage (robustos)
// -----------------------------------------------------------------------------
// Lê string do NVS com segurança (trunca se necessário)
static esp_err_t nvs_get_str_safe(nvs_handle_t h, const char *key, char *out, size_t out_sz)
static esp_err_t store_flush_best_effort(void)
{
esp_err_t e = storage_flush_sync(STORE_FLUSH_TO);
if (e != ESP_OK)
ESP_LOGW(TAG, "storage_flush_sync failed: %s", esp_err_to_name(e));
return e;
}
static esp_err_t store_set_u8_best_effort(const char *ns, const char *key, uint8_t v)
{
for (int attempt = 0; attempt < 3; ++attempt)
{
esp_err_t e = storage_set_u8_async(ns, key, v);
if (e == ESP_OK)
return ESP_OK;
if (e == ESP_ERR_TIMEOUT)
{
(void)store_flush_best_effort();
vTaskDelay(pdMS_TO_TICKS(10));
continue;
}
return e;
}
return ESP_ERR_TIMEOUT;
}
static esp_err_t store_set_str_best_effort(const char *ns, const char *key, const char *s)
{
for (int attempt = 0; attempt < 3; ++attempt)
{
esp_err_t e = storage_set_str_async(ns, key, s);
if (e == ESP_OK)
return ESP_OK;
if (e == ESP_ERR_TIMEOUT)
{
(void)store_flush_best_effort();
vTaskDelay(pdMS_TO_TICKS(10));
continue;
}
return e;
}
return ESP_ERR_TIMEOUT;
}
// Lê string de forma segura (lê para buffer grande e depois trunca para out)
// Nota: isto ajuda se houver lixo antigo no NVS com strings maiores do que o esperado.
static esp_err_t store_get_str_safe(const char *ns, const char *key, char *out, size_t out_sz)
{
if (!out || out_sz == 0)
return ESP_ERR_INVALID_ARG;
out[0] = '\0';
size_t need = 0;
esp_err_t err = nvs_get_str(h, key, NULL, &need);
if (err == ESP_ERR_NVS_NOT_FOUND)
return ESP_OK;
if (err != ESP_OK)
return err;
// buffer grande (sem heap): usa o máximo definido no storage_service
char tmp[STORAGE_MAX_VALUE_BYTES + 1];
memset(tmp, 0, sizeof(tmp));
if (need == 0)
return ESP_OK; // vazio
if (need > out_sz)
esp_err_t e = storage_get_str_sync(ns, key, tmp, sizeof(tmp), STORE_TO);
if (e == ESP_ERR_NOT_FOUND)
{
// Truncar de forma segura
char *tmp = (char *)malloc(need);
if (!tmp)
return ESP_ERR_NO_MEM;
err = nvs_get_str(h, key, tmp, &need);
if (err == ESP_OK)
{
snprintf(out, out_sz, "%s", tmp);
}
free(tmp);
return err;
out[0] = '\0';
return ESP_OK;
}
return nvs_get_str(h, key, out, &need);
if (e != ESP_OK)
{
out[0] = '\0';
return e;
}
size_t n = strnlen(tmp, out_sz - 1); // no máximo out_sz-1
memcpy(out, tmp, n);
out[n] = '\0';
return ESP_OK;
}
// -----------------------------------------------------------------------------
@@ -96,6 +144,8 @@ static esp_err_t nvs_get_str_safe(nvs_handle_t h, const char *key, char *out, si
// -----------------------------------------------------------------------------
static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
{
(void)arg;
if (event_base == WIFI_EVENT)
{
switch (event_id)
@@ -128,7 +178,6 @@ static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_
case WIFI_EVENT_STA_CONNECTED:
{
ESP_LOGI(TAG, "STA associated (L2 connected)");
// dispara evento genérico de STA_CONNECTED
esp_event_post(NETWORK_EVENTS,
NETWORK_EVENT_STA_CONNECTED,
NULL,
@@ -144,14 +193,12 @@ static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_
wifi_event_sta_disconnected_t *ev = (wifi_event_sta_disconnected_t *)event_data;
ESP_LOGW(TAG, "STA disconnected, reason=%d", ev ? ev->reason : -1);
// dispara evento genérico de “STA desconectou”
esp_event_post(NETWORK_EVENTS,
NETWORK_EVENT_STA_DISCONNECTED,
ev,
ev ? sizeof(*ev) : 0,
portMAX_DELAY);
// NÃO bloquear o event loop com vTaskDelay
if (s_retry_count < s_retry_max)
{
esp_err_t err = esp_wifi_connect();
@@ -162,7 +209,7 @@ static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_
}
else
{
ESP_LOGW(TAG, "esp_wifi_connect failed (%d)", err);
ESP_LOGW(TAG, "esp_wifi_connect failed (%s)", esp_err_to_name(err));
}
}
else
@@ -185,22 +232,12 @@ static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_
xEventGroupSetBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
s_retry_count = 0;
// Dispara evento “STA GOT IP”
esp_event_post(NETWORK_EVENTS,
NETWORK_EVENT_STA_GOT_IP,
&event->ip_info,
sizeof(event->ip_info),
portMAX_DELAY);
}
else if (event_id == IP_EVENT_GOT_IP6)
{
ip_event_got_ip6_t *event = (ip_event_got_ip6_t *)event_data;
ESP_LOGI(TAG, "WiFi STA got ip6: " IPV6STR, IPV62STR(event->ip6_info.ip));
xEventGroupClearBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT);
xEventGroupSetBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
s_retry_count = 0;
// se quiseres, podes também propagar um NETWORK_EVENT_STA_GOT_IP aqui
}
else if (event_id == IP_EVENT_STA_LOST_IP)
{
ESP_LOGW(TAG, "STA lost IP");
@@ -227,28 +264,21 @@ static void sta_set_config(void)
wifi_config.sta.pmf_cfg.capable = true;
wifi_config.sta.pmf_cfg.required = false;
// buffers "seguros" vindos da NVS (estes sim têm terminador)
char ssid_buf[SSID_BUF_SZ] = {0}; // 33 (32 + '\0')
char pass_buf[PASS_BUF_SZ] = {0}; // 65 (64 + '\0')
char ssid_buf[SSID_BUF_SZ] = {0};
char pass_buf[PASS_BUF_SZ] = {0};
wifi_get_ssid(ssid_buf);
wifi_get_password(pass_buf);
// Copiar **sem** terminador para os campos do esp_wifi (32/64 bytes)
// SSID: max 32
size_t ssid_len = strnlen(ssid_buf, SSID_MAX_LEN); // até 32
size_t ssid_len = strnlen(ssid_buf, SSID_MAX_LEN);
memcpy(wifi_config.sta.ssid, ssid_buf, ssid_len);
// Password WPA/WPA2: 8..63 chars (campo tem 64 bytes)
// (se usares rede aberta, pass_len pode ser 0)
size_t pass_len = strnlen(pass_buf, 63); // até 63
size_t pass_len = strnlen(pass_buf, 63);
memcpy(wifi_config.sta.password, pass_buf, pass_len);
if (pass_len <= 63)
{
wifi_config.sta.password[pass_len] = '\0';
}
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config)); // v5.x
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
}
static void ap_set_config(void)
@@ -257,14 +287,13 @@ static void ap_set_config(void)
wifi_config_t wifi_ap_config = {0};
wifi_ap_config.ap.max_connection = 1;
wifi_ap_config.ap.authmode = WIFI_AUTH_OPEN; // para portal cativo, por exemplo
wifi_ap_config.ap.authmode = WIFI_AUTH_OPEN;
uint8_t mac[6];
esp_wifi_get_mac(WIFI_IF_AP, mac);
snprintf((char *)wifi_ap_config.ap.ssid, sizeof(wifi_ap_config.ap.ssid),
AP_SSID, mac[3], mac[4], mac[5]); // "plx-XXXXXX"
AP_SSID, mac[3], mac[4], mac[5]);
// Só AP (não mexer na config STA aqui para não a limpar)
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_ap_config));
}
@@ -283,7 +312,7 @@ static void sta_try_start(void)
esp_err_t e = esp_wifi_start();
if (e != ESP_OK && e != ESP_ERR_WIFI_CONN)
{
ESP_LOGW(TAG, "esp_wifi_start returned %d", e);
ESP_LOGW(TAG, "esp_wifi_start returned %s", esp_err_to_name(e));
}
xEventGroupSetBits(wifi_event_group, WIFI_STA_MODE_BIT);
}
@@ -296,8 +325,10 @@ void wifi_ini(void)
{
ESP_LOGI(TAG, "Wifi init");
// Abre NVS (assume que nvs_flash_init() já foi chamado no boot geral)
ESP_ERROR_CHECK(nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs));
// garante storage pronto (não assume NVS handle aberto aqui)
esp_err_t se = storage_service_init();
if (se != ESP_OK)
ESP_LOGW(TAG, "storage_service_init failed: %s", esp_err_to_name(se));
wifi_event_group = xEventGroupCreate();
@@ -310,14 +341,11 @@ void wifi_ini(void)
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
// mDNS: usa dois bytes do MAC para identificar
uint8_t mac[6];
esp_wifi_get_mac(WIFI_IF_STA, mac);
char chargeid[16];
// ex.: "plx00"
snprintf(chargeid, sizeof(chargeid), MDNS_SSID, 0);
// Hostname das interfaces alinhado com o mDNS
ESP_ERROR_CHECK(esp_netif_set_hostname(sta_netif, chargeid));
ESP_ERROR_CHECK(esp_netif_set_hostname(ap_netif, chargeid));
@@ -335,10 +363,9 @@ esp_err_t wifi_set_config(bool enabled, const char *ssid, const char *password)
{
ESP_LOGI(TAG, "wifi_set_config(enabled=%d)", enabled);
// Validação (quando habilitar STA)
// Validação
if (enabled)
{
// SSID 1..32
if (ssid && (strlen(ssid) == 0 || strlen(ssid) > SSID_MAX_LEN))
{
ESP_LOGE(TAG, "SSID out of range");
@@ -346,15 +373,15 @@ esp_err_t wifi_set_config(bool enabled, const char *ssid, const char *password)
}
if (!ssid)
{
size_t len = 0;
esp_err_t e = nvs_get_str(nvs, NVS_SSID, NULL, &len);
if (e != ESP_OK || len <= 1)
char cur_ssid[SSID_BUF_SZ] = {0};
wifi_get_ssid(cur_ssid);
if (strlen(cur_ssid) == 0)
{
ESP_LOGE(TAG, "Required SSID");
return ESP_ERR_INVALID_ARG;
}
}
// Password: 8..63 (se não for vazia). Aceita "" para rede open (caso uses).
if (password)
{
size_t lp = strlen(password);
@@ -366,13 +393,27 @@ esp_err_t wifi_set_config(bool enabled, const char *ssid, const char *password)
}
}
// Persiste no NVS
ESP_ERROR_CHECK(nvs_set_u8(nvs, NVS_ENABLED, enabled));
// Persiste via storage_service
esp_err_t err = store_set_u8_best_effort(NVS_NAMESPACE, NVS_ENABLED, enabled ? 1 : 0);
if (err != ESP_OK)
return err;
if (ssid)
ESP_ERROR_CHECK(nvs_set_str(nvs, NVS_SSID, ssid));
{
err = store_set_str_best_effort(NVS_NAMESPACE, NVS_SSID, ssid);
if (err != ESP_OK)
return err;
}
if (password)
ESP_ERROR_CHECK(nvs_set_str(nvs, NVS_PASSWORD, password));
ESP_ERROR_CHECK(nvs_commit(nvs));
{
err = store_set_str_best_effort(NVS_NAMESPACE, NVS_PASSWORD, password);
if (err != ESP_OK)
return err;
}
// Força persistência (para sobreviver a reboot imediato)
(void)store_flush_best_effort();
// Reinicia modo
ESP_LOGI(TAG, "Stopping AP/STA");
@@ -380,7 +421,7 @@ esp_err_t wifi_set_config(bool enabled, const char *ssid, const char *password)
esp_err_t e = esp_wifi_stop();
if (e != ESP_OK && e != ESP_ERR_WIFI_NOT_INIT && e != ESP_ERR_WIFI_STOP_STATE)
{
ESP_LOGW(TAG, "esp_wifi_stop returned %d", e);
ESP_LOGW(TAG, "esp_wifi_stop returned %s", esp_err_to_name(e));
}
sta_try_start();
@@ -402,21 +443,21 @@ uint16_t wifi_scan(wifi_scan_ap_t *scan_aps)
esp_err_t err = esp_wifi_scan_start(NULL, true);
if (err != ESP_OK)
{
ESP_LOGW(TAG, "esp_wifi_scan_start failed (%d)", err);
ESP_LOGW(TAG, "esp_wifi_scan_start failed (%s)", esp_err_to_name(err));
return 0;
}
err = esp_wifi_scan_get_ap_records(&number, ap_info);
if (err != ESP_OK)
{
ESP_LOGW(TAG, "esp_wifi_scan_get_ap_records failed (%d)", err);
ESP_LOGW(TAG, "esp_wifi_scan_get_ap_records failed (%s)", esp_err_to_name(err));
return 0;
}
err = esp_wifi_scan_get_ap_num(&ap_count);
if (err != ESP_OK)
{
ESP_LOGW(TAG, "esp_wifi_scan_get_ap_num failed (%d)", err);
ESP_LOGW(TAG, "esp_wifi_scan_get_ap_num failed (%s)", esp_err_to_name(err));
return 0;
}
@@ -424,7 +465,6 @@ uint16_t wifi_scan(wifi_scan_ap_t *scan_aps)
for (int i = 0; (i < WIFI_SCAN_SCAN_LIST_SIZE) && (i < ap_count); i++)
{
// garante que scan_aps[i].ssid tenha pelo menos 33 bytes
snprintf(scan_aps[i].ssid, sizeof(scan_aps[i].ssid), "%s", (const char *)ap_info[i].ssid);
scan_aps[i].rssi = ap_info[i].rssi;
scan_aps[i].auth = ap_info[i].authmode != WIFI_AUTH_OPEN;
@@ -436,29 +476,29 @@ uint16_t wifi_scan(wifi_scan_ap_t *scan_aps)
bool wifi_get_enabled(void)
{
uint8_t value = 0;
esp_err_t e = nvs_get_u8(nvs, NVS_ENABLED, &value);
if (e == ESP_ERR_NVS_NOT_FOUND)
esp_err_t e = storage_get_u8_sync(NVS_NAMESPACE, NVS_ENABLED, &value, STORE_TO);
if (e == ESP_ERR_NOT_FOUND)
return false;
if (e != ESP_OK)
{
ESP_LOGW(TAG, "nvs_get_u8(NVS_ENABLED) failed (%d), assuming disabled", e);
ESP_LOGW(TAG, "storage_get_u8_sync(enabled) failed (%s), assuming disabled", esp_err_to_name(e));
return false;
}
return value;
return (value != 0);
}
void wifi_get_ssid(char *value)
{
if (!value)
return;
nvs_get_str_safe(nvs, NVS_SSID, value, SSID_BUF_SZ); // 33
(void)store_get_str_safe(NVS_NAMESPACE, NVS_SSID, value, SSID_BUF_SZ);
}
void wifi_get_password(char *value)
{
if (!value)
return;
nvs_get_str_safe(nvs, NVS_PASSWORD, value, PASS_BUF_SZ); // 65
(void)store_get_str_safe(NVS_NAMESPACE, NVS_PASSWORD, value, PASS_BUF_SZ);
}
void wifi_ap_start(void)
@@ -474,7 +514,7 @@ void wifi_ap_start(void)
esp_err_t e = esp_wifi_start();
if (e != ESP_OK && e != ESP_ERR_WIFI_CONN)
{
ESP_LOGW(TAG, "esp_wifi_start (AP) returned %d", e);
ESP_LOGW(TAG, "esp_wifi_start (AP) returned %s", esp_err_to_name(e));
}
xEventGroupSetBits(wifi_event_group, WIFI_AP_MODE_BIT);
@@ -499,4 +539,4 @@ bool wifi_is_ap(void)
EventBits_t bits = xEventGroupGetBits(wifi_event_group);
return (bits & WIFI_AP_MODE_BIT) != 0;
}
}