672 lines
18 KiB
C
Executable File
672 lines
18 KiB
C
Executable File
// 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"
|
|
|
|
#include "modbus_params.h"
|
|
#include "mbcontroller.h"
|
|
#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>
|
|
|
|
#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
|
|
|
|
// ======= 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 locais por meter =======
|
|
enum
|
|
{
|
|
CID_VOLTAGE = 0,
|
|
CID_CURRENT,
|
|
CID_ACTIVE_POWER_KW,
|
|
CID_POWER_FACTOR,
|
|
CID_FREQUENCY,
|
|
CID_TOTAL_ACTIVE_ENERGY_KWH,
|
|
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)
|
|
#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)
|
|
|
|
// ======= 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},
|
|
|
|
{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},
|
|
};
|
|
|
|
// 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)
|
|
{
|
|
if (!param || param->param_offset == 0)
|
|
return NULL;
|
|
return ((uint8_t *)&holding_reg_params + param->param_offset - 1);
|
|
}
|
|
|
|
static bool dds661_has_registered_instance_locked(void)
|
|
{
|
|
for (uint8_t i = 0; i < DDS661_MAX_INSTANCES; ++i)
|
|
{
|
|
if (dds661_instances[i].registered)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static esp_err_t dds661_rebuild_descriptors_locked(void)
|
|
{
|
|
num_device_parameters_dds661 = 0;
|
|
dds661_descriptor_dirty = true;
|
|
|
|
for (uint8_t inst_idx = 0; inst_idx < DDS661_MAX_INSTANCES; ++inst_idx)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
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,
|
|
.mode = MB_MODE_RTU,
|
|
.baudrate = MB_DEV_SPEED,
|
|
.parity = UART_PARITY_EVEN, // DDS-661: 9600 8E1
|
|
};
|
|
|
|
void *handler = NULL;
|
|
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
|
|
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;
|
|
}
|
|
|
|
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
|
|
err = uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX);
|
|
if (err != ESP_OK)
|
|
{
|
|
(void)mbc_master_destroy();
|
|
return err;
|
|
}
|
|
|
|
// 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));
|
|
|
|
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)
|
|
{
|
|
ESP_LOGE(TAG, "meter_dds661 not initialized");
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
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);
|
|
}
|