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

new release

Browse Source
This commit is contained in:
PlxEV
2025-11-20 07:45:00 +00:00
parent 96b2ab1f57
commit 4820d9111e
106 changed files with 4264 additions and 15581 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
components/meter_manager/CMakeLists.txt
View File

@@ -3,7 +3,11 @@ set(srcs
"driver/meter_ade7758/meter_ade7758.c"
"driver/meter_ade7758/ade7758.c"
"driver/meter_orno/meter_orno513.c"
"driver/meter_orno/meter_orno526.c"
"driver/meter_orno/meter_orno516.c"
"driver/meter_orno/meter_dts6619.c"
"driver/meter_orno/meter_dds661.c"
"driver/meter_orno/meter_ea777.c"
"driver/meter_orno/modbus_params.c"
"driver/meter_zigbee/meter_zigbee.c"
"src/meter_manager.c"

289
components/meter_manager/driver/meter_orno/meter_dds661.c Executable file
View File

@@ -0,0 +1,289 @@
// components/meter_manager/driver/meter_dds661.c
#include "meter_dds661.h"
#include "modbus_params.h"
#include "mbcontroller.h"
#include "meter_events.h"
#include "esp_log.h"
#include "driver/uart.h"
#include <string.h>
#include <math.h>
#define TAG "serial_mdb_dds661"
// ======= UART/Modbus config =======
#define MB_PORT_NUM 2
#define MB_DEV_SPEED 9600
// Ajuste os pinos conforme seu hardware (evite GPIO2 para RTS/DE/RE se possível)
#define MB_UART_TXD 17
#define MB_UART_RXD 16
#define MB_UART_RTS 2 // pino DE/RE do transceiver RS-485
#define UPDATE_INTERVAL (3000 / portTICK_PERIOD_MS)
#define POLL_INTERVAL (120 / portTICK_PERIOD_MS)
// ======= Helpers típicos do teu projeto =======
#define HOLD_OFFSET(field) ((uint16_t)(offsetof(holding_reg_params_t, field) + 1))
#define STR(x) ((const char *)(x))
#define OPTS(min, max, step) {.opt1 = min, .opt2 = max, .opt3 = step}
// ======= Estado =======
static bool is_initialized = false;
static TaskHandle_t meter_task = NULL;
// ======= CIDs (sequenciais) =======
enum
{
CID_VOLTAGE = 0,
CID_CURRENT,
CID_ACTIVE_POWER_KW,
CID_POWER_FACTOR,
CID_FREQUENCY,
CID_TOTAL_ACTIVE_ENERGY_KWH,
CID_COUNT
};
// ======= Mapa de registradores (Input Registers; FC=0x04) =======
// Endereços típicos para DDS-661 (float32):
#define REG_VOLTAGE 0x0000 // V (float32)
#define REG_CURRENT 0x0008 // A (float32)
#define REG_ACTIVE_POWER_KW 0x0012 // kW (float32)
#define REG_POWER_FACTOR 0x002A // PF (float32)
#define REG_FREQUENCY 0x0036 // Hz (float32)
#define REG_E_ACTIVE_KWH 0x0100 // kWh (float32)
// ======= Tabela de parâmetros (Data Dictionary) =======
const mb_parameter_descriptor_t device_parameters_dds661[] = {
{CID_VOLTAGE, "Voltage", "V", 1,
MB_PARAM_INPUT, REG_VOLTAGE, 2, HOLD_OFFSET(l1_voltage),
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
{CID_CURRENT, "Current", "A", 1,
MB_PARAM_INPUT, REG_CURRENT, 2, HOLD_OFFSET(l1_current),
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 100, 0.1), PAR_PERMS_READ},
{CID_ACTIVE_POWER_KW, "Active Power", "kW", 1,
MB_PARAM_INPUT, REG_ACTIVE_POWER_KW, 2, HOLD_OFFSET(active_power),
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(-100, 100, 0.01), PAR_PERMS_READ},
{CID_POWER_FACTOR, "Power Factor", "", 1,
MB_PARAM_INPUT, REG_POWER_FACTOR, 2, HOLD_OFFSET(power_factor),
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(-1, 1, 0.001), PAR_PERMS_READ},
{CID_FREQUENCY, "Frequency", "Hz", 1,
MB_PARAM_INPUT, REG_FREQUENCY, 2, HOLD_OFFSET(frequency),
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 100, 0.1), PAR_PERMS_READ},
{CID_TOTAL_ACTIVE_ENERGY_KWH, "Total Active Energy", "kWh", 1,
MB_PARAM_INPUT, REG_E_ACTIVE_KWH, 2, HOLD_OFFSET(active_energy),
PARAM_TYPE_FLOAT_CDAB, 4, OPTS(0, 1000000, 0.01), PAR_PERMS_READ},
};
const uint16_t num_device_parameters_dds661 =
sizeof(device_parameters_dds661) / sizeof(device_parameters_dds661[0]);
// ======= Ponteiro para buffer destino =======
static void *get_param_ptr(const mb_parameter_descriptor_t *param)
{
if (!param || param->param_offset == 0)
return NULL;
return ((uint8_t *)&holding_reg_params + param->param_offset - 1);
}
// ======= Tarefa de aquisição =======
static void serial_mdb_task(void *param)
{
esp_err_t err;
const mb_parameter_descriptor_t *desc = NULL;
// Valores lidos
float v = 0.0f; // V
float i = 0.0f; // A
float pf = 0.0f; // -
float hz = 0.0f; // Hz
float e_kwh = 0.0f; // kWh
float p_kw = 0.0f; // kW
// Buffers para o evento
float voltage[3] = {0};
float current[3] = {0};
int watt[3] = {0};
while (1)
{
for (uint16_t cid = 0; cid < num_device_parameters_dds661; cid++)
{
err = mbc_master_get_cid_info(cid, &desc);
if (err != ESP_OK || !desc)
{
ESP_LOGE(TAG, "get_cid_info(%u) failed: %s", cid, esp_err_to_name(err));
continue;
}
void *data_ptr = get_param_ptr(desc);
if (!data_ptr)
{
ESP_LOGE(TAG, "CID %u (%s): null data_ptr", cid, desc->param_key);
continue;
}
uint8_t type = 0;
err = mbc_master_get_parameter(cid, (char *)desc->param_key, (uint8_t *)data_ptr, &type);
if (err != ESP_OK)
{
ESP_LOGE(TAG, "CID %u (%s) read failed: %s", cid, desc->param_key, esp_err_to_name(err));
vTaskDelay(POLL_INTERVAL);
continue;
}
// Dump dos bytes recebidos (4 bytes do float bruto)
uint8_t raw[4];
memcpy(raw, data_ptr, 4);
ESP_LOGD(TAG, "CID %u (%s) raw bytes: %02X %02X %02X %02X",
cid, desc->param_key, raw[0], raw[1], raw[2], raw[3]);
float val = 0.0f;
val = *(float *)data_ptr;
ESP_LOGD(TAG, "%s: %.3f %s", desc->param_key, val, desc->param_units);
switch (cid)
{
case CID_VOLTAGE:
v = val;
voltage[0] = v;
break;
case CID_CURRENT:
i = val;
current[0] = i;
break;
case CID_POWER_FACTOR:
pf = val;
break;
case CID_FREQUENCY:
hz = val;
break;
case CID_ACTIVE_POWER_KW:
{
p_kw = val;
float p_w = p_kw * 1000.0f;
int pwi = (int)lrintf(p_w);
watt[0] = pwi;
watt[1] = pwi;
watt[2] = pwi;
break;
}
case CID_TOTAL_ACTIVE_ENERGY_KWH:
e_kwh = val;
break;
default:
break;
}
vTaskDelay(POLL_INTERVAL);
}
meter_event_data_t evt = {
.frequency = hz,
.power_factor = pf,
.total_energy = e_kwh,
.source = "GRID",
};
memcpy(evt.vrms, voltage, sizeof(evt.vrms));
memcpy(evt.irms, current, sizeof(evt.irms));
memcpy(evt.watt, watt, sizeof(evt.watt));
esp_event_post(METER_EVENT, METER_EVENT_DATA_READY, &evt, sizeof(evt), pdMS_TO_TICKS(10));
vTaskDelay(UPDATE_INTERVAL);
}
}
// ======= API pública =======
esp_err_t meter_dds661_init(void)
{
if (is_initialized)
{
ESP_LOGW(TAG, "meter_dds661 already initialized");
return ESP_ERR_INVALID_STATE;
}
ESP_LOGI(TAG, "meter_dds661_init");
mb_communication_info_t comm = {
.port = MB_PORT_NUM,
.mode = MB_MODE_RTU,
.baudrate = MB_DEV_SPEED,
.parity = UART_PARITY_EVEN, // DDS-661: 9600 8E1
};
void *handler = NULL;
ESP_ERROR_CHECK(mbc_master_init(MB_PORT_SERIAL_MASTER, &handler));
ESP_ERROR_CHECK(mbc_master_setup(&comm));
// Pinos e parâmetros básicos
ESP_ERROR_CHECK(uart_set_pin(MB_PORT_NUM, MB_UART_TXD, MB_UART_RXD, MB_UART_RTS, UART_PIN_NO_CHANGE));
ESP_ERROR_CHECK(uart_set_word_length(MB_PORT_NUM, UART_DATA_8_BITS));
ESP_ERROR_CHECK(uart_set_hw_flow_ctrl(MB_PORT_NUM, UART_HW_FLOWCTRL_DISABLE, 0));
ESP_ERROR_CHECK(uart_set_stop_bits(MB_PORT_NUM, UART_STOP_BITS_1));
// >>> IMPORTANTE: start antes do set_mode <<<
ESP_ERROR_CHECK(mbc_master_start());
// Só agora muda para RS485 half duplex
ESP_ERROR_CHECK(uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX));
// (opcional) logs de debug Modbus
esp_log_level_set("MB_CONTROLLER_MASTER", ESP_LOG_DEBUG);
esp_log_level_set("MB_PORT_COMMON", ESP_LOG_DEBUG);
esp_log_level_set("MB_SERIAL_MASTER", ESP_LOG_DEBUG);
vTaskDelay(pdMS_TO_TICKS(5));
ESP_ERROR_CHECK(mbc_master_set_descriptor(device_parameters_dds661, num_device_parameters_dds661));
is_initialized = true;
return ESP_OK;
}
esp_err_t meter_dds661_start(void)
{
if (!is_initialized)
{
ESP_LOGE(TAG, "meter_dds661 not initialized");
return ESP_ERR_INVALID_STATE;
}
if (meter_task == NULL)
{
xTaskCreate(serial_mdb_task, "meter_dds661_task", 4096, NULL, 3, &meter_task);
ESP_LOGI(TAG, "meter_dds661 task started");
}
return ESP_OK;
}
void meter_dds661_stop(void)
{
if (!is_initialized)
{
ESP_LOGW(TAG, "meter_dds661 not initialized");
return;
}
ESP_LOGI(TAG, "Stopping meter_dds661");
// 1) Destrói o master primeiro
esp_err_t err = mbc_master_destroy();
if (err != ESP_OK)
{
ESP_LOGW(TAG, "mbc_master_destroy() returned %s", esp_err_to_name(err));
}
// 2) Depois solta a UART
uart_driver_delete(MB_PORT_NUM);
is_initialized = false;
}

29
components/meter_manager/driver/meter_orno/meter_dds661.h Executable file
View File

@@ -0,0 +1,29 @@
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdbool.h>
#include "esp_err.h"
/**
* @brief Inicializa o driver do medidor DDS 661 (SPI, mutex, registradores).
*/
esp_err_t meter_dds661_init(void);
/**
* @brief Inicia a tarefa de leitura de dados do medidor DDS 661.
*/
esp_err_t meter_dds661_start(void);
/**
* @brief Para a tarefa de leitura e limpa os dados internos do medidor DDS 661.
*/
void meter_dds661_stop(void);
#ifdef __cplusplus
}
#endif

326
components/meter_manager/driver/meter_orno/meter_dts6619.c Executable file
View File

@@ -0,0 +1,326 @@
// meter_dts6619.c — Driver Modbus RTU para SINOTIMER DTS6619 (ESP-IDF)
#include "meter_events.h"
#include "modbus_params.h"
#include "mbcontroller.h"
#include "esp_log.h"
#include "driver/uart.h"
#include <stddef.h>
#include <string.h>
#define TAG "serial_mdb_dts6619"
// ===== UART / RS-485 =====
#define MB_PORT_NUM 2
#define MB_DEV_SPEED 9600
// Ajuste os pinos conforme seu hardware (evite GPIO2 para RTS/DE/RE se possível)
#define MB_UART_TXD 17
#define MB_UART_RXD 16
#define MB_UART_RTS 2 // pino DE/RE do transceiver RS-485
// ===== Timings =====
#define UPDATE_INTERVAL (5000 / portTICK_PERIOD_MS)
#define POLL_INTERVAL (200 / portTICK_PERIOD_MS) // DTS6619 prefere >100 ms
// ===== Helpers =====
#define HOLD_OFFSET(field) ((uint16_t)(offsetof(holding_reg_params_t, field) + 1))
#define STR(fieldname) ((const char *)(fieldname))
#define OPTS(min_val, max_val, step_val) {.opt1 = min_val, .opt2 = max_val, .opt3 = step_val}
// ===== Estado =====
static bool is_initialized = false;
static TaskHandle_t meter_task = NULL;
// ====== Config de endianness ======
// 0: usa float lido direto; 1: faz word-swap (DTS6619 em alguns firmwares)
#ifndef DTS6619_WORD_SWAP
#define DTS6619_WORD_SWAP 0
#endif
static inline float maybe_swap_float(float in)
{
#if DTS6619_WORD_SWAP
// swap de words: 0-1-2-3 -> 2-3-0-1
float out;
char *src = (char *)&in;
char *dst = (char *)&out;
dst[0] = src[2];
dst[1] = src[3];
dst[2] = src[0];
dst[3] = src[1];
return out;
#else
return in;
#endif
}
// ============================================================================
// =================== MAPA DE REGISTROS DTS6619 (Input 0x04) ===============
// Todos float32, 2 regs cada, endereços zero-based
// Tensões
#define DTS_L1VOLTAGE 0x0000
#define DTS_L2VOLTAGE 0x0002
#define DTS_L3VOLTAGE 0x0004
// Correntes (total e por fase)
#define DTS_TOTALCURRENT 0x0006
#define DTS_L1CURRENT 0x0008
#define DTS_L2CURRENT 0x000A
#define DTS_L3CURRENT 0x000C
// Potências ativas
#define DTS_TOTALACTIVEPOWER 0x0010
#define DTS_L1ACTIVEPOWER 0x0012
#define DTS_L2ACTIVEPOWER 0x0014
#define DTS_L3ACTIVEPOWER 0x0016
// Fator de potência (por fase)
#define DTS_PF_L1 0x002A
#define DTS_PF_L2 0x002C
#define DTS_PF_L3 0x002E
// Frequência
#define DTS_FREQUENCY 0x0036
// Energia total ativa (Wh)
#define DTS_TOTAL_ACTIVE_ENERGY 0x0100
// ============================================================================
// ============ CIDs ============
enum
{
CID_L1_VOLTAGE = 0,
CID_L2_VOLTAGE,
CID_L3_VOLTAGE,
CID_L1_CURRENT,
CID_L2_CURRENT,
CID_L3_CURRENT,
};
// ======= Descritores (usando INPUT registers) =======
const mb_parameter_descriptor_t device_parameters_dts6619[] = {
{CID_L1_VOLTAGE, STR("L1 Voltage"), STR("V"), 1, MB_PARAM_INPUT, DTS_L1VOLTAGE, 2,
HOLD_OFFSET(l1_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
{CID_L2_VOLTAGE, STR("L2 Voltage"), STR("V"), 1, MB_PARAM_INPUT, DTS_L2VOLTAGE, 2,
HOLD_OFFSET(l2_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
{CID_L3_VOLTAGE, STR("L3 Voltage"), STR("V"), 1, MB_PARAM_INPUT, DTS_L3VOLTAGE, 2,
HOLD_OFFSET(l3_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
{CID_L1_CURRENT, STR("L1 Current"), STR("A"), 1, MB_PARAM_INPUT, DTS_L1CURRENT, 2,
HOLD_OFFSET(l1_current), PARAM_TYPE_FLOAT, 4, OPTS(0, 1000, 0.1), PAR_PERMS_READ},
{CID_L2_CURRENT, STR("L2 Current"), STR("A"), 1, MB_PARAM_INPUT, DTS_L2CURRENT, 2,
HOLD_OFFSET(l2_current), PARAM_TYPE_FLOAT, 4, OPTS(0, 1000, 0.1), PAR_PERMS_READ},
{CID_L3_CURRENT, STR("L3 Current"), STR("A"), 1, MB_PARAM_INPUT, DTS_L3CURRENT, 2,
HOLD_OFFSET(l3_current), PARAM_TYPE_FLOAT, 4, OPTS(0, 1000, 0.1), PAR_PERMS_READ},
};
const uint16_t num_device_parameters_dts6619 =
sizeof(device_parameters_dts6619) / sizeof(device_parameters_dts6619[0]);
// ===== Ponteiro para a struct de holding (vinda do teu projeto)
extern holding_reg_params_t holding_reg_params;
// ===== Acesso a memória local usada pela stack
static void *get_param_ptr(const mb_parameter_descriptor_t *param)
{
if (!param || param->param_offset == 0)
return NULL;
return ((uint8_t *)&holding_reg_params + param->param_offset - 1);
}
// ===== Post do evento de medição
static void meter_dts6619_post_event(float *voltage, float *current, int *power_w,
float freq_hz, float pf_avg, float total_kwh)
{
meter_event_data_t evt = {
.source = "GRID",
.frequency = freq_hz,
.power_factor = pf_avg,
.total_energy = total_kwh};
memcpy(evt.vrms, voltage, sizeof(evt.vrms));
memcpy(evt.irms, current, sizeof(evt.irms));
memcpy(evt.watt, power_w, sizeof(evt.watt));
esp_err_t err = esp_event_post(METER_EVENT, METER_EVENT_DATA_READY,
&evt, sizeof(evt), pdMS_TO_TICKS(10));
if (err != ESP_OK)
{
ESP_LOGW(TAG, "Falha ao emitir evento: %s", esp_err_to_name(err));
}
}
// ===== Task de polling
static void serial_mdb_task(void *param)
{
esp_err_t err;
const mb_parameter_descriptor_t *desc = NULL;
float v[3] = {0}, i[3] = {0}, p_ph[3] = {0};
float p_total = 0.0f, pf[3] = {0}, freq = 0.0f, e_total_wh = 0.0f;
// pequeno settle antes da 1ª leitura
vTaskDelay(pdMS_TO_TICKS(200));
while (1)
{
for (uint16_t cid = 0; cid < num_device_parameters_dts6619; cid++)
{
err = mbc_master_get_cid_info(cid, &desc);
if (err != ESP_OK || !desc)
continue;
void *data_ptr = get_param_ptr(desc);
uint8_t type = 0;
// 1 retry simples em caso de timeout
err = mbc_master_get_parameter(cid, (char *)desc->param_key, (uint8_t *)data_ptr, &type);
if (err == ESP_ERR_TIMEOUT)
{
vTaskDelay(pdMS_TO_TICKS(60));
err = mbc_master_get_parameter(cid, (char *)desc->param_key, (uint8_t *)data_ptr, &type);
}
if (err == ESP_OK && data_ptr)
{
float raw = *(float *)data_ptr;
float val = maybe_swap_float(raw);
// logging enxuto
ESP_LOGI(TAG, "%s: %.3f %s", desc->param_key, val, desc->param_units);
switch (cid)
{
case CID_L1_VOLTAGE:
v[0] = val;
break;
case CID_L2_VOLTAGE:
v[1] = val;
break;
case CID_L3_VOLTAGE:
v[2] = val;
break;
case CID_L1_CURRENT:
i[0] = val;
break;
case CID_L2_CURRENT:
i[1] = val;
break;
case CID_L3_CURRENT:
i[2] = val;
break;
default:
break;
}
}
else
{
ESP_LOGE(TAG, "CID %u (%s) read failed: %s",
cid, desc->param_key, esp_err_to_name(err));
}
vTaskDelay(POLL_INTERVAL);
}
// prepara payload do evento
int p_int[3] = {
(int)(p_ph[0]),
(int)(p_ph[1]),
(int)(p_ph[2])};
// PF médio simples (ignora zeros)
float pf_sum = 0.0f;
int pf_cnt = 0;
for (int k = 0; k < 3; ++k)
{
if (pf[k] != 0.0f)
{
pf_sum += pf[k];
pf_cnt++;
}
}
float pf_avg = (pf_cnt ? pf_sum / pf_cnt : 0.0f);
// energia em kWh se veio em Wh
float total_kwh = e_total_wh / 1000.0f;
meter_dts6619_post_event(v, i, p_int, freq, pf_avg, total_kwh);
vTaskDelay(UPDATE_INTERVAL);
}
}
// ============ Init / Start / Stop ============
esp_err_t meter_dts6619_init(void)
{
if (is_initialized)
{
ESP_LOGW(TAG, "Already initialized");
return ESP_ERR_INVALID_STATE;
}
// limpa UART se já houver driver
if (uart_is_driver_installed(MB_PORT_NUM))
{
uart_driver_delete(MB_PORT_NUM);
ESP_LOGI(TAG, "UART driver deleted");
}
// destruir master anterior (ignora erro se não estiver init)
(void)mbc_master_destroy();
mb_communication_info_t comm = {
.port = MB_PORT_NUM,
.mode = MB_MODE_RTU,
.baudrate = MB_DEV_SPEED,
.parity = UART_PARITY_EVEN};
void *handler = NULL;
ESP_ERROR_CHECK(mbc_master_init(MB_PORT_SERIAL_MASTER, &handler));
ESP_ERROR_CHECK(mbc_master_setup(&comm));
ESP_ERROR_CHECK(uart_set_pin(MB_PORT_NUM, MB_UART_TXD, MB_UART_RXD, MB_UART_RTS, UART_PIN_NO_CHANGE));
ESP_ERROR_CHECK(mbc_master_start());
ESP_ERROR_CHECK(uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX));
vTaskDelay(pdMS_TO_TICKS(50));
ESP_ERROR_CHECK(mbc_master_set_descriptor(device_parameters_dts6619, num_device_parameters_dts6619));
is_initialized = true;
ESP_LOGI(TAG, "DTS6619 Modbus master initialized (9600 8E1, Input Reg 0x04)");
return ESP_OK;
}
esp_err_t meter_dts6619_start(void)
{
if (!is_initialized)
{
ESP_LOGE(TAG, "Not initialized");
return ESP_ERR_INVALID_STATE;
}
if (meter_task == NULL)
{
xTaskCreate(serial_mdb_task, "meter_dts6619_task", 4096, NULL, 3, &meter_task);
ESP_LOGI(TAG, "Task started");
}
return ESP_OK;
}
void meter_dts6619_stop(void)
{
if (!is_initialized)
{
ESP_LOGW(TAG, "Not initialized, skipping stop");
return;
}
if (meter_task)
{
vTaskDelete(meter_task);
meter_task = NULL;
ESP_LOGI(TAG, "Task stopped");
}
(void)mbc_master_destroy();
if (uart_is_driver_installed(MB_PORT_NUM))
{
uart_driver_delete(MB_PORT_NUM);
ESP_LOGI(TAG, "UART driver deleted");
}
is_initialized = false;
ESP_LOGI(TAG, "Meter DTS6619 cleaned up");
}

35
components/meter_manager/driver/meter_orno/meter_dts6619.h Executable file
View File

@@ -0,0 +1,35 @@
#ifndef METER_EA777_H_
#define METER_EA777_H_
#include <stdint.h>
#include <stdbool.h>
#include "esp_err.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Inicializa o driver do medidor EA777 (UART RS485, Modbus, registradores).
*
* @return esp_err_t Retorna ESP_OK se a inicialização for bem-sucedida, caso contrário retorna um erro.
*/
esp_err_t meter_ea777_init(void);
/**
* @brief Inicia a tarefa de leitura de dados do medidor EA777.
*
* @return esp_err_t Retorna ESP_OK se a tarefa for iniciada com sucesso, caso contrário retorna um erro.
*/
esp_err_t meter_ea777_start(void);
/**
* @brief Para a tarefa de leitura e limpa os dados internos do medidor EA777.
*/
void meter_ea777_stop(void);
#ifdef __cplusplus
}
#endif
#endif /* METER_EA777_H_ */

379
components/meter_manager/driver/meter_orno/meter_ea777.c Executable file
View File

@@ -0,0 +1,379 @@
// meter_ea777.c — Driver Modbus RTU para EARU EA777 (ESP-IDF)
#include "meter_events.h"
#include "modbus_params.h"
#include "mbcontroller.h"
#include "esp_log.h"
#include "driver/uart.h"
#include <stddef.h>
#include <string.h>
#define TAG "serial_mdb_ea777"
// ===== UART / RS-485 =====
#define MB_PORT_NUM 2
#define MB_DEV_SPEED 9600
// Ajuste os pinos conforme seu hardware
#define MB_UART_TXD 17
#define MB_UART_RXD 16
#define MB_UART_RTS 2 // pino DE/RE do transceiver RS-485
// ===== Timings =====
#define UPDATE_INTERVAL (5000 / portTICK_PERIOD_MS)
#define POLL_INTERVAL (200 / portTICK_PERIOD_MS)
// ===== Helpers =====
#define STR(fieldname) ((const char *)(fieldname))
#define OPTS(min_val, max_val, step_val) {.opt1 = min_val, .opt2 = max_val, .opt3 = step_val}
// ===== Estado =====
static bool is_initialized = false;
static TaskHandle_t meter_task = NULL;
// ============================================================================
// ============ MAPA DE REGISTROS EA777 (Holding 0x03) ========================
// Endereços zero-based. Tipos reais (engenharia) via fator de escala.
// Tensões (0.1 V)
#define EA777_L1VOLTAGE 0x0000
#define EA777_L2VOLTAGE 0x0001
#define EA777_L3VOLTAGE 0x0002
// Correntes (0.01 A)
#define EA777_L1CURRENT 0x0003
#define EA777_L2CURRENT 0x0004
#define EA777_L3CURRENT 0x0005
// Potência ativa total (W)
#define EA777_TOTAL_ACTIVE_P 0x0007
// (se quiser por fase, pode usar 0x0008/0x0009/0x000A)
// Fator de potência por fase (0.001)
#define EA777_PF_L1 0x0014
#define EA777_PF_L2 0x0015
#define EA777_PF_L3 0x0016
// Frequência (0.01 Hz)
#define EA777_FREQUENCY 0x001A
// Energia ativa total (U32 * 0.01 kWh, 2 registradores)
#define EA777_TOTAL_ACTIVE_E 0x001D
// ============================================================================
// ============ CIDs ============
enum
{
CID_EA777_L1_VOLTAGE = 0,
CID_EA777_L2_VOLTAGE,
CID_EA777_L3_VOLTAGE,
CID_EA777_L1_CURRENT,
CID_EA777_L2_CURRENT,
CID_EA777_L3_CURRENT,
CID_EA777_TOTAL_ACTIVE_P,
CID_EA777_PF_L1,
CID_EA777_PF_L2,
CID_EA777_PF_L3,
CID_EA777_FREQUENCY,
CID_EA777_TOTAL_ACTIVE_E,
};
// ======= Descritores (Holding registers) =======
// Nota: param_offset = 0 -> não usamos holding_reg_params_t aqui.
const mb_parameter_descriptor_t device_parameters_ea777[] = {
// Tensões (0.1 V)
{CID_EA777_L1_VOLTAGE, STR("L1 Voltage"), STR("V"), 1,
MB_PARAM_HOLDING, EA777_L1VOLTAGE, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 4000, 1), PAR_PERMS_READ},
{CID_EA777_L2_VOLTAGE, STR("L2 Voltage"), STR("V"), 1,
MB_PARAM_HOLDING, EA777_L2VOLTAGE, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 4000, 1), PAR_PERMS_READ},
{CID_EA777_L3_VOLTAGE, STR("L3 Voltage"), STR("V"), 1,
MB_PARAM_HOLDING, EA777_L3VOLTAGE, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 4000, 1), PAR_PERMS_READ},
// Correntes (0.01 A)
{CID_EA777_L1_CURRENT, STR("L1 Current"), STR("A"), 1,
MB_PARAM_HOLDING, EA777_L1CURRENT, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 10000, 1), PAR_PERMS_READ},
{CID_EA777_L2_CURRENT, STR("L2 Current"), STR("A"), 1,
MB_PARAM_HOLDING, EA777_L2CURRENT, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 10000, 1), PAR_PERMS_READ},
{CID_EA777_L3_CURRENT, STR("L3 Current"), STR("A"), 1,
MB_PARAM_HOLDING, EA777_L3CURRENT, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 10000, 1), PAR_PERMS_READ},
// Potência ativa total (W)
{CID_EA777_TOTAL_ACTIVE_P, STR("Total Active Power"), STR("W"), 1,
MB_PARAM_HOLDING, EA777_TOTAL_ACTIVE_P, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 60000, 1), PAR_PERMS_READ},
// Fator de potência (0.001)
{CID_EA777_PF_L1, STR("L1 PF"), STR(""), 1,
MB_PARAM_HOLDING, EA777_PF_L1, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 1000, 1), PAR_PERMS_READ},
{CID_EA777_PF_L2, STR("L2 PF"), STR(""), 1,
MB_PARAM_HOLDING, EA777_PF_L2, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 1000, 1), PAR_PERMS_READ},
{CID_EA777_PF_L3, STR("L3 PF"), STR(""), 1,
MB_PARAM_HOLDING, EA777_PF_L3, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 1000, 1), PAR_PERMS_READ},
// Frequência (0.01 Hz)
{CID_EA777_FREQUENCY, STR("Frequency"), STR("Hz"), 1,
MB_PARAM_HOLDING, EA777_FREQUENCY, 1,
0, PARAM_TYPE_U16, 2, OPTS(0, 10000, 1), PAR_PERMS_READ},
// Energia ativa total (U32 * 0.01 kWh, 2 regs)
{CID_EA777_TOTAL_ACTIVE_E, STR("Total Active Energy"), STR("kWh"), 1,
MB_PARAM_HOLDING, EA777_TOTAL_ACTIVE_E, 2,
0, PARAM_TYPE_U32, 4, OPTS(0, 0xFFFFFFFF, 1), PAR_PERMS_READ},
};
const uint16_t num_device_parameters_ea777 =
sizeof(device_parameters_ea777) / sizeof(device_parameters_ea777[0]);
// ===== Post do evento de medição =====
static void meter_ea777_post_event(float *voltage, float *current, int *power_w,
float freq_hz, float pf_avg, float total_kwh)
{
meter_event_data_t evt = {
.source = "GRID",
.frequency = freq_hz,
.power_factor = pf_avg,
.total_energy = total_kwh};
memcpy(evt.vrms, voltage, sizeof(evt.vrms));
memcpy(evt.irms, current, sizeof(evt.irms));
memcpy(evt.watt, power_w, sizeof(evt.watt));
esp_err_t err = esp_event_post(METER_EVENT, METER_EVENT_DATA_READY,
&evt, sizeof(evt), pdMS_TO_TICKS(10));
if (err != ESP_OK)
{
ESP_LOGW(TAG, "Falha ao emitir evento: %s", esp_err_to_name(err));
}
}
// ===== Task de polling =====
static void serial_mdb_ea777_task(void *param)
{
esp_err_t err;
const mb_parameter_descriptor_t *desc = NULL;
float v[3] = {0};
float i[3] = {0};
float pf[3] = {0};
float freq = 0.0f;
float total_kwh = 0.0f;
// pequeno settle antes da 1ª leitura
vTaskDelay(pdMS_TO_TICKS(200));
while (1)
{
for (uint16_t cid = 0; cid < num_device_parameters_ea777; cid++)
{
err = mbc_master_get_cid_info(cid, &desc);
if (err != ESP_OK || !desc)
{
continue;
}
uint8_t type = 0;
uint16_t raw16 = 0;
uint32_t raw32 = 0;
void *value_ptr = (cid == CID_EA777_TOTAL_ACTIVE_E) ? (void *)&raw32 : (void *)&raw16;
// 1 retry simples em caso de timeout
err = mbc_master_get_parameter(cid,
(char *)desc->param_key,
(uint8_t *)value_ptr,
&type);
if (err == ESP_ERR_TIMEOUT)
{
vTaskDelay(pdMS_TO_TICKS(60));
err = mbc_master_get_parameter(cid,
(char *)desc->param_key,
(uint8_t *)value_ptr,
&type);
}
if (err == ESP_OK)
{
switch (cid)
{
case CID_EA777_L1_VOLTAGE:
v[0] = ((float)raw16) * 0.1f;
break;
case CID_EA777_L2_VOLTAGE:
v[1] = ((float)raw16) * 0.1f;
break;
case CID_EA777_L3_VOLTAGE:
v[2] = ((float)raw16) * 0.1f;
break;
case CID_EA777_L1_CURRENT:
i[0] = ((float)raw16) * 0.01f;
break;
case CID_EA777_L2_CURRENT:
i[1] = ((float)raw16) * 0.01f;
break;
case CID_EA777_L3_CURRENT:
i[2] = ((float)raw16) * 0.01f;
break;
case CID_EA777_TOTAL_ACTIVE_P:
// guarda se quiser usar em debug; para o evento usamos
// aproximação por fase abaixo
// (poderia ser passado direto em power_w[0..2] também)
break;
case CID_EA777_PF_L1:
pf[0] = ((float)raw16) * 0.001f;
break;
case CID_EA777_PF_L2:
pf[1] = ((float)raw16) * 0.001f;
break;
case CID_EA777_PF_L3:
pf[2] = ((float)raw16) * 0.001f;
break;
case CID_EA777_FREQUENCY:
freq = ((float)raw16) * 0.01f;
break;
case CID_EA777_TOTAL_ACTIVE_E:
total_kwh = ((float)raw32) * 0.01f;
break;
default:
break;
}
ESP_LOGD(TAG, "%s (cid=%u) -> raw16=%u raw32=%u",
desc->param_key, cid,
(unsigned int)raw16,
(unsigned int)raw32);
}
else
{
ESP_LOGE(TAG, "CID %u (%s) read failed: %s",
cid, desc->param_key, esp_err_to_name(err));
}
vTaskDelay(POLL_INTERVAL);
}
// Potência por fase aproximada: P = V * I * PF
int p_int[3] = {
(int)(v[0] * i[0] * pf[0]),
(int)(v[1] * i[1] * pf[1]),
(int)(v[2] * i[2] * pf[2]),
};
// PF médio simples (ignora zeros)
float pf_sum = 0.0f;
int pf_cnt = 0;
for (int k = 0; k < 3; ++k)
{
if (pf[k] != 0.0f)
{
pf_sum += pf[k];
pf_cnt++;
}
}
float pf_avg = (pf_cnt ? pf_sum / pf_cnt : 0.0f);
meter_ea777_post_event(v, i, p_int, freq, pf_avg, total_kwh);
vTaskDelay(UPDATE_INTERVAL);
}
}
// ============ Init / Start / Stop ============
esp_err_t meter_ea777_init(void)
{
if (is_initialized)
{
ESP_LOGW(TAG, "Already initialized");
return ESP_ERR_INVALID_STATE;
}
// limpa UART se já houver driver
if (uart_is_driver_installed(MB_PORT_NUM))
{
uart_driver_delete(MB_PORT_NUM);
ESP_LOGI(TAG, "UART driver deleted");
}
// destruir master anterior (ignora erro se não estiver init)
(void)mbc_master_destroy();
mb_communication_info_t comm = {
.port = MB_PORT_NUM,
.mode = MB_MODE_RTU,
.baudrate = MB_DEV_SPEED,
.parity = UART_PARITY_EVEN};
void *handler = NULL;
ESP_ERROR_CHECK(mbc_master_init(MB_PORT_SERIAL_MASTER, &handler));
ESP_ERROR_CHECK(mbc_master_setup(&comm));
ESP_ERROR_CHECK(uart_set_pin(MB_PORT_NUM,
MB_UART_TXD, MB_UART_RXD,
MB_UART_RTS, UART_PIN_NO_CHANGE));
ESP_ERROR_CHECK(mbc_master_start());
ESP_ERROR_CHECK(uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX));
vTaskDelay(pdMS_TO_TICKS(50));
ESP_ERROR_CHECK(mbc_master_set_descriptor(device_parameters_ea777,
num_device_parameters_ea777));
is_initialized = true;
ESP_LOGI(TAG, "EA777 Modbus master initialized (9600 8E1, Holding Reg 0x03)");
return ESP_OK;
}
esp_err_t meter_ea777_start(void)
{
if (!is_initialized)
{
ESP_LOGE(TAG, "Not initialized");
return ESP_ERR_INVALID_STATE;
}
if (meter_task == NULL)
{
xTaskCreate(serial_mdb_ea777_task,
"meter_ea777_task",
4096, NULL, 3, &meter_task);
ESP_LOGI(TAG, "EA777 task started");
}
return ESP_OK;
}
void meter_ea777_stop(void)
{
if (!is_initialized)
{
ESP_LOGW(TAG, "Not initialized, skipping stop");
return;
}
if (meter_task)
{
vTaskDelete(meter_task);
meter_task = NULL;
ESP_LOGI(TAG, "EA777 task stopped");
}
(void)mbc_master_destroy();
if (uart_is_driver_installed(MB_PORT_NUM))
{
uart_driver_delete(MB_PORT_NUM);
ESP_LOGI(TAG, "UART driver deleted");
}
is_initialized = false;
ESP_LOGI(TAG, "Meter EA777 cleaned up");
}

32
components/meter_manager/driver/meter_orno/meter_ea777.h Executable file
View File

@@ -0,0 +1,32 @@
#ifndef METER_DTS6619_H_
#define METER_DTS6619_H_
#include <stdint.h>
#include <stdbool.h>
#include "esp_err.h"
/**
* @brief Inicializa o driver do medidor dts6619 (SPI, mutex, registradores).
*
* @return esp_err_t Retorna ESP_OK se a inicialização for bem-sucedida, caso contrário retorna um erro.
*/
esp_err_t meter_dts6619_init(void);
/**
* @brief Inicia a tarefa de leitura de dados do medidor DTS6619.
*
* @return esp_err_t Retorna ESP_OK se a tarefa for iniciada com sucesso, caso contrário retorna um erro.
*/
esp_err_t meter_dts6619_start(void);
/**
* @brief Para a tarefa de leitura e limpa os dados internos do medidor DTS6619.
*/
void meter_dts6619_stop(void);
#ifdef __cplusplus
}
#endif
#endif /* METER_DTS6619_H_ */

4
components/meter_manager/driver/meter_orno/meter_orno513.c
View File

@@ -46,10 +46,10 @@ enum {
const mb_parameter_descriptor_t device_parameters_orno513[] = {
{CID_TOTAL_ACTIVE_ENERGY, STR("Total Active Energy"), STR("kWh"), 1, MB_PARAM_HOLDING, TOTALFACTIVE, 2,
HOLD_OFFSET(total_active_power), PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
HOLD_OFFSET(active_power), PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
{CID_TOTAL_REACTIVE_ENERGY, STR("Total Reactive Energy"), STR("kWh"), 1, MB_PARAM_HOLDING, TOTALRACTIVE, 2,
HOLD_OFFSET(total_reactive_power), PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
HOLD_OFFSET(reactive_power), PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
{CID_ACTIVE_POWER, STR("Active Power"), STR("W"), 1, MB_PARAM_HOLDING, ACTIVEPOWER, 2,
HOLD_OFFSET(active_power), PARAM_TYPE_I32_CDAB, 4, OPTS(-100000, 100000, 1), PAR_PERMS_READ},

10
components/meter_manager/driver/meter_orno/meter_orno516.c
View File

@@ -12,7 +12,7 @@
#define MB_DEV_SPEED 9600
#define MB_UART_TXD 17
#define MB_UART_RXD 16
#define MB_UART_RTS 5
#define MB_UART_RTS 2
#define UPDATE_INTERVAL (5000 / portTICK_PERIOD_MS)
#define POLL_INTERVAL (100 / portTICK_PERIOD_MS)
@@ -40,7 +40,7 @@ enum {
CID_L1_VOLTAGE,
CID_L2_VOLTAGE,
CID_L3_VOLTAGE,
CID_TOTAL_ACTIVE_POWER
CID_ACTIVE_POWER
};
const mb_parameter_descriptor_t device_parameters_orno516[] = {
@@ -56,8 +56,8 @@ const mb_parameter_descriptor_t device_parameters_orno516[] = {
HOLD_OFFSET(l2_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
{CID_L3_VOLTAGE, STR("L3 Voltage"), STR("V"), 1, MB_PARAM_HOLDING, L3VOLTAGE, 2,
HOLD_OFFSET(l3_voltage), PARAM_TYPE_FLOAT, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
{CID_TOTAL_ACTIVE_POWER, STR("Total Active Power"), STR("W"), 1, MB_PARAM_HOLDING, TOTALACTIVEPOWER, 2,
HOLD_OFFSET(total_active_power), PARAM_TYPE_FLOAT, 4, OPTS(0, 100000, 1), PAR_PERMS_READ}
{CID_ACTIVE_POWER, STR("Active Power"), STR("W"), 1, MB_PARAM_HOLDING, TOTALACTIVEPOWER, 2,
HOLD_OFFSET(active_power), PARAM_TYPE_FLOAT, 4, OPTS(0, 100000, 1), PAR_PERMS_READ}
};
const uint16_t num_device_parameters_orno516 = sizeof(device_parameters_orno516) / sizeof(device_parameters_orno516[0]);
@@ -124,7 +124,7 @@ static void serial_mdb_task(void *param) {
case CID_L1_CURRENT: current[0] = val; break;
case CID_L2_CURRENT: current[1] = val; break;
case CID_L3_CURRENT: current[2] = val; break;
case CID_TOTAL_ACTIVE_POWER:
case CID_ACTIVE_POWER:
power[0] = (int)(val / 3);
power[1] = (int)(val / 3);
power[2] = (int)(val / 3);

310
components/meter_manager/driver/meter_orno/meter_orno526.c Executable file
View File

@@ -0,0 +1,310 @@
#include "meter_orno526.h"
#include "modbus_params.h"
#include "mbcontroller.h"
#include "meter_events.h"
#include "esp_log.h"
#include "driver/uart.h"
#include <stddef.h>
#include <math.h>
#define TAG "serial_mdb_orno526"
#define MB_PORT_NUM 2
#define MB_DEV_SPEED 9600
#define MB_UART_TXD 17
#define MB_UART_RXD 16
#define MB_UART_RTS 2
#define UPDATE_INTERVAL (3000 / portTICK_PERIOD_MS)
#define POLL_INTERVAL (100 / portTICK_PERIOD_MS)
#define HOLD_OFFSET(field) ((uint16_t)(offsetof(holding_reg_params_t, field) + 1))
#define STR(x) ((const char *)(x))
#define OPTS(min, max, step) {.opt1 = min, .opt2 = max, .opt3 = step}
// State flag
static bool is_initialized = false;
static TaskHandle_t meter_task = NULL;
// CID enums
enum
{
CID_ACTIVE_ENERGY = 0,
CID_REACTIVE_ENERGY,
CID_ACTIVE_POWER,
CID_APPARENT_POWER,
CID_REACTIVE_POWER,
CID_L1_CURRENT,
CID_L1_VOLTAGE,
CID_FREQUENCY
};
// Register addresses
#define TOTALFACTIVE 0x010E
#define TOTALRACTIVE 0x0118
#define ACTIVEPOWER 0x0104
#define APPARENTPOWER 0x0106
#define REACTIVEPOWER 0x0108
#define L1CURRENT 0x0102
#define L1VOLTAGE 0x0100
#define FREQUENCY 0x010A
const mb_parameter_descriptor_t device_parameters_orno526[] = {
{CID_ACTIVE_ENERGY, "Active Energy", "kWh", 1,
MB_PARAM_INPUT, TOTALFACTIVE, 2, HOLD_OFFSET(active_energy),
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
{CID_REACTIVE_ENERGY, "Reactive Energy", "kWh", 1,
MB_PARAM_INPUT, TOTALRACTIVE, 2, HOLD_OFFSET(reactive_energy),
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
{CID_ACTIVE_POWER, "Active Power", "W", 1,
MB_PARAM_INPUT, ACTIVEPOWER, 2, HOLD_OFFSET(active_power),
PARAM_TYPE_I32_CDAB, 4, OPTS(-100000, 100000, 1), PAR_PERMS_READ},
{CID_APPARENT_POWER, "Apparent Power", "VA", 1,
MB_PARAM_INPUT, APPARENTPOWER, 2, HOLD_OFFSET(apparent_power),
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100000, 1), PAR_PERMS_READ},
{CID_REACTIVE_POWER, "Reactive Power", "VAR", 1,
MB_PARAM_INPUT, REACTIVEPOWER, 2, HOLD_OFFSET(reactive_power),
PARAM_TYPE_I32_CDAB, 4, OPTS(-100000, 100000, 1), PAR_PERMS_READ},
{CID_L1_CURRENT, "L1 Current", "A", 1,
MB_PARAM_INPUT, L1CURRENT, 2, HOLD_OFFSET(l1_current),
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 100, 0.1), PAR_PERMS_READ},
{CID_L1_VOLTAGE, "L1 Voltage", "V", 1,
MB_PARAM_INPUT, L1VOLTAGE, 2, HOLD_OFFSET(l1_voltage),
PARAM_TYPE_I32_CDAB, 4, OPTS(0, 300, 0.1), PAR_PERMS_READ},
{CID_FREQUENCY, "Frequency", "Hz", 1,
MB_PARAM_INPUT, FREQUENCY, 1, HOLD_OFFSET(frequency),
PARAM_TYPE_I32_CDAB, 2, OPTS(0, 1000, 0.1), PAR_PERMS_READ}
};
const uint16_t num_device_parameters_orno526 = sizeof(device_parameters_orno526) / sizeof(device_parameters_orno526[0]);
static void *get_param_ptr(const mb_parameter_descriptor_t *param)
{
if (!param || param->param_offset == 0)
return NULL;
return ((uint8_t *)&holding_reg_params + param->param_offset - 1);
}
static inline float scale_for_cid(uint16_t cid)
{
switch (cid)
{
case CID_L1_VOLTAGE:
case CID_L1_CURRENT:
return 1000.0f; // V/A = raw / 1000
case CID_ACTIVE_POWER:
case CID_APPARENT_POWER:
case CID_REACTIVE_POWER:
return 1.0f; // W/VA/var = raw
case CID_ACTIVE_ENERGY:
case CID_REACTIVE_ENERGY:
return 100.0f; // kWh = raw / 100
case CID_FREQUENCY:
return 10.0f; // Hz = raw / 10
default:
return 1.0f;
}
}
static void serial_mdb_task(void *param)
{
esp_err_t err;
const mb_parameter_descriptor_t *desc = NULL;
float voltage[3] = {0};
float current[3] = {0};
int watt[3] = {0};
float energy = 0.0f;
float frequency_hz = 0.0f; // <- armazenar frequência lida (0x010A)
while (1)
{
for (uint16_t cid = 0; cid < num_device_parameters_orno526; cid++)
{
err = mbc_master_get_cid_info(cid, &desc);
if (err != ESP_OK || !desc)
{
ESP_LOGE(TAG, "mbc_master_get_cid_info(%u) failed: %s", cid, esp_err_to_name(err));
continue;
}
void *data_ptr = get_param_ptr(desc);
if (!data_ptr)
{
ESP_LOGE(TAG, "CID %u (%s): null data_ptr", cid, desc->param_key);
continue;
}
uint8_t type = 0;
err = mbc_master_get_parameter(cid, (char *)desc->param_key, (uint8_t *)data_ptr, &type);
if (err == ESP_OK)
{
float val = 0.0f;
if (cid == CID_FREQUENCY)
{
// Frequência é U16 (1 registo), escala = /10.0
uint16_t raw16 = *(uint16_t *)data_ptr;
val = raw16 / 10.0f;
frequency_hz = val;
}
else
{
// Demais CIDs são I32_CDAB (2 registos)
int32_t raw32 = *(int32_t *)data_ptr;
float scale = scale_for_cid(cid);
val = raw32 / scale;
}
ESP_LOGI(TAG, "%s: %.3f %s", desc->param_key, val, desc->param_units);
switch (cid)
{
case CID_L1_VOLTAGE:
voltage[0] = val;
break;
case CID_L1_CURRENT:
current[0] = val;
break;
case CID_ACTIVE_POWER:
watt[0] = (int)lrintf(val);
watt[1] = watt[2] = watt[0];
break;
case CID_ACTIVE_ENERGY:
energy = val; // já em kWh (raw/100)
break;
// CID_FREQUENCY já atualiza 'frequency_hz' acima
default:
break;
}
}
else
{
ESP_LOGE(TAG, "CID %u (%s) read failed: %s", cid, desc->param_key, esp_err_to_name(err));
}
vTaskDelay(POLL_INTERVAL);
}
meter_event_data_t evt = {
.frequency = frequency_hz, // agora preenchido
.power_factor = 0.0f, // (adicione PF se quiser ler 0x010B)
.total_energy = energy,
.source = "GRID",
};
memcpy(evt.vrms, voltage, sizeof(evt.vrms));
memcpy(evt.irms, current, sizeof(evt.irms));
memcpy(evt.watt, watt, sizeof(evt.watt));
esp_event_post(METER_EVENT, METER_EVENT_DATA_READY, &evt, sizeof(evt), pdMS_TO_TICKS(10));
vTaskDelay(UPDATE_INTERVAL);
}
}
esp_err_t meter_orno526_init(void)
{
if (is_initialized)
{
ESP_LOGW(TAG, "meter_orno526 already initialized");
return ESP_ERR_INVALID_STATE;
}
ESP_LOGI(TAG, "meter_orno526_init");
// ORNO costuma vir 9600, 8E1. Se o teu estiver 8E2, troca os stop bits mais abaixo.
mb_communication_info_t comm = {
.port = MB_PORT_NUM,
.mode = MB_MODE_RTU,
.baudrate = MB_DEV_SPEED, // 9600
.parity = UART_PARITY_DISABLE, // 8E1 por padrão
};
void *handler = NULL;
esp_err_t err = mbc_master_init(MB_PORT_SERIAL_MASTER, &handler);
if (err != ESP_OK)
{
ESP_LOGE(TAG, "mbc_master_init failed");
return err;
}
ESP_ERROR_CHECK(mbc_master_setup(&comm));
// Pinos RS-485 (TX, RX, RTS=DE/RE). CTS não usado.
ESP_ERROR_CHECK(uart_set_pin(MB_PORT_NUM, MB_UART_TXD, MB_UART_RXD, MB_UART_RTS, UART_PIN_NO_CHANGE));
// Garanta 8 bits de dados e sem flow-control.
ESP_ERROR_CHECK(uart_set_word_length(MB_PORT_NUM, UART_DATA_8_BITS));
ESP_ERROR_CHECK(uart_set_hw_flow_ctrl(MB_PORT_NUM, UART_HW_FLOWCTRL_DISABLE, 0));
// Stop bits: a maioria usa 1. Se continuar a dar INVALID_RESPONSE, teste 2.
ESP_ERROR_CHECK(uart_set_stop_bits(MB_PORT_NUM, UART_STOP_BITS_1));
// Alternativa, se o medidor estiver configurado p/ 2 stop bits:
// ESP_ERROR_CHECK(uart_set_stop_bits(MB_PORT_NUM, UART_STOP_BITS_2));
ESP_ERROR_CHECK(mbc_master_start());
ESP_ERROR_CHECK(uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX));
// (Opcional) Logs detalhados para ver TX/RX/frames durante debug:
esp_log_level_set("MB_CONTROLLER_MASTER", ESP_LOG_DEBUG);
esp_log_level_set("MB_PORT_COMMON", ESP_LOG_DEBUG);
esp_log_level_set("MB_SERIAL_MASTER", ESP_LOG_DEBUG);
vTaskDelay(pdMS_TO_TICKS(5));
ESP_ERROR_CHECK(mbc_master_set_descriptor(device_parameters_orno526, num_device_parameters_orno526));
is_initialized = true;
return ESP_OK;
}
esp_err_t meter_orno526_start(void)
{
ESP_LOGI(TAG, "meter_orno526_start");
if (!is_initialized)
{
ESP_LOGE(TAG, "meter_orno526 not initialized");
return ESP_ERR_INVALID_STATE;
}
if (meter_task == NULL)
{
xTaskCreate(serial_mdb_task, "meter_orno526_task", 4096, NULL, 3, &meter_task);
ESP_LOGI(TAG, "meter_orno526 task started");
}
return ESP_OK;
}
void meter_orno526_stop(void)
{
if (!is_initialized)
{
ESP_LOGW(TAG, "meter_orno526 not initialized");
return;
}
ESP_LOGI(TAG, "Stopping meter_orno526");
uart_driver_delete(MB_PORT_NUM);
esp_err_t err = mbc_master_destroy();
if (err != ESP_OK)
{
ESP_LOGW(TAG, "mbc_master_destroy() returned %s", esp_err_to_name(err));
}
is_initialized = false;
}

29
components/meter_manager/driver/meter_orno/meter_orno526.h Executable file
View File

@@ -0,0 +1,29 @@
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdbool.h>
#include "esp_err.h"
/**
* @brief Inicializa o driver do medidor ORNO 526 (SPI, mutex, registradores).
*/
esp_err_t meter_orno526_init(void);
/**
* @brief Inicia a tarefa de leitura de dados do medidor ORNO 526.
*/
esp_err_t meter_orno526_start(void);
/**
* @brief Para a tarefa de leitura e limpa os dados internos do medidor ORNO 526.
*/
void meter_orno526_stop(void);
#ifdef __cplusplus
}
#endif

22
components/meter_manager/driver/meter_orno/modbus_params.h
View File

@@ -46,24 +46,30 @@ typedef struct {
uint16_t data_block1[150];
} input_reg_params_t;
// Holding Registers (ajustado para os campos usados no ORNO 516)
typedef struct {
float l1_current; // 0x0016
float l2_current; // 0x0018
float l3_current; // 0x001A
float l1_current;
float l2_current;
float l3_current;
float l1_voltage; // 0x000E
float l2_voltage; // 0x0010
float l3_voltage; // 0x0012
float l1_voltage;
float l2_voltage;
float l3_voltage;
float active_energy;
float reactive_energy;
float total_active_power; // 0x001C
float total_reactive_power;
float active_power;
float apparent_power;
float reactive_power;
float frequency;
float power_factor;
} holding_reg_params_t;
#pragma pack(pop)
// Instâncias globais das estruturas

20
components/meter_manager/driver/meter_zigbee/meter_zigbee.c
View File

@@ -64,9 +64,9 @@ bool meter_zigbee_is_running(void) {
}
void send_stop_command(void) {
const char *cmd = "stop\n"; // Comando enviado para o outro lado interpretar e dormir
uart_write_bytes(UART_PORT, cmd, strlen(cmd));
uart_wait_tx_done(UART_PORT, pdMS_TO_TICKS(100)); // Aguarda envio terminar
//const char *cmd = "stop\n"; // Comando enviado para o outro lado interpretar e dormir
//uart_write_bytes(UART_PORT, cmd, strlen(cmd));
//uart_wait_tx_done(UART_PORT, pdMS_TO_TICKS(100)); // Aguarda envio terminar
}
static void meter_zigbee_post_event(void) {
@@ -115,8 +115,8 @@ static void handle_zigbee_frame(const uint8_t *buf, size_t len) {
uint32_t power_raw = (buf[11] << 16) | (buf[12] << 8) | buf[13];
float volt = volt_raw / 10.0f;
float current = current_raw / 100.0f;
float power = power_raw / 1000.0f;
float current = current_raw / 1000.0f;
float power = power_raw;
ESP_LOGI(TAG, "Parsed Attr 0x%04X: V=%.1fV I=%.2fA P=%.1fW", attr, volt, current, power);
@@ -144,13 +144,13 @@ static void handle_zigbee_frame(const uint8_t *buf, size_t len) {
phase_updated[PHASE_L3] = true;
break;
case ATTR_POWER_FACTOR:
meter_data.power_factor = current;
meter_data.power_factor = 0;
break;
case ATTR_FREQUENCY:
meter_data.frequency = current;
meter_data.frequency = 0;
break;
case ATTR_TOTAL_ENERGY:
meter_data.total_energy = current;
meter_data.total_energy = 0;
break;
default:
ESP_LOGW(TAG, "Unknown attr: 0x%04X", attr);
@@ -227,9 +227,9 @@ esp_err_t meter_zigbee_start(void) {
void meter_zigbee_stop(void) {
send_stop_command();
//send_stop_command();
vTaskDelay(pdMS_TO_TICKS(100)); // Aguarda o outro lado processar
//vTaskDelay(pdMS_TO_TICKS(100)); // Aguarda o outro lado processar
if (meter_zigbee_task) {
vTaskDelete(meter_zigbee_task);

6
components/meter_manager/include/meter_manager.h
View File

@@ -12,8 +12,12 @@ typedef enum {
METER_TYPE_ADE7758, // ADE7758 meter
METER_TYPE_ORNO513, // ORNO-513
METER_TYPE_ORNO516, // ORNO-516
METER_TYPE_ORNO526, // ORNO-516
METER_TYPE_DDS661, // DDS-661
METER_TYPE_DTS6619, // dts6619
METER_TYPE_MONO_ZIGBEE, // Zigbee single-phase
METER_TYPE_TRIF_ZIGBEE // Zigbee three-phase
METER_TYPE_TRIF_ZIGBEE, // Zigbee three-phase
METER_TYPE_EA777 // EA777
} meter_type_t;
/**

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

@@ -1,15 +1,20 @@
#include "meter_manager.h"
#include "esp_log.h"
#include "meter_ade7758.h"
#include "meter_orno513.h"
#include "meter_orno516.h"
#include "meter_orno526.h"
#include "meter_dts6619.h"
#include "meter_dds661.h"
#include "meter_zigbee.h"
#include "meter_ea777.h"
#include "nvs_flash.h"
#include "nvs.h"
#include <string.h>
#include "network_events.h"
static const char *TAG = "meter_manager";
// Tipos de medidores EVSE e GRID
@@ -20,48 +25,53 @@ static meter_type_t meter_grid_type = METER_TYPE_NONE;
#define NVS_EVSE_MODEL "evse_model"
#define NVS_GRID_MODEL "grid_model"
static void meter_manager_network_event_handler(void *arg, esp_event_base_t base, int32_t event_id, void *data)
{
if (base != NETWORK_EVENTS)
return;
static void meter_manager_network_event_handler(void* arg, esp_event_base_t base, int32_t event_id, void* data){
switch (event_id)
{
case NETWORK_EVENT_AP_STARTED:
ESP_LOGI(TAG, "Recebido NETWORK_EVENT_AP_STARTED, parando medidor de grid");
// meter_manager_grid_stop();
break;
if (base != NETWORK_EVENTS) return;
case NETWORK_EVENT_AP_STOP:
ESP_LOGI(TAG, "Recebido NETWORK_EVENT_AP_STOP, reiniciando medidor de grid");
// meter_manager_grid_start();
break;
switch (event_id) {
case NETWORK_EVENT_AP_STARTED:
ESP_LOGI(TAG, "Recebido NETWORK_EVENT_AP_STARTED, parando medidor de grid");
meter_manager_grid_stop();
break;
case NETWORK_EVENT_STA_GOT_IP:
ESP_LOGI(TAG, "Recebido NETWORK_EVENT_STA_GOT_IP");
// opcional: reiniciar ou logar
break;
case NETWORK_EVENT_AP_STOP:
ESP_LOGI(TAG, "Recebido NETWORK_EVENT_AP_STOP, reiniciando medidor de grid");
meter_manager_grid_start();
break;
case NETWORK_EVENT_STA_GOT_IP:
ESP_LOGI(TAG, "Recebido NETWORK_EVENT_STA_GOT_IP");
// opcional: reiniciar ou logar
break;
default:
break;
default:
break;
}
}
// 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) {
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) {
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) {
if (err == ESP_OK && value < 255)
{
*type = (meter_type_t)value;
ESP_LOGI(TAG, "Loaded meter type %d from NVS key '%s'", value, key);
} else {
}
else
{
*type = METER_TYPE_NONE;
nvs_set_u8(handle, key, *type);
nvs_commit(handle);
@@ -72,19 +82,24 @@ static esp_err_t load_or_init_meter_model(const char *key, meter_type_t *type) {
return ESP_OK;
}
static esp_err_t write_meter_model_to_nvs(const char *key, meter_type_t meter_type) {
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) {
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) {
if (err == ESP_OK)
{
err = nvs_commit(handle);
ESP_LOGI(TAG, "Saved meter type %d to NVS key '%s'", meter_type, key);
} else {
}
else
{
ESP_LOGE(TAG, "Failed to write meter type to NVS key '%s'", key);
}
@@ -92,7 +107,6 @@ static esp_err_t write_meter_model_to_nvs(const char *key, meter_type_t meter_ty
return err;
}
/**
* @brief Initializes the meter manager system.
*
@@ -102,16 +116,18 @@ static esp_err_t write_meter_model_to_nvs(const char *key, meter_type_t meter_ty
*
* @return esp_err_t ESP_OK on success, or an error code.
*/
esp_err_t meter_manager_init(void) {
esp_err_t meter_manager_init(void)
{
esp_err_t err;
// Initialize EVSE meter
//err = meter_manager_evse_init();
//if (err != ESP_OK) return err;
// Initialize EVSE meter (habilite quando quiser)
// err = meter_manager_evse_init();
// if (err != ESP_OK) return err;
// Initialize GRID meter
err = meter_manager_grid_init();
if (err != ESP_OK) return err;
if (err != ESP_OK)
return err;
// Register handler for custom network events
ESP_LOGI(TAG, "Registering network event handler");
@@ -121,7 +137,6 @@ esp_err_t meter_manager_init(void) {
NULL);
}
/**
* @brief Starts all configured meters (EVSE and GRID).
*
@@ -130,21 +145,22 @@ esp_err_t meter_manager_init(void) {
*
* @return esp_err_t ESP_OK on success, or an error code from one of the start calls.
*/
esp_err_t meter_manager_start(void) {
esp_err_t meter_manager_start(void)
{
esp_err_t err;
// Start EVSE meter
//err = meter_manager_evse_start();
//if (err != ESP_OK) return err;
// Start EVSE meter (habilite quando quiser)
// err = meter_manager_evse_start();
// if (err != ESP_OK) return err;
// Start GRID meter
err = meter_manager_grid_start();
if (err != ESP_OK) return err;
if (err != ESP_OK)
return err;
return ESP_OK;
}
/**
* @brief Stops all meters and unregisters event handlers.
*
@@ -153,153 +169,307 @@ esp_err_t meter_manager_start(void) {
*
* @return esp_err_t ESP_OK on success, or an error code.
*/
esp_err_t meter_manager_stop(void) {
esp_err_t meter_manager_stop(void)
{
esp_err_t err;
// Stop EVSE meter
//err = meter_manager_evse_stop();
//if (err != ESP_OK) return err;
// err = meter_manager_evse_stop();
// if (err != ESP_OK) return err;
// Stop GRID meter
err = meter_manager_grid_stop();
if (err != ESP_OK) return err;
if (err != ESP_OK)
return err;
return ESP_OK;
}
// ---------- EVSE ----------
// Função para inicializar o medidor EVSE
esp_err_t meter_manager_evse_init() {
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;
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;
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_ORNO526:
return meter_orno526_init();
case METER_TYPE_DTS6619:
return meter_dts6619_init();
case METER_TYPE_DDS661:
return meter_dds661_init();
case METER_TYPE_EA777:
return meter_ea777_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_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, "Initializing GRID meter of type %s", meter_type_to_str(meter_grid_type));
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;
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_ORNO526:
return meter_orno526_start();
case METER_TYPE_DTS6619:
return meter_dts6619_start();
case METER_TYPE_DDS661:
return meter_dds661_start();
case METER_TYPE_EA777:
return meter_ea777_start();
case METER_TYPE_MONO_ZIGBEE:
case METER_TYPE_TRIF_ZIGBEE:
return meter_zigbee_start();
default:
return ESP_ERR_INVALID_ARG;
}
}
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;
}
}
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;
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_ORNO526:
meter_orno526_stop();
break;
case METER_TYPE_DTS6619:
meter_dts6619_stop();
break;
case METER_TYPE_DDS661:
meter_dds661_stop();
break;
case METER_TYPE_EA777:
meter_ea777_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;
}
// ---------- GRID ----------
esp_err_t meter_manager_evse_set_model(meter_type_t meter_type) {
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, "Initializing GRID meter of type %s", meter_type_to_str(meter_grid_type));
switch (meter_grid_type) // corrigido: ORNO-513 -> driver orno513
{
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_ORNO526:
return meter_orno526_init();
case METER_TYPE_DTS6619:
return meter_dts6619_init();
case METER_TYPE_DDS661:
return meter_dds661_init();
case METER_TYPE_EA777:
return meter_ea777_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_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(); // corrigido
case METER_TYPE_ORNO516:
return meter_orno516_start();
case METER_TYPE_ORNO526:
return meter_orno526_start();
case METER_TYPE_DTS6619:
return meter_dts6619_start();
case METER_TYPE_DDS661:
return meter_dds661_start();
case METER_TYPE_EA777:
return meter_ea777_start();
case METER_TYPE_MONO_ZIGBEE:
case METER_TYPE_TRIF_ZIGBEE:
return meter_zigbee_start();
default:
return ESP_ERR_INVALID_ARG;
}
}
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(); // corrigido
break;
case METER_TYPE_ORNO516:
meter_orno516_stop();
break;
case METER_TYPE_ORNO526:
meter_orno526_stop();
break;
case METER_TYPE_DTS6619:
meter_dts6619_stop();
break;
case METER_TYPE_DDS661:
meter_dds661_stop();
break;
case METER_TYPE_EA777:
meter_ea777_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;
}
// ---------- Utilidades ----------
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) {
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;
}
}
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) {
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) {
meter_type_t meter_manager_evse_get_model(void)
{
return meter_evse_type;
}
meter_type_t meter_manager_grid_get_model(void) {
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";
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_ORNO526:
return "ORNO-526";
case METER_TYPE_DTS6619:
return "DTS-6619";
case METER_TYPE_DDS661:
return "DDS-661";
case METER_TYPE_MONO_ZIGBEE:
return "MONO-ZIGBEE";
case METER_TYPE_TRIF_ZIGBEE:
return "TRIF-ZIGBEE";
case METER_TYPE_EA777:
return "EA-777";
default:
return "NENHUM";
}
}
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;
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, "ORNO-526") == 0)
return METER_TYPE_ORNO526;
if (strcmp(str, "DTS-6619") == 0)
return METER_TYPE_DTS6619;
if (strcmp(str, "DDS-661") == 0)
return METER_TYPE_DDS661;
if (strcmp(str, "MONO-ZIGBEE") == 0)
return METER_TYPE_MONO_ZIGBEE;
if (strcmp(str, "TRIF-ZIGBEE") == 0)
return METER_TYPE_TRIF_ZIGBEE;
if (strcmp(str, "EA-777") == 0)
return METER_TYPE_EA777;
return METER_TYPE_NONE;
}