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

new meter

Browse Source
This commit is contained in:
PlxEV
2025-06-14 10:27:29 +01:00
parent 4892718736
commit 6f95c7ba59
228 changed files with 3178 additions and 3115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
components/meter_manager/src/meter_events.c Normal file
View File

@@ -0,0 +1,4 @@
#include "meter_events.h"
// Define a base de eventos
ESP_EVENT_DEFINE_BASE(METER_EVENT);

275
components/meter_manager/src/meter_manager.c
View File

@@ -4,135 +4,196 @@
#include "meter_orno513.h"
#include "meter_orno516.h"
#include "meter_zigbee.h"
#include "nvs_flash.h"
#include "nvs.h"
#include <string.h>
static const char *TAG = "meter_manager";
// Variáveis para armazenar o tipo de medidor atual
static meter_type_t current_meter_type = METER_TYPE_NONE;
// Tipos de medidores EVSE e GRID
static meter_type_t meter_evse_type = METER_TYPE_NONE;
static meter_type_t meter_grid_type = METER_TYPE_NONE;
esp_err_t meter_init(meter_type_t meter_type) {
current_meter_type = meter_type;
ESP_LOGI(TAG, "Initializing meter of type: %d", meter_type);
#define NVS_NAMESPACE "meterconfig"
#define NVS_EVSE_MODEL "evse_model"
#define NVS_GRID_MODEL "grid_model"
switch (current_meter_type) {
case METER_TYPE_EVSE_ADE7758:
return meter_ade7758_init(); // Inicializa o medidor ADE7758 (EVSE)
case METER_TYPE_GRID_ORNO513:
return meter_orno513_init(); // Inicializa o medidor ORNO 513 ou 516 (Grid)
case METER_TYPE_GRID_ORNO516:
return meter_init_orno516(); // Inicializa o medidor ORNO 513 ou 516 (Grid)
case METER_TYPE_GRID_ZIGBEE:
return meter_init_zigbee(); // Inicializa o medidor Zigbee (Grid)
default:
ESP_LOGE(TAG, "Unsupported meter type");
return ESP_ERR_INVALID_ARG;
// Função unificada para ler ou inicializar um modelo de medidor
static esp_err_t load_or_init_meter_model(const char *key, meter_type_t *type) {
nvs_handle_t handle;
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to open NVS handle for %s: %s", key, esp_err_to_name(err));
return err;
}
uint8_t value = 0;
err = nvs_get_u8(handle, key, &value);
if (err == ESP_OK && value <= METER_TYPE_TRIF_ZIGBEE) {
*type = (meter_type_t)value;
ESP_LOGI(TAG, "Loaded meter type %d from NVS key '%s'", value, key);
} else {
*type = METER_TYPE_NONE;
nvs_set_u8(handle, key, *type);
nvs_commit(handle);
ESP_LOGW(TAG, "Invalid or missing key '%s', setting default (NONE)", key);
}
nvs_close(handle);
return ESP_OK;
}
static esp_err_t write_meter_model_to_nvs(const char *key, meter_type_t meter_type) {
nvs_handle_t handle;
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to open NVS handle for writing");
return err;
}
err = nvs_set_u8(handle, key, (uint8_t)meter_type);
if (err == ESP_OK) {
err = nvs_commit(handle);
ESP_LOGI(TAG, "Saved meter type %d to NVS key '%s'", meter_type, key);
} else {
ESP_LOGE(TAG, "Failed to write meter type to NVS key '%s'", key);
}
nvs_close(handle);
return err;
}
// Função para inicializar o medidor EVSE
esp_err_t meter_manager_evse_init() {
esp_err_t err = load_or_init_meter_model(NVS_EVSE_MODEL, &meter_evse_type);
if (err != ESP_OK) return err;
ESP_LOGI(TAG, "Initializing EVSE meter of type %s", meter_type_to_str(meter_evse_type));
switch (meter_evse_type) {
case METER_TYPE_NONE: return ESP_OK;
case METER_TYPE_ADE7758: return meter_ade7758_init();
case METER_TYPE_ORNO513: return meter_orno513_init();
case METER_TYPE_ORNO516: return meter_orno516_init();
case METER_TYPE_MONO_ZIGBEE:
case METER_TYPE_TRIF_ZIGBEE: return meter_zigbee_init();
default: return ESP_ERR_INVALID_ARG;
}
}
esp_err_t meter_start(void) {
if (current_meter_type == METER_TYPE_NONE) {
ESP_LOGE(TAG, "Meter type is not initialized");
return ESP_ERR_INVALID_STATE;
}
esp_err_t meter_manager_grid_init() {
esp_err_t err = load_or_init_meter_model(NVS_GRID_MODEL, &meter_grid_type);
if (err != ESP_OK) return err;
ESP_LOGI(TAG, "Starting meter");
ESP_LOGI(TAG, "Initializing GRID meter of type %s", meter_type_to_str(meter_grid_type));
switch (current_meter_type) {
case METER_TYPE_EVSE_ADE7758:
return meter_ade7758_start();
case METER_TYPE_GRID_ORNO513:
return meter_orno513_start();
case METER_TYPE_GRID_ORNO516:
return meter_start_orno516();
case METER_TYPE_GRID_ZIGBEE:
return meter_start_zigbee();
default:
ESP_LOGE(TAG, "Unsupported meter type");
return ESP_ERR_INVALID_ARG;
switch (meter_grid_type) {
case METER_TYPE_NONE: return ESP_OK;
case METER_TYPE_ADE7758: return meter_ade7758_init();
case METER_TYPE_ORNO513: return meter_orno513_init();
case METER_TYPE_ORNO516: return meter_orno516_init();
case METER_TYPE_MONO_ZIGBEE:
case METER_TYPE_TRIF_ZIGBEE: return meter_zigbee_init();
default: return ESP_ERR_INVALID_ARG;
}
}
void meter_stop(void) {
if (current_meter_type == METER_TYPE_NONE) {
ESP_LOGE(TAG, "Meter is not initialized");
return;
}
ESP_LOGI(TAG, "Stopping meter");
switch (current_meter_type) {
case METER_TYPE_EVSE_ADE7758:
meter_ade7758_stop();
break;
case METER_TYPE_GRID_ORNO513:
meter_orno513_stop();
break;
case METER_TYPE_GRID_ORNO516:
meter_stop_orno516();
break;
case METER_TYPE_GRID_ZIGBEE:
meter_stop_zigbee();
break;
default:
ESP_LOGE(TAG, "Unsupported meter type");
break;
esp_err_t meter_manager_grid_start() {
meter_type_t type = meter_manager_grid_get_model();
switch (type) {
case METER_TYPE_NONE: return ESP_OK;
case METER_TYPE_ADE7758: return meter_ade7758_start();
case METER_TYPE_ORNO513: return meter_orno513_start();
case METER_TYPE_ORNO516: return meter_orno516_start();
case METER_TYPE_MONO_ZIGBEE:
case METER_TYPE_TRIF_ZIGBEE: return meter_zigbee_start();
default: return ESP_ERR_INVALID_ARG;
}
}
bool meter_is_running(void) {
if (current_meter_type == METER_TYPE_NONE) {
ESP_LOGE(TAG, "Meter is not initialized");
return false;
esp_err_t meter_manager_grid_stop(void) {
meter_type_t type = meter_manager_grid_get_model();
switch (type) {
case METER_TYPE_NONE: return ESP_OK;
case METER_TYPE_ADE7758: meter_ade7758_stop(); break;
case METER_TYPE_ORNO513: meter_orno513_stop(); break;
case METER_TYPE_ORNO516: meter_orno516_stop(); break;
case METER_TYPE_MONO_ZIGBEE:
case METER_TYPE_TRIF_ZIGBEE: meter_zigbee_stop(); break;
default: return ESP_ERR_INVALID_ARG;
}
return ESP_OK;
}
switch (current_meter_type) {
case METER_TYPE_EVSE_ADE7758:
return meter_ade7758_is_running();
case METER_TYPE_GRID_ORNO513:
return meter_orno513_is_running();
case METER_TYPE_GRID_ORNO516:
return meter_is_running_orno516();
case METER_TYPE_GRID_ZIGBEE:
return meter_is_running_zigbee();
default:
ESP_LOGE(TAG, "Unsupported meter type");
return false;
esp_err_t meter_manager_evse_set_model(meter_type_t meter_type) {
meter_evse_type = meter_type;
return write_meter_model_to_nvs(NVS_EVSE_MODEL, meter_evse_type);
}
esp_err_t meter_manager_grid_set_model(meter_type_t meter_type) {
meter_grid_type = meter_type;
return write_meter_model_to_nvs(NVS_GRID_MODEL, meter_grid_type);
}
esp_err_t meter_manager_evse_start() {
meter_type_t type = meter_manager_evse_get_model();
switch (type) {
case METER_TYPE_NONE: return ESP_OK;
case METER_TYPE_ADE7758: return meter_ade7758_start();
case METER_TYPE_ORNO513: return meter_orno513_start();
case METER_TYPE_ORNO516: return meter_orno516_start();
case METER_TYPE_MONO_ZIGBEE:
case METER_TYPE_TRIF_ZIGBEE: return meter_zigbee_start();
default: return ESP_ERR_INVALID_ARG;
}
}
float meter_get_vrms_l1(void) {
if (current_meter_type == METER_TYPE_NONE) return 0;
switch (current_meter_type) {
case METER_TYPE_EVSE_ADE7758:
return meter_ade7758_get_vrms_l1();
case METER_TYPE_GRID_ORNO513:
return meter_orno513_get_vrms_l1();
case METER_TYPE_GRID_ORNO516:
return meter_get_vrms_l1_orno516();
case METER_TYPE_GRID_ZIGBEE:
return meter_get_vrms_l1_zigbee();
default:
ESP_LOGE(TAG, "Unsupported meter type for reading vrms_l1");
return 0;
esp_err_t meter_manager_evse_stop(void) {
meter_type_t type = meter_manager_evse_get_model();
switch (type) {
case METER_TYPE_NONE: return ESP_OK;
case METER_TYPE_ADE7758: meter_ade7758_stop(); break;
case METER_TYPE_ORNO513: meter_orno513_stop(); break;
case METER_TYPE_ORNO516: meter_orno516_stop(); break;
case METER_TYPE_MONO_ZIGBEE:
case METER_TYPE_TRIF_ZIGBEE: meter_zigbee_stop(); break;
default: return ESP_ERR_INVALID_ARG;
}
return ESP_OK;
}
bool meter_manager_evse_is_enabled(void) {
return meter_manager_evse_get_model() != METER_TYPE_NONE;
}
meter_type_t meter_manager_evse_get_model(void) {
return meter_evse_type;
}
meter_type_t meter_manager_grid_get_model(void) {
return meter_grid_type;
}
const char* meter_type_to_str(meter_type_t type) {
switch (type) {
case METER_TYPE_NONE: return "NENHUM";
case METER_TYPE_ADE7758: return "IC ADE";
case METER_TYPE_ORNO513: return "ORNO-513";
case METER_TYPE_ORNO516: return "ORNO-516";
case METER_TYPE_MONO_ZIGBEE: return "MONO-ZIGBEE";
case METER_TYPE_TRIF_ZIGBEE: return "TRIF-ZIGBEE";
default: return "NENHUM";
}
}
// Continue as funções `meter_get_*` para cada tipo de dado (corrente, potência, etc.)
float meter_get_irms_l1(void) {
if (current_meter_type == METER_TYPE_NONE) return 0;
switch (current_meter_type) {
case METER_TYPE_EVSE_ADE7758:
return meter_ade7758_get_irms_l1();
case METER_TYPE_GRID_ORNO513:
return meter_orno513_get_irms_l1();
case METER_TYPE_GRID_ORNO516:
return meter_get_irms_l1_orno516();
case METER_TYPE_GRID_ZIGBEE:
return meter_get_irms_l1_zigbee();
default:
ESP_LOGE(TAG, "Unsupported meter type for reading irms_l1");
return 0;
}
meter_type_t string_to_meter_type(const char *str) {
if (!str) return METER_TYPE_NONE;
if (strcmp(str, "IC ADE") == 0) return METER_TYPE_ADE7758;
if (strcmp(str, "ORNO-513") == 0) return METER_TYPE_ORNO513;
if (strcmp(str, "ORNO-516") == 0) return METER_TYPE_ORNO516;
if (strcmp(str, "MONO-ZIGBEE") == 0) return METER_TYPE_MONO_ZIGBEE;
if (strcmp(str, "TRIF-ZIGBEE") == 0) return METER_TYPE_TRIF_ZIGBEE;
return METER_TYPE_NONE;
}
// You should add the rest of the functions similarly as you progress