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

chore: snapshot before shared RS485 bus integration

Browse Source
This commit is contained in:
PlxEV
2026-07-22 15:36:04 +01:00
parent ef02e5c5f5
commit 2a803fcef1
167 changed files with 5749 additions and 1128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

678
components/meter_manager/driver/meter_modbus/meter_dds661.c
View File

@@ -1,4 +1,9 @@
// components/meter_manager/driver/meter_dds661.c
// components/meter_manager/driver/meter_modbus/meter_dds661.c
// Driver Modbus RTU para DDS661.
// Suporta 1 ou 2 DDS661 no mesmo bus RS485:
// GRID -> slave ID 1
// EVSE -> slave ID 2
// Usa um único Modbus master e uma única task de leitura.
#include "meter_dds661.h"
@@ -7,7 +12,13 @@
#include "meter_events.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "driver/uart.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include <stddef.h>
#include <string.h>
#include <math.h>
@@ -22,19 +33,27 @@
#define MB_UART_RXD 16
#define MB_UART_RTS 2 // pino DE/RE do transceiver RS-485
// ======= DDS661 no mesmo bus =======
#define DDS661_GRID_SLAVE_ID 1
#define DDS661_EVSE_SLAVE_ID 2
#define UPDATE_INTERVAL (3000 / portTICK_PERIOD_MS)
#define POLL_INTERVAL (120 / portTICK_PERIOD_MS)
#define DDS661_LOCK_TIMEOUT pdMS_TO_TICKS(10000)
// ======= 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}
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
// ======= Estado =======
static bool is_initialized = false;
static volatile bool task_should_run = false;
static TaskHandle_t meter_task = NULL;
static SemaphoreHandle_t dds661_lock = NULL;
// ======= CIDs (sequenciais) =======
// ======= CIDs locais por meter =======
enum
{
CID_VOLTAGE = 0,
@@ -46,6 +65,36 @@ enum
CID_COUNT
};
typedef enum
{
DDS661_SLOT_GRID = 0,
DDS661_SLOT_EVSE,
DDS661_MAX_INSTANCES
} dds661_slot_t;
typedef struct
{
bool registered;
const char *source; // "GRID" ou "EVSE"
uint8_t slave_id; // 1 ou 2
uint16_t cid_base; // atribuído dinamicamente em dds661_rebuild_descriptors_locked()
} dds661_instance_t;
static dds661_instance_t dds661_instances[DDS661_MAX_INSTANCES] = {
[DDS661_SLOT_GRID] = {
.registered = false,
.source = "GRID",
.slave_id = DDS661_GRID_SLAVE_ID,
.cid_base = 0,
},
[DDS661_SLOT_EVSE] = {
.registered = false,
.source = "EVSE",
.slave_id = DDS661_EVSE_SLAVE_ID,
.cid_base = 0,
},
};
// ======= Mapa de registradores (Input Registers; FC=0x04) =======
// Endereços típicos para DDS-661 (float32):
#define REG_VOLTAGE 0x0000 // V (float32)
@@ -55,8 +104,8 @@ enum
#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[] = {
// ======= Template de parâmetros para um DDS661 =======
static const mb_parameter_descriptor_t dds661_param_template[CID_COUNT] = {
{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},
@@ -82,8 +131,30 @@ const mb_parameter_descriptor_t device_parameters_dds661[] = {
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]);
// O esp-modbus exige cid e param_key únicos no Data Dictionary.
// Como GRID e EVSE usam o mesmo mapa de registos, o param_key precisa de prefixo por instância.
static const char *const dds661_param_keys[DDS661_MAX_INSTANCES][CID_COUNT] = {
[DDS661_SLOT_GRID] = {
"GRID Voltage",
"GRID Current",
"GRID Active Power",
"GRID Power Factor",
"GRID Frequency",
"GRID Total Active Energy",
},
[DDS661_SLOT_EVSE] = {
"EVSE Voltage",
"EVSE Current",
"EVSE Active Power",
"EVSE Power Factor",
"EVSE Frequency",
"EVSE Total Active Energy",
},
};
static mb_parameter_descriptor_t device_parameters_dds661[DDS661_MAX_INSTANCES * CID_COUNT];
static uint16_t num_device_parameters_dds661 = 0;
static bool dds661_descriptor_dirty = true;
// ======= Ponteiro para buffer destino =======
static void *get_param_ptr(const mb_parameter_descriptor_t *param)
@@ -93,125 +164,80 @@ static void *get_param_ptr(const mb_parameter_descriptor_t *param)
return ((uint8_t *)&holding_reg_params + param->param_offset - 1);
}
// ======= Tarefa de aquisição =======
static void serial_mdb_task(void *param)
static bool dds661_has_registered_instance_locked(void)
{
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 (uint8_t i = 0; i < DDS661_MAX_INSTANCES; ++i)
{
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), portMAX_DELAY);
vTaskDelay(UPDATE_INTERVAL);
if (dds661_instances[i].registered)
return true;
}
return false;
}
// ======= API pública =======
esp_err_t meter_dds661_init(void)
static esp_err_t dds661_rebuild_descriptors_locked(void)
{
if (is_initialized)
num_device_parameters_dds661 = 0;
dds661_descriptor_dirty = true;
for (uint8_t inst_idx = 0; inst_idx < DDS661_MAX_INSTANCES; ++inst_idx)
{
ESP_LOGW(TAG, "meter_dds661 already initialized");
return ESP_ERR_INVALID_STATE;
dds661_instance_t *inst = &dds661_instances[inst_idx];
if (!inst->registered)
continue;
// Mantém os CIDs contíguos no descriptor ativo.
// Isto evita problemas em versões do esp-modbus que tratam CID como índice.
inst->cid_base = num_device_parameters_dds661;
for (uint16_t local_cid = 0; local_cid < CID_COUNT; ++local_cid)
{
mb_parameter_descriptor_t *dst = &device_parameters_dds661[num_device_parameters_dds661++];
*dst = dds661_param_template[local_cid];
dst->cid = inst->cid_base + local_cid;
dst->param_key = dds661_param_keys[inst_idx][local_cid];
dst->mb_slave_addr = inst->slave_id;
}
}
ESP_LOGI(TAG, "meter_dds661_init");
dds661_descriptor_dirty = true;
ESP_LOGI(TAG, "DDS661 descriptor table prepared: %u parameters", num_device_parameters_dds661);
return ESP_OK;
}
static esp_err_t dds661_apply_descriptors_locked(void)
{
if (num_device_parameters_dds661 == 0)
return ESP_ERR_INVALID_STATE;
if (!dds661_descriptor_dirty)
return ESP_OK;
esp_err_t err = mbc_master_set_descriptor(device_parameters_dds661, num_device_parameters_dds661);
if (err != ESP_OK)
{
ESP_LOGE(TAG, "mbc_master_set_descriptor failed: %s", esp_err_to_name(err));
return err;
}
dds661_descriptor_dirty = false;
ESP_LOGI(TAG, "DDS661 descriptor table applied: %u parameters", num_device_parameters_dds661);
return ESP_OK;
}
static esp_err_t dds661_master_init_once(void)
{
if (is_initialized)
return ESP_OK;
if (!dds661_lock)
{
dds661_lock = xSemaphoreCreateMutex();
if (!dds661_lock)
return ESP_ERR_NO_MEM;
}
ESP_LOGI(TAG, "meter_dds661 Modbus master init");
mb_communication_info_t comm = {
.port = MB_PORT_NUM,
@@ -221,34 +247,359 @@ esp_err_t meter_dds661_init(void)
};
void *handler = NULL;
ESP_ERROR_CHECK(mbc_master_init(MB_PORT_SERIAL_MASTER, &handler));
ESP_ERROR_CHECK(mbc_master_setup(&comm));
esp_err_t err = mbc_master_init(MB_PORT_SERIAL_MASTER, &handler);
if (err != ESP_OK)
return err;
err = mbc_master_setup(&comm);
if (err != ESP_OK)
{
(void)mbc_master_destroy();
return err;
}
// 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));
err = uart_set_pin(MB_PORT_NUM, MB_UART_TXD, MB_UART_RXD, MB_UART_RTS, UART_PIN_NO_CHANGE);
if (err != ESP_OK)
{
(void)mbc_master_destroy();
return err;
}
// >>> IMPORTANTE: start antes do set_mode <<<
ESP_ERROR_CHECK(mbc_master_start());
err = uart_set_word_length(MB_PORT_NUM, UART_DATA_8_BITS);
if (err != ESP_OK)
{
(void)mbc_master_destroy();
return err;
}
err = uart_set_hw_flow_ctrl(MB_PORT_NUM, UART_HW_FLOWCTRL_DISABLE, 0);
if (err != ESP_OK)
{
(void)mbc_master_destroy();
return err;
}
err = uart_set_stop_bits(MB_PORT_NUM, UART_STOP_BITS_1);
if (err != ESP_OK)
{
(void)mbc_master_destroy();
return err;
}
// IMPORTANTE: start antes do set_mode
err = mbc_master_start();
if (err != ESP_OK)
{
(void)mbc_master_destroy();
return err;
}
// Só agora muda para RS485 half duplex
ESP_ERROR_CHECK(uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX));
err = uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX);
if (err != ESP_OK)
{
(void)mbc_master_destroy();
return err;
}
// (opcional) logs de debug Modbus
// Logs de debug Modbus. Reduz para ESP_LOG_INFO/ESP_LOG_WARN em produção se necessário.
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;
}
static esp_err_t dds661_register_instance(dds661_slot_t slot)
{
if (slot >= DDS661_MAX_INSTANCES)
return ESP_ERR_INVALID_ARG;
esp_err_t err = dds661_master_init_once();
if (err != ESP_OK)
return err;
if (xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) != pdTRUE)
return ESP_ERR_TIMEOUT;
dds661_instances[slot].registered = true;
ESP_LOGI(TAG, "DDS661 %s registered on Modbus slave ID %u",
dds661_instances[slot].source,
dds661_instances[slot].slave_id);
err = dds661_rebuild_descriptors_locked();
xSemaphoreGive(dds661_lock);
return err;
}
static void dds661_shutdown_if_idle(void)
{
bool any_registered = false;
if (dds661_lock && xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) == pdTRUE)
{
any_registered = dds661_has_registered_instance_locked();
xSemaphoreGive(dds661_lock);
}
if (any_registered || !is_initialized)
return;
ESP_LOGI(TAG, "No DDS661 instances registered; stopping shared Modbus master");
task_should_run = false;
for (int i = 0; i < 20 && meter_task != NULL; ++i)
{
vTaskDelay(pdMS_TO_TICKS(10));
}
if (meter_task != NULL)
{
ESP_LOGW(TAG, "DDS661 task did not exit in time; deleting it");
vTaskDelete(meter_task);
meter_task = NULL;
}
esp_err_t err = mbc_master_destroy();
if (err != ESP_OK)
ESP_LOGW(TAG, "mbc_master_destroy() returned %s", esp_err_to_name(err));
if (uart_is_driver_installed(MB_PORT_NUM))
uart_driver_delete(MB_PORT_NUM);
is_initialized = false;
num_device_parameters_dds661 = 0;
dds661_descriptor_dirty = true;
}
static void dds661_unregister_instance(dds661_slot_t slot)
{
if (slot >= DDS661_MAX_INSTANCES)
return;
if (!is_initialized || !dds661_lock)
return;
if (xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) == pdTRUE)
{
ESP_LOGI(TAG, "DDS661 %s unregistered", dds661_instances[slot].source);
dds661_instances[slot].registered = false;
(void)dds661_rebuild_descriptors_locked();
xSemaphoreGive(dds661_lock);
}
dds661_shutdown_if_idle();
}
static void dds661_read_instance_locked(const dds661_instance_t *inst)
{
esp_err_t err;
const mb_parameter_descriptor_t *desc = NULL;
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
float voltage[3] = {0};
float current[3] = {0};
int32_t watt[3] = {0};
bool got_any_value = false;
for (uint16_t local_cid = 0; local_cid < CID_COUNT; local_cid++)
{
const uint16_t cid = inst->cid_base + local_cid;
err = mbc_master_get_cid_info(cid, &desc);
if (err != ESP_OK || !desc)
{
ESP_LOGE(TAG, "%s get_cid_info(%u) failed: %s", inst->source, cid, esp_err_to_name(err));
continue;
}
void *data_ptr = get_param_ptr(desc);
if (!data_ptr)
{
ESP_LOGE(TAG, "%s CID %u (%s): null data_ptr", inst->source, 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, "%s CID %u (%s) read failed: %s",
inst->source, cid, desc->param_key, esp_err_to_name(err));
vTaskDelay(POLL_INTERVAL);
continue;
}
uint8_t raw[4];
memcpy(raw, data_ptr, sizeof(raw));
ESP_LOGD(TAG, "%s CID %u (%s) raw bytes: %02X %02X %02X %02X",
inst->source, cid, desc->param_key, raw[0], raw[1], raw[2], raw[3]);
const float val = *(float *)data_ptr;
got_any_value = true;
ESP_LOGD(TAG, "%s %s: %.3f %s", inst->source, desc->param_key, val, desc->param_units);
switch (local_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;
/*
* DDS661 bidirecional:
* p_w > 0 => importação
* p_w < 0 => exportação
*
* Alguns modelos devolvem W apesar do registo estar nomeado como kW.
* Outros podem devolver kW.
*
* Não usar abs() no valor final, apenas na deteção de escala.
*/
float p_w = p_kw;
const float apparent_w = fabsf(v * i);
if (apparent_w > 1.0f && fabsf(p_w) < (apparent_w * 0.2f))
{
// Exemplo: -0.723 kW -> -723 W
p_w *= 1000.0f;
}
watt[0] = (int32_t)lrintf(p_w);
watt[1] = 0;
watt[2] = 0;
break;
}
case CID_TOTAL_ACTIVE_ENERGY_KWH:
e_kwh = val;
break;
default:
break;
}
vTaskDelay(POLL_INTERVAL);
}
if (!got_any_value)
{
ESP_LOGW(TAG, "%s no valid DDS661 values read in this cycle", inst->source);
return;
}
meter_event_data_t evt = {
.source = inst->source,
.frequency = hz,
.power_factor = pf,
.total_energy = e_kwh,
.watt_total = watt[0] + watt[1] + watt[2],
.timestamp_us = esp_timer_get_time(),
};
memcpy(evt.vrms, voltage, sizeof(evt.vrms));
memcpy(evt.irms, current, sizeof(evt.irms));
memcpy(evt.watt, watt, sizeof(evt.watt));
const int32_t p_total_w = watt[0] + watt[1] + watt[2];
ESP_LOGI(TAG,
"%s DDS661 event: V=%.1fV I=%.3fA P=%ldW E=%.3fkWh Hz=%.2f PF=%.3f",
inst->source,
voltage[0],
current[0],
(long)p_total_w,
e_kwh,
hz,
pf);
esp_err_t post_err = esp_event_post(METER_EVENT, METER_EVENT_DATA_READY, &evt, sizeof(evt), portMAX_DELAY);
if (post_err != ESP_OK)
ESP_LOGW(TAG, "%s failed to post meter event: %s", inst->source, esp_err_to_name(post_err));
}
// ======= Tarefa de aquisição =======
static void serial_mdb_task(void *param)
{
(void)param;
while (task_should_run)
{
if (!is_initialized || !dds661_lock)
{
vTaskDelay(UPDATE_INTERVAL);
continue;
}
bool had_instance = false;
for (uint8_t slot = 0; slot < DDS661_MAX_INSTANCES && task_should_run; ++slot)
{
if (xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) != pdTRUE)
{
ESP_LOGW(TAG, "DDS661 task timeout waiting lock");
continue;
}
dds661_instance_t inst = dds661_instances[slot];
if (inst.registered)
{
had_instance = true;
dds661_read_instance_locked(&inst);
}
xSemaphoreGive(dds661_lock);
}
vTaskDelay(had_instance ? UPDATE_INTERVAL : pdMS_TO_TICKS(500));
}
ESP_LOGI(TAG, "DDS661 task stopped");
meter_task = NULL;
vTaskDelete(NULL);
}
// ======= API pública =======
// Compatibilidade: chamada antiga inicializa DDS661 como GRID/ID 1.
esp_err_t meter_dds661_init(void)
{
return meter_dds661_grid_init();
}
esp_err_t meter_dds661_grid_init(void)
{
return dds661_register_instance(DDS661_SLOT_GRID);
}
esp_err_t meter_dds661_evse_init(void)
{
return dds661_register_instance(DDS661_SLOT_EVSE);
}
esp_err_t meter_dds661_start(void)
{
if (!is_initialized)
@@ -257,33 +608,64 @@ esp_err_t meter_dds661_start(void)
return ESP_ERR_INVALID_STATE;
}
if (!dds661_lock)
return ESP_ERR_INVALID_STATE;
if (xSemaphoreTake(dds661_lock, DDS661_LOCK_TIMEOUT) != pdTRUE)
return ESP_ERR_TIMEOUT;
const bool has_instance = dds661_has_registered_instance_locked();
esp_err_t desc_err = ESP_OK;
if (has_instance)
desc_err = dds661_apply_descriptors_locked();
xSemaphoreGive(dds661_lock);
if (!has_instance)
{
ESP_LOGW(TAG, "meter_dds661 start ignored: no instances registered");
return ESP_ERR_INVALID_STATE;
}
if (desc_err != ESP_OK)
return desc_err;
if (meter_task == NULL)
{
xTaskCreate(serial_mdb_task, "meter_dds661_task", 4096, NULL, 3, &meter_task);
ESP_LOGI(TAG, "meter_dds661 task started");
task_should_run = true;
BaseType_t ok = xTaskCreate(serial_mdb_task, "meter_dds661_task", 4096, NULL, 3, &meter_task);
if (ok != pdPASS)
{
task_should_run = false;
meter_task = NULL;
return ESP_ERR_NO_MEM;
}
ESP_LOGI(TAG, "meter_dds661 shared task started");
}
return ESP_OK;
}
esp_err_t meter_dds661_grid_start(void)
{
return meter_dds661_start();
}
esp_err_t meter_dds661_evse_start(void)
{
return meter_dds661_start();
}
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;
meter_dds661_grid_stop();
}
void meter_dds661_grid_stop(void)
{
dds661_unregister_instance(DDS661_SLOT_GRID);
}
void meter_dds661_evse_stop(void)
{
dds661_unregister_instance(DDS661_SLOT_EVSE);
}